@angular/core 15.1.0-next.0 → 15.1.0-next.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (48) hide show
  1. package/esm2020/src/application_ref.mjs +13 -13
  2. package/esm2020/src/core.mjs +2 -1
  3. package/esm2020/src/core_render3_private_export.mjs +1 -2
  4. package/esm2020/src/di/create_injector.mjs +1 -1
  5. package/esm2020/src/di/r3_injector.mjs +7 -7
  6. package/esm2020/src/linker/query_list.mjs +7 -7
  7. package/esm2020/src/render/api.mjs +1 -3
  8. package/esm2020/src/render3/assert.mjs +1 -10
  9. package/esm2020/src/render3/component_ref.mjs +7 -18
  10. package/esm2020/src/render3/definition.mjs +9 -1
  11. package/esm2020/src/render3/index.mjs +2 -2
  12. package/esm2020/src/render3/instructions/shared.mjs +95 -169
  13. package/esm2020/src/render3/interfaces/context.mjs +5 -5
  14. package/esm2020/src/render3/interfaces/view.mjs +1 -10
  15. package/esm2020/src/render3/jit/module.mjs +2 -3
  16. package/esm2020/src/render3/namespaces.mjs +1 -8
  17. package/esm2020/src/render3/node_manipulation.mjs +3 -7
  18. package/esm2020/src/render3/node_selector_matcher.mjs +1 -4
  19. package/esm2020/src/render3/query.mjs +1 -6
  20. package/esm2020/src/render3/state.mjs +1 -4
  21. package/esm2020/src/render3/util/discovery_utils.mjs +3 -32
  22. package/esm2020/src/render3/util/view_utils.mjs +1 -15
  23. package/esm2020/src/render3/view_ref.mjs +6 -6
  24. package/esm2020/src/util/array_utils.mjs +3 -71
  25. package/esm2020/src/version.mjs +1 -1
  26. package/esm2020/testing/src/logger.mjs +3 -3
  27. package/esm2020/testing/src/ng_zone_mock.mjs +3 -3
  28. package/fesm2015/core.mjs +282 -1253
  29. package/fesm2015/core.mjs.map +1 -1
  30. package/fesm2015/testing.mjs +287 -1258
  31. package/fesm2015/testing.mjs.map +1 -1
  32. package/fesm2020/core.mjs +282 -1253
  33. package/fesm2020/core.mjs.map +1 -1
  34. package/fesm2020/testing.mjs +287 -1258
  35. package/fesm2020/testing.mjs.map +1 -1
  36. package/index.d.ts +11 -224
  37. package/package.json +1 -1
  38. package/schematics/migrations/relative-link-resolution/util.d.ts +1 -1
  39. package/schematics/migrations/router-link-with-href/util.d.ts +1 -1
  40. package/schematics/migrations/typed-forms/util.d.ts +1 -1
  41. package/schematics/utils/import_manager.js +23 -3
  42. package/schematics/utils/ng_decorators.d.ts +1 -1
  43. package/schematics/utils/typescript/compiler_host.d.ts +1 -1
  44. package/schematics/utils/typescript/imports.d.ts +1 -1
  45. package/schematics/utils/typescript/property_name.d.ts +1 -1
  46. package/testing/index.d.ts +1 -1
  47. package/esm2020/src/render3/instructions/lview_debug.mjs +0 -684
  48. package/esm2020/src/util/named_array_type.mjs +0 -40
package/fesm2015/core.mjs CHANGED
@@ -1,5 +1,5 @@
1
1
  /**
2
- * @license Angular v15.1.0-next.0
2
+ * @license Angular v15.1.0-next.2
3
3
  * (c) 2010-2022 Google LLC. https://angular.io/
4
4
  * License: MIT
5
5
  */
