@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/fesm2020/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;
@@ -1444,18 +1452,9 @@ const EMBEDDED_VIEW_INJECTOR = 21;
1444
1452
  * there should be no need to refer to `HEADER_OFFSET` anywhere else.
1445
1453
  */
1446
1454
  const HEADER_OFFSET = 22;
1447
- /**
1448
- * Converts `TViewType` into human readable text.
1449
- * Make sure this matches with `TViewType`
1450
- */
1451
- const TViewTypeAsString = [
1452
- 'Root',
1453
- 'Component',
1454
- 'Embedded', // 2
1455
- ];
1456
1455
  // Note: This hack is necessary so we don't erroneously get a circular dependency
1457
1456
  // failure based on types.
1458
- const unusedValueExportToPlacateAjd$8 = 1;
1457
+ const unusedValueExportToPlacateAjd$4 = 1;
1459
1458
 
1460
1459
  /**
1461
1460
  * @license
@@ -1500,7 +1499,7 @@ const MOVED_VIEWS = 9;
1500
1499
  const CONTAINER_HEADER_OFFSET = 10;
1501
1500
  // Note: This hack is necessary so we don't erroneously get a circular dependency
1502
1501
  // failure based on types.
1503
- const unusedValueExportToPlacateAjd$7 = 1;
1502
+ const unusedValueExportToPlacateAjd$3 = 1;
1504
1503
 
1505
1504
  /**
1506
1505
  * @license
@@ -1585,11 +1584,6 @@ function assertHasParent(tNode) {
1585
1584
  assertDefined(tNode, 'currentTNode should exist!');
1586
1585
  assertDefined(tNode.parent, 'currentTNode should have a parent');
1587
1586
  }
1588
- function assertDataNext(lView, index, arr) {
1589
- if (arr == null)
1590
- arr = lView;
1591
- assertEqual(arr.length, index, `index ${index} expected to be at the end of arr (length ${arr.length})`);
1592
- }
1593
1587
  function assertLContainer(value) {
1594
1588
  assertDefined(value, 'LContainer must be defined');
1595
1589
  assertEqual(isLContainer(value), true, 'Expecting LContainer');
@@ -1620,10 +1614,6 @@ function assertIndexInDeclRange(lView, index) {
1620
1614
  const tView = lView[1];
1621
1615
  assertBetween(HEADER_OFFSET, tView.bindingStartIndex, index);
1622
1616
  }
1623
- function assertIndexInVarsRange(lView, index) {
1624
- const tView = lView[1];
1625
- assertBetween(tView.bindingStartIndex, tView.expandoStartIndex, index);
1626
- }
1627
1617
  function assertIndexInExpandoRange(lView, index) {
1628
1618
  const tView = lView[1];
1629
1619
  assertBetween(tView.expandoStartIndex, lView.length, index);
@@ -1842,14 +1832,7 @@ const profiler = function (event, instance, hookOrListener) {
1842
1832
  * found in the LICENSE file at https://angular.io/license
1843
1833
  */
1844
1834
  const SVG_NAMESPACE = 'svg';
1845
- const SVG_NAMESPACE_URI = 'http://www.w3.org/2000/svg';
1846
1835
  const MATH_ML_NAMESPACE = 'math';
1847
- const MATH_ML_NAMESPACE_URI = 'http://www.w3.org/1998/MathML/';
1848
- function getNamespaceUri(namespace) {
1849
- const name = namespace.toLowerCase();
1850
- return name === SVG_NAMESPACE ? SVG_NAMESPACE_URI :
1851
- (name === MATH_ML_NAMESPACE ? MATH_ML_NAMESPACE_URI : null);
1852
- }
1853
1836
 
1854
1837
  /**
1855
1838
  * @license
@@ -1898,20 +1881,6 @@ function unwrapLView(value) {
1898
1881
  }
1899
1882
  return null;
1900
1883
  }
1901
- /**
1902
- * Returns `LContainer` or `null` if not found.
1903
- * @param value wrapped value of `RNode`, `LView`, `LContainer`
1904
- */
1905
- function unwrapLContainer(value) {
1906
- while (Array.isArray(value)) {
1907
- // This check is same as `isLContainer()` but we don't call at as we don't want to call
1908
- // `Array.isArray()` twice and give JITer more work for inlining.
1909
- if (value[TYPE] === true)
1910
- return value;
1911
- value = value[HOST];
1912
- }
1913
- return null;
1914
- }
1915
1884
  /**
1916
1885
  * Retrieves an element value from the provided `viewData`, by unwrapping
1917
1886
  * from any containers, component views, or style contexts.
@@ -2171,9 +2140,6 @@ function isCurrentTNodeParent() {
2171
2140
  function setCurrentTNodeAsNotParent() {
2172
2141
  instructionState.lFrame.isParent = false;
2173
2142
  }
2174
- function setCurrentTNodeAsParent() {
2175
- instructionState.lFrame.isParent = true;
2176
- }
2177
2143
  function getContextLView() {
2178
2144
  const contextLView = instructionState.lFrame.contextLView;
2179
2145
  ngDevMode && assertDefined(contextLView, 'contextLView must be defined.');
@@ -2896,7 +2862,7 @@ function isFactory(obj) {
2896
2862
  }
2897
2863
  // Note: This hack is necessary so we don't erroneously get a circular dependency
2898
2864
  // failure based on types.
2899
- const unusedValueExportToPlacateAjd$6 = 1;
2865
+ const unusedValueExportToPlacateAjd$2 = 1;
2900
2866
 
2901
2867
  /**
2902
2868
  * Converts `TNodeType` into human readable text.
@@ -2915,7 +2881,7 @@ function toTNodeTypeAsString(tNodeType) {
2915
2881
  }
2916
2882
  // Note: This hack is necessary so we don't erroneously get a circular dependency
2917
2883
  // failure based on types.
2918
- const unusedValueExportToPlacateAjd$5 = 1;
2884
+ const unusedValueExportToPlacateAjd$1 = 1;
2919
2885
  /**
2920
2886
  * Returns `true` if the `TNode` has a directive which has `@Input()` for `class` binding.
2921
2887
  *
@@ -4412,17 +4378,6 @@ function isType(v) {
4412
4378
  * Use of this source code is governed by an MIT-style license that can be
4413
4379
  * found in the LICENSE file at https://angular.io/license
4414
4380
  */
4415
- /**
4416
- * Equivalent to ES6 spread, add each item to an array.
4417
- *
4418
- * @param items The items to add
4419
- * @param arr The array to which you want to add the items
4420
- */
4421
- function addAllToArray(items, arr) {
4422
- for (let i = 0; i < items.length; i++) {
4423
- arr.push(items[i]);
4424
- }
4425
- }
4426
4381
  /**
4427
4382
  * Determines if the contents of two arrays is identical
4428
4383
  *
@@ -4450,25 +4405,8 @@ function arrayEquals(a, b, identityAccessor) {
4450
4405
  /**
4451
4406
  * Flattens an array.
4452
4407
  */