@@ -1391,6 +1391,14 @@ function getDirectiveDef(type) {
1391
1391
  function getPipeDef$1(type) {
1392
1392
  return type[NG_PIPE_DEF] || null;
1393
1393
  }
1394
+ /**
1395
+ * Checks whether a given Component, Directive or Pipe is marked as standalone.
1396
+ * This will return false if passed anything other than a Component, Directive, or Pipe class
1397
+ * See this guide for additional information: https://angular.io/guide/standalone-components
1398
+ *
1399
+ * @param type A reference to a Component, Directive or Pipe.
1400
+ * @publicApi
1401
+ */
1394
1402
  function isStandalone(type) {
1395
1403
  const def = getComponentDef(type) || getDirectiveDef(type) || getPipeDef$1(type);
1396
1404
  return def !== null ? def.standalone : false;
@@ -1439,7 +1447,7 @@ const MOVED_VIEWS = 9;
1439
1447
  const CONTAINER_HEADER_OFFSET = 10;
1440
1448
  // Note: This hack is necessary so we don't erroneously get a circular dependency
1441
1449
  // failure based on types.
1442
- const unusedValueExportToPlacateAjd$8 = 1;
1450
+ const unusedValueExportToPlacateAjd$4 = 1;
1443
1451
 
1444
1452
  /**
1445
1453
  * @license
@@ -1482,18 +1490,9 @@ const EMBEDDED_VIEW_INJECTOR = 21;
1482
1490
  * there should be no need to refer to `HEADER_OFFSET` anywhere else.
1483
1491
  */
1484
1492
  const HEADER_OFFSET = 22;
1485
- /**
1486
- * Converts `TViewType` into human readable text.
1487
- * Make sure this matches with `TViewType`
1488
- */
1489
- const TViewTypeAsString = [
1490
- 'Root',
1491
- 'Component',
1492
- 'Embedded', // 2
1493
- ];
1494
1493
  // Note: This hack is necessary so we don't erroneously get a circular dependency
1495
1494
  // failure based on types.
1496
- const unusedValueExportToPlacateAjd$7 = 1;
1495
+ const unusedValueExportToPlacateAjd$3 = 1;
1497
1496
 
1498
1497
  /**
1499
1498
  * @license
@@ -1578,11 +1577,6 @@ function assertHasParent(tNode) {
1578
1577
  assertDefined(tNode, 'currentTNode should exist!');
1579
1578
  assertDefined(tNode.parent, 'currentTNode should have a parent');
1580
1579
  }
1581
- function assertDataNext(lView, index, arr) {
1582
- if (arr == null)
1583
- arr = lView;
1584
- assertEqual(arr.length, index, `index ${index} expected to be at the end of arr (length ${arr.length})`);
1585
- }
1586
1580
  function assertLContainer(value) {
1587
1581
  assertDefined(value, 'LContainer must be defined');
1588
1582
  assertEqual(isLContainer(value), true, 'Expecting LContainer');
@@ -1613,10 +1607,6 @@ function assertIndexInDeclRange(lView, index) {
1613
1607
  const tView = lView[1];
1614
1608
  assertBetween(HEADER_OFFSET, tView.bindingStartIndex, index);
1615
1609
  }
1616
- function assertIndexInVarsRange(lView, index) {
1617
- const tView = lView[1];
1618
- assertBetween(tView.bindingStartIndex, tView.expandoStartIndex, index);
1619
- }
1620
1610
  function assertIndexInExpandoRange(lView, index) {
1621
1611
  const tView = lView[1];
1622
1612
  assertBetween(tView.expandoStartIndex, lView.length, index);
@@ -1835,14 +1825,7 @@ const profiler = function (event, instance, hookOrListener) {
1835
1825
  * found in the LICENSE file at https://angular.io/license
1836
1826
  */
1837
1827
  const SVG_NAMESPACE = 'svg';
1838
- const SVG_NAMESPACE_URI = 'http://www.w3.org/2000/svg';
1839
1828
  const MATH_ML_NAMESPACE = 'math';
1840
- const MATH_ML_NAMESPACE_URI = 'http://www.w3.org/1998/MathML/';
1841
- function getNamespaceUri(namespace) {
1842
- const name = namespace.toLowerCase();
1843
- return name === SVG_NAMESPACE ? SVG_NAMESPACE_URI :
1844
- (name === MATH_ML_NAMESPACE ? MATH_ML_NAMESPACE_URI : null);
1845
- }
1846
1829
 
1847
1830
  /**
1848
1831
  * @license
@@ -1891,20 +1874,6 @@ function unwrapLView(value) {
1891
1874
  }
1892
1875
  return null;
1893
1876
  }
1894
- /**
1895
- * Returns `LContainer` or `null` if not found.
1896
- * @param value wrapped value of `RNode`, `LView`, `LContainer`
1897
- */
1898
- function unwrapLContainer(value) {
1899
- while (Array.isArray(value)) {
1900
- // This check is same as `isLContainer()` but we don't call at as we don't want to call
1901
- // `Array.isArray()` twice and give JITer more work for inlining.
1902
- if (value[TYPE] === true)
1903
- return value;
1904
- value = value[HOST];
1905
- }
1906
- return null;
1907
- }
1908
1877
  /**
1909
1878
  * Retrieves an element value from the provided `viewData`, by unwrapping
1910
1879
  * from any containers, component views, or style contexts.
@@ -2164,9 +2133,6 @@ function isCurrentTNodeParent() {
2164
2133
  function setCurrentTNodeAsNotParent() {
2165
2134
  instructionState.lFrame.isParent = false;
2166
2135
  }
2167
- function setCurrentTNodeAsParent() {
2168
- instructionState.lFrame.isParent = true;
2169
- }
2170
2136
  function getContextLView() {
2171
2137
  const contextLView = instructionState.lFrame.contextLView;
2172
2138
  ngDevMode && assertDefined(contextLView, 'contextLView must be defined.');
@@ -2889,7 +2855,7 @@ function isFactory(obj) {
2889
2855
  }
2890
2856
  // Note: This hack is necessary so we don't erroneously get a circular dependency
2891
2857
  // failure based on types.
2892
- const unusedValueExportToPlacateAjd$6 = 1;
2858
+ const unusedValueExportToPlacateAjd$2 = 1;
2893
2859
 
2894
2860
  /**
2895
2861
  * Converts `TNodeType` into human readable text.
@@ -2908,7 +2874,7 @@ function toTNodeTypeAsString(tNodeType) {
2908
2874
  }
2909
2875
  // Note: This hack is necessary so we don't erroneously get a circular dependency
2910
2876
  // failure based on types.
2911
- const unusedValueExportToPlacateAjd$5 = 1;
2877
+ const unusedValueExportToPlacateAjd$1 = 1;
2912
2878
  /**
2913
2879
  * Returns `true` if the `TNode` has a directive which has `@Input()` for `class` binding.
2914
2880
  *
@@ -4391,17 +4357,6 @@ function isType(v) {
4391
4357
  * Use of this source code is governed by an MIT-style license that can be
4392
4358
  * found in the LICENSE file at https://angular.io/license
4393
4359
  */
4394
- /**
4395
- * Equivalent to ES6 spread, add each item to an array.
4396
- *
4397
- * @param items The items to add
4398
- * @param arr The array to which you want to add the items
4399
- */
4400
- function addAllToArray(items, arr) {
4401
- for (let i = 0; i < items.length; i++) {
4402
- arr.push(items[i]);
4403
- }
4404
- }
4405
4360
  /**
4406
4361
  * Determines if the contents of two arrays is identical
4407
4362
  *
@@ -4429,25 +4384,8 @@ function arrayEquals(a, b, identityAccessor) {
4429
4384
  /**
4430
4385
  * Flattens an array.
4431
4386
  */
4432
- function flatten(list, dst) {
4433
- if (dst === undefined)
4434
- dst = list;
4435
- for (let i = 0; i < list.length; i++) {
4436
- let item = list[i];
4437
- if (Array.isArray(item)) {
4438
- // we need to inline it.
4439
- if (dst === list) {
4440
- // Our assumption that the list was already flat was wrong and
4441
- // we need to clone flat since we need to write to it.
4442
- dst = list.slice(0, i);
4443
- }
4444
- flatten(item, dst);
4445
- }
4446
- else if (dst !== list) {
4447
- dst.push(item);
4448
- }
4449
- }
4450
- return dst;
4387
+ function flatten(list) {
4388
+ return list.flat(Number.POSITIVE_INFINITY);
4451
4389
  }
4452
4390
  function deepForEach(input, fn) {
4453
4391
  input.forEach(value => Array.isArray(value) ? deepForEach(value, fn) : fn(value));
@@ -4557,46 +4495,6 @@ function arrayInsert2(array, index, value1, value2) {
4557
4495
  array[index + 1] = value2;
4558
4496
  }
4559
4497
  }
4560
- /**
4561
- * Insert a `value` into an `array` so that the array remains sorted.
4562
- *
4563
- * NOTE:
4564
- * - Duplicates are not allowed, and are ignored.
4565
- * - This uses binary search algorithm for fast inserts.
4566
- *
4567
- * @param array A sorted array to insert into.
4568
- * @param value The value to insert.
4569
- * @returns index of the inserted value.
4570
- */
4571
- function arrayInsertSorted(array, value) {
4572
- let index = arrayIndexOfSorted(array, value);
4573
- if (index < 0) {
4574
- // if we did not find it insert it.
4575
- index = ~index;
4576
- arrayInsert(array, index, value);
4577
- }
4578
- return index;
4579
- }
4580
- /**
4581
- * Remove `value` from a sorted `array`.
4582
- *
4583
- * NOTE:
4584
- * - This uses binary search algorithm for fast removals.
4585
- *
4586
- * @param array A sorted array to remove from.
4587
- * @param value The value to remove.
4588
- * @returns index of the removed value.
4589
- * - positive index if value found and removed.
4590
- * - negative index if value not found. (`~index` to get the value where it should have been
4591
- * inserted)
4592
- */
4593
- function arrayRemoveSorted(array, value) {
4594
- const index = arrayIndexOfSorted(array, value);
4595
- if (index >= 0) {
4596
- arraySplice(array, index, 1);
4597
- }
4598
- return index;
4599
- }
4600
4498
  /**
4601
4499
  * Get an index of an `value` in a sorted `array`.
4602
4500
  *
@@ -5690,6 +5588,10 @@ function unregisterLView(lView) {
5690
5588
  * of the context.
5691
5589
  */
5692
5590
  class LContext {
5591
+ /** Component's parent view data. */
5592
+ get lView() {
5593
+ return getLViewById(this.lViewId);
5594
+ }
5693
5595
  constructor(
5694
5596
  /**
5695
5597
  * ID of the component's parent view data.
@@ -5707,10 +5609,6 @@ class LContext {
5707
5609
  this.nodeIndex = nodeIndex;
5708
5610
  this.native = native;
5709
5611
  }
5710
- /** Component's parent view data. */
5711
- get lView() {
5712
- return getLViewById(this.lViewId);
5713
- }
5714
5612
  }
5715
5613
 
5716
5614
  /**
@@ -6049,28 +5947,6 @@ function ensureIcuContainerVisitorLoaded(loader) {
6049
5947
  }
6050
5948
  }
6051
5949
 
6052
- /**
6053
- * @license
6054
- * Copyright Google LLC All Rights Reserved.
6055
- *
6056
- * Use of this source code is governed by an MIT-style license that can be
6057
- * found in the LICENSE file at https://angular.io/license
6058
- */
6059
- // Note: This hack is necessary so we don't erroneously get a circular dependency
6060
- // failure based on types.
6061
- const unusedValueExportToPlacateAjd$4 = 1;
6062
-
6063
- /**
6064
- * @license
6065
- * Copyright Google LLC All Rights Reserved.
6066
- *
6067
- * Use of this source code is governed by an MIT-style license that can be
6068
- * found in the LICENSE file at https://angular.io/license
6069
- */
6070
- // Note: This hack is necessary so we don't erroneously get a circular dependency
6071
- // failure based on types.
6072
- const unusedValueExportToPlacateAjd$3 = 1;
6073
-
6074
5950
  /**
6075
5951
  * @license
6076
5952
  * Copyright Google LLC All Rights Reserved.
@@ -6142,7 +6018,6 @@ function getNearestLContainer(viewOrContainer) {
6142
6018
  * Use of this source code is governed by an MIT-style license that can be
6143
6019
  * found in the LICENSE file at https://angular.io/license
6144
6020
  */
6145
- const unusedValueToPlacateAjd$2 = unusedValueExportToPlacateAjd$8 + unusedValueExportToPlacateAjd$5 + unusedValueExportToPlacateAjd$4 + unusedValueExportToPlacateAjd$3 + unusedValueExportToPlacateAjd$7;
6146
6021
  /**
6147
6022
  * NOTE: for performance reasons, the possible actions are inlined within the function instead of
6148
6023
  * being passed as an argument.
@@ -8542,6 +8417,12 @@ function getNullInjector() {
8542
8417
  class EnvironmentInjector {
8543
8418
  }
8544
8419
  class R3Injector extends EnvironmentInjector {
8420
+ /**
8421
+ * Flag indicating that this injector was previously destroyed.
8422
+ */
8423
+ get destroyed() {
8424
+ return this._destroyed;
8425
+ }
8545
8426
  constructor(providers, parent, source, scopes) {
8546
8427
  super();
8547
8428
  this.parent = parent;
@@ -8576,12 +8457,6 @@ class R3Injector extends EnvironmentInjector {
8576
8457
  this.injectorDefTypes =
8577
8458
  new Set(this.get(INJECTOR_DEF_TYPES.multi, EMPTY_ARRAY, InjectFlags.Self));
8578
8459
  }
8579
- /**
8580
- * Flag indicating that this injector was previously destroyed.
8581
- */
8582
- get destroyed() {
8583
- return this._destroyed;
8584
- }
8585
8460
  /**
8586
8461
  * Destroy the injector and release references to every instance or provider associated with it.
8587
8462
  *
@@ -9041,7 +8916,6 @@ function unwrapElementRef(value) {
9041
8916
  * Use of this source code is governed by an MIT-style license that can be
9042
8917
  * found in the LICENSE file at https://angular.io/license
9043
8918
  */
9044
- const Renderer2Interceptor = new InjectionToken('Renderer2Interceptor');
9045
8919
  /**
9046
8920
  * Creates and initializes a custom renderer that implements the `Renderer2` base class.
9047
8921
  *
@@ -9125,7 +8999,7 @@ class Version {
9125
8999
  /**
9126
9000
  * @publicApi
9127
9001
  */
9128
- const VERSION = new Version('15.1.0-next.0');
9002
+ const VERSION = new Version('15.1.0-next.2');
9129
9003
 
9130
9004
  /**
9131
9005
  * @license
@@ -9446,7 +9320,6 @@ function classIndexOf(className, classToSearch, startingIndex) {
9446
9320
  * Use of this source code is governed by an MIT-style license that can be
9447
9321
  * found in the LICENSE file at https://angular.io/license
9448
9322
  */
9449
- const unusedValueToPlacateAjd$1 = unusedValueExportToPlacateAjd$5 + unusedValueExportToPlacateAjd$4;
9450
9323
  const NG_TEMPLATE_SELECTOR = 'ng-template';
9451
9324
  /**
9452
9325
  * Search the `TAttributes` to see if it contains `cssClassToMatch` (case insensitive)
@@ -10931,853 +10804,47 @@ function _mapProviders(injector, fn) {
10931
10804
  */
10932
10805
 
10933
10806
  /**
10934
- * @license
10935
- * Copyright Google LLC All Rights Reserved.
10936
- *
10937
- * Use of this source code is governed by an MIT-style license that can be
10938
- * found in the LICENSE file at https://angular.io/license
10939
- */
10940
-
10941
- /**
10942
- * @license
10943
- * Copyright Google LLC All Rights Reserved.
10944
- *
10945
- * Use of this source code is governed by an MIT-style license that can be
10946
- * found in the LICENSE file at https://angular.io/license
10947
- */
10948
- function ɵɵdirectiveInject(token, flags = InjectFlags.Default) {
10949
- const lView = getLView();
10950
- // Fall back to inject() if view hasn't been created. This situation can happen in tests
10951
- // if inject utilities are used before bootstrapping.
10952
- if (lView === null) {
10953
- // Verify that we will not get into infinite loop.
10954
- ngDevMode && assertInjectImplementationNotEqual(ɵɵdirectiveInject);
10955
- return ɵɵinject(token, flags);
10956
- }
10957
- const tNode = getCurrentTNode();
10958
- return getOrCreateInjectable(tNode, lView, resolveForwardRef(token), flags);
10959
- }
10960
- /**
10961
- * Throws an error indicating that a factory function could not be generated by the compiler for a
10962
- * particular class.
10963
- *
10964
- * This instruction allows the actual error message to be optimized away when ngDevMode is turned
10965
- * off, saving bytes of generated code while still providing a good experience in dev mode.
10966
- *
10967
- * The name of the class is not mentioned here, but will be in the generated factory function name
10968
- * and thus in the stack trace.
10969
- *
10970
- * @codeGenApi
10971
- */
10972
- function ɵɵinvalidFactory() {
10973
- const msg = ngDevMode ? `This constructor was not compatible with Dependency Injection.` : 'invalid';
10974
- throw new Error(msg);
10975
- }
10976
-
10977
- /**
10978
- * @license
10979
- * Copyright Google LLC All Rights Reserved.
10980
- *
10981
- * Use of this source code is governed by an MIT-style license that can be
10982
- * found in the LICENSE file at https://angular.io/license
10983
- */
10984
- /**
10985
- * THIS FILE CONTAINS CODE WHICH SHOULD BE TREE SHAKEN AND NEVER CALLED FROM PRODUCTION CODE!!!
10986
- */
10987
- /**
10988
- * Creates an `Array` construction with a given name. This is useful when
10989
- * looking for memory consumption to see what time of array it is.
10990
- *
10991
- *
10992
- * @param name Name to give to the constructor
10993
- * @returns A subclass of `Array` if possible. This can only be done in
10994
- * environments which support `class` construct.
10995
- */
10996
- function createNamedArrayType(name) {
10997
- // This should never be called in prod mode, so let's verify that is the case.
10998
- if (ngDevMode) {
10999
- try {
11000
- // If this function were compromised the following could lead to arbitrary
11001
- // script execution. We bless it with Trusted Types anyway since this
11002
- // function is stripped out of production binaries.
11003
- return (newTrustedFunctionForDev('Array', `return class ${name} extends Array{}`))(Array);
11004
- }
11005
- catch (e) {
11006
- // If it does not work just give up and fall back to regular Array.
11007
- return Array;
11008
- }
11009
- }
11010
- else {
11011
- throw new Error('Looks like we are in \'prod mode\', but we are creating a named Array type, which is wrong! Check your code');
11012
- }
11013
- }
11014
-
11015
- /**
11016
- * @license
11017
- * Copyright Google LLC All Rights Reserved.
11018
- *
11019
- * Use of this source code is governed by an MIT-style license that can be
11020
- * found in the LICENSE file at https://angular.io/license
11021
- */
11022
- function toTStylingRange(prev, next) {
11023
- ngDevMode && assertNumberInRange(prev, 0, 32767 /* StylingRange.UNSIGNED_MASK */);
11024
- ngDevMode && assertNumberInRange(next, 0, 32767 /* StylingRange.UNSIGNED_MASK */);
11025
- return (prev << 17 /* StylingRange.PREV_SHIFT */ | next << 2 /* StylingRange.NEXT_SHIFT */);
11026
- }
11027
- function getTStylingRangePrev(tStylingRange) {
11028
- ngDevMode && assertNumber(tStylingRange, 'expected number');
11029
- return (tStylingRange >> 17 /* StylingRange.PREV_SHIFT */) & 32767 /* StylingRange.UNSIGNED_MASK */;
11030
- }
11031
- function getTStylingRangePrevDuplicate(tStylingRange) {
11032
- ngDevMode && assertNumber(tStylingRange, 'expected number');
11033
- return (tStylingRange & 2 /* StylingRange.PREV_DUPLICATE */) ==
11034
- 2 /* StylingRange.PREV_DUPLICATE */;
11035
- }
11036
- function setTStylingRangePrev(tStylingRange, previous) {
11037
- ngDevMode && assertNumber(tStylingRange, 'expected number');
11038
- ngDevMode && assertNumberInRange(previous, 0, 32767 /* StylingRange.UNSIGNED_MASK */);
11039
- return ((tStylingRange & ~4294836224 /* StylingRange.PREV_MASK */) |
11040
- (previous << 17 /* StylingRange.PREV_SHIFT */));
11041
- }
11042
- function setTStylingRangePrevDuplicate(tStylingRange) {
11043
- ngDevMode && assertNumber(tStylingRange, 'expected number');
11044
- return (tStylingRange | 2 /* StylingRange.PREV_DUPLICATE */);
11045
- }
11046
- function getTStylingRangeNext(tStylingRange) {
11047
- ngDevMode && assertNumber(tStylingRange, 'expected number');
11048
- return (tStylingRange & 131068 /* StylingRange.NEXT_MASK */) >> 2 /* StylingRange.NEXT_SHIFT */;
11049
- }
11050
- function setTStylingRangeNext(tStylingRange, next) {
11051
- ngDevMode && assertNumber(tStylingRange, 'expected number');
11052
- ngDevMode && assertNumberInRange(next, 0, 32767 /* StylingRange.UNSIGNED_MASK */);
11053
- return ((tStylingRange & ~131068 /* StylingRange.NEXT_MASK */) | //
11054
- next << 2 /* StylingRange.NEXT_SHIFT */);
11055
- }
11056
- function getTStylingRangeNextDuplicate(tStylingRange) {
11057
- ngDevMode && assertNumber(tStylingRange, 'expected number');
11058
- return (tStylingRange & 1 /* StylingRange.NEXT_DUPLICATE */) ===
11059
- 1 /* StylingRange.NEXT_DUPLICATE */;
11060
- }
11061
- function setTStylingRangeNextDuplicate(tStylingRange) {
11062
- ngDevMode && assertNumber(tStylingRange, 'expected number');
11063
- return (tStylingRange | 1 /* StylingRange.NEXT_DUPLICATE */);
11064
- }
11065
- function getTStylingRangeTail(tStylingRange) {
11066
- ngDevMode && assertNumber(tStylingRange, 'expected number');
11067
- const next = getTStylingRangeNext(tStylingRange);
11068
- return next === 0 ? getTStylingRangePrev(tStylingRange) : next;
11069
- }
11070
-
11071
- /**
11072
- * @license
11073
- * Copyright Google LLC All Rights Reserved.
11074
- *
11075
- * Use of this source code is governed by an MIT-style license that can be
11076
- * found in the LICENSE file at https://angular.io/license
11077
- */
11078
- /**
11079
- * Patch a `debug` property on top of the existing object.
11080
- *
11081
- * NOTE: always call this method with `ngDevMode && attachDebugObject(...)`
11082
- *
11083
- * @param obj Object to patch
11084
- * @param debug Value to patch
11085
- */
11086
- function attachDebugObject(obj, debug) {
11087
- if (ngDevMode) {
11088
- Object.defineProperty(obj, 'debug', { value: debug, enumerable: false });
11089
- }
11090
- else {
11091
- throw new Error('This method should be guarded with `ngDevMode` so that it can be tree shaken in production!');
11092
- }
11093
- }
11094
- /**
11095
- * Patch a `debug` property getter on top of the existing object.
11096
- *
11097
- * NOTE: always call this method with `ngDevMode && attachDebugObject(...)`
11098
- *
11099
- * @param obj Object to patch
11100
- * @param debugGetter Getter returning a value to patch
11101
- */
11102
- function attachDebugGetter(obj, debugGetter) {
11103
- if (ngDevMode) {
11104
- Object.defineProperty(obj, 'debug', { get: debugGetter, enumerable: false });
11105
- }
11106
- else {
11107
- throw new Error('This method should be guarded with `ngDevMode` so that it can be tree shaken in production!');
11108
- }
11109
- }
11110
-
11111
- /**
11112
- * @license
11113
- * Copyright Google LLC All Rights Reserved.
11114
- *
11115
- * Use of this source code is governed by an MIT-style license that can be
11116
- * found in the LICENSE file at https://angular.io/license
11117
- */
11118
- /*
11119
- * This file contains conditionally attached classes which provide human readable (debug) level
11120
- * information for `LView`, `LContainer` and other internal data structures. These data structures
11121
- * are stored internally as array which makes it very difficult during debugging to reason about the
11122
- * current state of the system.
11123
- *
11124
- * Patching the array with extra property does change the array's hidden class' but it does not
11125
- * change the cost of access, therefore this patching should not have significant if any impact in
11126
- * `ngDevMode` mode. (see: https://jsperf.com/array-vs-monkey-patch-array)
11127
- *
11128
- * So instead of seeing:
11129
- * ```
11130
- * Array(30) [Object, 659, null, …]
11131
- * ```
11132
- *
11133
- * You get to see:
11134
- * ```
11135
- * LViewDebug {
11136
- * views: [...],
11137
- * flags: {attached: true, ...}
11138
- * nodes: [
11139
- * {html: '<div id="123">', ..., nodes: [
11140
- * {html: '<span>', ..., nodes: null}
11141
- * ]}
11142
- * ]
11143
- * }
11144
- * ```
11145
- */
11146
- let LVIEW_COMPONENT_CACHE;
11147
- let LVIEW_EMBEDDED_CACHE;
11148
- let LVIEW_ROOT;
11149
- let LVIEW_COMPONENT;
11150
- let LVIEW_EMBEDDED;
11151
- /**
11152
- * This function clones a blueprint and creates LView.
11153
- *
11154
- * Simple slice will keep the same type, and we need it to be LView
11155
- */
11156
- function cloneToLViewFromTViewBlueprint(tView) {
11157
- const debugTView = tView;
11158
- const lView = getLViewToClone(debugTView.type, tView.template && tView.template.name);
11159
- return lView.concat(tView.blueprint);
11160
- }
11161
- class LRootView extends Array {
11162
- }
11163
- class LComponentView extends Array {
11164
- }
11165
- class LEmbeddedView extends Array {
11166
- }
11167
- function getLViewToClone(type, name) {
11168
- switch (type) {
11169
- case 0 /* TViewType.Root */:
11170
- if (LVIEW_ROOT === undefined)
11171
- LVIEW_ROOT = new LRootView();
11172
- return LVIEW_ROOT;
11173
- case 1 /* TViewType.Component */:
11174
- if (!ngDevMode || !ngDevMode.namedConstructors) {
11175
- if (LVIEW_COMPONENT === undefined)
11176
- LVIEW_COMPONENT = new LComponentView();
11177
- return LVIEW_COMPONENT;
11178
- }
11179
- if (LVIEW_COMPONENT_CACHE === undefined)
11180
- LVIEW_COMPONENT_CACHE = new Map();
11181
- let componentArray = LVIEW_COMPONENT_CACHE.get(name);
11182
- if (componentArray === undefined) {
11183
- componentArray = new (createNamedArrayType('LComponentView' + nameSuffix(name)))();
11184
- LVIEW_COMPONENT_CACHE.set(name, componentArray);
11185
- }
11186
- return componentArray;
11187
- case 2 /* TViewType.Embedded */:
11188
- if (!ngDevMode || !ngDevMode.namedConstructors) {
11189
- if (LVIEW_EMBEDDED === undefined)
11190
- LVIEW_EMBEDDED = new LEmbeddedView();
11191
- return LVIEW_EMBEDDED;
11192
- }
11193
- if (LVIEW_EMBEDDED_CACHE === undefined)
11194
- LVIEW_EMBEDDED_CACHE = new Map();
11195
- let embeddedArray = LVIEW_EMBEDDED_CACHE.get(name);
11196
- if (embeddedArray === undefined) {
11197
- embeddedArray = new (createNamedArrayType('LEmbeddedView' + nameSuffix(name)))();
11198
- LVIEW_EMBEDDED_CACHE.set(name, embeddedArray);
11199
- }
11200
- return embeddedArray;
11201
- }
11202
- }
11203
- function nameSuffix(text) {
11204
- if (text == null)
11205
- return '';
11206
- const index = text.lastIndexOf('_Template');
11207
- return '_' + (index === -1 ? text : text.slice(0, index));
11208
- }
11209
- /**
11210
- * This class is a debug version of Object literal so that we can have constructor name show up
11211
- * in
11212
- * debug tools in ngDevMode.
11213
- */
11214
- const TViewConstructor = class TView {
11215
- constructor(type, blueprint, template, queries, viewQuery, declTNode, data, bindingStartIndex, expandoStartIndex, hostBindingOpCodes, firstCreatePass, firstUpdatePass, staticViewQueries, staticContentQueries, preOrderHooks, preOrderCheckHooks, contentHooks, contentCheckHooks, viewHooks, viewCheckHooks, destroyHooks, cleanup, contentQueries, components, directiveRegistry, pipeRegistry, firstChild, schemas, consts, incompleteFirstPass, _decls, _vars) {
11216
- this.type = type;
11217
- this.blueprint = blueprint;
11218
- this.template = template;
11219
- this.queries = queries;
11220
- this.viewQuery = viewQuery;
11221
- this.declTNode = declTNode;
11222
- this.data = data;
11223
- this.bindingStartIndex = bindingStartIndex;
11224
- this.expandoStartIndex = expandoStartIndex;
11225
- this.hostBindingOpCodes = hostBindingOpCodes;
11226
- this.firstCreatePass = firstCreatePass;
11227
- this.firstUpdatePass = firstUpdatePass;
11228
- this.staticViewQueries = staticViewQueries;
11229
- this.staticContentQueries = staticContentQueries;
11230
- this.preOrderHooks = preOrderHooks;
11231
- this.preOrderCheckHooks = preOrderCheckHooks;
11232
- this.contentHooks = contentHooks;
11233
- this.contentCheckHooks = contentCheckHooks;
11234
- this.viewHooks = viewHooks;
11235
- this.viewCheckHooks = viewCheckHooks;
11236
- this.destroyHooks = destroyHooks;
11237
- this.cleanup = cleanup;
11238
- this.contentQueries = contentQueries;
11239
- this.components = components;
11240
- this.directiveRegistry = directiveRegistry;
11241
- this.pipeRegistry = pipeRegistry;
11242
- this.firstChild = firstChild;
11243
- this.schemas = schemas;
11244
- this.consts = consts;
11245
- this.incompleteFirstPass = incompleteFirstPass;
11246
- this._decls = _decls;
11247
- this._vars = _vars;
11248
- }
11249
- get template_() {
11250
- const buf = [];
11251
- processTNodeChildren(this.firstChild, buf);
11252
- return buf.join('');
11253
- }
11254
- get type_() {
11255
- return TViewTypeAsString[this.type] || `TViewType.?${this.type}?`;
11256
- }
11257
- };
11258
- class TNode {
11259
- constructor(tView_, //
11260
- type, //
11261
- index, //
11262
- insertBeforeIndex, //
11263
- injectorIndex, //
11264
- componentOffset, //
11265
- directiveStart, //
11266
- directiveEnd, //
11267
- directiveStylingLast, //
11268
- propertyBindings, //
11269
- flags, //
11270
- providerIndexes, //
11271
- value, //
11272
- attrs, //
11273
- mergedAttrs, //
11274
- localNames, //
11275
- initialInputs, //
11276
- inputs, //
11277
- outputs, //
11278
- tViews, //
11279
- next, //
11280
- projectionNext, //
11281
- child, //
11282
- parent, //
11283
- projection, //
11284
- styles, //
11285
- stylesWithoutHost, //
11286
- residualStyles, //
11287
- classes, //
11288
- classesWithoutHost, //
11289
- residualClasses, //
11290
- classBindings, //
11291
- styleBindings) {
11292
- this.tView_ = tView_;
11293
- this.type = type;
11294
- this.index = index;
11295
- this.insertBeforeIndex = insertBeforeIndex;
11296
- this.injectorIndex = injectorIndex;
11297
- this.componentOffset = componentOffset;
11298
- this.directiveStart = directiveStart;
11299
- this.directiveEnd = directiveEnd;
11300
- this.directiveStylingLast = directiveStylingLast;
11301
- this.propertyBindings = propertyBindings;
11302
- this.flags = flags;
11303
- this.providerIndexes = providerIndexes;
11304
- this.value = value;
11305
- this.attrs = attrs;
11306
- this.mergedAttrs = mergedAttrs;
11307
- this.localNames = localNames;
11308
- this.initialInputs = initialInputs;
11309
- this.inputs = inputs;
11310
- this.outputs = outputs;
11311
- this.tViews = tViews;
11312
- this.next = next;
11313
- this.projectionNext = projectionNext;
11314
- this.child = child;
11315
- this.parent = parent;
11316
- this.projection = projection;
11317
- this.styles = styles;
11318
- this.stylesWithoutHost = stylesWithoutHost;
11319
- this.residualStyles = residualStyles;
11320
- this.classes = classes;
11321
- this.classesWithoutHost = classesWithoutHost;
11322
- this.residualClasses = residualClasses;
11323
- this.classBindings = classBindings;
11324
- this.styleBindings = styleBindings;
11325
- }
11326
- /**
11327
- * Return a human debug version of the set of `NodeInjector`s which will be consulted when
11328
- * resolving tokens from this `TNode`.
11329
- *
11330
- * When debugging applications, it is often difficult to determine which `NodeInjector`s will be
11331
- * consulted. This method shows a list of `DebugNode`s representing the `TNode`s which will be
11332
- * consulted in order when resolving a token starting at this `TNode`.
11333
- *
11334
- * The original data is stored in `LView` and `TView` with a lot of offset indexes, and so it is
11335
- * difficult to reason about.
11336
- *
11337
- * @param lView The `LView` instance for this `TNode`.
11338
- */
11339
- debugNodeInjectorPath(lView) {
11340
- const path = [];
11341
- let injectorIndex = getInjectorIndex(this, lView);
11342
- if (injectorIndex === -1) {
11343
- // Looks like the current `TNode` does not have `NodeInjector` associated with it => look for
11344
- // parent NodeInjector.
11345
- const parentLocation = getParentInjectorLocation(this, lView);
11346
- if (parentLocation !== NO_PARENT_INJECTOR) {
11347
- // We found a parent, so start searching from the parent location.
11348
- injectorIndex = getParentInjectorIndex(parentLocation);
11349
- lView = getParentInjectorView(parentLocation, lView);
11350
- }
11351
- else {
11352
- // No parents have been found, so there are no `NodeInjector`s to consult.
11353
- }
11354
- }
11355
- while (injectorIndex !== -1) {
11356
- ngDevMode && assertNodeInjector(lView, injectorIndex);
11357
- const tNode = lView[TVIEW].data[injectorIndex + 8 /* NodeInjectorOffset.TNODE */];
11358
- path.push(buildDebugNode(tNode, lView));
11359
- const parentLocation = lView[injectorIndex + 8 /* NodeInjectorOffset.PARENT */];
11360
- if (parentLocation === NO_PARENT_INJECTOR) {
11361
- injectorIndex = -1;
11362
- }
11363
- else {
11364
- injectorIndex = getParentInjectorIndex(parentLocation);
11365
- lView = getParentInjectorView(parentLocation, lView);
11366
- }
11367
- }
11368
- return path;
11369
- }
11370
- get type_() {
11371
- return toTNodeTypeAsString(this.type) || `TNodeType.?${this.type}?`;
11372
- }
11373
- get flags_() {
11374
- const flags = [];
11375
- if (this.flags & 8 /* TNodeFlags.hasClassInput */)
11376
- flags.push('TNodeFlags.hasClassInput');
11377
- if (this.flags & 4 /* TNodeFlags.hasContentQuery */)
11378
- flags.push('TNodeFlags.hasContentQuery');
11379
- if (this.flags & 16 /* TNodeFlags.hasStyleInput */)
11380
- flags.push('TNodeFlags.hasStyleInput');
11381
- if (this.flags & 64 /* TNodeFlags.hasHostBindings */)
11382
- flags.push('TNodeFlags.hasHostBindings');
11383
- if (this.flags & 1 /* TNodeFlags.isDirectiveHost */)
11384
- flags.push('TNodeFlags.isDirectiveHost');
11385
- if (this.flags & 32 /* TNodeFlags.isDetached */)
11386
- flags.push('TNodeFlags.isDetached');
11387
- if (this.flags & 2 /* TNodeFlags.isProjected */)
11388
- flags.push('TNodeFlags.isProjected');
11389
- return flags.join('|');
11390
- }
11391
- get template_() {
11392
- if (this.type & 1 /* TNodeType.Text */)
11393
- return this.value;
11394
- const buf = [];
11395
- const tagName = typeof this.value === 'string' && this.value || this.type_;
11396
- buf.push('<', tagName);
11397
- if (this.flags) {
11398
- buf.push(' ', this.flags_);
11399
- }
11400
- if (this.attrs) {
11401
- for (let i = 0; i < this.attrs.length;) {
11402
- const attrName = this.attrs[i++];
11403
- if (typeof attrName == 'number') {
11404
- break;
11405
- }
11406
- const attrValue = this.attrs[i++];
11407
- buf.push(' ', attrName, '="', attrValue, '"');
11408
- }
11409
- }
11410
- buf.push('>');
11411
- processTNodeChildren(this.child, buf);
11412
- buf.push('</', tagName, '>');
11413
- return buf.join('');
11414
- }
11415
- get styleBindings_() {
11416
- return toDebugStyleBinding(this, false);
11417
- }
11418
- get classBindings_() {
11419
- return toDebugStyleBinding(this, true);
11420
- }
11421
- get providerIndexStart_() {
11422
- return this.providerIndexes & 1048575 /* TNodeProviderIndexes.ProvidersStartIndexMask */;
11423
- }
11424
- get providerIndexEnd_() {
11425
- return this.providerIndexStart_ +
11426
- (this.providerIndexes >>> 20 /* TNodeProviderIndexes.CptViewProvidersCountShift */);
11427
- }
11428
- }
11429
- const TNodeDebug = TNode;
11430
- function toDebugStyleBinding(tNode, isClassBased) {
11431
- const tData = tNode.tView_.data;
11432
- const bindings = [];
11433
- const range = isClassBased ? tNode.classBindings : tNode.styleBindings;
11434
- const prev = getTStylingRangePrev(range);
11435
- const next = getTStylingRangeNext(range);
11436
- let isTemplate = next !== 0;
11437
- let cursor = isTemplate ? next : prev;
11438
- while (cursor !== 0) {
11439
- const itemKey = tData[cursor];
11440
- const itemRange = tData[cursor + 1];
11441
- bindings.unshift({
11442
- key: itemKey,
11443
- index: cursor,
11444
- isTemplate: isTemplate,
11445
- prevDuplicate: getTStylingRangePrevDuplicate(itemRange),
11446
- nextDuplicate: getTStylingRangeNextDuplicate(itemRange),
11447
- nextIndex: getTStylingRangeNext(itemRange),
11448
- prevIndex: getTStylingRangePrev(itemRange),
11449
- });
11450
- if (cursor === prev)
11451
- isTemplate = false;
11452
- cursor = getTStylingRangePrev(itemRange);
11453
- }
11454
- bindings.push((isClassBased ? tNode.residualClasses : tNode.residualStyles) || null);
11455
- return bindings;
11456
- }
11457
- function processTNodeChildren(tNode, buf) {
11458
- while (tNode) {
11459
- buf.push(tNode.template_);
11460
- tNode = tNode.next;
11461
- }
11462
- }
11463
- class TViewData extends Array {
11464
- }
11465
- let TVIEWDATA_EMPTY; // can't initialize here or it will not be tree shaken, because
11466
- // `LView` constructor could have side-effects.
11467
- /**
11468
- * This function clones a blueprint and creates TData.
11469
- *
11470
- * Simple slice will keep the same type, and we need it to be TData
11471
- */
11472
- function cloneToTViewData(list) {
11473
- if (TVIEWDATA_EMPTY === undefined)
11474
- TVIEWDATA_EMPTY = new TViewData();
11475
- return TVIEWDATA_EMPTY.concat(list);
11476
- }
11477
- class LViewBlueprint extends Array {
11478
- }
11479
- class MatchesArray extends Array {
11480
- }
11481
- class TViewComponents extends Array {
11482
- }
11483
- class TNodeLocalNames extends Array {
11484
- }
11485
- class TNodeInitialInputs extends Array {
11486
- }
11487
- class LCleanup extends Array {
11488
- }
11489
- class TCleanup extends Array {
11490
- }
11491
- function attachLViewDebug(lView) {
11492
- attachDebugObject(lView, new LViewDebug(lView));
11493
- }
11494
- function attachLContainerDebug(lContainer) {
11495
- attachDebugObject(lContainer, new LContainerDebug(lContainer));
11496
- }
11497
- function toDebug(obj) {
11498
- if (obj) {
11499
- const debug = obj.debug;
11500
- assertDefined(debug, 'Object does not have a debug representation.');
11501
- return debug;
11502
- }
11503
- else {
11504
- return obj;
11505
- }
11506
- }
11507
- /**
11508
- * Use this method to unwrap a native element in `LView` and convert it into HTML for easier
11509
- * reading.
11510
- *
11511
- * @param value possibly wrapped native DOM node.
11512
- * @param includeChildren If `true` then the serialized HTML form will include child elements
11513
- * (same
11514
- * as `outerHTML`). If `false` then the serialized HTML form will only contain the element
11515
- * itself
11516
- * (will not serialize child elements).
11517
- */
11518
- function toHtml(value, includeChildren = false) {
11519
- const node = unwrapRNode(value);
11520
- if (node) {
11521
- switch (node.nodeType) {
11522
- case Node.TEXT_NODE:
11523
- return node.textContent;
11524
- case Node.COMMENT_NODE:
11525
- return `<!--${node.textContent}-->`;
11526
- case Node.ELEMENT_NODE:
11527
- const outerHTML = node.outerHTML;
11528
- if (includeChildren) {
11529
- return outerHTML;
11530
- }
11531
- else {
11532
- const innerHTML = '>' + node.innerHTML + '<';
11533
- return (outerHTML.split(innerHTML)[0]) + '>';
11534
- }
11535
- }
11536
- }
11537
- return null;
11538
- }
11539
- class LViewDebug {
11540
- constructor(_raw_lView) {
11541
- this._raw_lView = _raw_lView;
11542
- }
11543
- /**
11544
- * Flags associated with the `LView` unpacked into a more readable state.
11545
- */
11546
- get flags() {
11547
- const flags = this._raw_lView[FLAGS];
11548
- return {
11549
- __raw__flags__: flags,
11550
- initPhaseState: flags & 3 /* LViewFlags.InitPhaseStateMask */,
11551
- creationMode: !!(flags & 4 /* LViewFlags.CreationMode */),
11552
- firstViewPass: !!(flags & 8 /* LViewFlags.FirstLViewPass */),
11553
- checkAlways: !!(flags & 16 /* LViewFlags.CheckAlways */),
11554
- dirty: !!(flags & 32 /* LViewFlags.Dirty */),
11555
- attached: !!(flags & 64 /* LViewFlags.Attached */),
11556
- destroyed: !!(flags & 128 /* LViewFlags.Destroyed */),
11557
- isRoot: !!(flags & 256 /* LViewFlags.IsRoot */),
11558
- indexWithinInitPhase: flags >> 11 /* LViewFlags.IndexWithinInitPhaseShift */,
11559
- };
11560
- }
11561
- get parent() {
11562
- return toDebug(this._raw_lView[PARENT]);
11563
- }
11564
- get hostHTML() {
11565
- return toHtml(this._raw_lView[HOST], true);
11566
- }
11567
- get html() {
11568
- return (this.nodes || []).map(mapToHTML).join('');
11569
- }
11570
- get context() {
11571
- return this._raw_lView[CONTEXT];
11572
- }
11573
- /**
11574
- * The tree of nodes associated with the current `LView`. The nodes have been normalized into
11575
- * a tree structure with relevant details pulled out for readability.
11576
- */
11577
- get nodes() {
11578
- const lView = this._raw_lView;
11579
- const tNode = lView[TVIEW].firstChild;
11580
- return toDebugNodes(tNode, lView);
11581
- }
11582
- get template() {
11583
- return this.tView.template_;
11584
- }
11585
- get tView() {
11586
- return this._raw_lView[TVIEW];
11587
- }
11588
- get cleanup() {
11589
- return this._raw_lView[CLEANUP];
11590
- }
11591
- get injector() {
11592
- return this._raw_lView[INJECTOR$1];
11593
- }
11594
- get rendererFactory() {
11595
- return this._raw_lView[RENDERER_FACTORY];
11596
- }
11597
- get renderer() {
11598
- return this._raw_lView[RENDERER];
11599
- }
11600
- get sanitizer() {
11601
- return this._raw_lView[SANITIZER];
11602
- }
11603
- get childHead() {
11604
- return toDebug(this._raw_lView[CHILD_HEAD]);
11605
- }
11606
- get next() {
11607
- return toDebug(this._raw_lView[NEXT]);
11608
- }
11609
- get childTail() {
11610
- return toDebug(this._raw_lView[CHILD_TAIL]);
11611
- }
11612
- get declarationView() {
11613
- return toDebug(this._raw_lView[DECLARATION_VIEW]);
11614
- }
11615
- get queries() {
11616
- return this._raw_lView[QUERIES];
11617
- }
11618
- get tHost() {
11619
- return this._raw_lView[T_HOST];
11620
- }
11621
- get id() {
11622
- return this._raw_lView[ID];
11623
- }
11624
- get decls() {
11625
- return toLViewRange(this.tView, this._raw_lView, HEADER_OFFSET, this.tView.bindingStartIndex);
11626
- }
11627
- get vars() {
11628
- return toLViewRange(this.tView, this._raw_lView, this.tView.bindingStartIndex, this.tView.expandoStartIndex);
11629
- }
11630
- get expando() {
11631
- return toLViewRange(this.tView, this._raw_lView, this.tView.expandoStartIndex, this._raw_lView.length);
11632
- }
11633
- /**
11634
- * Normalized view of child views (and containers) attached at this location.
11635
- */
11636
- get childViews() {
11637
- const childViews = [];
11638
- let child = this.childHead;
11639
- while (child) {
11640
- childViews.push(child);
11641
- child = child.next;
11642
- }
11643
- return childViews;
11644
- }
11645
- }
11646
- function mapToHTML(node) {
11647
- if (node.type === 'ElementContainer') {
11648
- return (node.children || []).map(mapToHTML).join('');
11649
- }
11650
- else if (node.type === 'IcuContainer') {
11651
- throw new Error('Not implemented');
11652
- }
11653
- else {
11654
- return toHtml(node.native, true) || '';
11655
- }
11656
- }
11657
- function toLViewRange(tView, lView, start, end) {
11658
- let content = [];
11659
- for (let index = start; index < end; index++) {
11660
- content.push({ index: index, t: tView.data[index], l: lView[index] });
11661
- }
11662
- return { start: start, end: end, length: end - start, content: content };
11663
- }
11664
- /**
11665
- * Turns a flat list of nodes into a tree by walking the associated `TNode` tree.
11666
- *
11667
- * @param tNode
11668
- * @param lView
11669
- */
11670
- function toDebugNodes(tNode, lView) {
11671
- if (tNode) {
11672
- const debugNodes = [];
11673
- let tNodeCursor = tNode;
11674
- while (tNodeCursor) {
11675
- debugNodes.push(buildDebugNode(tNodeCursor, lView));
11676
- tNodeCursor = tNodeCursor.next;
11677
- }
11678
- return debugNodes;
11679
- }
11680
- else {
11681
- return [];
11682
- }
11683
- }
11684
- function buildDebugNode(tNode, lView) {
11685
- const rawValue = lView[tNode.index];
11686
- const native = unwrapRNode(rawValue);
11687
- const factories = [];
11688
- const instances = [];
11689
- const tView = lView[TVIEW];
11690
- for (let i = tNode.directiveStart; i < tNode.directiveEnd; i++) {
11691
- const def = tView.data[i];
11692
- factories.push(def.type);
11693
- instances.push(lView[i]);
11694
- }
11695
- return {
11696
- html: toHtml(native),
11697
- type: toTNodeTypeAsString(tNode.type),
11698
- tNode,
11699
- native: native,
11700
- children: toDebugNodes(tNode.child, lView),
11701
- factories,
11702
- instances,
11703
- injector: buildNodeInjectorDebug(tNode, tView, lView),
11704
- get injectorResolutionPath() {
11705
- return tNode.debugNodeInjectorPath(lView);
11706
- },
11707
- };
11708
- }
11709
- function buildNodeInjectorDebug(tNode, tView, lView) {
11710
- const viewProviders = [];
11711
- for (let i = tNode.providerIndexStart_; i < tNode.providerIndexEnd_; i++) {
11712
- viewProviders.push(tView.data[i]);
11713
- }
11714
- const providers = [];
11715
- for (let i = tNode.providerIndexEnd_; i < tNode.directiveEnd; i++) {
11716
- providers.push(tView.data[i]);
11717
- }
11718
- const nodeInjectorDebug = {
11719
- bloom: toBloom(lView, tNode.injectorIndex),
11720
- cumulativeBloom: toBloom(tView.data, tNode.injectorIndex),
11721
- providers,
11722
- viewProviders,
11723
- parentInjectorIndex: lView[tNode.providerIndexStart_ - 1],
11724
- };
11725
- return nodeInjectorDebug;
11726
- }
11727
- /**
11728
- * Convert a number at `idx` location in `array` into binary representation.
10807
+ * @license
10808
+ * Copyright Google LLC All Rights Reserved.
11729
10809
  *
11730
- * @param array
11731
- * @param idx
10810
+ * Use of this source code is governed by an MIT-style license that can be
10811
+ * found in the LICENSE file at https://angular.io/license
11732
10812
  */
11733
- function binary(array, idx) {
11734
- const value = array[idx];
11735
- // If not a number we print 8 `?` to retain alignment but let user know that it was called on
11736
- // wrong type.
11737
- if (typeof value !== 'number')
11738
- return '????????';
11739
- // We prefix 0s so that we have constant length number
11740
- const text = '00000000' + value.toString(2);
11741
- return text.substring(text.length - 8);
11742
- }
10813
+
11743
10814
  /**
11744
- * Convert a bloom filter at location `idx` in `array` into binary representation.
10815
+ * @license
10816
+ * Copyright Google LLC All Rights Reserved.
11745
10817
  *
11746
- * @param array
11747
- * @param idx
10818
+ * Use of this source code is governed by an MIT-style license that can be
10819
+ * found in the LICENSE file at https://angular.io/license
11748
10820
  */
11749
- function toBloom(array, idx) {
11750
- if (idx < 0) {
11751
- return 'NO_NODE_INJECTOR';
10821
+ function ɵɵdirectiveInject(token, flags = InjectFlags.Default) {
10822
+ const lView = getLView();
10823
+ // Fall back to inject() if view hasn't been created. This situation can happen in tests
10824
+ // if inject utilities are used before bootstrapping.
10825
+ if (lView === null) {
10826
+ // Verify that we will not get into infinite loop.
10827
+ ngDevMode && assertInjectImplementationNotEqual(ɵɵdirectiveInject);
10828
+ return ɵɵinject(token, flags);
11752
10829
  }
11753
- return `${binary(array, idx + 7)}_${binary(array, idx + 6)}_${binary(array, idx + 5)}_${binary(array, idx + 4)}_${binary(array, idx + 3)}_${binary(array, idx + 2)}_${binary(array, idx + 1)}_${binary(array, idx + 0)}`;
10830
+ const tNode = getCurrentTNode();
10831
+ return getOrCreateInjectable(tNode, lView, resolveForwardRef(token), flags);
11754
10832
  }
11755
- class LContainerDebug {
11756
- constructor(_raw_lContainer) {
11757
- this._raw_lContainer = _raw_lContainer;
11758
- }
11759
- get hasTransplantedViews() {
11760
- return this._raw_lContainer[HAS_TRANSPLANTED_VIEWS];
11761
- }
11762
- get views() {
11763
- return this._raw_lContainer.slice(CONTAINER_HEADER_OFFSET)
11764
- .map(toDebug);
11765
- }
11766
- get parent() {
11767
- return toDebug(this._raw_lContainer[PARENT]);
11768
- }
11769
- get movedViews() {
11770
- return this._raw_lContainer[MOVED_VIEWS];
11771
- }
11772
- get host() {
11773
- return this._raw_lContainer[HOST];
11774
- }
11775
- get native() {
11776
- return this._raw_lContainer[NATIVE];
11777
- }
11778
- get next() {
11779
- return toDebug(this._raw_lContainer[NEXT]);
11780
- }
10833
+ /**
10834
+ * Throws an error indicating that a factory function could not be generated by the compiler for a
10835
+ * particular class.
10836
+ *
10837
+ * This instruction allows the actual error message to be optimized away when ngDevMode is turned
10838
+ * off, saving bytes of generated code while still providing a good experience in dev mode.
10839
+ *
10840
+ * The name of the class is not mentioned here, but will be in the generated factory function name
10841
+ * and thus in the stack trace.
10842
+ *
10843
+ * @codeGenApi
10844
+ */
10845
+ function ɵɵinvalidFactory() {
10846
+ const msg = ngDevMode ? `This constructor was not compatible with Dependency Injection.` : 'invalid';
10847
+ throw new Error(msg);
11781
10848
  }
11782
10849
 
11783
10850
  /**
@@ -11853,7 +10920,7 @@ function renderChildComponents(hostLView, components) {
11853
10920
  }
11854
10921
  }
11855
10922
  function createLView(parentLView, tView, context, flags, host, tHostNode, rendererFactory, renderer, sanitizer, injector, embeddedViewInjector) {
11856
- const lView = ngDevMode ? cloneToLViewFromTViewBlueprint(tView) : tView.blueprint.slice();
10923
+ const lView = tView.blueprint.slice();
11857
10924
  lView[HOST] = host;
11858
10925
  lView[FLAGS] = flags | 4 /* LViewFlags.CreationMode */ | 64 /* LViewFlags.Attached */ | 8 /* LViewFlags.FirstLViewPass */;
11859
10926
  if (embeddedViewInjector !== null ||
@@ -11877,7 +10944,6 @@ function createLView(parentLView, tView, context, flags, host, tHostNode, render
11877
10944
  assertEqual(tView.type == 2 /* TViewType.Embedded */ ? parentLView !== null : true, true, 'Embedded views must have parentLView');
11878
10945
  lView[DECLARATION_COMPONENT_VIEW] =
11879
10946
  tView.type == 2 /* TViewType.Embedded */ ? parentLView[DECLARATION_COMPONENT_VIEW] : lView;
11880
- ngDevMode && attachLViewDebug(lView);
11881
10947
  return lView;
11882
10948
  }
11883
10949
  function getOrCreateTNode(tView, index, type, name, attrs) {
@@ -12260,73 +11326,38 @@ function createTView(type, declTNode, templateFn, decls, vars, directives, pipes
12260
11326
  const initialViewLength = bindingStartIndex + vars;
12261
11327
  const blueprint = createViewBlueprint(bindingStartIndex, initialViewLength);
12262
11328
  const consts = typeof constsOrFactory === 'function' ? constsOrFactory() : constsOrFactory;
12263
- const tView = blueprint[TVIEW] = ngDevMode ?
12264
- new TViewConstructor(type, // type: TViewType,
12265
- blueprint, // blueprint: LView,
12266
- templateFn, // template: ComponentTemplate<{}>|null,
12267
- null, // queries: TQueries|null
12268
- viewQuery, // viewQuery: ViewQueriesFunction<{}>|null,
12269
- declTNode, // declTNode: TNode|null,
12270
- cloneToTViewData(blueprint).fill(null, bindingStartIndex), // data: TData,
12271
- bindingStartIndex, // bindingStartIndex: number,
12272
- initialViewLength, // expandoStartIndex: number,
12273
- null, // hostBindingOpCodes: HostBindingOpCodes,
12274
- true, // firstCreatePass: boolean,
12275
- true, // firstUpdatePass: boolean,
12276
- false, // staticViewQueries: boolean,
12277
- false, // staticContentQueries: boolean,
12278
- null, // preOrderHooks: HookData|null,
12279
- null, // preOrderCheckHooks: HookData|null,
12280
- null, // contentHooks: HookData|null,
12281
- null, // contentCheckHooks: HookData|null,
12282
- null, // viewHooks: HookData|null,
12283
- null, // viewCheckHooks: HookData|null,
12284
- null, // destroyHooks: DestroyHookData|null,
12285
- null, // cleanup: any[]|null,
12286
- null, // contentQueries: number[]|null,
12287
- null, // components: number[]|null,
12288
- typeof directives === 'function' ? //
12289
- directives() : //
12290
- directives, // directiveRegistry: DirectiveDefList|null,
12291
- typeof pipes === 'function' ? pipes() : pipes, // pipeRegistry: PipeDefList|null,
12292
- null, // firstChild: TNode|null,
12293
- schemas, // schemas: SchemaMetadata[]|null,
12294
- consts, // consts: TConstants|null
12295
- false, // incompleteFirstPass: boolean
12296
- decls, // ngDevMode only: decls
12297
- vars) :
12298
- {
12299
- type: type,
12300
- blueprint: blueprint,
12301
- template: templateFn,
12302
- queries: null,
12303
- viewQuery: viewQuery,
12304
- declTNode: declTNode,
12305
- data: blueprint.slice().fill(null, bindingStartIndex),
12306
- bindingStartIndex: bindingStartIndex,
12307
- expandoStartIndex: initialViewLength,
12308
- hostBindingOpCodes: null,
12309
- firstCreatePass: true,
12310
- firstUpdatePass: true,
12311
- staticViewQueries: false,
12312
- staticContentQueries: false,
12313
- preOrderHooks: null,
12314
- preOrderCheckHooks: null,
12315
- contentHooks: null,
12316
- contentCheckHooks: null,
12317
- viewHooks: null,
12318
- viewCheckHooks: null,
12319
- destroyHooks: null,
12320
- cleanup: null,
12321
- contentQueries: null,
12322
- components: null,
12323
- directiveRegistry: typeof directives === 'function' ? directives() : directives,
12324
- pipeRegistry: typeof pipes === 'function' ? pipes() : pipes,
12325
- firstChild: null,
12326
- schemas: schemas,
12327
- consts: consts,
12328
- incompleteFirstPass: false
12329
- };
11329
+ const tView = blueprint[TVIEW] = {
11330
+ type: type,
11331
+ blueprint: blueprint,
11332
+ template: templateFn,
11333
+ queries: null,
11334
+ viewQuery: viewQuery,
11335
+ declTNode: declTNode,
11336
+ data: blueprint.slice().fill(null, bindingStartIndex),
11337
+ bindingStartIndex: bindingStartIndex,
11338
+ expandoStartIndex: initialViewLength,
11339
+ hostBindingOpCodes: null,
11340
+ firstCreatePass: true,
11341
+ firstUpdatePass: true,
11342
+ staticViewQueries: false,
11343
+ staticContentQueries: false,
11344
+ preOrderHooks: null,
11345
+ preOrderCheckHooks: null,
11346
+ contentHooks: null,
11347
+ contentCheckHooks: null,
11348
+ viewHooks: null,
11349
+ viewCheckHooks: null,
11350
+ destroyHooks: null,
11351
+ cleanup: null,
11352
+ contentQueries: null,
11353
+ components: null,
11354
+ directiveRegistry: typeof directives === 'function' ? directives() : directives,
11355
+ pipeRegistry: typeof pipes === 'function' ? pipes() : pipes,
11356
+ firstChild: null,
11357
+ schemas: schemas,
11358
+ consts: consts,
11359
+ incompleteFirstPass: false
11360
+ };
12330
11361
  if (ngDevMode) {
12331
11362
  // For performance reasons it is important that the tView retains the same shape during runtime.
12332
11363
  // (To make sure that all of the code is monomorphic.) For this reason we seal the object to
@@ -12336,7 +11367,7 @@ function createTView(type, declTNode, templateFn, decls, vars, directives, pipes
12336
11367
  return tView;
12337
11368
  }
12338
11369
  function createViewBlueprint(bindingStartIndex, initialViewLength) {
12339
- const blueprint = ngDevMode ? new LViewBlueprint() : [];
11370
+ const blueprint = [];
12340
11371
  for (let i = 0; i < initialViewLength; i++) {
12341
11372
  blueprint.push(i < bindingStartIndex ? null : NO_CHANGE);
12342
11373
  }
@@ -12389,74 +11420,40 @@ function createTNode(tView, tParent, type, index, value, attrs) {
12389
11420
  ngDevMode && ngDevMode.tNode++;
12390
11421
  ngDevMode && tParent && assertTNodeForTView(tParent, tView);
12391
11422
  let injectorIndex = tParent ? tParent.injectorIndex : -1;
12392
- const tNode = ngDevMode ?
12393
- new TNodeDebug(tView, // tView_: TView
12394
- type, // type: TNodeType
12395
- index, // index: number
12396
- null, // insertBeforeIndex: null|-1|number|number[]
12397
- injectorIndex, // injectorIndex: number
12398
- -1, // componentOffset: number
12399
- -1, // directiveStart: number
12400
- -1, // directiveEnd: number
12401
- -1, // directiveStylingLast: number
12402
- null, // propertyBindings: number[]|null
12403
- 0, // flags: TNodeFlags
12404
- 0, // providerIndexes: TNodeProviderIndexes
12405
- value, // value: string|null
12406
- attrs, // attrs: (string|AttributeMarker|(string|SelectorFlags)[])[]|null
12407
- null, // mergedAttrs
12408
- null, // localNames: (string|number)[]|null
12409
- undefined, // initialInputs: (string[]|null)[]|null|undefined
12410
- null, // inputs: PropertyAliases|null
12411
- null, // outputs: PropertyAliases|null
12412
- null, // tViews: ITView|ITView[]|null
12413
- null, // next: ITNode|null
12414
- null, // projectionNext: ITNode|null
12415
- null, // child: ITNode|null
12416
- tParent, // parent: TElementNode|TContainerNode|null
12417
- null, // projection: number|(ITNode|RNode[])[]|null
12418
- null, // styles: string|null
12419
- null, // stylesWithoutHost: string|null
12420
- undefined, // residualStyles: string|null
12421
- null, // classes: string|null
12422
- null, // classesWithoutHost: string|null
12423
- undefined, // residualClasses: string|null
12424
- 0, // classBindings: TStylingRange;
12425
- 0) :
12426
- {
12427
- type,
12428
- index,
12429
- insertBeforeIndex: null,
12430
- injectorIndex,
12431
- directiveStart: -1,
12432
- directiveEnd: -1,
12433
- directiveStylingLast: -1,
12434
- componentOffset: -1,
12435
- propertyBindings: null,
12436
- flags: 0,
12437
- providerIndexes: 0,
12438
- value: value,
12439
- attrs: attrs,
12440
- mergedAttrs: null,
12441
- localNames: null,
12442
- initialInputs: undefined,
12443
- inputs: null,
12444
- outputs: null,
12445
- tViews: null,
12446
- next: null,
12447
- projectionNext: null,
12448
- child: null,
12449
- parent: tParent,
12450
- projection: null,
12451
- styles: null,
12452
- stylesWithoutHost: null,
12453
- residualStyles: undefined,
12454
- classes: null,
12455
- classesWithoutHost: null,
12456
- residualClasses: undefined,
12457
- classBindings: 0,
12458
- styleBindings: 0,
12459
- };
11423
+ const tNode = {
11424
+ type,
11425
+ index,
11426
+ insertBeforeIndex: null,
11427
+ injectorIndex,
11428
+ directiveStart: -1,
11429
+ directiveEnd: -1,
11430
+ directiveStylingLast: -1,
11431
+ componentOffset: -1,
11432
+ propertyBindings: null,
11433
+ flags: 0,
11434
+ providerIndexes: 0,
11435
+ value: value,
11436
+ attrs: attrs,
11437
+ mergedAttrs: null,
11438
+ localNames: null,
11439
+ initialInputs: undefined,
11440
+ inputs: null,
11441
+ outputs: null,
11442
+ tViews: null,
11443
+ next: null,
11444
+ projectionNext: null,
11445
+ child: null,
11446
+ parent: tParent,
11447
+ projection: null,
11448
+ styles: null,
11449
+ stylesWithoutHost: null,
11450
+ residualStyles: undefined,
11451
+ classes: null,
11452
+ classesWithoutHost: null,
11453
+ residualClasses: undefined,
11454
+ classBindings: 0,
11455
+ styleBindings: 0,
11456
+ };
12460
11457
  if (ngDevMode) {
12461
11458
  // For performance reasons it is important that the tNode retains the same shape during runtime.
12462
11459
  // (To make sure that all of the code is monomorphic.) For this reason we seal the object to
@@ -12513,7 +11510,7 @@ function initializeInputAndOutputAliases(tView, tNode, hostDirectiveDefinitionMa
12513
11510
  const end = tNode.directiveEnd;
12514
11511
  const tViewData = tView.data;
12515
11512
  const tNodeAttrs = tNode.attrs;
12516
- const inputsFromAttrs = ngDevMode ? new TNodeInitialInputs() : [];
11513
+ const inputsFromAttrs = [];
12517
11514
  let inputsStore = null;
12518
11515
  let outputsStore = null;
12519
11516
  for (let directiveIndex = start; directiveIndex < end; directiveIndex++) {
@@ -12782,6 +11779,12 @@ function lastSelectedElementIdx(hostBindingOpCodes) {
12782
11779
  function instantiateAllDirectives(tView, lView, tNode, native) {
12783
11780
  const start = tNode.directiveStart;
12784
11781
  const end = tNode.directiveEnd;
11782
+ // The component view needs to be created before creating the node injector
11783
+ // since it is used to inject some special symbols like `ChangeDetectorRef`.
11784
+ if (isComponentHost(tNode)) {
11785
+ ngDevMode && assertTNodeType(tNode, 3 /* TNodeType.AnyRNode */);
11786
+ addComponentLogic(lView, tNode, tView.data[start + tNode.componentOffset]);
11787
+ }
12785
11788
  if (!tView.firstCreatePass) {
12786
11789
  getOrCreateNodeInjectorForNode(tNode, lView);
12787
11790
  }
@@ -12789,19 +11792,14 @@ function instantiateAllDirectives(tView, lView, tNode, native) {
12789
11792
  const initialInputs = tNode.initialInputs;
12790
11793
  for (let i = start; i < end; i++) {
12791
11794
  const def = tView.data[i];
12792
- const isComponent = isComponentDef(def);
12793
- if (isComponent) {
12794
- ngDevMode && assertTNodeType(tNode, 3 /* TNodeType.AnyRNode */);
12795
- addComponentLogic(lView, tNode, def);
12796
- }
12797
11795
  const directive = getNodeInjectable(lView, tView, i, tNode);
12798
11796
  attachPatchData(directive, lView);
12799
11797
  if (initialInputs !== null) {
12800
11798
  setInputsFromAttrs(lView, i - start, directive, def, tNode, initialInputs);
12801
11799
  }
12802
- if (isComponent) {
11800
+ if (isComponentDef(def)) {
12803
11801
  const componentView = getComponentLViewByIndex(tNode.index, lView);
12804
- componentView[CONTEXT] = directive;
11802
+ componentView[CONTEXT] = getNodeInjectable(lView, tView, i, tNode);
12805
11803
  }
12806
11804
  }
12807
11805
  }
@@ -12852,7 +11850,7 @@ function findDirectiveDefMatches(tView, tNode) {
12852
11850
  for (let i = 0; i < registry.length; i++) {
12853
11851
  const def = registry[i];
12854
11852
  if (isNodeMatchingSelectorList(tNode, def.selectors, /* isProjectionMode */ false)) {
12855
- matches || (matches = ngDevMode ? new MatchesArray() : []);
11853
+ matches || (matches = []);
12856
11854
  if (isComponentDef(def)) {
12857
11855
  if (ngDevMode) {
12858
11856
  assertTNodeType(tNode, 2 /* TNodeType.Element */, `"${tNode.value}" tags cannot be used as component hosts. ` +
@@ -12910,13 +11908,12 @@ function markAsComponentHost(tView, hostTNode, componentOffset) {
12910
11908
  ngDevMode && assertFirstCreatePass(tView);
12911
11909
  ngDevMode && assertGreaterThan(componentOffset, -1, 'componentOffset must be great than -1');
12912
11910
  hostTNode.componentOffset = componentOffset;
12913
- (tView.components || (tView.components = ngDevMode ? new TViewComponents() : []))
12914
- .push(hostTNode.index);
11911
+ (tView.components || (tView.components = [])).push(hostTNode.index);
12915
11912
  }
12916
11913
  /** Caches local names and their matching directive indices for query and template lookups. */
12917
11914
  function cacheMatchingLocalNames(tNode, localRefs, exportsMap) {
12918
11915
  if (localRefs) {
12919
- const localNames = tNode.localNames = ngDevMode ? new TNodeLocalNames() : [];
11916
+ const localNames = tNode.localNames = [];
12920
11917
  // Local names must be stored in tNode in the same order that localRefs are defined
12921
11918
  // in the template to ensure the data is loaded in the same slots as their refs
12922
11919
  // in the template (for template queries).
@@ -13099,9 +12096,6 @@ function generateInitialInputs(inputs, directiveIndex, attrs) {
13099
12096
  //////////////////////////
13100
12097
  //// ViewContainer & View
13101
12098
  //////////////////////////
13102
- // Not sure why I need to do `any` here but TS complains later.
13103
- const LContainerArray = class LContainer extends Array {
13104
- };
13105
12099
  /**
13106
12100
  * Creates a LContainer, either from a container instruction, or for a ViewContainerRef.
13107
12101
  *
@@ -13114,20 +12108,20 @@ const LContainerArray = class LContainer extends Array {
13114
12108
  */
13115
12109
  function createLContainer(hostNative, currentView, native, tNode) {
13116
12110
  ngDevMode && assertLView(currentView);
13117
- // https://jsperf.com/array-literal-vs-new-array-really
13118
- const lContainer = new (ngDevMode ? LContainerArray : Array)(hostNative, // host native
13119
- true, // Boolean `true` in this position signifies that this is an `LContainer`
13120
- false, // has transplanted views
13121
- currentView, // parent
13122
- null, // next
13123
- 0, // transplanted views to refresh count
13124
- tNode, // t_host
13125
- native, // native,
13126
- null, // view refs
13127
- null);
12111
+ const lContainer = [
12112
+ hostNative,
12113
+ true,
12114
+ false,
12115
+ currentView,
12116
+ null,
12117
+ 0,
12118
+ tNode,
12119
+ native,
12120
+ null,
12121
+ null, // moved views
12122
+ ];
13128
12123
  ngDevMode &&
13129
12124
  assertEqual(lContainer.length, CONTAINER_HEADER_OFFSET, 'Should allocate correct number of slots for LContainer header.');
13130
- ngDevMode && attachLContainerDebug(lContainer);
13131
12125
  return lContainer;
13132
12126
  }
13133
12127
  /**
@@ -13401,10 +12395,10 @@ function storePropertyBindingMetadata(tData, tNode, propertyName, bindingIndex,
13401
12395
  }
13402
12396
  function getOrCreateLViewCleanup(view) {
13403
12397
  // top level variables should not be exported for performance reasons (PERF_NOTES.md)
13404
- return view[CLEANUP] || (view[CLEANUP] = ngDevMode ? new LCleanup() : []);
12398
+ return view[CLEANUP] || (view[CLEANUP] = []);
13405
12399
  }
13406
12400
  function getOrCreateTViewCleanup(tView) {
13407
- return tView.cleanup || (tView.cleanup = ngDevMode ? new TCleanup() : []);
12401
+ return tView.cleanup || (tView.cleanup = []);
13408
12402
  }
13409
12403
  /**
13410
12404
  * There are cases where the sub component's renderer needs to be included
@@ -13570,6 +12564,11 @@ function collectNativeNodes(tView, lView, tNode, result, isProjection = false) {
13570
12564
  * found in the LICENSE file at https://angular.io/license
13571
12565
  */
13572
12566
  class ViewRef$1 {
12567
+ get rootNodes() {
12568
+ const lView = this._lView;
12569
+ const tView = lView[TVIEW];
12570
+ return collectNativeNodes(tView, lView, tView.firstChild, []);
12571
+ }
13573
12572
  constructor(
13574
12573
  /**
13575
12574
  * This represents `LView` associated with the component when ViewRef is a ChangeDetectorRef.
@@ -13595,11 +12594,6 @@ class ViewRef$1 {
13595
12594
  this._appRef = null;
13596
12595
  this._attachedToViewContainer = false;
13597
12596
  }
13598
- get rootNodes() {
13599
- const lView = this._lView;
13600
- const tView = lView[TVIEW];
13601
- return collectNativeNodes(tView, lView, tView.firstChild, []);
13602
- }
13603
12597
  get context() {
13604
12598
  return this._lView[CONTEXT];
13605
12599
  }
@@ -13921,6 +12915,12 @@ class ChainedInjector {
13921
12915
  * ComponentFactory interface implementation.
13922
12916
  */
13923
12917
  class ComponentFactory extends ComponentFactory$1 {
12918
+ get inputs() {
12919
+ return toRefArray(this.componentDef.inputs);
12920
+ }
12921
+ get outputs() {
12922
+ return toRefArray(this.componentDef.outputs);
12923
+ }
13924
12924
  /**
13925
12925
  * @param componentDef The component definition.
13926
12926
  * @param ngModule The NgModuleRef to which the factory is bound.
@@ -13935,12 +12935,6 @@ class ComponentFactory extends ComponentFactory$1 {
13935
12935
  componentDef.ngContentSelectors ? componentDef.ngContentSelectors : [];
13936
12936
  this.isBoundToModule = !!ngModule;
13937
12937
  }
13938
- get inputs() {
13939
- return toRefArray(this.componentDef.inputs);
13940
- }
13941
- get outputs() {
13942
- return toRefArray(this.componentDef.outputs);
13943
- }
13944
12938
  create(injector, projectableNodes, rootSelectorOrNode, environmentInjector) {
13945
12939
  environmentInjector = environmentInjector || this.ngModule;
13946
12940
  let realEnvironmentInjector = environmentInjector instanceof EnvironmentInjector ?
@@ -14016,17 +13010,6 @@ class ComponentFactory extends ComponentFactory$1 {
14016
13010
  return new ComponentRef(this.componentType, component, createElementRef(tElementNode, rootLView), rootLView, tElementNode);
14017
13011
  }
14018
13012
  }
14019
- const componentFactoryResolver = new ComponentFactoryResolver();
14020
- /**
14021
- * Creates a ComponentFactoryResolver and stores it on the injector. Or, if the
14022
- * ComponentFactoryResolver
14023
- * already exists, retrieves the existing ComponentFactoryResolver.
14024
- *
14025
- * @returns The ComponentFactoryResolver instance to use
14026
- */
14027
- function injectComponentFactoryResolver() {
14028
- return componentFactoryResolver;
14029
- }
14030
13013
  /**
14031
13014
  * Represents an instance of a Component created via a {@link ComponentFactory}.
14032
13015
  *
@@ -16612,6 +15595,62 @@ function ɵɵpropertyInterpolateV(propName, values, sanitizer) {
16612
15595
  return ɵɵpropertyInterpolateV;
16613
15596
  }
16614
15597
 
15598
+ /**
15599
+ * @license
15600
+ * Copyright Google LLC All Rights Reserved.
15601
+ *
15602
+ * Use of this source code is governed by an MIT-style license that can be
15603
+ * found in the LICENSE file at https://angular.io/license
15604
+ */
15605
+ function toTStylingRange(prev, next) {
15606
+ ngDevMode && assertNumberInRange(prev, 0, 32767 /* StylingRange.UNSIGNED_MASK */);
15607
+ ngDevMode && assertNumberInRange(next, 0, 32767 /* StylingRange.UNSIGNED_MASK */);
15608
+ return (prev << 17 /* StylingRange.PREV_SHIFT */ | next << 2 /* StylingRange.NEXT_SHIFT */);
15609
+ }
15610
+ function getTStylingRangePrev(tStylingRange) {
15611
+ ngDevMode && assertNumber(tStylingRange, 'expected number');
15612
+ return (tStylingRange >> 17 /* StylingRange.PREV_SHIFT */) & 32767 /* StylingRange.UNSIGNED_MASK */;
15613
+ }
15614
+ function getTStylingRangePrevDuplicate(tStylingRange) {
15615
+ ngDevMode && assertNumber(tStylingRange, 'expected number');
15616
+ return (tStylingRange & 2 /* StylingRange.PREV_DUPLICATE */) ==
15617
+ 2 /* StylingRange.PREV_DUPLICATE */;
15618
+ }
15619
+ function setTStylingRangePrev(tStylingRange, previous) {
15620
+ ngDevMode && assertNumber(tStylingRange, 'expected number');
15621
+ ngDevMode && assertNumberInRange(previous, 0, 32767 /* StylingRange.UNSIGNED_MASK */);
15622
+ return ((tStylingRange & ~4294836224 /* StylingRange.PREV_MASK */) |
15623
+ (previous << 17 /* StylingRange.PREV_SHIFT */));
15624
+ }
15625
+ function setTStylingRangePrevDuplicate(tStylingRange) {
15626
+ ngDevMode && assertNumber(tStylingRange, 'expected number');
15627
+ return (tStylingRange | 2 /* StylingRange.PREV_DUPLICATE */);
15628
+ }
15629
+ function getTStylingRangeNext(tStylingRange) {
15630
+ ngDevMode && assertNumber(tStylingRange, 'expected number');
15631
+ return (tStylingRange & 131068 /* StylingRange.NEXT_MASK */) >> 2 /* StylingRange.NEXT_SHIFT */;
15632
+ }
15633
+ function setTStylingRangeNext(tStylingRange, next) {
15634
+ ngDevMode && assertNumber(tStylingRange, 'expected number');
15635
+ ngDevMode && assertNumberInRange(next, 0, 32767 /* StylingRange.UNSIGNED_MASK */);
15636
+ return ((tStylingRange & ~131068 /* StylingRange.NEXT_MASK */) | //
15637
+ next << 2 /* StylingRange.NEXT_SHIFT */);
15638
+ }
15639
+ function getTStylingRangeNextDuplicate(tStylingRange) {
15640
+ ngDevMode && assertNumber(tStylingRange, 'expected number');
15641
+ return (tStylingRange & 1 /* StylingRange.NEXT_DUPLICATE */) ===
15642
+ 1 /* StylingRange.NEXT_DUPLICATE */;
15643
+ }
15644
+ function setTStylingRangeNextDuplicate(tStylingRange) {
15645
+ ngDevMode && assertNumber(tStylingRange, 'expected number');
15646
+ return (tStylingRange | 1 /* StylingRange.NEXT_DUPLICATE */);
15647
+ }
15648
+ function getTStylingRangeTail(tStylingRange) {
15649
+ ngDevMode && assertNumber(tStylingRange, 'expected number');
15650
+ const next = getTStylingRangeNext(tStylingRange);
15651
+ return next === 0 ? getTStylingRangePrev(tStylingRange) : next;
15652
+ }
15653
+
16615
15654
  /**
16616
15655
  * @license
16617
15656
  * Copyright Google LLC All Rights Reserved.
@@ -19664,7 +18703,7 @@ var I18nCreateOpCode;
19664
18703
  })(I18nCreateOpCode || (I18nCreateOpCode = {}));
19665
18704
  // Note: This hack is necessary so we don't erroneously get a circular dependency
19666
18705
  // failure based on types.
19667
- const unusedValueExportToPlacateAjd$2 = 1;
18706
+ const unusedValueExportToPlacateAjd = 1;
19668
18707
 
19669
18708
  /**
19670
18709
  * @license
@@ -20433,6 +19472,46 @@ function loadIcuContainerVisitor() {
20433
19472
  return icuContainerIteratorStart;
20434
19473
  }
20435
19474
 
19475
+ /**
19476
+ * @license
19477
+ * Copyright Google LLC All Rights Reserved.
19478
+ *
19479
+ * Use of this source code is governed by an MIT-style license that can be
19480
+ * found in the LICENSE file at https://angular.io/license
19481
+ */
19482
+ /**
19483
+ * Patch a `debug` property on top of the existing object.
19484
+ *
19485
+ * NOTE: always call this method with `ngDevMode && attachDebugObject(...)`
19486
+ *
19487
+ * @param obj Object to patch
19488
+ * @param debug Value to patch
19489
+ */
19490
+ function attachDebugObject(obj, debug) {
19491
+ if (ngDevMode) {
19492
+ Object.defineProperty(obj, 'debug', { value: debug, enumerable: false });
19493
+ }
19494
+ else {
19495
+ throw new Error('This method should be guarded with `ngDevMode` so that it can be tree shaken in production!');
19496
+ }
19497
+ }
19498
+ /**
19499
+ * Patch a `debug` property getter on top of the existing object.
19500
+ *
19501
+ * NOTE: always call this method with `ngDevMode && attachDebugObject(...)`
19502
+ *
19503
+ * @param obj Object to patch
19504
+ * @param debugGetter Getter returning a value to patch
19505
+ */
19506
+ function attachDebugGetter(obj, debugGetter) {
19507
+ if (ngDevMode) {
19508
+ Object.defineProperty(obj, 'debug', { get: debugGetter, enumerable: false });
19509
+ }
19510
+ else {
19511
+ throw new Error('This method should be guarded with `ngDevMode` so that it can be tree shaken in production!');
19512
+ }
19513
+ }
19514
+
20436
19515
  /**
20437
19516
  * @license
20438
19517
  * Copyright Google LLC All Rights Reserved.
@@ -22402,32 +21481,6 @@ function sortListeners(a, b) {
22402
21481
  function isDirectiveDefHack(obj) {
22403
21482
  return obj.type !== undefined && obj.template !== undefined && obj.declaredInputs !== undefined;
22404
21483
  }
22405
- /**
22406
- * Returns the attached `DebugNode` instance for an element in the DOM.
22407
- *
22408
- * @param element DOM element which is owned by an existing component's view.
22409
- */
22410
- function getDebugNode$1(element) {
22411
- if (ngDevMode && !(element instanceof Node)) {
22412
- throw new Error('Expecting instance of DOM Element');
22413
- }
22414
- const lContext = getLContext(element);
22415
- const lView = lContext ? lContext.lView : null;
22416
- if (lView === null) {
22417
- return null;
22418
- }
22419
- const nodeIndex = lContext.nodeIndex;
22420
- if (nodeIndex !== -1) {
22421
- const valueInLView = lView[nodeIndex];
22422
- // this means that value in the lView is a component with its own
22423
- // data. In this situation the TNode is not accessed at the same spot.
22424
- const tNode = isLView(valueInLView) ? valueInLView[T_HOST] : getTNode(lView[TVIEW], nodeIndex);
22425
- ngDevMode &&
22426
- assertEqual(tNode.index, nodeIndex, 'Expecting that TNode at index is same as index');
22427
- return buildDebugNode(tNode, lView);
22428
- }
22429
- return null;
22430
- }
22431
21484
  /**
22432
21485
  * Retrieve the component `LView` from component/element.
22433
21486
  *
@@ -23133,6 +22186,12 @@ function symbolIterator() {
23133
22186
  * @publicApi
23134
22187
  */
23135
22188
  class QueryList {
22189
+ /**
22190
+ * Returns `Observable` of `QueryList` notifying the subscriber of changes.
22191
+ */
22192
+ get changes() {
22193
+ return this._changes || (this._changes = new EventEmitter());
22194
+ }
23136
22195
  /**
23137
22196
  * @param emitDistinctChangesOnly Whether `QueryList.changes` should fire only when actual change
23138
22197
  * has occurred. Or if it should fire when query is recomputed. (recomputing could resolve in
@@ -23156,12 +22215,6 @@ class QueryList {
23156
22215
  if (!proto[symbol])
23157
22216
  proto[symbol] = symbolIterator;
23158
22217
  }
23159
- /**
23160
- * Returns `Observable` of `QueryList` notifying the subscriber of changes.
23161
- */
23162
- get changes() {
23163
- return this._changes || (this._changes = new EventEmitter());
23164
- }
23165
22218
  /**
23166
22219
  * Returns the QueryList entry at `index`.
23167
22220
  */
@@ -23648,29 +22701,6 @@ function createContainerRef(hostTNode, hostLView) {
23648
22701
  * Use of this source code is governed by an MIT-style license that can be
23649
22702
  * found in the LICENSE file at https://angular.io/license
23650
22703
  */
23651
- // Note: This hack is necessary so we don't erroneously get a circular dependency
23652
- // failure based on types.
23653
- const unusedValueExportToPlacateAjd$1 = 1;
23654
-
23655
- /**
23656
- * @license
23657
- * Copyright Google LLC All Rights Reserved.
23658
- *
23659
- * Use of this source code is governed by an MIT-style license that can be
23660
- * found in the LICENSE file at https://angular.io/license
23661
- */
23662
- // Note: This hack is necessary so we don't erroneously get a circular dependency
23663
- // failure based on types.
23664
- const unusedValueExportToPlacateAjd = 1;
23665
-
23666
- /**
23667
- * @license
23668
- * Copyright Google LLC All Rights Reserved.
23669
- *
23670
- * Use of this source code is governed by an MIT-style license that can be
23671
- * found in the LICENSE file at https://angular.io/license
23672
- */
23673
- const unusedValueToPlacateAjd = unusedValueExportToPlacateAjd$1 + unusedValueExportToPlacateAjd$6 + unusedValueExportToPlacateAjd$5 + unusedValueExportToPlacateAjd;
23674
22704
  class LQuery_ {
23675
22705
  constructor(queryList) {
23676
22706
  this.queryList = queryList;
@@ -24500,8 +23530,7 @@ function compileNgModuleDefs(moduleType, ngModule, allowDuplicateDeclarationsInR
24500
23530
  Object.defineProperty(moduleType, NG_INJ_DEF, {
24501
23531
  get: () => {
24502
23532
  if (ngInjectorDef === null) {
24503
- ngDevMode &&
24504
- verifySemanticsOfNgModuleDef(moduleType, allowDuplicateDeclarationsInRoot);
23533
+ ngDevMode && verifySemanticsOfNgModuleDef(moduleType, allowDuplicateDeclarationsInRoot);
24505
23534
  const meta = {
24506
23535
  name: moduleType.name,
24507
23536
  type: moduleType,
@@ -27510,6 +26539,18 @@ function optionsReducer(dst, objs) {
27510
26539
  * @publicApi
27511
26540
  */
27512
26541
  class ApplicationRef {
26542
+ /**
26543
+ * Indicates whether this instance was destroyed.
26544
+ */
26545
+ get destroyed() {
26546
+ return this._destroyed;
26547
+ }
26548
+ /**
26549
+ * The `EnvironmentInjector` used to create this application.
26550
+ */
26551
+ get injector() {
26552
+ return this._injector;
26553
+ }
27513
26554
  /** @internal */
27514
26555
  constructor(_zone, _injector, _exceptionHandler) {
27515
26556
  this._zone = _zone;
@@ -27581,18 +26622,6 @@ class ApplicationRef {
27581
26622
  this.isStable =
27582
26623
  merge$1(isCurrentlyStable, isStable.pipe(share()));
27583
26624
  }
27584
- /**
27585
- * Indicates whether this instance was destroyed.
27586
- */
27587
- get destroyed() {
27588
- return this._destroyed;
27589
- }
27590
- /**
27591
- * The `EnvironmentInjector` used to create this application.
27592
- */
27593
- get injector() {
27594
- return this._injector;
27595
- }
27596
26625
  /**
27597
26626
  * Bootstrap a component onto the element identified by its selector or, optionally, to a
27598
26627
  * specified element.
@@ -30101,5 +29130,5 @@ if (typeof ngDevMode !== 'undefined' && ngDevMode) {
30101
29130
  * Generated bundle index. Do not edit.
30102
29131
  */
30103
29132
 
30104
- export { ANALYZE_FOR_ENTRY_COMPONENTS, ANIMATION_MODULE_TYPE, APP_BOOTSTRAP_LISTENER, APP_ID, APP_INITIALIZER, ApplicationInitStatus, ApplicationModule, ApplicationRef, Attribute, COMPILER_OPTIONS, CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, ChangeDetectorRef, Compiler, CompilerFactory, Component, ComponentFactory$1 as ComponentFactory, ComponentFactoryResolver$1 as ComponentFactoryResolver, ComponentRef$1 as ComponentRef, ContentChild, ContentChildren, DEFAULT_CURRENCY_CODE, DebugElement, DebugEventListener, DebugNode, DefaultIterableDiffer, Directive, ENVIRONMENT_INITIALIZER, ElementRef, EmbeddedViewRef, EnvironmentInjector, ErrorHandler, EventEmitter, Host, HostBinding, HostListener, INJECTOR, Inject, InjectFlags, Injectable, InjectionToken, Injector, Input, IterableDiffers, KeyValueDiffers, LOCALE_ID, MissingTranslationStrategy, ModuleWithComponentFactories, NO_ERRORS_SCHEMA, NgModule, NgModuleFactory$1 as NgModuleFactory, NgModuleRef$1 as NgModuleRef, NgProbeToken, NgZone, Optional, Output, PACKAGE_ROOT_URL, PLATFORM_ID, PLATFORM_INITIALIZER, Pipe, PlatformRef, Query, QueryList, ReflectiveInjector, ReflectiveKey, Renderer2, RendererFactory2, RendererStyleFlags2, ResolvedReflectiveFactory, Sanitizer, SecurityContext, Self, SimpleChange, SkipSelf, TRANSLATIONS, TRANSLATIONS_FORMAT, TemplateRef, Testability, TestabilityRegistry, Type, VERSION, Version, ViewChild, ViewChildren, ViewContainerRef, ViewEncapsulation$1 as ViewEncapsulation, ViewRef, asNativeElements, assertPlatform, createComponent, createEnvironmentInjector, createNgModule, createNgModuleRef, createPlatform, createPlatformFactory, defineInjectable, destroyPlatform, enableProdMode, forwardRef, getDebugNode, getModuleFactory, getNgModuleById, getPlatform, importProvidersFrom, inject, isDevMode, makeEnvironmentProviders, platformCore, reflectComponentType, resolveForwardRef, setTestabilityGetter, ALLOW_MULTIPLE_PLATFORMS as ɵALLOW_MULTIPLE_PLATFORMS, APP_ID_RANDOM_PROVIDER as ɵAPP_ID_RANDOM_PROVIDER, ChangeDetectorStatus as ɵChangeDetectorStatus, ComponentFactory$1 as ɵComponentFactory, Console as ɵConsole, DEFAULT_LOCALE_ID as ɵDEFAULT_LOCALE_ID, INJECTOR_SCOPE as ɵINJECTOR_SCOPE, LContext as ɵLContext, LifecycleHooksFeature as ɵLifecycleHooksFeature, LocaleDataIndex as ɵLocaleDataIndex, NG_COMP_DEF as ɵNG_COMP_DEF, NG_DIR_DEF as ɵNG_DIR_DEF, NG_ELEMENT_ID as ɵNG_ELEMENT_ID, NG_INJ_DEF as ɵNG_INJ_DEF, NG_MOD_DEF as ɵNG_MOD_DEF, NG_PIPE_DEF as ɵNG_PIPE_DEF, NG_PROV_DEF as ɵNG_PROV_DEF, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR as ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR, NO_CHANGE as ɵNO_CHANGE, NgModuleFactory as ɵNgModuleFactory, NoopNgZone as ɵNoopNgZone, ReflectionCapabilities as ɵReflectionCapabilities, ComponentFactory as ɵRender3ComponentFactory, ComponentRef as ɵRender3ComponentRef, NgModuleRef as ɵRender3NgModuleRef, RuntimeError as ɵRuntimeError, TESTABILITY as ɵTESTABILITY, TESTABILITY_GETTER as ɵTESTABILITY_GETTER, ViewRef$1 as ɵViewRef, XSS_SECURITY_URL as ɵXSS_SECURITY_URL, _sanitizeHtml as ɵ_sanitizeHtml, _sanitizeUrl as ɵ_sanitizeUrl, allowSanitizationBypassAndThrow as ɵallowSanitizationBypassAndThrow, bypassSanitizationTrustHtml as ɵbypassSanitizationTrustHtml, bypassSanitizationTrustResourceUrl as ɵbypassSanitizationTrustResourceUrl, bypassSanitizationTrustScript as ɵbypassSanitizationTrustScript, bypassSanitizationTrustStyle as ɵbypassSanitizationTrustStyle, bypassSanitizationTrustUrl as ɵbypassSanitizationTrustUrl, clearResolutionOfComponentResourcesQueue as ɵclearResolutionOfComponentResourcesQueue, coerceToBoolean as ɵcoerceToBoolean, compileComponent as ɵcompileComponent, compileDirective as ɵcompileDirective, compileNgModule as ɵcompileNgModule, compileNgModuleDefs as ɵcompileNgModuleDefs, compileNgModuleFactory as ɵcompileNgModuleFactory, compilePipe as ɵcompilePipe, convertToBitFlags as ɵconvertToBitFlags, createInjector as ɵcreateInjector, defaultIterableDiffers as ɵdefaultIterableDiffers, defaultKeyValueDiffers as ɵdefaultKeyValueDiffers, detectChanges as ɵdetectChanges, devModeEqual as ɵdevModeEqual, findLocaleData as ɵfindLocaleData, flushModuleScopingQueueAsMuchAsPossible as ɵflushModuleScopingQueueAsMuchAsPossible, formatRuntimeError as ɵformatRuntimeError, getDebugNode as ɵgetDebugNode, getDebugNodeR2 as ɵgetDebugNodeR2, getDirectives as ɵgetDirectives, getHostElement as ɵgetHostElement, getInjectableDef as ɵgetInjectableDef, getLContext as ɵgetLContext, getLocaleCurrencyCode as ɵgetLocaleCurrencyCode, getLocalePluralCase as ɵgetLocalePluralCase, getSanitizationBypassType as ɵgetSanitizationBypassType, ɵgetUnknownElementStrictMode, ɵgetUnknownPropertyStrictMode, _global as ɵglobal, injectChangeDetectorRef as ɵinjectChangeDetectorRef, internalCreateApplication as ɵinternalCreateApplication, isBoundToModule as ɵisBoundToModule, isDefaultChangeDetectionStrategy as ɵisDefaultChangeDetectionStrategy, isEnvironmentProviders as ɵisEnvironmentProviders, isInjectable as ɵisInjectable, isListLikeIterable as ɵisListLikeIterable, isObservable as ɵisObservable, isPromise as ɵisPromise, isStandalone as ɵisStandalone, isSubscribable as ɵisSubscribable, ɵivyEnabled, makeDecorator as ɵmakeDecorator, noSideEffects as ɵnoSideEffects, patchComponentDefWithScope as ɵpatchComponentDefWithScope, publishDefaultGlobalUtils$1 as ɵpublishDefaultGlobalUtils, publishGlobalUtil as ɵpublishGlobalUtil, registerLocaleData as ɵregisterLocaleData, resetCompiledComponents as ɵresetCompiledComponents, resetJitOptions as ɵresetJitOptions, resolveComponentResources as ɵresolveComponentResources, setAllowDuplicateNgModuleIdsForTest as ɵsetAllowDuplicateNgModuleIdsForTest, setClassMetadata as ɵsetClassMetadata, setCurrentInjector as ɵsetCurrentInjector, setDocument as ɵsetDocument, setLocaleId as ɵsetLocaleId, ɵsetUnknownElementStrictMode, ɵsetUnknownPropertyStrictMode, store as ɵstore, stringify as ɵstringify, transitiveScopesFor as ɵtransitiveScopesFor, unregisterAllLocaleData as ɵunregisterLocaleData, unwrapSafeValue as ɵunwrapSafeValue, ɵɵCopyDefinitionFeature, FactoryTarget as ɵɵFactoryTarget, ɵɵHostDirectivesFeature, ɵɵInheritDefinitionFeature, ɵɵNgOnChangesFeature, ɵɵProvidersFeature, ɵɵStandaloneFeature, ɵɵadvance, ɵɵattribute, ɵɵattributeInterpolate1, ɵɵattributeInterpolate2, ɵɵattributeInterpolate3, ɵɵattributeInterpolate4, ɵɵattributeInterpolate5, ɵɵattributeInterpolate6, ɵɵattributeInterpolate7, ɵɵattributeInterpolate8, ɵɵattributeInterpolateV, ɵɵclassMap, ɵɵclassMapInterpolate1, ɵɵclassMapInterpolate2, ɵɵclassMapInterpolate3, ɵɵclassMapInterpolate4, ɵɵclassMapInterpolate5, ɵɵclassMapInterpolate6, ɵɵclassMapInterpolate7, ɵɵclassMapInterpolate8, ɵɵclassMapInterpolateV, ɵɵclassProp, ɵɵcontentQuery, ɵɵdefineComponent, ɵɵdefineDirective, ɵɵdefineInjectable, ɵɵdefineInjector, ɵɵdefineNgModule, ɵɵdefinePipe, ɵɵdirectiveInject, ɵɵdisableBindings, ɵɵelement, ɵɵelementContainer, ɵɵelementContainerEnd, ɵɵelementContainerStart, ɵɵelementEnd, ɵɵelementStart, ɵɵenableBindings, ɵɵgetCurrentView, ɵɵgetInheritedFactory, ɵɵhostProperty, ɵɵi18n, ɵɵi18nApply, ɵɵi18nAttributes, ɵɵi18nEnd, ɵɵi18nExp, ɵɵi18nPostprocess, ɵɵi18nStart, ɵɵinject, ɵɵinjectAttribute, ɵɵinvalidFactory, ɵɵinvalidFactoryDep, ɵɵlistener, ɵɵloadQuery, ɵɵnamespaceHTML, ɵɵnamespaceMathML, ɵɵnamespaceSVG, ɵɵnextContext, ɵɵngDeclareClassMetadata, ɵɵngDeclareComponent, ɵɵngDeclareDirective, ɵɵngDeclareFactory, ɵɵngDeclareInjectable, ɵɵngDeclareInjector, ɵɵngDeclareNgModule, ɵɵngDeclarePipe, ɵɵpipe, ɵɵpipeBind1, ɵɵpipeBind2, ɵɵpipeBind3, ɵɵpipeBind4, ɵɵpipeBindV, ɵɵprojection, ɵɵprojectionDef, ɵɵproperty, ɵɵpropertyInterpolate, ɵɵpropertyInterpolate1, ɵɵpropertyInterpolate2, ɵɵpropertyInterpolate3, ɵɵpropertyInterpolate4, ɵɵpropertyInterpolate5, ɵɵpropertyInterpolate6, ɵɵpropertyInterpolate7, ɵɵpropertyInterpolate8, ɵɵpropertyInterpolateV, ɵɵpureFunction0, ɵɵpureFunction1, ɵɵpureFunction2, ɵɵpureFunction3, ɵɵpureFunction4, ɵɵpureFunction5, ɵɵpureFunction6, ɵɵpureFunction7, ɵɵpureFunction8, ɵɵpureFunctionV, ɵɵqueryRefresh, ɵɵreference, registerNgModuleType as ɵɵregisterNgModuleType, ɵɵresetView, ɵɵresolveBody, ɵɵresolveDocument, ɵɵresolveWindow, ɵɵrestoreView, ɵɵsanitizeHtml, ɵɵsanitizeResourceUrl, ɵɵsanitizeScript, ɵɵsanitizeStyle, ɵɵsanitizeUrl, ɵɵsanitizeUrlOrResourceUrl, ɵɵsetComponentScope, ɵɵsetNgModuleScope, ɵɵstyleMap, ɵɵstyleMapInterpolate1, ɵɵstyleMapInterpolate2, ɵɵstyleMapInterpolate3, ɵɵstyleMapInterpolate4, ɵɵstyleMapInterpolate5, ɵɵstyleMapInterpolate6, ɵɵstyleMapInterpolate7, ɵɵstyleMapInterpolate8, ɵɵstyleMapInterpolateV, ɵɵstyleProp, ɵɵstylePropInterpolate1, ɵɵstylePropInterpolate2, ɵɵstylePropInterpolate3, ɵɵstylePropInterpolate4, ɵɵstylePropInterpolate5, ɵɵstylePropInterpolate6, ɵɵstylePropInterpolate7, ɵɵstylePropInterpolate8, ɵɵstylePropInterpolateV, ɵɵsyntheticHostListener, ɵɵsyntheticHostProperty, ɵɵtemplate, ɵɵtemplateRefExtractor, ɵɵtext, ɵɵtextInterpolate, ɵɵtextInterpolate1, ɵɵtextInterpolate2, ɵɵtextInterpolate3, ɵɵtextInterpolate4, ɵɵtextInterpolate5, ɵɵtextInterpolate6, ɵɵtextInterpolate7, ɵɵtextInterpolate8, ɵɵtextInterpolateV, ɵɵtrustConstantHtml, ɵɵtrustConstantResourceUrl, ɵɵvalidateIframeAttribute, ɵɵviewQuery };
29133
+ export { ANALYZE_FOR_ENTRY_COMPONENTS, ANIMATION_MODULE_TYPE, APP_BOOTSTRAP_LISTENER, APP_ID, APP_INITIALIZER, ApplicationInitStatus, ApplicationModule, ApplicationRef, Attribute, COMPILER_OPTIONS, CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, ChangeDetectorRef, Compiler, CompilerFactory, Component, ComponentFactory$1 as ComponentFactory, ComponentFactoryResolver$1 as ComponentFactoryResolver, ComponentRef$1 as ComponentRef, ContentChild, ContentChildren, DEFAULT_CURRENCY_CODE, DebugElement, DebugEventListener, DebugNode, DefaultIterableDiffer, Directive, ENVIRONMENT_INITIALIZER, ElementRef, EmbeddedViewRef, EnvironmentInjector, ErrorHandler, EventEmitter, Host, HostBinding, HostListener, INJECTOR, Inject, InjectFlags, Injectable, InjectionToken, Injector, Input, IterableDiffers, KeyValueDiffers, LOCALE_ID, MissingTranslationStrategy, ModuleWithComponentFactories, NO_ERRORS_SCHEMA, NgModule, NgModuleFactory$1 as NgModuleFactory, NgModuleRef$1 as NgModuleRef, NgProbeToken, NgZone, Optional, Output, PACKAGE_ROOT_URL, PLATFORM_ID, PLATFORM_INITIALIZER, Pipe, PlatformRef, Query, QueryList, ReflectiveInjector, ReflectiveKey, Renderer2, RendererFactory2, RendererStyleFlags2, ResolvedReflectiveFactory, Sanitizer, SecurityContext, Self, SimpleChange, SkipSelf, TRANSLATIONS, TRANSLATIONS_FORMAT, TemplateRef, Testability, TestabilityRegistry, Type, VERSION, Version, ViewChild, ViewChildren, ViewContainerRef, ViewEncapsulation$1 as ViewEncapsulation, ViewRef, asNativeElements, assertPlatform, createComponent, createEnvironmentInjector, createNgModule, createNgModuleRef, createPlatform, createPlatformFactory, defineInjectable, destroyPlatform, enableProdMode, forwardRef, getDebugNode, getModuleFactory, getNgModuleById, getPlatform, importProvidersFrom, inject, isDevMode, isStandalone, makeEnvironmentProviders, platformCore, reflectComponentType, resolveForwardRef, setTestabilityGetter, ALLOW_MULTIPLE_PLATFORMS as ɵALLOW_MULTIPLE_PLATFORMS, APP_ID_RANDOM_PROVIDER as ɵAPP_ID_RANDOM_PROVIDER, ChangeDetectorStatus as ɵChangeDetectorStatus, ComponentFactory$1 as ɵComponentFactory, Console as ɵConsole, DEFAULT_LOCALE_ID as ɵDEFAULT_LOCALE_ID, INJECTOR_SCOPE as ɵINJECTOR_SCOPE, LContext as ɵLContext, LifecycleHooksFeature as ɵLifecycleHooksFeature, LocaleDataIndex as ɵLocaleDataIndex, NG_COMP_DEF as ɵNG_COMP_DEF, NG_DIR_DEF as ɵNG_DIR_DEF, NG_ELEMENT_ID as ɵNG_ELEMENT_ID, NG_INJ_DEF as ɵNG_INJ_DEF, NG_MOD_DEF as ɵNG_MOD_DEF, NG_PIPE_DEF as ɵNG_PIPE_DEF, NG_PROV_DEF as ɵNG_PROV_DEF, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR as ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR, NO_CHANGE as ɵNO_CHANGE, NgModuleFactory as ɵNgModuleFactory, NoopNgZone as ɵNoopNgZone, ReflectionCapabilities as ɵReflectionCapabilities, ComponentFactory as ɵRender3ComponentFactory, ComponentRef as ɵRender3ComponentRef, NgModuleRef as ɵRender3NgModuleRef, RuntimeError as ɵRuntimeError, TESTABILITY as ɵTESTABILITY, TESTABILITY_GETTER as ɵTESTABILITY_GETTER, ViewRef$1 as ɵViewRef, XSS_SECURITY_URL as ɵXSS_SECURITY_URL, _sanitizeHtml as ɵ_sanitizeHtml, _sanitizeUrl as ɵ_sanitizeUrl, allowSanitizationBypassAndThrow as ɵallowSanitizationBypassAndThrow, bypassSanitizationTrustHtml as ɵbypassSanitizationTrustHtml, bypassSanitizationTrustResourceUrl as ɵbypassSanitizationTrustResourceUrl, bypassSanitizationTrustScript as ɵbypassSanitizationTrustScript, bypassSanitizationTrustStyle as ɵbypassSanitizationTrustStyle, bypassSanitizationTrustUrl as ɵbypassSanitizationTrustUrl, clearResolutionOfComponentResourcesQueue as ɵclearResolutionOfComponentResourcesQueue, coerceToBoolean as ɵcoerceToBoolean, compileComponent as ɵcompileComponent, compileDirective as ɵcompileDirective, compileNgModule as ɵcompileNgModule, compileNgModuleDefs as ɵcompileNgModuleDefs, compileNgModuleFactory as ɵcompileNgModuleFactory, compilePipe as ɵcompilePipe, convertToBitFlags as ɵconvertToBitFlags, createInjector as ɵcreateInjector, defaultIterableDiffers as ɵdefaultIterableDiffers, defaultKeyValueDiffers as ɵdefaultKeyValueDiffers, detectChanges as ɵdetectChanges, devModeEqual as ɵdevModeEqual, findLocaleData as ɵfindLocaleData, flushModuleScopingQueueAsMuchAsPossible as ɵflushModuleScopingQueueAsMuchAsPossible, formatRuntimeError as ɵformatRuntimeError, getDebugNode as ɵgetDebugNode, getDebugNodeR2 as ɵgetDebugNodeR2, getDirectives as ɵgetDirectives, getHostElement as ɵgetHostElement, getInjectableDef as ɵgetInjectableDef, getLContext as ɵgetLContext, getLocaleCurrencyCode as ɵgetLocaleCurrencyCode, getLocalePluralCase as ɵgetLocalePluralCase, getSanitizationBypassType as ɵgetSanitizationBypassType, ɵgetUnknownElementStrictMode, ɵgetUnknownPropertyStrictMode, _global as ɵglobal, injectChangeDetectorRef as ɵinjectChangeDetectorRef, internalCreateApplication as ɵinternalCreateApplication, isBoundToModule as ɵisBoundToModule, isDefaultChangeDetectionStrategy as ɵisDefaultChangeDetectionStrategy, isEnvironmentProviders as ɵisEnvironmentProviders, isInjectable as ɵisInjectable, isListLikeIterable as ɵisListLikeIterable, isObservable as ɵisObservable, isPromise as ɵisPromise, isSubscribable as ɵisSubscribable, ɵivyEnabled, makeDecorator as ɵmakeDecorator, noSideEffects as ɵnoSideEffects, patchComponentDefWithScope as ɵpatchComponentDefWithScope, publishDefaultGlobalUtils$1 as ɵpublishDefaultGlobalUtils, publishGlobalUtil as ɵpublishGlobalUtil, registerLocaleData as ɵregisterLocaleData, resetCompiledComponents as ɵresetCompiledComponents, resetJitOptions as ɵresetJitOptions, resolveComponentResources as ɵresolveComponentResources, setAllowDuplicateNgModuleIdsForTest as ɵsetAllowDuplicateNgModuleIdsForTest, setClassMetadata as ɵsetClassMetadata, setCurrentInjector as ɵsetCurrentInjector, setDocument as ɵsetDocument, setLocaleId as ɵsetLocaleId, ɵsetUnknownElementStrictMode, ɵsetUnknownPropertyStrictMode, store as ɵstore, stringify as ɵstringify, transitiveScopesFor as ɵtransitiveScopesFor, unregisterAllLocaleData as ɵunregisterLocaleData, unwrapSafeValue as ɵunwrapSafeValue, ɵɵCopyDefinitionFeature, FactoryTarget as ɵɵFactoryTarget, ɵɵHostDirectivesFeature, ɵɵInheritDefinitionFeature, ɵɵNgOnChangesFeature, ɵɵProvidersFeature, ɵɵStandaloneFeature, ɵɵadvance, ɵɵattribute, ɵɵattributeInterpolate1, ɵɵattributeInterpolate2, ɵɵattributeInterpolate3, ɵɵattributeInterpolate4, ɵɵattributeInterpolate5, ɵɵattributeInterpolate6, ɵɵattributeInterpolate7, ɵɵattributeInterpolate8, ɵɵattributeInterpolateV, ɵɵclassMap, ɵɵclassMapInterpolate1, ɵɵclassMapInterpolate2, ɵɵclassMapInterpolate3, ɵɵclassMapInterpolate4, ɵɵclassMapInterpolate5, ɵɵclassMapInterpolate6, ɵɵclassMapInterpolate7, ɵɵclassMapInterpolate8, ɵɵclassMapInterpolateV, ɵɵclassProp, ɵɵcontentQuery, ɵɵdefineComponent, ɵɵdefineDirective, ɵɵdefineInjectable, ɵɵdefineInjector, ɵɵdefineNgModule, ɵɵdefinePipe, ɵɵdirectiveInject, ɵɵdisableBindings, ɵɵelement, ɵɵelementContainer, ɵɵelementContainerEnd, ɵɵelementContainerStart, ɵɵelementEnd, ɵɵelementStart, ɵɵenableBindings, ɵɵgetCurrentView, ɵɵgetInheritedFactory, ɵɵhostProperty, ɵɵi18n, ɵɵi18nApply, ɵɵi18nAttributes, ɵɵi18nEnd, ɵɵi18nExp, ɵɵi18nPostprocess, ɵɵi18nStart, ɵɵinject, ɵɵinjectAttribute, ɵɵinvalidFactory, ɵɵinvalidFactoryDep, ɵɵlistener, ɵɵloadQuery, ɵɵnamespaceHTML, ɵɵnamespaceMathML, ɵɵnamespaceSVG, ɵɵnextContext, ɵɵngDeclareClassMetadata, ɵɵngDeclareComponent, ɵɵngDeclareDirective, ɵɵngDeclareFactory, ɵɵngDeclareInjectable, ɵɵngDeclareInjector, ɵɵngDeclareNgModule, ɵɵngDeclarePipe, ɵɵpipe, ɵɵpipeBind1, ɵɵpipeBind2, ɵɵpipeBind3, ɵɵpipeBind4, ɵɵpipeBindV, ɵɵprojection, ɵɵprojectionDef, ɵɵproperty, ɵɵpropertyInterpolate, ɵɵpropertyInterpolate1, ɵɵpropertyInterpolate2, ɵɵpropertyInterpolate3, ɵɵpropertyInterpolate4, ɵɵpropertyInterpolate5, ɵɵpropertyInterpolate6, ɵɵpropertyInterpolate7, ɵɵpropertyInterpolate8, ɵɵpropertyInterpolateV, ɵɵpureFunction0, ɵɵpureFunction1, ɵɵpureFunction2, ɵɵpureFunction3, ɵɵpureFunction4, ɵɵpureFunction5, ɵɵpureFunction6, ɵɵpureFunction7, ɵɵpureFunction8, ɵɵpureFunctionV, ɵɵqueryRefresh, ɵɵreference, registerNgModuleType as ɵɵregisterNgModuleType, ɵɵresetView, ɵɵresolveBody, ɵɵresolveDocument, ɵɵresolveWindow, ɵɵrestoreView, ɵɵsanitizeHtml, ɵɵsanitizeResourceUrl, ɵɵsanitizeScript, ɵɵsanitizeStyle, ɵɵsanitizeUrl, ɵɵsanitizeUrlOrResourceUrl, ɵɵsetComponentScope, ɵɵsetNgModuleScope, ɵɵstyleMap, ɵɵstyleMapInterpolate1, ɵɵstyleMapInterpolate2, ɵɵstyleMapInterpolate3, ɵɵstyleMapInterpolate4, ɵɵstyleMapInterpolate5, ɵɵstyleMapInterpolate6, ɵɵstyleMapInterpolate7, ɵɵstyleMapInterpolate8, ɵɵstyleMapInterpolateV, ɵɵstyleProp, ɵɵstylePropInterpolate1, ɵɵstylePropInterpolate2, ɵɵstylePropInterpolate3, ɵɵstylePropInterpolate4, ɵɵstylePropInterpolate5, ɵɵstylePropInterpolate6, ɵɵstylePropInterpolate7, ɵɵstylePropInterpolate8, ɵɵstylePropInterpolateV, ɵɵsyntheticHostListener, ɵɵsyntheticHostProperty, ɵɵtemplate, ɵɵtemplateRefExtractor, ɵɵtext, ɵɵtextInterpolate, ɵɵtextInterpolate1, ɵɵtextInterpolate2, ɵɵtextInterpolate3, ɵɵtextInterpolate4, ɵɵtextInterpolate5, ɵɵtextInterpolate6, ɵɵtextInterpolate7, ɵɵtextInterpolate8, ɵɵtextInterpolateV, ɵɵtrustConstantHtml, ɵɵtrustConstantResourceUrl, ɵɵvalidateIframeAttribute, ɵɵviewQuery };
30105
29134
  //# sourceMappingURL=core.mjs.map