4453
- function flatten(list, dst) {
4454
- if (dst === undefined)
4455
- dst = list;
4456
- for (let i = 0; i < list.length; i++) {
4457
- let item = list[i];
4458
- if (Array.isArray(item)) {
4459
- // we need to inline it.
4460
- if (dst === list) {
4461
- // Our assumption that the list was already flat was wrong and
4462
- // we need to clone flat since we need to write to it.
4463
- dst = list.slice(0, i);
4464
- }
4465
- flatten(item, dst);
4466
- }
4467
- else if (dst !== list) {
4468
- dst.push(item);
4469
- }
4470
- }
4471
- return dst;
4408
+ function flatten(list) {
4409
+ return list.flat(Number.POSITIVE_INFINITY);
4472
4410
  }
4473
4411
  function deepForEach(input, fn) {
4474
4412
  input.forEach(value => Array.isArray(value) ? deepForEach(value, fn) : fn(value));
@@ -4578,46 +4516,6 @@ function arrayInsert2(array, index, value1, value2) {
4578
4516
  array[index + 1] = value2;
4579
4517
  }
4580
4518
  }
4581
- /**
4582
- * Insert a `value` into an `array` so that the array remains sorted.
4583
- *
4584
- * NOTE:
4585
- * - Duplicates are not allowed, and are ignored.
4586
- * - This uses binary search algorithm for fast inserts.
4587
- *
4588
- * @param array A sorted array to insert into.
4589
- * @param value The value to insert.
4590
- * @returns index of the inserted value.
4591
- */
4592
- function arrayInsertSorted(array, value) {
4593
- let index = arrayIndexOfSorted(array, value);
4594
- if (index < 0) {
4595
- // if we did not find it insert it.
4596
- index = ~index;
4597
- arrayInsert(array, index, value);
4598
- }
4599
- return index;
4600
- }
4601
- /**
4602
- * Remove `value` from a sorted `array`.
4603
- *
4604
- * NOTE:
4605
- * - This uses binary search algorithm for fast removals.
4606
- *
4607
- * @param array A sorted array to remove from.
4608
- * @param value The value to remove.
4609
- * @returns index of the removed value.
4610
- * - positive index if value found and removed.
4611
- * - negative index if value not found. (`~index` to get the value where it should have been
4612
- * inserted)
4613
- */
4614
- function arrayRemoveSorted(array, value) {
4615
- const index = arrayIndexOfSorted(array, value);
4616
- if (index >= 0) {
4617
- arraySplice(array, index, 1);
4618
- }
4619
- return index;
4620
- }
4621
4519
  /**
4622
4520
  * Get an index of an `value` in a sorted `array`.
4623
4521
  *
@@ -5710,6 +5608,10 @@ function unregisterLView(lView) {
5710
5608
  * of the context.
5711
5609
  */
5712
5610
  class LContext {
5611
+ /** Component's parent view data. */
5612
+ get lView() {
5613
+ return getLViewById(this.lViewId);
5614
+ }
5713
5615
  constructor(
5714
5616
  /**
5715
5617
  * ID of the component's parent view data.
@@ -5727,10 +5629,6 @@ class LContext {
5727
5629
  this.nodeIndex = nodeIndex;
5728
5630
  this.native = native;
5729
5631
  }
5730
- /** Component's parent view data. */
5731
- get lView() {
5732
- return getLViewById(this.lViewId);
5733
- }
5734
5632
  }
5735
5633
 
5736
5634
  /**
@@ -6069,28 +5967,6 @@ function ensureIcuContainerVisitorLoaded(loader) {
6069
5967
  }
6070
5968
  }
6071
5969
 
6072
- /**
6073
- * @license
6074
- * Copyright Google LLC All Rights Reserved.
6075
- *
6076
- * Use of this source code is governed by an MIT-style license that can be
6077
- * found in the LICENSE file at https://angular.io/license
6078
- */
6079
- // Note: This hack is necessary so we don't erroneously get a circular dependency
6080
- // failure based on types.
6081
- const unusedValueExportToPlacateAjd$4 = 1;
6082
-
6083
- /**
6084
- * @license
6085
- * Copyright Google LLC All Rights Reserved.
6086
- *
6087
- * Use of this source code is governed by an MIT-style license that can be
6088
- * found in the LICENSE file at https://angular.io/license
6089
- */
6090
- // Note: This hack is necessary so we don't erroneously get a circular dependency
6091
- // failure based on types.
6092
- const unusedValueExportToPlacateAjd$3 = 1;
6093
-
6094
5970
  /**
6095
5971
  * @license
6096
5972
  * Copyright Google LLC All Rights Reserved.
@@ -6162,7 +6038,6 @@ function getNearestLContainer(viewOrContainer) {
6162
6038
  * Use of this source code is governed by an MIT-style license that can be
6163
6039
  * found in the LICENSE file at https://angular.io/license
6164
6040
  */
6165
- const unusedValueToPlacateAjd$2 = unusedValueExportToPlacateAjd$7 + unusedValueExportToPlacateAjd$5 + unusedValueExportToPlacateAjd$4 + unusedValueExportToPlacateAjd$3 + unusedValueExportToPlacateAjd$8;
6166
6041
  /**
6167
6042
  * NOTE: for performance reasons, the possible actions are inlined within the function instead of
6168
6043
  * being passed as an argument.
@@ -8556,6 +8431,12 @@ function getNullInjector() {
8556
8431
  class EnvironmentInjector {
8557
8432
  }
8558
8433
  class R3Injector extends EnvironmentInjector {
8434
+ /**
8435
+ * Flag indicating that this injector was previously destroyed.
8436
+ */
8437
+ get destroyed() {
8438
+ return this._destroyed;
8439
+ }
8559
8440
  constructor(providers, parent, source, scopes) {
8560
8441
  super();
8561
8442
  this.parent = parent;
@@ -8590,12 +8471,6 @@ class R3Injector extends EnvironmentInjector {
8590
8471
  this.injectorDefTypes =
8591
8472
  new Set(this.get(INJECTOR_DEF_TYPES.multi, EMPTY_ARRAY, InjectFlags.Self));
8592
8473
  }
8593
- /**
8594
- * Flag indicating that this injector was previously destroyed.
8595
- */
8596
- get destroyed() {
8597
- return this._destroyed;
8598
- }
8599
8474
  /**
8600
8475
  * Destroy the injector and release references to every instance or provider associated with it.
8601
8476
  *
@@ -9055,7 +8930,6 @@ function unwrapElementRef(value) {
9055
8930
  * Use of this source code is governed by an MIT-style license that can be
9056
8931
  * found in the LICENSE file at https://angular.io/license
9057
8932
  */
9058
- const Renderer2Interceptor = new InjectionToken('Renderer2Interceptor');
9059
8933
  /**
9060
8934
  * Creates and initializes a custom renderer that implements the `Renderer2` base class.
9061
8935
  *
@@ -9139,7 +9013,7 @@ class Version {
9139
9013
  /**
9140
9014
  * @publicApi
9141
9015
  */
9142
- const VERSION = new Version('15.1.0-next.0');
9016
+ const VERSION = new Version('15.1.0-next.2');
9143
9017
 
9144
9018
  /**
9145
9019
  * @license
@@ -9460,7 +9334,6 @@ function classIndexOf(className, classToSearch, startingIndex) {
9460
9334
  * Use of this source code is governed by an MIT-style license that can be
9461
9335
  * found in the LICENSE file at https://angular.io/license
9462
9336
  */
9463
- const unusedValueToPlacateAjd$1 = unusedValueExportToPlacateAjd$5 + unusedValueExportToPlacateAjd$4;
9464
9337
  const NG_TEMPLATE_SELECTOR = 'ng-template';
9465
9338
  /**
9466
9339
  * Search the `TAttributes` to see if it contains `cssClassToMatch` (case insensitive)
@@ -10944,853 +10817,47 @@ function _mapProviders(injector, fn) {
10944
10817
  */
10945
10818
 
10946
10819
  /**
10947
- * @license
10948
- * Copyright Google LLC All Rights Reserved.
10949
- *
10950
- * Use of this source code is governed by an MIT-style license that can be
10951
- * found in the LICENSE file at https://angular.io/license
10952
- */
10953
-
10954
- /**
10955
- * @license
10956
- * Copyright Google LLC All Rights Reserved.
10957
- *
10958
- * Use of this source code is governed by an MIT-style license that can be
10959
- * found in the LICENSE file at https://angular.io/license
10960
- */
10961
- function ɵɵdirectiveInject(token, flags = InjectFlags.Default) {
10962
- const lView = getLView();
10963
- // Fall back to inject() if view hasn't been created. This situation can happen in tests
10964
- // if inject utilities are used before bootstrapping.
10965
- if (lView === null) {
10966
- // Verify that we will not get into infinite loop.
10967
- ngDevMode && assertInjectImplementationNotEqual(ɵɵdirectiveInject);
10968
- return ɵɵinject(token, flags);
10969
- }
10970
- const tNode = getCurrentTNode();
10971
- return getOrCreateInjectable(tNode, lView, resolveForwardRef(token), flags);
10972
- }
10973
- /**
10974
- * Throws an error indicating that a factory function could not be generated by the compiler for a
10975
- * particular class.
10976
- *
10977
- * This instruction allows the actual error message to be optimized away when ngDevMode is turned
10978
- * off, saving bytes of generated code while still providing a good experience in dev mode.
10979
- *
10980
- * The name of the class is not mentioned here, but will be in the generated factory function name
10981
- * and thus in the stack trace.
10982
- *
10983
- * @codeGenApi
10984
- */
10985
- function ɵɵinvalidFactory() {
10986
- const msg = ngDevMode ? `This constructor was not compatible with Dependency Injection.` : 'invalid';
10987
- throw new Error(msg);
10988
- }
10989
-
10990
- /**
10991
- * @license
10992
- * Copyright Google LLC All Rights Reserved.
10993
- *
10994
- * Use of this source code is governed by an MIT-style license that can be
10995
- * found in the LICENSE file at https://angular.io/license
10996
- */
10997
- /**
10998
- * THIS FILE CONTAINS CODE WHICH SHOULD BE TREE SHAKEN AND NEVER CALLED FROM PRODUCTION CODE!!!
10999
- */
11000
- /**
11001
- * Creates an `Array` construction with a given name. This is useful when
11002
- * looking for memory consumption to see what time of array it is.
11003
- *
11004
- *
11005
- * @param name Name to give to the constructor
11006
- * @returns A subclass of `Array` if possible. This can only be done in
11007
- * environments which support `class` construct.
11008
- */
11009
- function createNamedArrayType(name) {
11010
- // This should never be called in prod mode, so let's verify that is the case.
11011
- if (ngDevMode) {
11012
- try {
11013
- // If this function were compromised the following could lead to arbitrary
11014
- // script execution. We bless it with Trusted Types anyway since this
11015
- // function is stripped out of production binaries.
11016
- return (newTrustedFunctionForDev('Array', `return class ${name} extends Array{}`))(Array);
11017
- }
11018
- catch (e) {
11019
- // If it does not work just give up and fall back to regular Array.
11020
- return Array;
11021
- }
11022
- }
11023
- else {
11024
- throw new Error('Looks like we are in \'prod mode\', but we are creating a named Array type, which is wrong! Check your code');
11025
- }
11026
- }
11027
-
11028
- /**
11029
- * @license
11030
- * Copyright Google LLC All Rights Reserved.
11031
- *
11032
- * Use of this source code is governed by an MIT-style license that can be
11033
- * found in the LICENSE file at https://angular.io/license
11034
- */
11035
- function toTStylingRange(prev, next) {
11036
- ngDevMode && assertNumberInRange(prev, 0, 32767 /* StylingRange.UNSIGNED_MASK */);
11037
- ngDevMode && assertNumberInRange(next, 0, 32767 /* StylingRange.UNSIGNED_MASK */);
11038
- return (prev << 17 /* StylingRange.PREV_SHIFT */ | next << 2 /* StylingRange.NEXT_SHIFT */);
11039
- }
11040
- function getTStylingRangePrev(tStylingRange) {
11041
- ngDevMode && assertNumber(tStylingRange, 'expected number');
11042
- return (tStylingRange >> 17 /* StylingRange.PREV_SHIFT */) & 32767 /* StylingRange.UNSIGNED_MASK */;
11043
- }
11044
- function getTStylingRangePrevDuplicate(tStylingRange) {
11045
- ngDevMode && assertNumber(tStylingRange, 'expected number');
11046
- return (tStylingRange & 2 /* StylingRange.PREV_DUPLICATE */) ==
11047
- 2 /* StylingRange.PREV_DUPLICATE */;
11048
- }
11049
- function setTStylingRangePrev(tStylingRange, previous) {
11050
- ngDevMode && assertNumber(tStylingRange, 'expected number');
11051
- ngDevMode && assertNumberInRange(previous, 0, 32767 /* StylingRange.UNSIGNED_MASK */);
11052
- return ((tStylingRange & ~4294836224 /* StylingRange.PREV_MASK */) |
11053
- (previous << 17 /* StylingRange.PREV_SHIFT */));
11054
- }
11055
- function setTStylingRangePrevDuplicate(tStylingRange) {
11056
- ngDevMode && assertNumber(tStylingRange, 'expected number');
11057
- return (tStylingRange | 2 /* StylingRange.PREV_DUPLICATE */);
11058
- }
11059
- function getTStylingRangeNext(tStylingRange) {
11060
- ngDevMode && assertNumber(tStylingRange, 'expected number');
11061
- return (tStylingRange & 131068 /* StylingRange.NEXT_MASK */) >> 2 /* StylingRange.NEXT_SHIFT */;
11062
- }
11063
- function setTStylingRangeNext(tStylingRange, next) {
11064
- ngDevMode && assertNumber(tStylingRange, 'expected number');
11065
- ngDevMode && assertNumberInRange(next, 0, 32767 /* StylingRange.UNSIGNED_MASK */);
11066
- return ((tStylingRange & ~131068 /* StylingRange.NEXT_MASK */) | //
11067
- next << 2 /* StylingRange.NEXT_SHIFT */);
11068
- }
11069
- function getTStylingRangeNextDuplicate(tStylingRange) {
11070
- ngDevMode && assertNumber(tStylingRange, 'expected number');
11071
- return (tStylingRange & 1 /* StylingRange.NEXT_DUPLICATE */) ===
11072
- 1 /* StylingRange.NEXT_DUPLICATE */;
11073
- }
11074
- function setTStylingRangeNextDuplicate(tStylingRange) {
11075
- ngDevMode && assertNumber(tStylingRange, 'expected number');
11076
- return (tStylingRange | 1 /* StylingRange.NEXT_DUPLICATE */);
11077
- }
11078
- function getTStylingRangeTail(tStylingRange) {
11079
- ngDevMode && assertNumber(tStylingRange, 'expected number');
11080
- const next = getTStylingRangeNext(tStylingRange);
11081
- return next === 0 ? getTStylingRangePrev(tStylingRange) : next;
11082
- }
11083
-
11084
- /**
11085
- * @license
11086
- * Copyright Google LLC All Rights Reserved.
11087
- *
11088
- * Use of this source code is governed by an MIT-style license that can be
11089
- * found in the LICENSE file at https://angular.io/license
11090
- */
11091
- /**
11092
- * Patch a `debug` property on top of the existing object.
11093
- *
11094
- * NOTE: always call this method with `ngDevMode && attachDebugObject(...)`
11095
- *
11096
- * @param obj Object to patch
11097
- * @param debug Value to patch
11098
- */
11099
- function attachDebugObject(obj, debug) {
11100
- if (ngDevMode) {
11101
- Object.defineProperty(obj, 'debug', { value: debug, enumerable: false });
11102
- }
11103
- else {
11104
- throw new Error('This method should be guarded with `ngDevMode` so that it can be tree shaken in production!');
11105
- }
11106
- }
11107
- /**
11108
- * Patch a `debug` property getter on top of the existing object.
11109
- *
11110
- * NOTE: always call this method with `ngDevMode && attachDebugObject(...)`
11111
- *
11112
- * @param obj Object to patch
11113
- * @param debugGetter Getter returning a value to patch
11114
- */
11115
- function attachDebugGetter(obj, debugGetter) {
11116
- if (ngDevMode) {
11117
- Object.defineProperty(obj, 'debug', { get: debugGetter, enumerable: false });
11118
- }
11119
- else {
11120
- throw new Error('This method should be guarded with `ngDevMode` so that it can be tree shaken in production!');
11121
- }
11122
- }
11123
-
11124
- /**
11125
- * @license
11126
- * Copyright Google LLC All Rights Reserved.
11127
- *
11128
- * Use of this source code is governed by an MIT-style license that can be
11129
- * found in the LICENSE file at https://angular.io/license
11130
- */
11131
- /*
11132
- * This file contains conditionally attached classes which provide human readable (debug) level
11133
- * information for `LView`, `LContainer` and other internal data structures. These data structures
11134
- * are stored internally as array which makes it very difficult during debugging to reason about the
11135
- * current state of the system.
11136
- *
11137
- * Patching the array with extra property does change the array's hidden class' but it does not
11138
- * change the cost of access, therefore this patching should not have significant if any impact in
11139
- * `ngDevMode` mode. (see: https://jsperf.com/array-vs-monkey-patch-array)
11140
- *
11141
- * So instead of seeing:
11142
- * ```
11143
- * Array(30) [Object, 659, null, …]
11144
- * ```
11145
- *
11146
- * You get to see:
11147
- * ```
11148
- * LViewDebug {
11149
- * views: [...],
11150
- * flags: {attached: true, ...}
11151
- * nodes: [
11152
- * {html: '<div id="123">', ..., nodes: [
11153
- * {html: '<span>', ..., nodes: null}
11154
- * ]}
11155
- * ]
11156
- * }
11157
- * ```
11158
- */
11159
- let LVIEW_COMPONENT_CACHE;
11160
- let LVIEW_EMBEDDED_CACHE;
11161
- let LVIEW_ROOT;
11162
- let LVIEW_COMPONENT;
11163
- let LVIEW_EMBEDDED;
11164
- /**
11165
- * This function clones a blueprint and creates LView.
11166
- *
11167
- * Simple slice will keep the same type, and we need it to be LView
11168
- */
11169
- function cloneToLViewFromTViewBlueprint(tView) {
11170
- const debugTView = tView;
11171
- const lView = getLViewToClone(debugTView.type, tView.template && tView.template.name);
11172
- return lView.concat(tView.blueprint);
11173
- }
11174
- class LRootView extends Array {
11175
- }
11176
- class LComponentView extends Array {
11177
- }
11178
- class LEmbeddedView extends Array {
11179
- }
11180
- function getLViewToClone(type, name) {
11181
- switch (type) {
11182
- case 0 /* TViewType.Root */:
11183
- if (LVIEW_ROOT === undefined)
11184
- LVIEW_ROOT = new LRootView();
11185
- return LVIEW_ROOT;
11186
- case 1 /* TViewType.Component */:
11187
- if (!ngDevMode || !ngDevMode.namedConstructors) {
11188
- if (LVIEW_COMPONENT === undefined)
11189
- LVIEW_COMPONENT = new LComponentView();
11190
- return LVIEW_COMPONENT;
11191
- }
11192
- if (LVIEW_COMPONENT_CACHE === undefined)
11193
- LVIEW_COMPONENT_CACHE = new Map();
11194
- let componentArray = LVIEW_COMPONENT_CACHE.get(name);
11195
- if (componentArray === undefined) {
11196
- componentArray = new (createNamedArrayType('LComponentView' + nameSuffix(name)))();
11197
- LVIEW_COMPONENT_CACHE.set(name, componentArray);
11198
- }
11199
- return componentArray;
11200
- case 2 /* TViewType.Embedded */:
11201
- if (!ngDevMode || !ngDevMode.namedConstructors) {
11202
- if (LVIEW_EMBEDDED === undefined)
11203
- LVIEW_EMBEDDED = new LEmbeddedView();
11204
- return LVIEW_EMBEDDED;
11205
- }
11206
- if (LVIEW_EMBEDDED_CACHE === undefined)
11207
- LVIEW_EMBEDDED_CACHE = new Map();
11208
- let embeddedArray = LVIEW_EMBEDDED_CACHE.get(name);
11209
- if (embeddedArray === undefined) {
11210
- embeddedArray = new (createNamedArrayType('LEmbeddedView' + nameSuffix(name)))();
11211
- LVIEW_EMBEDDED_CACHE.set(name, embeddedArray);
11212
- }
11213
- return embeddedArray;
11214
- }
11215
- }
11216
- function nameSuffix(text) {
11217
- if (text == null)
11218
- return '';
11219
- const index = text.lastIndexOf('_Template');
11220
- return '_' + (index === -1 ? text : text.slice(0, index));
11221
- }
11222
- /**
11223
- * This class is a debug version of Object literal so that we can have constructor name show up
11224
- * in
11225
- * debug tools in ngDevMode.
11226
- */
11227
- const TViewConstructor = class TView {
11228
- 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) {
11229
- this.type = type;
11230
- this.blueprint = blueprint;
11231
- this.template = template;
11232
- this.queries = queries;
11233
- this.viewQuery = viewQuery;
11234
- this.declTNode = declTNode;
11235
- this.data = data;
11236
- this.bindingStartIndex = bindingStartIndex;
11237
- this.expandoStartIndex = expandoStartIndex;
11238
- this.hostBindingOpCodes = hostBindingOpCodes;
11239
- this.firstCreatePass = firstCreatePass;
11240
- this.firstUpdatePass = firstUpdatePass;
11241
- this.staticViewQueries = staticViewQueries;
11242
- this.staticContentQueries = staticContentQueries;
11243
- this.preOrderHooks = preOrderHooks;
11244
- this.preOrderCheckHooks = preOrderCheckHooks;
11245
- this.contentHooks = contentHooks;
11246
- this.contentCheckHooks = contentCheckHooks;
11247
- this.viewHooks = viewHooks;
11248
- this.viewCheckHooks = viewCheckHooks;
11249
- this.destroyHooks = destroyHooks;
11250
- this.cleanup = cleanup;
11251
- this.contentQueries = contentQueries;
11252
- this.components = components;
11253
- this.directiveRegistry = directiveRegistry;
11254
- this.pipeRegistry = pipeRegistry;
11255
- this.firstChild = firstChild;
11256
- this.schemas = schemas;
11257
- this.consts = consts;
11258
- this.incompleteFirstPass = incompleteFirstPass;
11259
- this._decls = _decls;
11260
- this._vars = _vars;
11261
- }
11262
- get template_() {
11263
- const buf = [];
11264
- processTNodeChildren(this.firstChild, buf);
11265
- return buf.join('');
11266
- }
11267
- get type_() {
11268
- return TViewTypeAsString[this.type] || `TViewType.?${this.type}?`;
11269
- }
11270
- };
11271
- class TNode {
11272
- constructor(tView_, //
11273
- type, //
11274
- index, //
11275
- insertBeforeIndex, //
11276
- injectorIndex, //
11277
- componentOffset, //
11278
- directiveStart, //
11279
- directiveEnd, //
11280
- directiveStylingLast, //
11281
- propertyBindings, //
11282
- flags, //
11283
- providerIndexes, //
11284
- value, //
11285
- attrs, //
11286
- mergedAttrs, //
11287
- localNames, //
11288
- initialInputs, //
11289
- inputs, //
11290
- outputs, //
11291
- tViews, //
11292
- next, //
11293
- projectionNext, //
11294
- child, //
11295
- parent, //
11296
- projection, //
11297
- styles, //
11298
- stylesWithoutHost, //
11299
- residualStyles, //
11300
- classes, //
11301
- classesWithoutHost, //
11302
- residualClasses, //
11303
- classBindings, //
11304
- styleBindings) {
11305
- this.tView_ = tView_;
11306
- this.type = type;
11307
- this.index = index;
11308
- this.insertBeforeIndex = insertBeforeIndex;
11309
- this.injectorIndex = injectorIndex;
11310
- this.componentOffset = componentOffset;
11311
- this.directiveStart = directiveStart;
11312
- this.directiveEnd = directiveEnd;
11313
- this.directiveStylingLast = directiveStylingLast;
11314
- this.propertyBindings = propertyBindings;
11315
- this.flags = flags;
11316
- this.providerIndexes = providerIndexes;
11317
- this.value = value;
11318
- this.attrs = attrs;
11319
- this.mergedAttrs = mergedAttrs;
11320
- this.localNames = localNames;
11321
- this.initialInputs = initialInputs;
11322
- this.inputs = inputs;
11323
- this.outputs = outputs;
11324
- this.tViews = tViews;
11325
- this.next = next;
11326
- this.projectionNext = projectionNext;
11327
- this.child = child;
11328
- this.parent = parent;
11329
- this.projection = projection;
11330
- this.styles = styles;
11331
- this.stylesWithoutHost = stylesWithoutHost;
11332
- this.residualStyles = residualStyles;
11333
- this.classes = classes;
11334
- this.classesWithoutHost = classesWithoutHost;
11335
- this.residualClasses = residualClasses;
11336
- this.classBindings = classBindings;
11337
- this.styleBindings = styleBindings;
11338
- }
11339
- /**
11340
- * Return a human debug version of the set of `NodeInjector`s which will be consulted when
11341
- * resolving tokens from this `TNode`.
11342
- *
11343
- * When debugging applications, it is often difficult to determine which `NodeInjector`s will be
11344
- * consulted. This method shows a list of `DebugNode`s representing the `TNode`s which will be
11345
- * consulted in order when resolving a token starting at this `TNode`.
11346
- *
11347
- * The original data is stored in `LView` and `TView` with a lot of offset indexes, and so it is
11348
- * difficult to reason about.
11349
- *
11350
- * @param lView The `LView` instance for this `TNode`.
11351
- */
11352
- debugNodeInjectorPath(lView) {
11353
- const path = [];
11354
- let injectorIndex = getInjectorIndex(this, lView);
11355
- if (injectorIndex === -1) {
11356
- // Looks like the current `TNode` does not have `NodeInjector` associated with it => look for
11357
- // parent NodeInjector.
11358
- const parentLocation = getParentInjectorLocation(this, lView);
11359
- if (parentLocation !== NO_PARENT_INJECTOR) {
11360
- // We found a parent, so start searching from the parent location.
11361
- injectorIndex = getParentInjectorIndex(parentLocation);
11362
- lView = getParentInjectorView(parentLocation, lView);
11363
- }
11364
- else {
11365
- // No parents have been found, so there are no `NodeInjector`s to consult.
11366
- }
11367
- }
11368
- while (injectorIndex !== -1) {
11369
- ngDevMode && assertNodeInjector(lView, injectorIndex);
11370
- const tNode = lView[TVIEW].data[injectorIndex + 8 /* NodeInjectorOffset.TNODE */];
11371
- path.push(buildDebugNode(tNode, lView));
11372
- const parentLocation = lView[injectorIndex + 8 /* NodeInjectorOffset.PARENT */];
11373
- if (parentLocation === NO_PARENT_INJECTOR) {
11374
- injectorIndex = -1;
11375
- }
11376
- else {
11377
- injectorIndex = getParentInjectorIndex(parentLocation);
11378
- lView = getParentInjectorView(parentLocation, lView);
11379
- }
11380
- }
11381
- return path;
11382
- }
11383
- get type_() {
11384
- return toTNodeTypeAsString(this.type) || `TNodeType.?${this.type}?`;
11385
- }
11386
- get flags_() {
11387
- const flags = [];
11388
- if (this.flags & 8 /* TNodeFlags.hasClassInput */)
11389
- flags.push('TNodeFlags.hasClassInput');
11390
- if (this.flags & 4 /* TNodeFlags.hasContentQuery */)
11391
- flags.push('TNodeFlags.hasContentQuery');
11392
- if (this.flags & 16 /* TNodeFlags.hasStyleInput */)
11393
- flags.push('TNodeFlags.hasStyleInput');
11394
- if (this.flags & 64 /* TNodeFlags.hasHostBindings */)
11395
- flags.push('TNodeFlags.hasHostBindings');
11396
- if (this.flags & 1 /* TNodeFlags.isDirectiveHost */)
11397
- flags.push('TNodeFlags.isDirectiveHost');
11398
- if (this.flags & 32 /* TNodeFlags.isDetached */)
11399
- flags.push('TNodeFlags.isDetached');
11400
- if (this.flags & 2 /* TNodeFlags.isProjected */)
11401
- flags.push('TNodeFlags.isProjected');
11402
- return flags.join('|');
11403
- }
11404
- get template_() {
11405
- if (this.type & 1 /* TNodeType.Text */)
11406
- return this.value;
11407
- const buf = [];
11408
- const tagName = typeof this.value === 'string' && this.value || this.type_;
11409
- buf.push('<', tagName);
11410
- if (this.flags) {
11411
- buf.push(' ', this.flags_);
11412
- }
11413
- if (this.attrs) {
11414
- for (let i = 0; i < this.attrs.length;) {
11415
- const attrName = this.attrs[i++];
11416
- if (typeof attrName == 'number') {
11417
- break;
11418
- }
11419
- const attrValue = this.attrs[i++];
11420
- buf.push(' ', attrName, '="', attrValue, '"');
11421
- }
11422
- }
11423
- buf.push('>');
11424
- processTNodeChildren(this.child, buf);
11425
- buf.push('</', tagName, '>');
11426
- return buf.join('');
11427
- }
11428
- get styleBindings_() {
11429
- return toDebugStyleBinding(this, false);
11430
- }
11431
- get classBindings_() {
11432
- return toDebugStyleBinding(this, true);
11433
- }
11434
- get providerIndexStart_() {
11435
- return this.providerIndexes & 1048575 /* TNodeProviderIndexes.ProvidersStartIndexMask */;
11436
- }
11437
- get providerIndexEnd_() {
11438
- return this.providerIndexStart_ +
11439
- (this.providerIndexes >>> 20 /* TNodeProviderIndexes.CptViewProvidersCountShift */);
11440
- }
11441
- }
11442
- const TNodeDebug = TNode;
11443
- function toDebugStyleBinding(tNode, isClassBased) {
11444
- const tData = tNode.tView_.data;
11445
- const bindings = [];
11446
- const range = isClassBased ? tNode.classBindings : tNode.styleBindings;
11447
- const prev = getTStylingRangePrev(range);
11448
- const next = getTStylingRangeNext(range);
11449
- let isTemplate = next !== 0;
11450
- let cursor = isTemplate ? next : prev;
11451
- while (cursor !== 0) {
11452
- const itemKey = tData[cursor];
11453
- const itemRange = tData[cursor + 1];
11454
- bindings.unshift({
11455
- key: itemKey,
11456
- index: cursor,
11457
- isTemplate: isTemplate,
11458
- prevDuplicate: getTStylingRangePrevDuplicate(itemRange),
11459
- nextDuplicate: getTStylingRangeNextDuplicate(itemRange),
11460
- nextIndex: getTStylingRangeNext(itemRange),
11461
- prevIndex: getTStylingRangePrev(itemRange),
11462
- });
11463
- if (cursor === prev)
11464
- isTemplate = false;
11465
- cursor = getTStylingRangePrev(itemRange);
11466
- }
11467
- bindings.push((isClassBased ? tNode.residualClasses : tNode.residualStyles) || null);
11468
- return bindings;
11469
- }
11470
- function processTNodeChildren(tNode, buf) {
11471
- while (tNode) {
11472
- buf.push(tNode.template_);
11473
- tNode = tNode.next;
11474
- }
11475
- }
11476
- class TViewData extends Array {
11477
- }
11478
- let TVIEWDATA_EMPTY; // can't initialize here or it will not be tree shaken, because
11479
- // `LView` constructor could have side-effects.
11480
- /**
11481
- * This function clones a blueprint and creates TData.
11482
- *
11483
- * Simple slice will keep the same type, and we need it to be TData
11484
- */
11485
- function cloneToTViewData(list) {
11486
- if (TVIEWDATA_EMPTY === undefined)
11487
- TVIEWDATA_EMPTY = new TViewData();
11488
- return TVIEWDATA_EMPTY.concat(list);
11489
- }
11490
- class LViewBlueprint extends Array {
11491
- }
11492
- class MatchesArray extends Array {
11493
- }
11494
- class TViewComponents extends Array {
11495
- }
11496
- class TNodeLocalNames extends Array {
11497
- }
11498
- class TNodeInitialInputs extends Array {
11499
- }
11500
- class LCleanup extends Array {
11501
- }
11502
- class TCleanup extends Array {
11503
- }
11504
- function attachLViewDebug(lView) {
11505
- attachDebugObject(lView, new LViewDebug(lView));
11506
- }
11507
- function attachLContainerDebug(lContainer) {
11508
- attachDebugObject(lContainer, new LContainerDebug(lContainer));
11509
- }
11510
- function toDebug(obj) {
11511
- if (obj) {
11512
- const debug = obj.debug;
11513
- assertDefined(debug, 'Object does not have a debug representation.');
11514
- return debug;
11515
- }
11516
- else {
11517
- return obj;
11518
- }
11519
- }
11520
- /**
11521
- * Use this method to unwrap a native element in `LView` and convert it into HTML for easier
11522
- * reading.
11523
- *
11524
- * @param value possibly wrapped native DOM node.
11525
- * @param includeChildren If `true` then the serialized HTML form will include child elements
11526
- * (same
11527
- * as `outerHTML`). If `false` then the serialized HTML form will only contain the element
11528
- * itself
11529
- * (will not serialize child elements).
11530
- */
11531
- function toHtml(value, includeChildren = false) {
11532
- const node = unwrapRNode(value);
11533
- if (node) {
11534
- switch (node.nodeType) {
11535
- case Node.TEXT_NODE:
11536
- return node.textContent;
11537
- case Node.COMMENT_NODE:
11538
- return `<!--${node.textContent}-->`;
11539
- case Node.ELEMENT_NODE:
11540
- const outerHTML = node.outerHTML;
11541
- if (includeChildren) {
11542
- return outerHTML;
11543
- }
11544
- else {
11545
- const innerHTML = '>' + node.innerHTML + '<';
11546
- return (outerHTML.split(innerHTML)[0]) + '>';
11547
- }
11548
- }
11549
- }
11550
- return null;
11551
- }
11552
- class LViewDebug {
11553
- constructor(_raw_lView) {
11554
- this._raw_lView = _raw_lView;
11555
- }
11556
- /**
11557
- * Flags associated with the `LView` unpacked into a more readable state.
11558
- */
11559
- get flags() {
11560
- const flags = this._raw_lView[FLAGS];
11561
- return {
11562
- __raw__flags__: flags,
11563
- initPhaseState: flags & 3 /* LViewFlags.InitPhaseStateMask */,
11564
- creationMode: !!(flags & 4 /* LViewFlags.CreationMode */),
11565
- firstViewPass: !!(flags & 8 /* LViewFlags.FirstLViewPass */),
11566
- checkAlways: !!(flags & 16 /* LViewFlags.CheckAlways */),
11567
- dirty: !!(flags & 32 /* LViewFlags.Dirty */),
11568
- attached: !!(flags & 64 /* LViewFlags.Attached */),
11569
- destroyed: !!(flags & 128 /* LViewFlags.Destroyed */),
11570
- isRoot: !!(flags & 256 /* LViewFlags.IsRoot */),
11571
- indexWithinInitPhase: flags >> 11 /* LViewFlags.IndexWithinInitPhaseShift */,
11572
- };
11573
- }
11574
- get parent() {
11575
- return toDebug(this._raw_lView[PARENT]);
11576
- }
11577
- get hostHTML() {
11578
- return toHtml(this._raw_lView[HOST], true);
11579
- }
11580
- get html() {
11581
- return (this.nodes || []).map(mapToHTML).join('');
11582
- }
11583
- get context() {
11584
- return this._raw_lView[CONTEXT];
11585
- }
11586
- /**
11587
- * The tree of nodes associated with the current `LView`. The nodes have been normalized into
11588
- * a tree structure with relevant details pulled out for readability.
11589
- */
11590
- get nodes() {
11591
- const lView = this._raw_lView;
11592
- const tNode = lView[TVIEW].firstChild;
11593
- return toDebugNodes(tNode, lView);
11594
- }
11595
- get template() {
11596
- return this.tView.template_;
11597
- }
11598
- get tView() {
11599
- return this._raw_lView[TVIEW];
11600
- }
11601
- get cleanup() {
11602
- return this._raw_lView[CLEANUP];
11603
- }
11604
- get injector() {
11605
- return this._raw_lView[INJECTOR$1];
11606
- }
11607
- get rendererFactory() {
11608
- return this._raw_lView[RENDERER_FACTORY];
11609
- }
11610
- get renderer() {
11611
- return this._raw_lView[RENDERER];
11612
- }
11613
- get sanitizer() {
11614
- return this._raw_lView[SANITIZER];
11615
- }
11616
- get childHead() {
11617
- return toDebug(this._raw_lView[CHILD_HEAD]);
11618
- }
11619
- get next() {
11620
- return toDebug(this._raw_lView[NEXT]);
11621
- }
11622
- get childTail() {
11623
- return toDebug(this._raw_lView[CHILD_TAIL]);
11624
- }
11625
- get declarationView() {
11626
- return toDebug(this._raw_lView[DECLARATION_VIEW]);
11627
- }
11628
- get queries() {
11629
- return this._raw_lView[QUERIES];
11630
- }
11631
- get tHost() {
11632
- return this._raw_lView[T_HOST];
11633
- }
11634
- get id() {
11635
- return this._raw_lView[ID];
11636
- }
11637
- get decls() {
11638
- return toLViewRange(this.tView, this._raw_lView, HEADER_OFFSET, this.tView.bindingStartIndex);
11639
- }
11640
- get vars() {
11641
- return toLViewRange(this.tView, this._raw_lView, this.tView.bindingStartIndex, this.tView.expandoStartIndex);
11642
- }
11643
- get expando() {
11644
- return toLViewRange(this.tView, this._raw_lView, this.tView.expandoStartIndex, this._raw_lView.length);
11645
- }
11646
- /**
11647
- * Normalized view of child views (and containers) attached at this location.
11648
- */
11649
- get childViews() {
11650
- const childViews = [];
11651
- let child = this.childHead;
11652
- while (child) {
11653
- childViews.push(child);
11654
- child = child.next;
11655
- }
11656
- return childViews;
11657
- }
11658
- }
11659
- function mapToHTML(node) {
11660
- if (node.type === 'ElementContainer') {
11661
- return (node.children || []).map(mapToHTML).join('');
11662
- }
11663
- else if (node.type === 'IcuContainer') {
11664
- throw new Error('Not implemented');
11665
- }
11666
- else {
11667
- return toHtml(node.native, true) || '';
11668
- }
11669
- }
11670
- function toLViewRange(tView, lView, start, end) {
11671
- let content = [];
11672
- for (let index = start; index < end; index++) {
11673
- content.push({ index: index, t: tView.data[index], l: lView[index] });
11674
- }
11675
- return { start: start, end: end, length: end - start, content: content };
11676
- }
11677
- /**
11678
- * Turns a flat list of nodes into a tree by walking the associated `TNode` tree.
11679
- *
11680
- * @param tNode
11681
- * @param lView
11682
- */
11683
- function toDebugNodes(tNode, lView) {
11684
- if (tNode) {
11685
- const debugNodes = [];
11686
- let tNodeCursor = tNode;
11687
- while (tNodeCursor) {
11688
- debugNodes.push(buildDebugNode(tNodeCursor, lView));
11689
- tNodeCursor = tNodeCursor.next;
11690
- }
11691
- return debugNodes;
11692
- }
11693
- else {
11694
- return [];
11695
- }
11696
- }
11697
- function buildDebugNode(tNode, lView) {
11698
- const rawValue = lView[tNode.index];
11699
- const native = unwrapRNode(rawValue);
11700
- const factories = [];
11701
- const instances = [];
11702
- const tView = lView[TVIEW];
11703
- for (let i = tNode.directiveStart; i < tNode.directiveEnd; i++) {
11704
- const def = tView.data[i];
11705
- factories.push(def.type);
11706
- instances.push(lView[i]);
11707
- }
11708
- return {
11709
- html: toHtml(native),
11710
- type: toTNodeTypeAsString(tNode.type),
11711
- tNode,
11712
- native: native,
11713
- children: toDebugNodes(tNode.child, lView),
11714
- factories,
11715
- instances,
11716
- injector: buildNodeInjectorDebug(tNode, tView, lView),
11717
- get injectorResolutionPath() {
11718
- return tNode.debugNodeInjectorPath(lView);
11719
- },
11720
- };
11721
- }
11722
- function buildNodeInjectorDebug(tNode, tView, lView) {
11723
- const viewProviders = [];
11724
- for (let i = tNode.providerIndexStart_; i < tNode.providerIndexEnd_; i++) {
11725
- viewProviders.push(tView.data[i]);
11726
- }
11727
- const providers = [];
11728
- for (let i = tNode.providerIndexEnd_; i < tNode.directiveEnd; i++) {
11729
- providers.push(tView.data[i]);
11730
- }
11731
- const nodeInjectorDebug = {
11732
- bloom: toBloom(lView, tNode.injectorIndex),
11733
- cumulativeBloom: toBloom(tView.data, tNode.injectorIndex),
11734
- providers,
11735
- viewProviders,
11736
- parentInjectorIndex: lView[tNode.providerIndexStart_ - 1],
11737
- };
11738
- return nodeInjectorDebug;
11739
- }
11740
- /**
11741
- * Convert a number at `idx` location in `array` into binary representation.
10820
+ * @license
10821
+ * Copyright Google LLC All Rights Reserved.
11742
10822
  *
11743
- * @param array
11744
- * @param idx
10823
+ * Use of this source code is governed by an MIT-style license that can be
10824
+ * found in the LICENSE file at https://angular.io/license
11745
10825
  */
11746
- function binary(array, idx) {
11747
- const value = array[idx];
11748
- // If not a number we print 8 `?` to retain alignment but let user know that it was called on
11749
- // wrong type.
11750
- if (typeof value !== 'number')
11751
- return '????????';
11752
- // We prefix 0s so that we have constant length number
11753
- const text = '00000000' + value.toString(2);
11754
- return text.substring(text.length - 8);
11755
- }
10826
+
11756
10827
  /**
11757
- * Convert a bloom filter at location `idx` in `array` into binary representation.
10828
+ * @license
10829
+ * Copyright Google LLC All Rights Reserved.
11758
10830
  *
11759
- * @param array
11760
- * @param idx
10831
+ * Use of this source code is governed by an MIT-style license that can be
10832
+ * found in the LICENSE file at https://angular.io/license
11761
10833
  */
11762
- function toBloom(array, idx) {
11763
- if (idx < 0) {
11764
- return 'NO_NODE_INJECTOR';
10834
+ function ɵɵdirectiveInject(token, flags = InjectFlags.Default) {
10835
+ const lView = getLView();
10836
+ // Fall back to inject() if view hasn't been created. This situation can happen in tests
10837
+ // if inject utilities are used before bootstrapping.
10838
+ if (lView === null) {
10839
+ // Verify that we will not get into infinite loop.
10840
+ ngDevMode && assertInjectImplementationNotEqual(ɵɵdirectiveInject);
10841
+ return ɵɵinject(token, flags);
11765
10842
  }
11766
- 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)}`;
10843
+ const tNode = getCurrentTNode();
10844
+ return getOrCreateInjectable(tNode, lView, resolveForwardRef(token), flags);
11767
10845
  }
11768
- class LContainerDebug {
11769
- constructor(_raw_lContainer) {
11770
- this._raw_lContainer = _raw_lContainer;
11771
- }
11772
- get hasTransplantedViews() {
11773
- return this._raw_lContainer[HAS_TRANSPLANTED_VIEWS];
11774
- }
11775
- get views() {
11776
- return this._raw_lContainer.slice(CONTAINER_HEADER_OFFSET)
11777
- .map(toDebug);
11778
- }
11779
- get parent() {
11780
- return toDebug(this._raw_lContainer[PARENT]);
11781
- }
11782
- get movedViews() {
11783
- return this._raw_lContainer[MOVED_VIEWS];
11784
- }
11785
- get host() {
11786
- return this._raw_lContainer[HOST];
11787
- }
11788
- get native() {
11789
- return this._raw_lContainer[NATIVE];
11790
- }
11791
- get next() {
11792
- return toDebug(this._raw_lContainer[NEXT]);
11793
- }
10846
+ /**
10847
+ * Throws an error indicating that a factory function could not be generated by the compiler for a
10848
+ * particular class.
10849
+ *
10850
+ * This instruction allows the actual error message to be optimized away when ngDevMode is turned
10851
+ * off, saving bytes of generated code while still providing a good experience in dev mode.
10852
+ *
10853
+ * The name of the class is not mentioned here, but will be in the generated factory function name
10854
+ * and thus in the stack trace.
10855
+ *
10856
+ * @codeGenApi
10857
+ */
10858
+ function ɵɵinvalidFactory() {
10859
+ const msg = ngDevMode ? `This constructor was not compatible with Dependency Injection.` : 'invalid';
10860
+ throw new Error(msg);
11794
10861
  }
11795
10862
 
11796
10863
  /**
@@ -11866,7 +10933,7 @@ function renderChildComponents(hostLView, components) {
11866
10933
  }
11867
10934
  }
11868
10935
  function createLView(parentLView, tView, context, flags, host, tHostNode, rendererFactory, renderer, sanitizer, injector, embeddedViewInjector) {
11869
- const lView = ngDevMode ? cloneToLViewFromTViewBlueprint(tView) : tView.blueprint.slice();
10936
+ const lView = tView.blueprint.slice();
11870
10937
  lView[HOST] = host;
11871
10938
  lView[FLAGS] = flags | 4 /* LViewFlags.CreationMode */ | 64 /* LViewFlags.Attached */ | 8 /* LViewFlags.FirstLViewPass */;
11872
10939
  if (embeddedViewInjector !== null ||
@@ -11890,7 +10957,6 @@ function createLView(parentLView, tView, context, flags, host, tHostNode, render
11890
10957
  assertEqual(tView.type == 2 /* TViewType.Embedded */ ? parentLView !== null : true, true, 'Embedded views must have parentLView');
11891
10958
  lView[DECLARATION_COMPONENT_VIEW] =
11892
10959
  tView.type == 2 /* TViewType.Embedded */ ? parentLView[DECLARATION_COMPONENT_VIEW] : lView;
11893
- ngDevMode && attachLViewDebug(lView);
11894
10960
  return lView;
11895
10961
  }
11896
10962
  function getOrCreateTNode(tView, index, type, name, attrs) {
@@ -12273,73 +11339,38 @@ function createTView(type, declTNode, templateFn, decls, vars, directives, pipes
12273
11339
  const initialViewLength = bindingStartIndex + vars;
12274
11340
  const blueprint = createViewBlueprint(bindingStartIndex, initialViewLength);
12275
11341
  const consts = typeof constsOrFactory === 'function' ? constsOrFactory() : constsOrFactory;
12276
- const tView = blueprint[TVIEW] = ngDevMode ?
12277
- new TViewConstructor(type, // type: TViewType,
12278
- blueprint, // blueprint: LView,
12279
- templateFn, // template: ComponentTemplate<{}>|null,
12280
- null, // queries: TQueries|null
12281
- viewQuery, // viewQuery: ViewQueriesFunction<{}>|null,
12282
- declTNode, // declTNode: TNode|null,
12283
- cloneToTViewData(blueprint).fill(null, bindingStartIndex), // data: TData,
12284
- bindingStartIndex, // bindingStartIndex: number,
12285
- initialViewLength, // expandoStartIndex: number,
12286
- null, // hostBindingOpCodes: HostBindingOpCodes,
12287
- true, // firstCreatePass: boolean,
12288
- true, // firstUpdatePass: boolean,
12289
- false, // staticViewQueries: boolean,
12290
- false, // staticContentQueries: boolean,
12291
- null, // preOrderHooks: HookData|null,
12292
- null, // preOrderCheckHooks: HookData|null,
12293
- null, // contentHooks: HookData|null,
12294
- null, // contentCheckHooks: HookData|null,
12295
- null, // viewHooks: HookData|null,
12296
- null, // viewCheckHooks: HookData|null,
12297
- null, // destroyHooks: DestroyHookData|null,
12298
- null, // cleanup: any[]|null,
12299
- null, // contentQueries: number[]|null,
12300
- null, // components: number[]|null,
12301
- typeof directives === 'function' ? //
12302
- directives() : //
12303
- directives, // directiveRegistry: DirectiveDefList|null,
12304
- typeof pipes === 'function' ? pipes() : pipes, // pipeRegistry: PipeDefList|null,
12305
- null, // firstChild: TNode|null,
12306
- schemas, // schemas: SchemaMetadata[]|null,
12307
- consts, // consts: TConstants|null
12308
- false, // incompleteFirstPass: boolean
12309
- decls, // ngDevMode only: decls
12310
- vars) :
12311
- {
12312
- type: type,
12313
- blueprint: blueprint,
12314
- template: templateFn,
12315
- queries: null,
12316
- viewQuery: viewQuery,
12317
- declTNode: declTNode,
12318
- data: blueprint.slice().fill(null, bindingStartIndex),
12319
- bindingStartIndex: bindingStartIndex,
12320
- expandoStartIndex: initialViewLength,
12321
- hostBindingOpCodes: null,
12322
- firstCreatePass: true,
12323
- firstUpdatePass: true,
12324
- staticViewQueries: false,
12325
- staticContentQueries: false,
12326
- preOrderHooks: null,
12327
- preOrderCheckHooks: null,
12328
- contentHooks: null,
12329
- contentCheckHooks: null,
12330
- viewHooks: null,
12331
- viewCheckHooks: null,
12332
- destroyHooks: null,
12333
- cleanup: null,
12334
- contentQueries: null,
12335
- components: null,
12336
- directiveRegistry: typeof directives === 'function' ? directives() : directives,
12337
- pipeRegistry: typeof pipes === 'function' ? pipes() : pipes,
12338
- firstChild: null,
12339
- schemas: schemas,
12340
- consts: consts,
12341
- incompleteFirstPass: false
12342
- };
11342
+ const tView = blueprint[TVIEW] = {
11343
+ type: type,
11344
+ blueprint: blueprint,
11345
+ template: templateFn,
11346
+ queries: null,
11347
+ viewQuery: viewQuery,
11348
+ declTNode: declTNode,
11349
+ data: blueprint.slice().fill(null, bindingStartIndex),
11350
+ bindingStartIndex: bindingStartIndex,
11351
+ expandoStartIndex: initialViewLength,
11352
+ hostBindingOpCodes: null,
11353
+ firstCreatePass: true,
11354
+ firstUpdatePass: true,
11355
+ staticViewQueries: false,
11356
+ staticContentQueries: false,
11357
+ preOrderHooks: null,
11358
+ preOrderCheckHooks: null,
11359
+ contentHooks: null,
11360
+ contentCheckHooks: null,
11361
+ viewHooks: null,
11362
+ viewCheckHooks: null,
11363
+ destroyHooks: null,
11364
+ cleanup: null,
11365
+ contentQueries: null,
11366
+ components: null,
11367
+ directiveRegistry: typeof directives === 'function' ? directives() : directives,
11368
+ pipeRegistry: typeof pipes === 'function' ? pipes() : pipes,
11369
+ firstChild: null,
11370
+ schemas: schemas,
11371
+ consts: consts,
11372
+ incompleteFirstPass: false
11373
+ };
12343
11374
  if (ngDevMode) {
12344
11375
  // For performance reasons it is important that the tView retains the same shape during runtime.
12345
11376
  // (To make sure that all of the code is monomorphic.) For this reason we seal the object to
@@ -12349,7 +11380,7 @@ function createTView(type, declTNode, templateFn, decls, vars, directives, pipes
12349
11380
  return tView;
12350
11381
  }
12351
11382
  function createViewBlueprint(bindingStartIndex, initialViewLength) {
12352
- const blueprint = ngDevMode ? new LViewBlueprint() : [];
11383
+ const blueprint = [];
12353
11384
  for (let i = 0; i < initialViewLength; i++) {
12354
11385
  blueprint.push(i < bindingStartIndex ? null : NO_CHANGE);
12355
11386
  }
@@ -12402,74 +11433,40 @@ function createTNode(tView, tParent, type, index, value, attrs) {
12402
11433
  ngDevMode && ngDevMode.tNode++;
12403
11434
  ngDevMode && tParent && assertTNodeForTView(tParent, tView);
12404
11435
  let injectorIndex = tParent ? tParent.injectorIndex : -1;
12405
- const tNode = ngDevMode ?
12406
- new TNodeDebug(tView, // tView_: TView
12407
- type, // type: TNodeType
12408
- index, // index: number
12409
- null, // insertBeforeIndex: null|-1|number|number[]
12410
- injectorIndex, // injectorIndex: number
12411
- -1, // componentOffset: number
12412
- -1, // directiveStart: number
12413
- -1, // directiveEnd: number
12414
- -1, // directiveStylingLast: number
12415
- null, // propertyBindings: number[]|null
12416
- 0, // flags: TNodeFlags
12417
- 0, // providerIndexes: TNodeProviderIndexes
12418
- value, // value: string|null
12419
- attrs, // attrs: (string|AttributeMarker|(string|SelectorFlags)[])[]|null
12420
- null, // mergedAttrs
12421
- null, // localNames: (string|number)[]|null
12422
- undefined, // initialInputs: (string[]|null)[]|null|undefined
12423
- null, // inputs: PropertyAliases|null
12424
- null, // outputs: PropertyAliases|null
12425
- null, // tViews: ITView|ITView[]|null
12426
- null, // next: ITNode|null
12427
- null, // projectionNext: ITNode|null
12428
- null, // child: ITNode|null
12429
- tParent, // parent: TElementNode|TContainerNode|null
12430
- null, // projection: number|(ITNode|RNode[])[]|null
12431
- null, // styles: string|null
12432
- null, // stylesWithoutHost: string|null
12433
- undefined, // residualStyles: string|null
12434
- null, // classes: string|null
12435
- null, // classesWithoutHost: string|null
12436
- undefined, // residualClasses: string|null
12437
- 0, // classBindings: TStylingRange;
12438
- 0) :
12439
- {
12440
- type,
12441
- index,
12442
- insertBeforeIndex: null,
12443
- injectorIndex,
12444
- directiveStart: -1,
12445
- directiveEnd: -1,
12446
- directiveStylingLast: -1,
12447
- componentOffset: -1,
12448
- propertyBindings: null,
12449
- flags: 0,
12450
- providerIndexes: 0,
12451
- value: value,
12452
- attrs: attrs,
12453
- mergedAttrs: null,
12454
- localNames: null,
12455
- initialInputs: undefined,
12456
- inputs: null,
12457
- outputs: null,
12458
- tViews: null,
12459
- next: null,
12460
- projectionNext: null,
12461
- child: null,
12462
- parent: tParent,
12463
- projection: null,
12464
- styles: null,
12465
- stylesWithoutHost: null,
12466
- residualStyles: undefined,
12467
- classes: null,
12468
- classesWithoutHost: null,
12469
- residualClasses: undefined,
12470
- classBindings: 0,
12471
- styleBindings: 0,
12472
- };
11436
+ const tNode = {
11437
+ type,
11438
+ index,
11439
+ insertBeforeIndex: null,
11440
+ injectorIndex,
11441
+ directiveStart: -1,
11442
+ directiveEnd: -1,
11443
+ directiveStylingLast: -1,
11444
+ componentOffset: -1,
11445
+ propertyBindings: null,
11446
+ flags: 0,
11447
+ providerIndexes: 0,
11448
+ value: value,
11449
+ attrs: attrs,
11450
+ mergedAttrs: null,
11451
+ localNames: null,
11452
+ initialInputs: undefined,
11453
+ inputs: null,
11454
+ outputs: null,
11455
+ tViews: null,
11456
+ next: null,
11457
+ projectionNext: null,
11458
+ child: null,
11459
+ parent: tParent,
11460
+ projection: null,
11461
+ styles: null,
11462
+ stylesWithoutHost: null,
11463
+ residualStyles: undefined,
11464
+ classes: null,
11465
+ classesWithoutHost: null,
11466
+ residualClasses: undefined,
11467
+ classBindings: 0,
11468
+ styleBindings: 0,
11469
+ };
12473
11470
  if (ngDevMode) {
12474
11471
  // For performance reasons it is important that the tNode retains the same shape during runtime.
12475
11472
  // (To make sure that all of the code is monomorphic.) For this reason we seal the object to
@@ -12526,7 +11523,7 @@ function initializeInputAndOutputAliases(tView, tNode, hostDirectiveDefinitionMa
12526
11523
  const end = tNode.directiveEnd;
12527
11524
  const tViewData = tView.data;
12528
11525
  const tNodeAttrs = tNode.attrs;
12529
- const inputsFromAttrs = ngDevMode ? new TNodeInitialInputs() : [];
11526
+ const inputsFromAttrs = [];
12530
11527
  let inputsStore = null;
12531
11528
  let outputsStore = null;
12532
11529
  for (let directiveIndex = start; directiveIndex < end; directiveIndex++) {
@@ -12795,6 +11792,12 @@ function lastSelectedElementIdx(hostBindingOpCodes) {
12795
11792
  function instantiateAllDirectives(tView, lView, tNode, native) {
12796
11793
  const start = tNode.directiveStart;
12797
11794
  const end = tNode.directiveEnd;
11795
+ // The component view needs to be created before creating the node injector
11796
+ // since it is used to inject some special symbols like `ChangeDetectorRef`.
11797
+ if (isComponentHost(tNode)) {
11798
+ ngDevMode && assertTNodeType(tNode, 3 /* TNodeType.AnyRNode */);
11799
+ addComponentLogic(lView, tNode, tView.data[start + tNode.componentOffset]);
11800
+ }
12798
11801
  if (!tView.firstCreatePass) {
12799
11802
  getOrCreateNodeInjectorForNode(tNode, lView);
12800
11803
  }
@@ -12802,19 +11805,14 @@ function instantiateAllDirectives(tView, lView, tNode, native) {
12802
11805
  const initialInputs = tNode.initialInputs;
12803
11806
  for (let i = start; i < end; i++) {
12804
11807
  const def = tView.data[i];
12805
- const isComponent = isComponentDef(def);
12806
- if (isComponent) {
12807
- ngDevMode && assertTNodeType(tNode, 3 /* TNodeType.AnyRNode */);
12808
- addComponentLogic(lView, tNode, def);
12809
- }
12810
11808
  const directive = getNodeInjectable(lView, tView, i, tNode);
12811
11809
  attachPatchData(directive, lView);
12812
11810
  if (initialInputs !== null) {
12813
11811
  setInputsFromAttrs(lView, i - start, directive, def, tNode, initialInputs);
12814
11812
  }
12815
- if (isComponent) {
11813
+ if (isComponentDef(def)) {
12816
11814
  const componentView = getComponentLViewByIndex(tNode.index, lView);
12817
- componentView[CONTEXT] = directive;
11815
+ componentView[CONTEXT] = getNodeInjectable(lView, tView, i, tNode);
12818
11816
  }
12819
11817
  }
12820
11818
  }
@@ -12864,7 +11862,7 @@ function findDirectiveDefMatches(tView, tNode) {
12864
11862
  for (let i = 0; i < registry.length; i++) {
12865
11863
  const def = registry[i];
12866
11864
  if (isNodeMatchingSelectorList(tNode, def.selectors, /* isProjectionMode */ false)) {
12867
- matches || (matches = ngDevMode ? new MatchesArray() : []);
11865
+ matches || (matches = []);
12868
11866
  if (isComponentDef(def)) {
12869
11867
  if (ngDevMode) {
12870
11868
  assertTNodeType(tNode, 2 /* TNodeType.Element */, `"${tNode.value}" tags cannot be used as component hosts. ` +
@@ -12922,13 +11920,12 @@ function markAsComponentHost(tView, hostTNode, componentOffset) {
12922
11920
  ngDevMode && assertFirstCreatePass(tView);
12923
11921
  ngDevMode && assertGreaterThan(componentOffset, -1, 'componentOffset must be great than -1');
12924
11922
  hostTNode.componentOffset = componentOffset;
12925
- (tView.components || (tView.components = ngDevMode ? new TViewComponents() : []))
12926
- .push(hostTNode.index);
11923
+ (tView.components || (tView.components = [])).push(hostTNode.index);
12927
11924
  }
12928
11925
  /** Caches local names and their matching directive indices for query and template lookups. */
12929
11926
  function cacheMatchingLocalNames(tNode, localRefs, exportsMap) {
12930
11927
  if (localRefs) {
12931
- const localNames = tNode.localNames = ngDevMode ? new TNodeLocalNames() : [];
11928
+ const localNames = tNode.localNames = [];
12932
11929
  // Local names must be stored in tNode in the same order that localRefs are defined
12933
11930
  // in the template to ensure the data is loaded in the same slots as their refs
12934
11931
  // in the template (for template queries).
@@ -13111,9 +12108,6 @@ function generateInitialInputs(inputs, directiveIndex, attrs) {
13111
12108
  //////////////////////////
13112
12109
  //// ViewContainer & View
13113
12110
  //////////////////////////
13114
- // Not sure why I need to do `any` here but TS complains later.
13115
- const LContainerArray = class LContainer extends Array {
13116
- };
13117
12111
  /**
13118
12112
  * Creates a LContainer, either from a container instruction, or for a ViewContainerRef.
13119
12113
  *
@@ -13126,20 +12120,20 @@ const LContainerArray = class LContainer extends Array {
13126
12120
  */
13127
12121
  function createLContainer(hostNative, currentView, native, tNode) {
13128
12122
  ngDevMode && assertLView(currentView);
13129
- // https://jsperf.com/array-literal-vs-new-array-really
13130
- const lContainer = new (ngDevMode ? LContainerArray : Array)(hostNative, // host native
13131
- true, // Boolean `true` in this position signifies that this is an `LContainer`
13132
- false, // has transplanted views
13133
- currentView, // parent
13134
- null, // next
13135
- 0, // transplanted views to refresh count
13136
- tNode, // t_host
13137
- native, // native,
13138
- null, // view refs
13139
- null);
12123
+ const lContainer = [
12124
+ hostNative,
12125
+ true,
12126
+ false,
12127
+ currentView,
12128
+ null,
12129
+ 0,
12130
+ tNode,
12131
+ native,
12132
+ null,
12133
+ null, // moved views
12134
+ ];
13140
12135
  ngDevMode &&
13141
12136
  assertEqual(lContainer.length, CONTAINER_HEADER_OFFSET, 'Should allocate correct number of slots for LContainer header.');
13142
- ngDevMode && attachLContainerDebug(lContainer);
13143
12137
  return lContainer;
13144
12138
  }
13145
12139
  /**
@@ -13413,10 +12407,10 @@ function storePropertyBindingMetadata(tData, tNode, propertyName, bindingIndex,
13413
12407
  }
13414
12408
  function getOrCreateLViewCleanup(view) {
13415
12409
  // top level variables should not be exported for performance reasons (PERF_NOTES.md)
13416
- return view[CLEANUP] || (view[CLEANUP] = ngDevMode ? new LCleanup() : []);
12410
+ return view[CLEANUP] || (view[CLEANUP] = []);
13417
12411
  }
13418
12412
  function getOrCreateTViewCleanup(tView) {
13419
- return tView.cleanup || (tView.cleanup = ngDevMode ? new TCleanup() : []);
12413
+ return tView.cleanup || (tView.cleanup = []);
13420
12414
  }
13421
12415
  /**
13422
12416
  * There are cases where the sub component's renderer needs to be included
@@ -13582,6 +12576,11 @@ function collectNativeNodes(tView, lView, tNode, result, isProjection = false) {
13582
12576
  * found in the LICENSE file at https://angular.io/license
13583
12577
  */
13584
12578
  class ViewRef$1 {
12579
+ get rootNodes() {
12580
+ const lView = this._lView;
12581
+ const tView = lView[TVIEW];
12582
+ return collectNativeNodes(tView, lView, tView.firstChild, []);
12583
+ }
13585
12584
  constructor(
13586
12585
  /**
13587
12586
  * This represents `LView` associated with the component when ViewRef is a ChangeDetectorRef.
@@ -13607,11 +12606,6 @@ class ViewRef$1 {
13607
12606
  this._appRef = null;
13608
12607
  this._attachedToViewContainer = false;
13609
12608
  }
13610
- get rootNodes() {
13611
- const lView = this._lView;
13612
- const tView = lView[TVIEW];
13613
- return collectNativeNodes(tView, lView, tView.firstChild, []);
13614
- }
13615
12609
  get context() {
13616
12610
  return this._lView[CONTEXT];
13617
12611
  }
@@ -13933,6 +12927,12 @@ class ChainedInjector {
13933
12927
  * ComponentFactory interface implementation.
13934
12928
  */
13935
12929
  class ComponentFactory extends ComponentFactory$1 {
12930
+ get inputs() {
12931
+ return toRefArray(this.componentDef.inputs);
12932
+ }
12933
+ get outputs() {
12934
+ return toRefArray(this.componentDef.outputs);
12935
+ }
13936
12936
  /**
13937
12937
  * @param componentDef The component definition.
13938
12938
  * @param ngModule The NgModuleRef to which the factory is bound.
@@ -13947,12 +12947,6 @@ class ComponentFactory extends ComponentFactory$1 {
13947
12947
  componentDef.ngContentSelectors ? componentDef.ngContentSelectors : [];
13948
12948
  this.isBoundToModule = !!ngModule;
13949
12949
  }
13950
- get inputs() {
13951
- return toRefArray(this.componentDef.inputs);
13952
- }
13953
- get outputs() {
13954
- return toRefArray(this.componentDef.outputs);
13955
- }
13956
12950
  create(injector, projectableNodes, rootSelectorOrNode, environmentInjector) {
13957
12951
  environmentInjector = environmentInjector || this.ngModule;
13958
12952
  let realEnvironmentInjector = environmentInjector instanceof EnvironmentInjector ?
@@ -14028,17 +13022,6 @@ class ComponentFactory extends ComponentFactory$1 {
14028
13022
  return new ComponentRef(this.componentType, component, createElementRef(tElementNode, rootLView), rootLView, tElementNode);
14029
13023
  }
14030
13024
  }
14031
- const componentFactoryResolver = new ComponentFactoryResolver();
14032
- /**
14033
- * Creates a ComponentFactoryResolver and stores it on the injector. Or, if the
14034
- * ComponentFactoryResolver
14035
- * already exists, retrieves the existing ComponentFactoryResolver.
14036
- *
14037
- * @returns The ComponentFactoryResolver instance to use
14038
- */
14039
- function injectComponentFactoryResolver() {
14040
- return componentFactoryResolver;
14041
- }
14042
13025
  /**
14043
13026
  * Represents an instance of a Component created via a {@link ComponentFactory}.
14044
13027
  *
@@ -16624,6 +15607,62 @@ function ɵɵpropertyInterpolateV(propName, values, sanitizer) {
16624
15607
  return ɵɵpropertyInterpolateV;
16625
15608
  }
16626
15609
 
15610
+ /**
15611
+ * @license
15612
+ * Copyright Google LLC All Rights Reserved.
15613
+ *
15614
+ * Use of this source code is governed by an MIT-style license that can be
15615
+ * found in the LICENSE file at https://angular.io/license
15616
+ */
15617
+ function toTStylingRange(prev, next) {
15618
+ ngDevMode && assertNumberInRange(prev, 0, 32767 /* StylingRange.UNSIGNED_MASK */);
15619
+ ngDevMode && assertNumberInRange(next, 0, 32767 /* StylingRange.UNSIGNED_MASK */);
15620
+ return (prev << 17 /* StylingRange.PREV_SHIFT */ | next << 2 /* StylingRange.NEXT_SHIFT */);
15621
+ }
15622
+ function getTStylingRangePrev(tStylingRange) {
15623
+ ngDevMode && assertNumber(tStylingRange, 'expected number');
15624
+ return (tStylingRange >> 17 /* StylingRange.PREV_SHIFT */) & 32767 /* StylingRange.UNSIGNED_MASK */;
15625
+ }
15626
+ function getTStylingRangePrevDuplicate(tStylingRange) {
15627
+ ngDevMode && assertNumber(tStylingRange, 'expected number');
15628
+ return (tStylingRange & 2 /* StylingRange.PREV_DUPLICATE */) ==
15629
+ 2 /* StylingRange.PREV_DUPLICATE */;
15630
+ }
15631
+ function setTStylingRangePrev(tStylingRange, previous) {
15632
+ ngDevMode && assertNumber(tStylingRange, 'expected number');
15633
+ ngDevMode && assertNumberInRange(previous, 0, 32767 /* StylingRange.UNSIGNED_MASK */);
15634
+ return ((tStylingRange & ~4294836224 /* StylingRange.PREV_MASK */) |
15635
+ (previous << 17 /* StylingRange.PREV_SHIFT */));
15636
+ }
15637
+ function setTStylingRangePrevDuplicate(tStylingRange) {
15638
+ ngDevMode && assertNumber(tStylingRange, 'expected number');
15639
+ return (tStylingRange | 2 /* StylingRange.PREV_DUPLICATE */);
15640
+ }
15641
+ function getTStylingRangeNext(tStylingRange) {
15642
+ ngDevMode && assertNumber(tStylingRange, 'expected number');
15643
+ return (tStylingRange & 131068 /* StylingRange.NEXT_MASK */) >> 2 /* StylingRange.NEXT_SHIFT */;
15644
+ }
15645
+ function setTStylingRangeNext(tStylingRange, next) {
15646
+ ngDevMode && assertNumber(tStylingRange, 'expected number');
15647
+ ngDevMode && assertNumberInRange(next, 0, 32767 /* StylingRange.UNSIGNED_MASK */);
15648
+ return ((tStylingRange & ~131068 /* StylingRange.NEXT_MASK */) | //
15649
+ next << 2 /* StylingRange.NEXT_SHIFT */);
15650
+ }
15651
+ function getTStylingRangeNextDuplicate(tStylingRange) {
15652
+ ngDevMode && assertNumber(tStylingRange, 'expected number');
15653
+ return (tStylingRange & 1 /* StylingRange.NEXT_DUPLICATE */) ===
15654
+ 1 /* StylingRange.NEXT_DUPLICATE */;
15655
+ }
15656
+ function setTStylingRangeNextDuplicate(tStylingRange) {
15657
+ ngDevMode && assertNumber(tStylingRange, 'expected number');
15658
+ return (tStylingRange | 1 /* StylingRange.NEXT_DUPLICATE */);
15659
+ }
15660
+ function getTStylingRangeTail(tStylingRange) {
15661
+ ngDevMode && assertNumber(tStylingRange, 'expected number');
15662
+ const next = getTStylingRangeNext(tStylingRange);
15663
+ return next === 0 ? getTStylingRangePrev(tStylingRange) : next;
15664
+ }
15665
+
16627
15666
  /**
16628
15667
  * @license
16629
15668
  * Copyright Google LLC All Rights Reserved.
@@ -19676,7 +18715,7 @@ var I18nCreateOpCode;
19676
18715
  })(I18nCreateOpCode || (I18nCreateOpCode = {}));
19677
18716
  // Note: This hack is necessary so we don't erroneously get a circular dependency
19678
18717
  // failure based on types.
19679
- const unusedValueExportToPlacateAjd$2 = 1;
18718
+ const unusedValueExportToPlacateAjd = 1;
19680
18719
 
19681
18720
  /**
19682
18721
  * @license
@@ -20445,6 +19484,46 @@ function loadIcuContainerVisitor() {
20445
19484
  return icuContainerIteratorStart;
20446
19485
  }
20447
19486
 
19487
+ /**
19488
+ * @license
19489
+ * Copyright Google LLC All Rights Reserved.
19490
+ *
19491
+ * Use of this source code is governed by an MIT-style license that can be
19492
+ * found in the LICENSE file at https://angular.io/license
19493
+ */
19494
+ /**
19495
+ * Patch a `debug` property on top of the existing object.
19496
+ *
19497
+ * NOTE: always call this method with `ngDevMode && attachDebugObject(...)`
19498
+ *
19499
+ * @param obj Object to patch
19500
+ * @param debug Value to patch
19501
+ */
19502
+ function attachDebugObject(obj, debug) {
19503
+ if (ngDevMode) {
19504
+ Object.defineProperty(obj, 'debug', { value: debug, enumerable: false });
19505
+ }
19506
+ else {
19507
+ throw new Error('This method should be guarded with `ngDevMode` so that it can be tree shaken in production!');
19508
+ }
19509
+ }
19510
+ /**
19511
+ * Patch a `debug` property getter on top of the existing object.
19512
+ *
19513
+ * NOTE: always call this method with `ngDevMode && attachDebugObject(...)`
19514
+ *
19515
+ * @param obj Object to patch
19516
+ * @param debugGetter Getter returning a value to patch
19517
+ */
19518
+ function attachDebugGetter(obj, debugGetter) {
19519
+ if (ngDevMode) {
19520
+ Object.defineProperty(obj, 'debug', { get: debugGetter, enumerable: false });
19521
+ }
19522
+ else {
19523
+ throw new Error('This method should be guarded with `ngDevMode` so that it can be tree shaken in production!');
19524
+ }
19525
+ }
19526
+
20448
19527
  /**
20449
19528
  * @license
20450
19529
  * Copyright Google LLC All Rights Reserved.
@@ -22414,32 +21493,6 @@ function sortListeners(a, b) {
22414
21493
  function isDirectiveDefHack(obj) {
22415
21494
  return obj.type !== undefined && obj.template !== undefined && obj.declaredInputs !== undefined;
22416
21495
  }
22417
- /**
22418
- * Returns the attached `DebugNode` instance for an element in the DOM.
22419
- *
22420
- * @param element DOM element which is owned by an existing component's view.
22421
- */
22422
- function getDebugNode$1(element) {
22423
- if (ngDevMode && !(element instanceof Node)) {
22424
- throw new Error('Expecting instance of DOM Element');
22425
- }
22426
- const lContext = getLContext(element);
22427
- const lView = lContext ? lContext.lView : null;
22428
- if (lView === null) {
22429
- return null;
22430
- }
22431
- const nodeIndex = lContext.nodeIndex;
22432
- if (nodeIndex !== -1) {
22433
- const valueInLView = lView[nodeIndex];
22434
- // this means that value in the lView is a component with its own
22435
- // data. In this situation the TNode is not accessed at the same spot.
22436
- const tNode = isLView(valueInLView) ? valueInLView[T_HOST] : getTNode(lView[TVIEW], nodeIndex);
22437
- ngDevMode &&
22438
- assertEqual(tNode.index, nodeIndex, 'Expecting that TNode at index is same as index');
22439
- return buildDebugNode(tNode, lView);
22440
- }
22441
- return null;
22442
- }
22443
21496
  /**
22444
21497
  * Retrieve the component `LView` from component/element.
22445
21498
  *
@@ -23144,6 +22197,12 @@ function symbolIterator() {
23144
22197
  * @publicApi
23145
22198
  */
23146
22199
  class QueryList {
22200
+ /**
22201
+ * Returns `Observable` of `QueryList` notifying the subscriber of changes.
22202
+ */
22203
+ get changes() {
22204
+ return this._changes || (this._changes = new EventEmitter());
22205
+ }
23147
22206
  /**
23148
22207
  * @param emitDistinctChangesOnly Whether `QueryList.changes` should fire only when actual change
23149
22208
  * has occurred. Or if it should fire when query is recomputed. (recomputing could resolve in
@@ -23167,12 +22226,6 @@ class QueryList {
23167
22226
  if (!proto[symbol])
23168
22227
  proto[symbol] = symbolIterator;
23169
22228
  }
23170
- /**
23171
- * Returns `Observable` of `QueryList` notifying the subscriber of changes.
23172
- */
23173
- get changes() {
23174
- return this._changes || (this._changes = new EventEmitter());
23175
- }
23176
22229
  /**
23177
22230
  * Returns the QueryList entry at `index`.
23178
22231
  */
@@ -23659,29 +22712,6 @@ function createContainerRef(hostTNode, hostLView) {
23659
22712
  * Use of this source code is governed by an MIT-style license that can be
23660
22713
  * found in the LICENSE file at https://angular.io/license
23661
22714
  */
23662
- // Note: This hack is necessary so we don't erroneously get a circular dependency
23663
- // failure based on types.
23664
- const unusedValueExportToPlacateAjd$1 = 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
- // Note: This hack is necessary so we don't erroneously get a circular dependency
23674
- // failure based on types.
23675
- const unusedValueExportToPlacateAjd = 1;
23676
-
23677
- /**
23678
- * @license
23679
- * Copyright Google LLC All Rights Reserved.
23680
- *
23681
- * Use of this source code is governed by an MIT-style license that can be
23682
- * found in the LICENSE file at https://angular.io/license
23683
- */
23684
- const unusedValueToPlacateAjd = unusedValueExportToPlacateAjd$1 + unusedValueExportToPlacateAjd$6 + unusedValueExportToPlacateAjd$5 + unusedValueExportToPlacateAjd;
23685
22715
  class LQuery_ {
23686
22716
  constructor(queryList) {
23687
22717
  this.queryList = queryList;
@@ -24511,8 +23541,7 @@ function compileNgModuleDefs(moduleType, ngModule, allowDuplicateDeclarationsInR
24511
23541
  Object.defineProperty(moduleType, NG_INJ_DEF, {
24512
23542
  get: () => {
24513
23543
  if (ngInjectorDef === null) {
24514
- ngDevMode &&
24515
- verifySemanticsOfNgModuleDef(moduleType, allowDuplicateDeclarationsInRoot);
23544
+ ngDevMode && verifySemanticsOfNgModuleDef(moduleType, allowDuplicateDeclarationsInRoot);
24516
23545
  const meta = {
24517
23546
  name: moduleType.name,
24518
23547
  type: moduleType,
@@ -27520,6 +26549,18 @@ function optionsReducer(dst, objs) {
27520
26549
  * @publicApi
27521
26550
  */
27522
26551
  class ApplicationRef {
26552
+ /**
26553
+ * Indicates whether this instance was destroyed.
26554
+ */
26555
+ get destroyed() {
26556
+ return this._destroyed;
26557
+ }
26558
+ /**
26559
+ * The `EnvironmentInjector` used to create this application.
26560
+ */
26561
+ get injector() {
26562
+ return this._injector;
26563
+ }
27523
26564
  /** @internal */
27524
26565
  constructor(_zone, _injector, _exceptionHandler) {
27525
26566
  this._zone = _zone;
@@ -27591,18 +26632,6 @@ class ApplicationRef {
27591
26632
  this.isStable =
27592
26633
  merge$1(isCurrentlyStable, isStable.pipe(share()));
27593
26634
  }
27594
- /**
27595
- * Indicates whether this instance was destroyed.
27596
- */
27597
- get destroyed() {
27598
- return this._destroyed;
27599
- }
27600
- /**
27601
- * The `EnvironmentInjector` used to create this application.
27602
- */
27603
- get injector() {
27604
- return this._injector;
27605
- }
27606
26635
  /**
27607
26636
  * Bootstrap a component onto the element identified by its selector or, optionally, to a
27608
26637
  * specified element.
@@ -30113,5 +29142,5 @@ if (typeof ngDevMode !== 'undefined' && ngDevMode) {
30113
29142
  * Generated bundle index. Do not edit.
30114
29143
  */
30115
29144
 
30116
- 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 };
29145
+ 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 };
30117
29146
  //# sourceMappingURL=core.mjs.map