@angular/core 7.1.0 → 7.1.4

package/esm2015/src/render3/interfaces/i18n.js

@@ -1,6 +1,6 @@
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
  */
 /**
  * @license
@@ -10,36 +10,51 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /** @enum {number} */
-var I18nMutateOpCode = {
+const I18nMutateOpCode = {
+    /// Stores shift amount for bits 17-3 that contain reference index.
     SHIFT_REF: 3,
+    /// Stores shift amount for bits 31-17 that contain parent index.
     SHIFT_PARENT: 17,
+    /// Mask for OpCode
     MASK_OPCODE: 7,
+    /// Mask for reference index.
     MASK_REF: 136,
+    /// OpCode to select a node. (next OpCode will contain the operation.)
     Select: 0,
+    /// OpCode to append the current node to `PARENT`.
     AppendChild: 1,
+    /// OpCode to insert the current node to `PARENT` before `REF`.
     InsertBefore: 2,
+    /// OpCode to remove the `REF` node from `PARENT`.
     Remove: 3,
+    /// OpCode to set the attribute of a node.
     Attr: 4,
+    /// OpCode to simulate elementEnd()
     ElementEnd: 5,
+    /// OpCode to read the remove OpCodes for the nested ICU
     RemoveNestedIcu: 6,
 };
 export { I18nMutateOpCode };
-/** *
+/**
  * Marks that the next string is for element.
  *
  * See `I18nMutateOpCodes` documentation.
-  @type {?} */
+ * @type {?}
+ */
 export const ELEMENT_MARKER = {
     marker: 'element'
 };
-/** *
+// WARNING: interface has both a type and a value, skipping emit
+/**
  * Marks that the next string is for comment.
  *
  * See `I18nMutateOpCodes` documentation.
-  @type {?} */
+ * @type {?}
+ */
 export const COMMENT_MARKER = {
     marker: 'comment'
 };
+// WARNING: interface has both a type and a value, skipping emit
 /**
  * Array storing OpCode for dynamically creating `i18n` blocks.
  *
@@ -117,14 +132,22 @@ export const COMMENT_MARKER = {
  */
 export function I18nMutateOpCodes() { }
 /** @enum {number} */
-var I18nUpdateOpCode = {
+const I18nUpdateOpCode = {
+    /// Stores shift amount for bits 17-2 that contain reference index.
     SHIFT_REF: 2,
+    /// Stores shift amount for bits 31-17 that contain which ICU in i18n block are we referring to.
     SHIFT_ICU: 17,
+    /// Mask for OpCode
     MASK_OPCODE: 3,
+    /// Mask for reference index.
     MASK_REF: 68,
+    /// OpCode to update a text node.
     Text: 0,
+    /// OpCode to update a attribute of a node.
     Attr: 1,
+    /// OpCode to switch the current ICU case.
     IcuSwitch: 2,
+    /// OpCode to update the current ICU case.
     IcuUpdate: 3,
 };
 export { I18nUpdateOpCode };
@@ -203,49 +226,51 @@ export function I18nUpdateOpCodes() { }
  * @record
  */
 export function TI18n() { }
-/**
- * Number of slots to allocate in expando.
- *
- * This is the max number of DOM elements which will be created by this i18n + ICU blocks. When
- * the DOM elements are being created they are stored in the EXPANDO, so that update OpCodes can
- * write into them.
- * @type {?}
- */
-TI18n.prototype.vars;
-/**
- * Index in EXPANDO where the i18n stores its DOM nodes.
- *
- * When the bindings are processed by the `i18nEnd` instruction it is necessary to know where the
- * newly created DOM nodes will be inserted.
- * @type {?}
- */
-TI18n.prototype.expandoStartIndex;
-/**
- * A set of OpCodes which will create the Text Nodes and ICU anchors for the translation blocks.
- *
- * NOTE: The ICU anchors are filled in with ICU Update OpCode.
- * @type {?}
- */
-TI18n.prototype.create;
-/**
- * A set of OpCodes which will be executed on each change detection to determine if any changes to
- * DOM are required.
- * @type {?}
- */
-TI18n.prototype.update;
-/**
- * A list of ICUs in a translation block (or `null` if block has no ICUs).
- *
- * Example:
- * Given: `<div i18n>You have {count, plural, ...} and {state, switch, ...}</div>`
- * There would be 2 ICUs in this array.
- *   1. `{count, plural, ...}`
- *   2. `{state, switch, ...}`
- * @type {?}
- */
-TI18n.prototype.icus;
+if (false) {
+    /**
+     * Number of slots to allocate in expando.
+     *
+     * This is the max number of DOM elements which will be created by this i18n + ICU blocks. When
+     * the DOM elements are being created they are stored in the EXPANDO, so that update OpCodes can
+     * write into them.
+     * @type {?}
+     */
+    TI18n.prototype.vars;
+    /**
+     * Index in EXPANDO where the i18n stores its DOM nodes.
+     *
+     * When the bindings are processed by the `i18nEnd` instruction it is necessary to know where the
+     * newly created DOM nodes will be inserted.
+     * @type {?}
+     */
+    TI18n.prototype.expandoStartIndex;
+    /**
+     * A set of OpCodes which will create the Text Nodes and ICU anchors for the translation blocks.
+     *
+     * NOTE: The ICU anchors are filled in with ICU Update OpCode.
+     * @type {?}
+     */
+    TI18n.prototype.create;
+    /**
+     * A set of OpCodes which will be executed on each change detection to determine if any changes to
+     * DOM are required.
+     * @type {?}
+     */
+    TI18n.prototype.update;
+    /**
+     * A list of ICUs in a translation block (or `null` if block has no ICUs).
+     *
+     * Example:
+     * Given: `<div i18n>You have {count, plural, ...} and {state, switch, ...}</div>`
+     * There would be 2 ICUs in this array.
+     *   1. `{count, plural, ...}`
+     *   2. `{state, switch, ...}`
+     * @type {?}
+     */
+    TI18n.prototype.icus;
+}
 /** @enum {number} */
-var IcuType = {
+const IcuType = {
     select: 0,
     plural: 1,
 };
@@ -254,82 +279,85 @@ export { IcuType };
  * @record
  */
 export function TIcu() { }
-/**
- * Defines the ICU type of `select` or `plural`
- * @type {?}
- */
-TIcu.prototype.type;
-/**
- * Number of slots to allocate in expando for each case.
- *
- * This is the max number of DOM elements which will be created by this i18n + ICU blocks. When
- * the DOM elements are being created they are stored in the EXPANDO, so that update OpCodes can
- * write into them.
- * @type {?}
- */
-TIcu.prototype.vars;
-/**
- * An optional array of child/sub ICUs.
- *
- * In case of nested ICUs such as:
- * ```
- * {�0�, plural,
- *   =0 {zero}
- *   other {�0� {�1�, select,
- *                     cat {cats}
- *                     dog {dogs}
- *                     other {animals}
- *                   }!
- *   }
- * }
- * ```
- * When the parent ICU is changing it must clean up child ICUs as well. For this reason it needs
- * to know which child ICUs to run clean up for as well.
- *
- * In the above example this would be:
- * ```
- * [
- *   [],   // `=0` has no sub ICUs
- *   [1],  // `other` has one subICU at `1`st index.
- * ]
- * ```
- *
- * The reason why it is Array of Arrays is because first array represents the case, and second
- * represents the child ICUs to clean up. There may be more than one child ICUs per case.
- * @type {?}
- */
-TIcu.prototype.childIcus;
-/**
- * Index in EXPANDO where the i18n stores its DOM nodes.
- *
- * When the bindings are processed by the `i18nEnd` instruction it is necessary to know where the
- * newly created DOM nodes will be inserted.
- * @type {?}
- */
-TIcu.prototype.expandoStartIndex;
-/**
- * A list of case values which the current ICU will try to match.
- *
- * The last value is `other`
- * @type {?}
- */
-TIcu.prototype.cases;
-/**
- * A set of OpCodes to apply in order to build up the DOM render tree for the ICU
- * @type {?}
- */
-TIcu.prototype.create;
-/**
- * A set of OpCodes to apply in order to destroy the DOM render tree for the ICU.
- * @type {?}
- */
-TIcu.prototype.remove;
-/**
- * A set of OpCodes to apply in order to update the DOM render tree for the ICU bindings.
- * @type {?}
- */
-TIcu.prototype.update;
+if (false) {
+    /**
+     * Defines the ICU type of `select` or `plural`
+     * @type {?}
+     */
+    TIcu.prototype.type;
+    /**
+     * Number of slots to allocate in expando for each case.
+     *
+     * This is the max number of DOM elements which will be created by this i18n + ICU blocks. When
+     * the DOM elements are being created they are stored in the EXPANDO, so that update OpCodes can
+     * write into them.
+     * @type {?}
+     */
+    TIcu.prototype.vars;
+    /**
+     * An optional array of child/sub ICUs.
+     *
+     * In case of nested ICUs such as:
+     * ```
+     * {�0�, plural,
+     *   =0 {zero}
+     *   other {�0� {�1�, select,
+     *                     cat {cats}
+     *                     dog {dogs}
+     *                     other {animals}
+     *                   }!
+     *   }
+     * }
+     * ```
+     * When the parent ICU is changing it must clean up child ICUs as well. For this reason it needs
+     * to know which child ICUs to run clean up for as well.
+     *
+     * In the above example this would be:
+     * ```
+     * [
+     *   [],   // `=0` has no sub ICUs
+     *   [1],  // `other` has one subICU at `1`st index.
+     * ]
+     * ```
+     *
+     * The reason why it is Array of Arrays is because first array represents the case, and second
+     * represents the child ICUs to clean up. There may be more than one child ICUs per case.
+     * @type {?}
+     */
+    TIcu.prototype.childIcus;
+    /**
+     * Index in EXPANDO where the i18n stores its DOM nodes.
+     *
+     * When the bindings are processed by the `i18nEnd` instruction it is necessary to know where the
+     * newly created DOM nodes will be inserted.
+     * @type {?}
+     */
+    TIcu.prototype.expandoStartIndex;
+    /**
+     * A list of case values which the current ICU will try to match.
+     *
+     * The last value is `other`
+     * @type {?}
+     */
+    TIcu.prototype.cases;
+    /**
+     * A set of OpCodes to apply in order to build up the DOM render tree for the ICU
+     * @type {?}
+     */
+    TIcu.prototype.create;
+    /**
+     * A set of OpCodes to apply in order to destroy the DOM render tree for the ICU.
+     * @type {?}
+     */
+    TIcu.prototype.remove;
+    /**
+     * A set of OpCodes to apply in order to update the DOM render tree for the ICU bindings.
+     * @type {?}
+     */
+    TIcu.prototype.update;
+}
+// Note: This hack is necessary so we don't erroneously get a circular dependency
+// failure based on types.
 /** @type {?} */
 export const unusedValueExportToPlacateAjd = 1;
-
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"i18n.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/interfaces/i18n.ts"],"names":[],"mappings":";;;;;;;;;;;;;IAsBE,YAAa;IAEb,gBAAiB;IAEjB,cAAmB;IAEnB,aAAsC;IAGtC,SAAc;IAEd,cAAmB;IAEnB,eAAoB;IAEpB,SAAc;IAEd,OAAY;IAEZ,aAAkB;IAElB,kBAAuB;;;;;;;;AAQzB,aAAa,cAAc,GAAmB;IAC5C,MAAM,EAAE,SAAS;CAClB,CAAC;;;;;;AAQF,aAAa,cAAc,GAAmB;IAC5C,MAAM,EAAE,SAAS;CAClB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmFA,YAAa;IAEb,aAAc;IAEd,cAAkB;IAElB,YAAsC;IAGtC,OAAW;IAEX,OAAW;IAEX,YAAgB;IAEhB,YAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA2HhB,SAAU;IACV,SAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkFZ,aAAa,6BAA6B,GAAG,CAAC,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * `I18nMutateOpCode` defines OpCodes for `I18nMutateOpCodes` array.\n *\n * OpCodes contain three parts:\n *  1) Parent node index offset.\n *  2) Reference node index offset.\n *  3) The OpCode to execute.\n *\n * See: `I18nCreateOpCodes` for example of usage.\n */\nimport {SanitizerFn} from './sanitization';\n\nexport const enum I18nMutateOpCode {\n  /// Stores shift amount for bits 17-3 that contain reference index.\n  SHIFT_REF = 3,\n  /// Stores shift amount for bits 31-17 that contain parent index.\n  SHIFT_PARENT = 17,\n  /// Mask for OpCode\n  MASK_OPCODE = 0b111,\n  /// Mask for reference index.\n  MASK_REF = ((2 ^ 16) - 1) << SHIFT_REF,\n\n  /// OpCode to select a node. (next OpCode will contain the operation.)\n  Select = 0b000,\n  /// OpCode to append the current node to `PARENT`.\n  AppendChild = 0b001,\n  /// OpCode to insert the current node to `PARENT` before `REF`.\n  InsertBefore = 0b010,\n  /// OpCode to remove the `REF` node from `PARENT`.\n  Remove = 0b011,\n  /// OpCode to set the attribute of a node.\n  Attr = 0b100,\n  /// OpCode to simulate elementEnd()\n  ElementEnd = 0b101,\n  /// OpCode to read the remove OpCodes for the nested ICU\n  RemoveNestedIcu = 0b110,\n}\n\n/**\n * Marks that the next string is for element.\n *\n * See `I18nMutateOpCodes` documentation.\n */\nexport const ELEMENT_MARKER: ELEMENT_MARKER = {\n  marker: 'element'\n};\nexport interface ELEMENT_MARKER { marker: 'element'; }\n\n/**\n * Marks that the next string is for comment.\n *\n * See `I18nMutateOpCodes` documentation.\n */\nexport const COMMENT_MARKER: COMMENT_MARKER = {\n  marker: 'comment'\n};\n\nexport interface COMMENT_MARKER { marker: 'comment'; }\n\n/**\n * Array storing OpCode for dynamically creating `i18n` blocks.\n *\n * Example:\n * ```\n * <I18nCreateOpCode>[\n *   // For adding text nodes\n *   // ---------------------\n *   // Equivalent to:\n *   //   const node = lViewData[index++] = document.createTextNode('abc');\n *   //   lViewData[1].insertBefore(node, lViewData[2]);\n *   'abc', 1 << SHIFT_PARENT | 2 << SHIFT_REF | InsertBefore,\n *\n *   // Equivalent to:\n *   //   const node = lViewData[index++] = document.createTextNode('xyz');\n *   //   lViewData[1].appendChild(node);\n *   'xyz', 1 << SHIFT_PARENT | AppendChild,\n *\n *   // For adding element nodes\n *   // ---------------------\n *   // Equivalent to:\n *   //   const node = lViewData[index++] = document.createElement('div');\n *   //   lViewData[1].insertBefore(node, lViewData[2]);\n *   ELEMENT_MARKER, 'div', 1 << SHIFT_PARENT | 2 << SHIFT_REF | InsertBefore,\n *\n *   // Equivalent to:\n *   //   const node = lViewData[index++] = document.createElement('div');\n *   //   lViewData[1].appendChild(node);\n *   ELEMENT_MARKER, 'div', 1 << SHIFT_PARENT | AppendChild,\n *\n *   // For adding comment nodes\n *   // ---------------------\n *   // Equivalent to:\n *   //   const node = lViewData[index++] = document.createComment('');\n *   //   lViewData[1].insertBefore(node, lViewData[2]);\n *   COMMENT_MARKER, '', 1 << SHIFT_PARENT | 2 << SHIFT_REF | InsertBefore,\n *\n *   // Equivalent to:\n *   //   const node = lViewData[index++] = document.createComment('');\n *   //   lViewData[1].appendChild(node);\n *   COMMENT_MARKER, '', 1 << SHIFT_PARENT | AppendChild,\n *\n *   // For moving existing nodes to a different location\n *   // --------------------------------------------------\n *   // Equivalent to:\n *   //   const node = lViewData[1];\n *   //   lViewData[2].insertBefore(node, lViewData[3]);\n *   1 << SHIFT_REF | Select, 2 << SHIFT_PARENT | 3 << SHIFT_REF | InsertBefore,\n *\n *   // Equivalent to:\n *   //   const node = lViewData[1];\n *   //   lViewData[2].appendChild(node);\n *   1 << SHIFT_REF | Select, 2 << SHIFT_PARENT | AppendChild,\n *\n *   // For removing existing nodes\n *   // --------------------------------------------------\n *   //   const node = lViewData[1];\n *   //   removeChild(tView.data(1), node, lViewData);\n *   1 << SHIFT_REF | Remove,\n *\n *   // For writing attributes\n *   // --------------------------------------------------\n *   //   const node = lViewData[1];\n *   //   node.setAttribute('attr', 'value');\n *   1 << SHIFT_REF | Select, 'attr', 'value'\n *            // NOTE: Select followed by two string (vs select followed by OpCode)\n * ];\n * ```\n * NOTE:\n *   - `index` is initial location where the extra nodes should be stored in the EXPANDO section of\n * `LVIewData`.\n *\n * See: `applyI18nCreateOpCodes`;\n */\nexport interface I18nMutateOpCodes extends Array<number|string|ELEMENT_MARKER|COMMENT_MARKER|null> {\n}\n\nexport const enum I18nUpdateOpCode {\n  /// Stores shift amount for bits 17-2 that contain reference index.\n  SHIFT_REF = 2,\n  /// Stores shift amount for bits 31-17 that contain which ICU in i18n block are we referring to.\n  SHIFT_ICU = 17,\n  /// Mask for OpCode\n  MASK_OPCODE = 0b11,\n  /// Mask for reference index.\n  MASK_REF = ((2 ^ 16) - 1) << SHIFT_REF,\n\n  /// OpCode to update a text node.\n  Text = 0b00,\n  /// OpCode to update a attribute of a node.\n  Attr = 0b01,\n  /// OpCode to switch the current ICU case.\n  IcuSwitch = 0b10,\n  /// OpCode to update the current ICU case.\n  IcuUpdate = 0b11,\n}\n\n/**\n * Stores DOM operations which need to be applied to update DOM render tree due to changes in\n * expressions.\n *\n * The basic idea is that `i18nExp` OpCodes capture expression changes and update a change\n * mask bit. (Bit 1 for expression 1, bit 2 for expression 2 etc..., bit 32 for expression 32 and\n * higher.) The OpCodes then compare its own change mask against the expression change mask to\n * determine if the OpCodes should execute.\n *\n * These OpCodes can be used by both the i18n block as well as ICU sub-block.\n *\n * ## Example\n *\n * Assume\n * ```\n *   if (rf & RenderFlags.Update) {\n *    i18nExp(bind(ctx.exp1)); // If changed set mask bit 1\n *    i18nExp(bind(ctx.exp2)); // If changed set mask bit 2\n *    i18nExp(bind(ctx.exp3)); // If changed set mask bit 3\n *    i18nExp(bind(ctx.exp4)); // If changed set mask bit 4\n *    i18nApply(0);            // Apply all changes by executing the OpCodes.\n *  }\n * ```\n * We can assume that each call to `i18nExp` sets an internal `changeMask` bit depending on the\n * index of `i18nExp`.\n *\n * OpCodes\n * ```\n * <I18nUpdateOpCodes>[\n *   // The following OpCodes represent: `<div i18n-title=\"pre{{exp1}}in{{exp2}}post\">`\n *   // If `changeMask & 0b11`\n *   //        has changed then execute update OpCodes.\n *   //        has NOT changed then skip `7` values and start processing next OpCodes.\n *   0b11, 7,\n *   // Concatenate `newValue = 'pre'+lViewData[bindIndex-4]+'in'+lViewData[bindIndex-3]+'post';`.\n *   'pre', -4, 'in', -3, 'post',\n *   // Update attribute: `elementAttribute(1, 'title', sanitizerFn(newValue));`\n *   1 << SHIFT_REF | Attr, 'title', sanitizerFn,\n *\n *   // The following OpCodes represent: `<div i18n>Hello {{exp3}}!\">`\n *   // If `changeMask & 0b100`\n *   //        has changed then execute update OpCodes.\n *   //        has NOT changed then skip `4` values and start processing next OpCodes.\n *   0b100, 4,\n *   // Concatenate `newValue = 'Hello ' + lViewData[bindIndex -2] + '!';`.\n *   'Hello ', -2, '!',\n *   // Update text: `lViewData[1].textContent = newValue;`\n *   1 << SHIFT_REF | Text,\n *\n *   // The following OpCodes represent: `<div i18n>{exp4, plural, ... }\">`\n *   // If `changeMask & 0b1000`\n *   //        has changed then execute update OpCodes.\n *   //        has NOT changed then skip `4` values and start processing next OpCodes.\n *   0b1000, 4,\n *   // Concatenate `newValue = lViewData[bindIndex -1];`.\n *   -1,\n *   // Switch ICU: `icuSwitchCase(lViewData[1], 0, newValue);`\n *   0 << SHIFT_ICU | 1 << SHIFT_REF | IcuSwitch,\n *\n *   // Note `changeMask & -1` is always true, so the IcuUpdate will always execute.\n *   -1, 1,\n *   // Update ICU: `icuUpdateCase(lViewData[1], 0);`\n *   0 << SHIFT_ICU | 1 << SHIFT_REF | IcuUpdate,\n *\n * ];\n * ```\n *\n */\nexport interface I18nUpdateOpCodes extends Array<string|number|SanitizerFn|null> {}\n\n/**\n * Store information for the i18n translation block.\n */\nexport interface TI18n {\n  /**\n   * Number of slots to allocate in expando.\n   *\n   * This is the max number of DOM elements which will be created by this i18n + ICU blocks. When\n   * the DOM elements are being created they are stored in the EXPANDO, so that update OpCodes can\n   * write into them.\n   */\n  vars: number;\n\n  /**\n   * Index in EXPANDO where the i18n stores its DOM nodes.\n   *\n   * When the bindings are processed by the `i18nEnd` instruction it is necessary to know where the\n   * newly created DOM nodes will be inserted.\n   */\n  expandoStartIndex: number;\n\n  /**\n   * A set of OpCodes which will create the Text Nodes and ICU anchors for the translation blocks.\n   *\n   * NOTE: The ICU anchors are filled in with ICU Update OpCode.\n   */\n  create: I18nMutateOpCodes;\n\n  /**\n   * A set of OpCodes which will be executed on each change detection to determine if any changes to\n   * DOM are required.\n   */\n  update: I18nUpdateOpCodes;\n\n  /**\n   * A list of ICUs in a translation block (or `null` if block has no ICUs).\n   *\n   * Example:\n   * Given: `<div i18n>You have {count, plural, ...} and {state, switch, ...}</div>`\n   * There would be 2 ICUs in this array.\n   *   1. `{count, plural, ...}`\n   *   2. `{state, switch, ...}`\n   */\n  icus: TIcu[]|null;\n}\n\n/**\n * Defines the ICU type of `select` or `plural`\n */\nexport const enum IcuType {\n  select = 0,\n  plural = 1,\n}\n\nexport interface TIcu {\n  /**\n   * Defines the ICU type of `select` or `plural`\n   */\n  type: IcuType;\n\n  /**\n   * Number of slots to allocate in expando for each case.\n   *\n   * This is the max number of DOM elements which will be created by this i18n + ICU blocks. When\n   * the DOM elements are being created they are stored in the EXPANDO, so that update OpCodes can\n   * write into them.\n   */\n  vars: number[];\n\n  /**\n   * An optional array of child/sub ICUs.\n   *\n   * In case of nested ICUs such as:\n   * ```\n   * {�0�, plural,\n   *   =0 {zero}\n   *   other {�0� {�1�, select,\n   *                     cat {cats}\n   *                     dog {dogs}\n   *                     other {animals}\n   *                   }!\n   *   }\n   * }\n   * ```\n   * When the parent ICU is changing it must clean up child ICUs as well. For this reason it needs\n   * to know which child ICUs to run clean up for as well.\n   *\n   * In the above example this would be:\n   * ```\n   * [\n   *   [],   // `=0` has no sub ICUs\n   *   [1],  // `other` has one subICU at `1`st index.\n   * ]\n   * ```\n   *\n   * The reason why it is Array of Arrays is because first array represents the case, and second\n   * represents the child ICUs to clean up. There may be more than one child ICUs per case.\n   */\n  childIcus: number[][];\n\n  /**\n   * Index in EXPANDO where the i18n stores its DOM nodes.\n   *\n   * When the bindings are processed by the `i18nEnd` instruction it is necessary to know where the\n   * newly created DOM nodes will be inserted.\n   */\n  expandoStartIndex: number;\n\n  /**\n   * A list of case values which the current ICU will try to match.\n   *\n   * The last value is `other`\n   */\n  cases: any[];\n\n  /**\n   * A set of OpCodes to apply in order to build up the DOM render tree for the ICU\n   */\n  create: I18nMutateOpCodes[];\n\n  /**\n   * A set of OpCodes to apply in order to destroy the DOM render tree for the ICU.\n   */\n  remove: I18nMutateOpCodes[];\n\n  /**\n   * A set of OpCodes to apply in order to update the DOM render tree for the ICU bindings.\n   */\n  update: I18nUpdateOpCodes[];\n}\n\n// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\nexport const unusedValueExportToPlacateAjd = 1;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"i18n.js","sourceRoot":"../../","sources":["packages/core/src/render3/interfaces/i18n.ts"],"names":[],"mappings":";;;;;;;;;;;;;IAqBE,mEAAmE;IACnE,YAAa;IACb,iEAAiE;IACjE,gBAAiB;IACjB,mBAAmB;IACnB,cAAmB;IACnB,6BAA6B;IAC7B,aAAsC;IAEtC,sEAAsE;IACtE,SAAc;IACd,kDAAkD;IAClD,cAAmB;IACnB,+DAA+D;IAC/D,eAAoB;IACpB,kDAAkD;IAClD,SAAc;IACd,0CAA0C;IAC1C,OAAY;IACZ,mCAAmC;IACnC,aAAkB;IAClB,wDAAwD;IACxD,kBAAuB;;;;;;;;;AAQzB,MAAM,OAAO,cAAc,GAAmB;IAC5C,MAAM,EAAE,SAAS;CAClB;;;;;;;;AAQD,MAAM,OAAO,cAAc,GAAmB;IAC5C,MAAM,EAAE,SAAS;CAClB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8ED,uCACC;;;IAGC,mEAAmE;IACnE,YAAa;IACb,gGAAgG;IAChG,aAAc;IACd,mBAAmB;IACnB,cAAkB;IAClB,6BAA6B;IAC7B,YAAsC;IAEtC,iCAAiC;IACjC,OAAW;IACX,2CAA2C;IAC3C,OAAW;IACX,0CAA0C;IAC1C,YAAgB;IAChB,0CAA0C;IAC1C,YAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuElB,uCAAmF;;;;;AAKnF,2BAyCC;;;;;;;;;;IAjCC,qBAAa;;;;;;;;IAQb,kCAA0B;;;;;;;IAO1B,uBAA0B;;;;;;IAM1B,uBAA0B;;;;;;;;;;;IAW1B,qBAAkB;;;;IAOlB,SAAU;IACV,SAAU;;;;;;AAGZ,0BA2EC;;;;;;IAvEC,oBAAc;;;;;;;;;IASd,oBAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA+Bf,yBAAsB;;;;;;;;IAQtB,iCAA0B;;;;;;;IAO1B,qBAAa;;;;;IAKb,sBAA4B;;;;;IAK5B,sBAA4B;;;;;IAK5B,sBAA4B;;;;;AAK9B,MAAM,OAAO,6BAA6B,GAAG,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * `I18nMutateOpCode` defines OpCodes for `I18nMutateOpCodes` array.\n *\n * OpCodes contain three parts:\n *  1) Parent node index offset.\n *  2) Reference node index offset.\n *  3) The OpCode to execute.\n *\n * See: `I18nCreateOpCodes` for example of usage.\n */\nimport {SanitizerFn} from './sanitization';\n\nexport const enum I18nMutateOpCode {\n  /// Stores shift amount for bits 17-3 that contain reference index.\n  SHIFT_REF = 3,\n  /// Stores shift amount for bits 31-17 that contain parent index.\n  SHIFT_PARENT = 17,\n  /// Mask for OpCode\n  MASK_OPCODE = 0b111,\n  /// Mask for reference index.\n  MASK_REF = ((2 ^ 16) - 1) << SHIFT_REF,\n\n  /// OpCode to select a node. (next OpCode will contain the operation.)\n  Select = 0b000,\n  /// OpCode to append the current node to `PARENT`.\n  AppendChild = 0b001,\n  /// OpCode to insert the current node to `PARENT` before `REF`.\n  InsertBefore = 0b010,\n  /// OpCode to remove the `REF` node from `PARENT`.\n  Remove = 0b011,\n  /// OpCode to set the attribute of a node.\n  Attr = 0b100,\n  /// OpCode to simulate elementEnd()\n  ElementEnd = 0b101,\n  /// OpCode to read the remove OpCodes for the nested ICU\n  RemoveNestedIcu = 0b110,\n}\n\n/**\n * Marks that the next string is for element.\n *\n * See `I18nMutateOpCodes` documentation.\n */\nexport const ELEMENT_MARKER: ELEMENT_MARKER = {\n  marker: 'element'\n};\nexport interface ELEMENT_MARKER { marker: 'element'; }\n\n/**\n * Marks that the next string is for comment.\n *\n * See `I18nMutateOpCodes` documentation.\n */\nexport const COMMENT_MARKER: COMMENT_MARKER = {\n  marker: 'comment'\n};\n\nexport interface COMMENT_MARKER { marker: 'comment'; }\n\n/**\n * Array storing OpCode for dynamically creating `i18n` blocks.\n *\n * Example:\n * ```\n * <I18nCreateOpCode>[\n *   // For adding text nodes\n *   // ---------------------\n *   // Equivalent to:\n *   //   const node = lViewData[index++] = document.createTextNode('abc');\n *   //   lViewData[1].insertBefore(node, lViewData[2]);\n *   'abc', 1 << SHIFT_PARENT | 2 << SHIFT_REF | InsertBefore,\n *\n *   // Equivalent to:\n *   //   const node = lViewData[index++] = document.createTextNode('xyz');\n *   //   lViewData[1].appendChild(node);\n *   'xyz', 1 << SHIFT_PARENT | AppendChild,\n *\n *   // For adding element nodes\n *   // ---------------------\n *   // Equivalent to:\n *   //   const node = lViewData[index++] = document.createElement('div');\n *   //   lViewData[1].insertBefore(node, lViewData[2]);\n *   ELEMENT_MARKER, 'div', 1 << SHIFT_PARENT | 2 << SHIFT_REF | InsertBefore,\n *\n *   // Equivalent to:\n *   //   const node = lViewData[index++] = document.createElement('div');\n *   //   lViewData[1].appendChild(node);\n *   ELEMENT_MARKER, 'div', 1 << SHIFT_PARENT | AppendChild,\n *\n *   // For adding comment nodes\n *   // ---------------------\n *   // Equivalent to:\n *   //   const node = lViewData[index++] = document.createComment('');\n *   //   lViewData[1].insertBefore(node, lViewData[2]);\n *   COMMENT_MARKER, '', 1 << SHIFT_PARENT | 2 << SHIFT_REF | InsertBefore,\n *\n *   // Equivalent to:\n *   //   const node = lViewData[index++] = document.createComment('');\n *   //   lViewData[1].appendChild(node);\n *   COMMENT_MARKER, '', 1 << SHIFT_PARENT | AppendChild,\n *\n *   // For moving existing nodes to a different location\n *   // --------------------------------------------------\n *   // Equivalent to:\n *   //   const node = lViewData[1];\n *   //   lViewData[2].insertBefore(node, lViewData[3]);\n *   1 << SHIFT_REF | Select, 2 << SHIFT_PARENT | 3 << SHIFT_REF | InsertBefore,\n *\n *   // Equivalent to:\n *   //   const node = lViewData[1];\n *   //   lViewData[2].appendChild(node);\n *   1 << SHIFT_REF | Select, 2 << SHIFT_PARENT | AppendChild,\n *\n *   // For removing existing nodes\n *   // --------------------------------------------------\n *   //   const node = lViewData[1];\n *   //   removeChild(tView.data(1), node, lViewData);\n *   1 << SHIFT_REF | Remove,\n *\n *   // For writing attributes\n *   // --------------------------------------------------\n *   //   const node = lViewData[1];\n *   //   node.setAttribute('attr', 'value');\n *   1 << SHIFT_REF | Select, 'attr', 'value'\n *            // NOTE: Select followed by two string (vs select followed by OpCode)\n * ];\n * ```\n * NOTE:\n *   - `index` is initial location where the extra nodes should be stored in the EXPANDO section of\n * `LVIewData`.\n *\n * See: `applyI18nCreateOpCodes`;\n */\nexport interface I18nMutateOpCodes extends Array<number|string|ELEMENT_MARKER|COMMENT_MARKER|null> {\n}\n\nexport const enum I18nUpdateOpCode {\n  /// Stores shift amount for bits 17-2 that contain reference index.\n  SHIFT_REF = 2,\n  /// Stores shift amount for bits 31-17 that contain which ICU in i18n block are we referring to.\n  SHIFT_ICU = 17,\n  /// Mask for OpCode\n  MASK_OPCODE = 0b11,\n  /// Mask for reference index.\n  MASK_REF = ((2 ^ 16) - 1) << SHIFT_REF,\n\n  /// OpCode to update a text node.\n  Text = 0b00,\n  /// OpCode to update a attribute of a node.\n  Attr = 0b01,\n  /// OpCode to switch the current ICU case.\n  IcuSwitch = 0b10,\n  /// OpCode to update the current ICU case.\n  IcuUpdate = 0b11,\n}\n\n/**\n * Stores DOM operations which need to be applied to update DOM render tree due to changes in\n * expressions.\n *\n * The basic idea is that `i18nExp` OpCodes capture expression changes and update a change\n * mask bit. (Bit 1 for expression 1, bit 2 for expression 2 etc..., bit 32 for expression 32 and\n * higher.) The OpCodes then compare its own change mask against the expression change mask to\n * determine if the OpCodes should execute.\n *\n * These OpCodes can be used by both the i18n block as well as ICU sub-block.\n *\n * ## Example\n *\n * Assume\n * ```\n *   if (rf & RenderFlags.Update) {\n *    i18nExp(bind(ctx.exp1)); // If changed set mask bit 1\n *    i18nExp(bind(ctx.exp2)); // If changed set mask bit 2\n *    i18nExp(bind(ctx.exp3)); // If changed set mask bit 3\n *    i18nExp(bind(ctx.exp4)); // If changed set mask bit 4\n *    i18nApply(0);            // Apply all changes by executing the OpCodes.\n *  }\n * ```\n * We can assume that each call to `i18nExp` sets an internal `changeMask` bit depending on the\n * index of `i18nExp`.\n *\n * OpCodes\n * ```\n * <I18nUpdateOpCodes>[\n *   // The following OpCodes represent: `<div i18n-title=\"pre{{exp1}}in{{exp2}}post\">`\n *   // If `changeMask & 0b11`\n *   //        has changed then execute update OpCodes.\n *   //        has NOT changed then skip `7` values and start processing next OpCodes.\n *   0b11, 7,\n *   // Concatenate `newValue = 'pre'+lViewData[bindIndex-4]+'in'+lViewData[bindIndex-3]+'post';`.\n *   'pre', -4, 'in', -3, 'post',\n *   // Update attribute: `elementAttribute(1, 'title', sanitizerFn(newValue));`\n *   1 << SHIFT_REF | Attr, 'title', sanitizerFn,\n *\n *   // The following OpCodes represent: `<div i18n>Hello {{exp3}}!\">`\n *   // If `changeMask & 0b100`\n *   //        has changed then execute update OpCodes.\n *   //        has NOT changed then skip `4` values and start processing next OpCodes.\n *   0b100, 4,\n *   // Concatenate `newValue = 'Hello ' + lViewData[bindIndex -2] + '!';`.\n *   'Hello ', -2, '!',\n *   // Update text: `lViewData[1].textContent = newValue;`\n *   1 << SHIFT_REF | Text,\n *\n *   // The following OpCodes represent: `<div i18n>{exp4, plural, ... }\">`\n *   // If `changeMask & 0b1000`\n *   //        has changed then execute update OpCodes.\n *   //        has NOT changed then skip `4` values and start processing next OpCodes.\n *   0b1000, 4,\n *   // Concatenate `newValue = lViewData[bindIndex -1];`.\n *   -1,\n *   // Switch ICU: `icuSwitchCase(lViewData[1], 0, newValue);`\n *   0 << SHIFT_ICU | 1 << SHIFT_REF | IcuSwitch,\n *\n *   // Note `changeMask & -1` is always true, so the IcuUpdate will always execute.\n *   -1, 1,\n *   // Update ICU: `icuUpdateCase(lViewData[1], 0);`\n *   0 << SHIFT_ICU | 1 << SHIFT_REF | IcuUpdate,\n *\n * ];\n * ```\n *\n */\nexport interface I18nUpdateOpCodes extends Array<string|number|SanitizerFn|null> {}\n\n/**\n * Store information for the i18n translation block.\n */\nexport interface TI18n {\n  /**\n   * Number of slots to allocate in expando.\n   *\n   * This is the max number of DOM elements which will be created by this i18n + ICU blocks. When\n   * the DOM elements are being created they are stored in the EXPANDO, so that update OpCodes can\n   * write into them.\n   */\n  vars: number;\n\n  /**\n   * Index in EXPANDO where the i18n stores its DOM nodes.\n   *\n   * When the bindings are processed by the `i18nEnd` instruction it is necessary to know where the\n   * newly created DOM nodes will be inserted.\n   */\n  expandoStartIndex: number;\n\n  /**\n   * A set of OpCodes which will create the Text Nodes and ICU anchors for the translation blocks.\n   *\n   * NOTE: The ICU anchors are filled in with ICU Update OpCode.\n   */\n  create: I18nMutateOpCodes;\n\n  /**\n   * A set of OpCodes which will be executed on each change detection to determine if any changes to\n   * DOM are required.\n   */\n  update: I18nUpdateOpCodes;\n\n  /**\n   * A list of ICUs in a translation block (or `null` if block has no ICUs).\n   *\n   * Example:\n   * Given: `<div i18n>You have {count, plural, ...} and {state, switch, ...}</div>`\n   * There would be 2 ICUs in this array.\n   *   1. `{count, plural, ...}`\n   *   2. `{state, switch, ...}`\n   */\n  icus: TIcu[]|null;\n}\n\n/**\n * Defines the ICU type of `select` or `plural`\n */\nexport const enum IcuType {\n  select = 0,\n  plural = 1,\n}\n\nexport interface TIcu {\n  /**\n   * Defines the ICU type of `select` or `plural`\n   */\n  type: IcuType;\n\n  /**\n   * Number of slots to allocate in expando for each case.\n   *\n   * This is the max number of DOM elements which will be created by this i18n + ICU blocks. When\n   * the DOM elements are being created they are stored in the EXPANDO, so that update OpCodes can\n   * write into them.\n   */\n  vars: number[];\n\n  /**\n   * An optional array of child/sub ICUs.\n   *\n   * In case of nested ICUs such as:\n   * ```\n   * {�0�, plural,\n   *   =0 {zero}\n   *   other {�0� {�1�, select,\n   *                     cat {cats}\n   *                     dog {dogs}\n   *                     other {animals}\n   *                   }!\n   *   }\n   * }\n   * ```\n   * When the parent ICU is changing it must clean up child ICUs as well. For this reason it needs\n   * to know which child ICUs to run clean up for as well.\n   *\n   * In the above example this would be:\n   * ```\n   * [\n   *   [],   // `=0` has no sub ICUs\n   *   [1],  // `other` has one subICU at `1`st index.\n   * ]\n   * ```\n   *\n   * The reason why it is Array of Arrays is because first array represents the case, and second\n   * represents the child ICUs to clean up. There may be more than one child ICUs per case.\n   */\n  childIcus: number[][];\n\n  /**\n   * Index in EXPANDO where the i18n stores its DOM nodes.\n   *\n   * When the bindings are processed by the `i18nEnd` instruction it is necessary to know where the\n   * newly created DOM nodes will be inserted.\n   */\n  expandoStartIndex: number;\n\n  /**\n   * A list of case values which the current ICU will try to match.\n   *\n   * The last value is `other`\n   */\n  cases: any[];\n\n  /**\n   * A set of OpCodes to apply in order to build up the DOM render tree for the ICU\n   */\n  create: I18nMutateOpCodes[];\n\n  /**\n   * A set of OpCodes to apply in order to destroy the DOM render tree for the ICU.\n   */\n  remove: I18nMutateOpCodes[];\n\n  /**\n   * A set of OpCodes to apply in order to update the DOM render tree for the ICU bindings.\n   */\n  update: I18nUpdateOpCodes[];\n}\n\n// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\nexport const unusedValueExportToPlacateAjd = 1;\n"]}

package/esm2015/src/render3/interfaces/injector.js

@@ -1,6 +1,6 @@
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
  */
 /**
  * @license
@@ -23,10 +23,12 @@ export const INJECTOR_SIZE = 9;
  * @record
  */
 export function RelativeInjectorLocation() { }
-/** @type {?} */
-RelativeInjectorLocation.prototype.__brand__;
+if (false) {
+    /** @type {?} */
+    RelativeInjectorLocation.prototype.__brand__;
+}
 /** @enum {number} */
-var RelativeInjectorLocationFlags = {
+const RelativeInjectorLocationFlags = {
     InjectorIndexMask: 32767,
     AcrossHostBoundary: 32768,
     ViewOffsetShift: 16,
@@ -34,7 +36,86 @@ var RelativeInjectorLocationFlags = {
 };
 export { RelativeInjectorLocationFlags };
 /** @type {?} */
-export const NO_PARENT_INJECTOR = /** @type {?} */ (-1);
+export const NO_PARENT_INJECTOR = (/** @type {?} */ (-1));
+/**
+ * Each injector is saved in 9 contiguous slots in `LViewData` and 9 contiguous slots in
+ * `TView.data`. This allows us to store information about the current node's tokens (which
+ * can be shared in `TView`) as well as the tokens of its ancestor nodes (which cannot be
+ * shared, so they live in `LViewData`).
+ *
+ * Each of these slots (aside from the last slot) contains a bloom filter. This bloom filter
+ * determines whether a directive is available on the associated node or not. This prevents us
+ * from searching the directives array at this level unless it's probable the directive is in it.
+ *
+ * See: https://en.wikipedia.org/wiki/Bloom_filter for more about bloom filters.
+ *
+ * Because all injectors have been flattened into `LViewData` and `TViewData`, they cannot typed
+ * using interfaces as they were previously. The start index of each `LInjector` and `TInjector`
+ * will differ based on where it is flattened into the main array, so it's not possible to know
+ * the indices ahead of time and save their types here. The interfaces are still included here
+ * for documentation purposes.
+ *
+ * export interface LInjector extends Array<any> {
+ *
+ *    // Cumulative bloom for directive IDs 0-31  (IDs are % BLOOM_SIZE)
+ *    [0]: number;
+ *
+ *    // Cumulative bloom for directive IDs 32-63
+ *    [1]: number;
+ *
+ *    // Cumulative bloom for directive IDs 64-95
+ *    [2]: number;
+ *
+ *    // Cumulative bloom for directive IDs 96-127
+ *    [3]: number;
+ *
+ *    // Cumulative bloom for directive IDs 128-159
+ *    [4]: number;
+ *
+ *    // Cumulative bloom for directive IDs 160 - 191
+ *    [5]: number;
+ *
+ *    // Cumulative bloom for directive IDs 192 - 223
+ *    [6]: number;
+ *
+ *    // Cumulative bloom for directive IDs 224 - 255
+ *    [7]: number;
+ *
+ *    // We need to store a reference to the injector's parent so DI can keep looking up
+ *    // the injector tree until it finds the dependency it's looking for.
+ *    [PARENT_INJECTOR]: number;
+ * }
+ *
+ * export interface TInjector extends Array<any> {
+ *
+ *    // Shared node bloom for directive IDs 0-31  (IDs are % BLOOM_SIZE)
+ *    [0]: number;
+ *
+ *    // Shared node bloom for directive IDs 32-63
+ *    [1]: number;
+ *
+ *    // Shared node bloom for directive IDs 64-95
+ *    [2]: number;
+ *
+ *    // Shared node bloom for directive IDs 96-127
+ *    [3]: number;
+ *
+ *    // Shared node bloom for directive IDs 128-159
+ *    [4]: number;
+ *
+ *    // Shared node bloom for directive IDs 160 - 191
+ *    [5]: number;
+ *
+ *    // Shared node bloom for directive IDs 192 - 223
+ *    [6]: number;
+ *
+ *    // Shared node bloom for directive IDs 224 - 255
+ *    [7]: number;
+ *
+ *    // Necessary to find directive indices for a particular node.
+ *    [TNODE]: TElementNode|TElementContainerNode|TContainerNode;
+ *  }
+ */
 /**
  * Factory for creating instances of injectors in the NodeInjector.
  *
@@ -56,9 +137,10 @@ export class NodeInjectorFactory {
      * @param {?} isViewProvider
      * @param {?} injectImplementation
      */
-    constructor(factory, /**
-           * Set to `true` if the token is declared in `viewProviders` (or if it is component).
-           */
+    constructor(factory, 
+    /**
+     * Set to `true` if the token is declared in `viewProviders` (or if it is component).
+     */
     isViewProvider, injectImplementation) {
         this.factory = factory;
         /**
@@ -168,7 +250,8 @@ export function isFactory(obj) {
     // See: https://jsperf.com/instanceof-vs-getprototypeof
     return obj != null && typeof obj == 'object' && Object.getPrototypeOf(obj) == FactoryPrototype;
 }
+// Note: This hack is necessary so we don't erroneously get a circular dependency
+// failure based on types.
 /** @type {?} */
 export const unusedValueExportToPlacateAjd = 1;
-
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"injector.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/interfaces/injector.ts"],"names":[],"mappings":";;;;;;;;;;;;AAcA,aAAa,KAAK,GAAG,CAAC,CAAC;;AACvB,aAAa,eAAe,GAAG,CAAC,CAAC;;AACjC,aAAa,aAAa,GAAG,CAAC,CAAC;;;;;;;;;;;;;IAW7B,wBAAqC;IACrC,yBAAuC;IACvC,mBAAoB;IACpB,aAAc;;;;AAGhB,aAAa,kBAAkB,qBAA6B,CAAC,CAAQ,EAAC;;;;;;;;;;;;;;;;AAiGtE,MAAM,OAAO,mBAAmB;;;;;;IAmF9B,YAIW;;;IAmBP,cAAuB,EACvB,oBAA2F;QApBpF,YAAO,GAAP,OAAO;;;;;QA7ElB,iBAAY,KAAK,CAAC;QAkGhB,IAAI,CAAC,mBAAmB,GAAG,cAAc,CAAC;QAC1C,IAAI,CAAC,UAAU,GAAG,oBAAoB,CAAC;KACxC;CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED,MAAM,gBAAgB,GAAG,mBAAmB,CAAC,SAAS,CAAC;;;;;AACvD,MAAM,UAAU,SAAS,CAAC,GAAQ;;IAEhC,OAAO,GAAG,IAAI,IAAI,IAAI,OAAO,GAAG,IAAI,QAAQ,IAAI,MAAM,CAAC,cAAc,CAAC,GAAG,CAAC,IAAI,gBAAgB,CAAC;CAChG;;AAID,aAAa,6BAA6B,GAAG,CAAC,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {InjectionToken} from '../../di/injection_token';\nimport {InjectFlags} from '../../di/injector_compatibility';\nimport {Type} from '../../type';\nimport {TElementNode} from './node';\nimport {LViewData, TData} from './view';\n\nexport const TNODE = 8;\nexport const PARENT_INJECTOR = 8;\nexport const INJECTOR_SIZE = 9;\n\n/**\n * Represents a relative location of parent injector.\n *\n * The interfaces encodes number of parents `LViewData`s to traverse and index in the `LViewData`\n * pointing to the parent injector.\n */\nexport interface RelativeInjectorLocation { __brand__: 'RelativeInjectorLocationFlags'; }\n\nexport const enum RelativeInjectorLocationFlags {\n  InjectorIndexMask = 0b111111111111111,\n  AcrossHostBoundary = 0b1000000000000000,\n  ViewOffsetShift = 16,\n  NO_PARENT = -1,\n}\n\nexport const NO_PARENT_INJECTOR: RelativeInjectorLocation = -1 as any;\n\n/**\n * Each injector is saved in 9 contiguous slots in `LViewData` and 9 contiguous slots in\n * `TView.data`. This allows us to store information about the current node's tokens (which\n * can be shared in `TView`) as well as the tokens of its ancestor nodes (which cannot be\n * shared, so they live in `LViewData`).\n *\n * Each of these slots (aside from the last slot) contains a bloom filter. This bloom filter\n * determines whether a directive is available on the associated node or not. This prevents us\n * from searching the directives array at this level unless it's probable the directive is in it.\n *\n * See: https://en.wikipedia.org/wiki/Bloom_filter for more about bloom filters.\n *\n * Because all injectors have been flattened into `LViewData` and `TViewData`, they cannot typed\n * using interfaces as they were previously. The start index of each `LInjector` and `TInjector`\n * will differ based on where it is flattened into the main array, so it's not possible to know\n * the indices ahead of time and save their types here. The interfaces are still included here\n * for documentation purposes.\n *\n * export interface LInjector extends Array<any> {\n *\n *    // Cumulative bloom for directive IDs 0-31  (IDs are % BLOOM_SIZE)\n *    [0]: number;\n *\n *    // Cumulative bloom for directive IDs 32-63\n *    [1]: number;\n *\n *    // Cumulative bloom for directive IDs 64-95\n *    [2]: number;\n *\n *    // Cumulative bloom for directive IDs 96-127\n *    [3]: number;\n *\n *    // Cumulative bloom for directive IDs 128-159\n *    [4]: number;\n *\n *    // Cumulative bloom for directive IDs 160 - 191\n *    [5]: number;\n *\n *    // Cumulative bloom for directive IDs 192 - 223\n *    [6]: number;\n *\n *    // Cumulative bloom for directive IDs 224 - 255\n *    [7]: number;\n *\n *    // We need to store a reference to the injector's parent so DI can keep looking up\n *    // the injector tree until it finds the dependency it's looking for.\n *    [PARENT_INJECTOR]: number;\n * }\n *\n * export interface TInjector extends Array<any> {\n *\n *    // Shared node bloom for directive IDs 0-31  (IDs are % BLOOM_SIZE)\n *    [0]: number;\n *\n *    // Shared node bloom for directive IDs 32-63\n *    [1]: number;\n *\n *    // Shared node bloom for directive IDs 64-95\n *    [2]: number;\n *\n *    // Shared node bloom for directive IDs 96-127\n *    [3]: number;\n *\n *    // Shared node bloom for directive IDs 128-159\n *    [4]: number;\n *\n *    // Shared node bloom for directive IDs 160 - 191\n *    [5]: number;\n *\n *    // Shared node bloom for directive IDs 192 - 223\n *    [6]: number;\n *\n *    // Shared node bloom for directive IDs 224 - 255\n *    [7]: number;\n *\n *    // Necessary to find directive indices for a particular node.\n *    [TNODE]: TElementNode|TElementContainerNode|TContainerNode;\n *  }\n */\n\n/**\n* Factory for creating instances of injectors in the NodeInjector.\n*\n* This factory is complicated by the fact that it can resolve `multi` factories as well.\n*\n* NOTE: Some of the fields are optional which means that this class has two hidden classes.\n* - One without `multi` support (most common)\n* - One with `multi` values, (rare).\n*\n* Since VMs can cache up to 4 inline hidden classes this is OK.\n*\n* - Single factory: Only `resolving` and `factory` is defined.\n* - `providers` factory: `componentProviders` is a number and `index = -1`.\n* - `viewProviders` factory: `componentProviders` is a number and `index` points to `providers`.\n*/\nexport class NodeInjectorFactory {\n  /**\n   * The inject implementation to be activated when using the factory.\n   */\n  injectImpl: null|(<T>(token: Type<T>|InjectionToken<T>, flags: InjectFlags) => T);\n\n  /**\n   * Marker set to true during factory invocation to see if we get into recursive loop.\n   * Recursive loop causes an error to be displayed.\n   */\n  resolving = false;\n\n  /**\n   * Marks that the token can see other Tokens declared in `viewProviders` on the same node.\n   */\n  canSeeViewProviders: boolean;\n\n  /**\n   * An array of factories to use in case of `multi` provider.\n   */\n  multi?: Array<() => any>;\n\n  /**\n   * Number of `multi`-providers which belong to the component.\n   *\n   * This is needed because when multiple components and directives declare the `multi` provider\n   * they have to be concatenated in the correct order.\n   *\n   * Example:\n   *\n   * If we have a component and directive active an a single element as declared here\n   * ```\n   * component:\n   *   provides: [ {provide: String, useValue: 'component', multi: true} ],\n   *   viewProvides: [ {provide: String, useValue: 'componentView', multi: true} ],\n   *\n   * directive:\n   *   provides: [ {provide: String, useValue: 'directive', multi: true} ],\n   * ```\n   *\n   * Then the expected results are:\n   *\n   * ```\n   * providers: ['component', 'directive']\n   * viewProviders: ['component', 'componentView', 'directive']\n   * ```\n   *\n   * The way to think about it is that the `viewProviders` have been inserted after the component\n   * but before the directives, which is why we need to know how many `multi`s have been declared by\n   * the component.\n   */\n  componentProviders?: number;\n\n  /**\n   * Current index of the Factory in the `data`. Needed for `viewProviders` and `providers` merging.\n   * See `providerFactory`.\n   */\n  index?: number;\n\n  /**\n   * Because the same `multi` provider can be declared in `provides` and `viewProvides` it is\n   * possible for `viewProvides` to shadow the `provides`. For this reason we store the\n   * `provideFactory` of the `providers` so that `providers` can be extended with `viewProviders`.\n   *\n   * Example:\n   *\n   * Given:\n   * ```\n   * provides: [ {provide: String, useValue: 'all', multi: true} ],\n   * viewProvides: [ {provide: String, useValue: 'viewOnly', multi: true} ],\n   * ```\n   *\n   * We have to return `['all']` in case of content injection, but `['all', 'viewOnly']` in case\n   * of view injection. We further have to make sure that the shared instances (in our case\n   * `all`) are the exact same instance in both the content as well as the view injection. (We\n   * have to make sure that we don't double instantiate.) For this reason the `viewProvides`\n   * `Factory` has a pointer to the shadowed `provides` factory so that it can instantiate the\n   * `providers` (`['all']`) and then extend it with `viewProviders` (`['all'] + ['viewOnly'] =\n   * ['all', 'viewOnly']`).\n   */\n  providerFactory?: NodeInjectorFactory|null;\n\n\n  constructor(\n      /**\n       * Factory to invoke in order to create a new instance.\n       */\n      public factory:\n          (this: NodeInjectorFactory, _: null,\n           /**\n            * array where injectables tokens are stored. This is used in\n            * case of an error reporting to produce friendlier errors.\n            */\n           tData: TData,\n           /**\n            * array where existing instances of injectables are stored. This is used in case\n            * of multi shadow is needed. See `multi` field documentation.\n            */\n           lData: LViewData,\n           /**\n            * The TNode of the same element injector.\n            */\n           tNode: TElementNode) => any,\n      /**\n       * Set to `true` if the token is declared in `viewProviders` (or if it is component).\n       */\n      isViewProvider: boolean,\n      injectImplementation: null|(<T>(token: Type<T>|InjectionToken<T>, flags: InjectFlags) => T)) {\n    this.canSeeViewProviders = isViewProvider;\n    this.injectImpl = injectImplementation;\n  }\n}\n\nconst FactoryPrototype = NodeInjectorFactory.prototype;\nexport function isFactory(obj: any): obj is NodeInjectorFactory {\n  // See: https://jsperf.com/instanceof-vs-getprototypeof\n  return obj != null && typeof obj == 'object' && Object.getPrototypeOf(obj) == FactoryPrototype;\n}\n\n// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\nexport const unusedValueExportToPlacateAjd = 1;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"injector.js","sourceRoot":"../../","sources":["packages/core/src/render3/interfaces/injector.ts"],"names":[],"mappings":";;;;;;;;;;;;AAcA,MAAM,OAAO,KAAK,GAAG,CAAC;;AACtB,MAAM,OAAO,eAAe,GAAG,CAAC;;AAChC,MAAM,OAAO,aAAa,GAAG,CAAC;;;;;;;;AAQ9B,8CAAyF;;;IAA7C,6CAA2C;;;;IAGrF,wBAAqC;IACrC,yBAAuC;IACvC,mBAAoB;IACpB,aAAc;;;;AAGhB,MAAM,OAAO,kBAAkB,GAA6B,mBAAA,CAAC,CAAC,EAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiGrE,MAAM,OAAO,mBAAmB;;;;;;IAmF9B,YAIW,OAeyB;IAChC;;OAEG;IACH,cAAuB,EACvB,oBAA2F;QApBpF,YAAO,GAAP,OAAO,CAekB;;;;;QA5FpC,cAAS,GAAG,KAAK,CAAC;QAkGhB,IAAI,CAAC,mBAAmB,GAAG,cAAc,CAAC;QAC1C,IAAI,CAAC,UAAU,GAAG,oBAAoB,CAAC;IACzC,CAAC;CACF;;;;;;IA3GC,yCAAkF;;;;;;IAMlF,wCAAkB;;;;;IAKlB,kDAA6B;;;;;IAK7B,oCAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA+BzB,iDAA4B;;;;;;IAM5B,oCAAe;;;;;;;;;;;;;;;;;;;;;;;IAuBf,8CAA2C;;;;;IAOvC,sCAegC;;;MAWhC,gBAAgB,GAAG,mBAAmB,CAAC,SAAS;;;;;AACtD,MAAM,UAAU,SAAS,CAAC,GAAQ;IAChC,uDAAuD;IACvD,OAAO,GAAG,IAAI,IAAI,IAAI,OAAO,GAAG,IAAI,QAAQ,IAAI,MAAM,CAAC,cAAc,CAAC,GAAG,CAAC,IAAI,gBAAgB,CAAC;AACjG,CAAC;;;;AAID,MAAM,OAAO,6BAA6B,GAAG,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {InjectionToken} from '../../di/injection_token';\nimport {InjectFlags} from '../../di/injector_compatibility';\nimport {Type} from '../../type';\nimport {TElementNode} from './node';\nimport {LViewData, TData} from './view';\n\nexport const TNODE = 8;\nexport const PARENT_INJECTOR = 8;\nexport const INJECTOR_SIZE = 9;\n\n/**\n * Represents a relative location of parent injector.\n *\n * The interfaces encodes number of parents `LViewData`s to traverse and index in the `LViewData`\n * pointing to the parent injector.\n */\nexport interface RelativeInjectorLocation { __brand__: 'RelativeInjectorLocationFlags'; }\n\nexport const enum RelativeInjectorLocationFlags {\n  InjectorIndexMask = 0b111111111111111,\n  AcrossHostBoundary = 0b1000000000000000,\n  ViewOffsetShift = 16,\n  NO_PARENT = -1,\n}\n\nexport const NO_PARENT_INJECTOR: RelativeInjectorLocation = -1 as any;\n\n/**\n * Each injector is saved in 9 contiguous slots in `LViewData` and 9 contiguous slots in\n * `TView.data`. This allows us to store information about the current node's tokens (which\n * can be shared in `TView`) as well as the tokens of its ancestor nodes (which cannot be\n * shared, so they live in `LViewData`).\n *\n * Each of these slots (aside from the last slot) contains a bloom filter. This bloom filter\n * determines whether a directive is available on the associated node or not. This prevents us\n * from searching the directives array at this level unless it's probable the directive is in it.\n *\n * See: https://en.wikipedia.org/wiki/Bloom_filter for more about bloom filters.\n *\n * Because all injectors have been flattened into `LViewData` and `TViewData`, they cannot typed\n * using interfaces as they were previously. The start index of each `LInjector` and `TInjector`\n * will differ based on where it is flattened into the main array, so it's not possible to know\n * the indices ahead of time and save their types here. The interfaces are still included here\n * for documentation purposes.\n *\n * export interface LInjector extends Array<any> {\n *\n *    // Cumulative bloom for directive IDs 0-31  (IDs are % BLOOM_SIZE)\n *    [0]: number;\n *\n *    // Cumulative bloom for directive IDs 32-63\n *    [1]: number;\n *\n *    // Cumulative bloom for directive IDs 64-95\n *    [2]: number;\n *\n *    // Cumulative bloom for directive IDs 96-127\n *    [3]: number;\n *\n *    // Cumulative bloom for directive IDs 128-159\n *    [4]: number;\n *\n *    // Cumulative bloom for directive IDs 160 - 191\n *    [5]: number;\n *\n *    // Cumulative bloom for directive IDs 192 - 223\n *    [6]: number;\n *\n *    // Cumulative bloom for directive IDs 224 - 255\n *    [7]: number;\n *\n *    // We need to store a reference to the injector's parent so DI can keep looking up\n *    // the injector tree until it finds the dependency it's looking for.\n *    [PARENT_INJECTOR]: number;\n * }\n *\n * export interface TInjector extends Array<any> {\n *\n *    // Shared node bloom for directive IDs 0-31  (IDs are % BLOOM_SIZE)\n *    [0]: number;\n *\n *    // Shared node bloom for directive IDs 32-63\n *    [1]: number;\n *\n *    // Shared node bloom for directive IDs 64-95\n *    [2]: number;\n *\n *    // Shared node bloom for directive IDs 96-127\n *    [3]: number;\n *\n *    // Shared node bloom for directive IDs 128-159\n *    [4]: number;\n *\n *    // Shared node bloom for directive IDs 160 - 191\n *    [5]: number;\n *\n *    // Shared node bloom for directive IDs 192 - 223\n *    [6]: number;\n *\n *    // Shared node bloom for directive IDs 224 - 255\n *    [7]: number;\n *\n *    // Necessary to find directive indices for a particular node.\n *    [TNODE]: TElementNode|TElementContainerNode|TContainerNode;\n *  }\n */\n\n/**\n* Factory for creating instances of injectors in the NodeInjector.\n*\n* This factory is complicated by the fact that it can resolve `multi` factories as well.\n*\n* NOTE: Some of the fields are optional which means that this class has two hidden classes.\n* - One without `multi` support (most common)\n* - One with `multi` values, (rare).\n*\n* Since VMs can cache up to 4 inline hidden classes this is OK.\n*\n* - Single factory: Only `resolving` and `factory` is defined.\n* - `providers` factory: `componentProviders` is a number and `index = -1`.\n* - `viewProviders` factory: `componentProviders` is a number and `index` points to `providers`.\n*/\nexport class NodeInjectorFactory {\n  /**\n   * The inject implementation to be activated when using the factory.\n   */\n  injectImpl: null|(<T>(token: Type<T>|InjectionToken<T>, flags: InjectFlags) => T);\n\n  /**\n   * Marker set to true during factory invocation to see if we get into recursive loop.\n   * Recursive loop causes an error to be displayed.\n   */\n  resolving = false;\n\n  /**\n   * Marks that the token can see other Tokens declared in `viewProviders` on the same node.\n   */\n  canSeeViewProviders: boolean;\n\n  /**\n   * An array of factories to use in case of `multi` provider.\n   */\n  multi?: Array<() => any>;\n\n  /**\n   * Number of `multi`-providers which belong to the component.\n   *\n   * This is needed because when multiple components and directives declare the `multi` provider\n   * they have to be concatenated in the correct order.\n   *\n   * Example:\n   *\n   * If we have a component and directive active an a single element as declared here\n   * ```\n   * component:\n   *   provides: [ {provide: String, useValue: 'component', multi: true} ],\n   *   viewProvides: [ {provide: String, useValue: 'componentView', multi: true} ],\n   *\n   * directive:\n   *   provides: [ {provide: String, useValue: 'directive', multi: true} ],\n   * ```\n   *\n   * Then the expected results are:\n   *\n   * ```\n   * providers: ['component', 'directive']\n   * viewProviders: ['component', 'componentView', 'directive']\n   * ```\n   *\n   * The way to think about it is that the `viewProviders` have been inserted after the component\n   * but before the directives, which is why we need to know how many `multi`s have been declared by\n   * the component.\n   */\n  componentProviders?: number;\n\n  /**\n   * Current index of the Factory in the `data`. Needed for `viewProviders` and `providers` merging.\n   * See `providerFactory`.\n   */\n  index?: number;\n\n  /**\n   * Because the same `multi` provider can be declared in `provides` and `viewProvides` it is\n   * possible for `viewProvides` to shadow the `provides`. For this reason we store the\n   * `provideFactory` of the `providers` so that `providers` can be extended with `viewProviders`.\n   *\n   * Example:\n   *\n   * Given:\n   * ```\n   * provides: [ {provide: String, useValue: 'all', multi: true} ],\n   * viewProvides: [ {provide: String, useValue: 'viewOnly', multi: true} ],\n   * ```\n   *\n   * We have to return `['all']` in case of content injection, but `['all', 'viewOnly']` in case\n   * of view injection. We further have to make sure that the shared instances (in our case\n   * `all`) are the exact same instance in both the content as well as the view injection. (We\n   * have to make sure that we don't double instantiate.) For this reason the `viewProvides`\n   * `Factory` has a pointer to the shadowed `provides` factory so that it can instantiate the\n   * `providers` (`['all']`) and then extend it with `viewProviders` (`['all'] + ['viewOnly'] =\n   * ['all', 'viewOnly']`).\n   */\n  providerFactory?: NodeInjectorFactory|null;\n\n\n  constructor(\n      /**\n       * Factory to invoke in order to create a new instance.\n       */\n      public factory:\n          (this: NodeInjectorFactory, _: null,\n           /**\n            * array where injectables tokens are stored. This is used in\n            * case of an error reporting to produce friendlier errors.\n            */\n           tData: TData,\n           /**\n            * array where existing instances of injectables are stored. This is used in case\n            * of multi shadow is needed. See `multi` field documentation.\n            */\n           lData: LViewData,\n           /**\n            * The TNode of the same element injector.\n            */\n           tNode: TElementNode) => any,\n      /**\n       * Set to `true` if the token is declared in `viewProviders` (or if it is component).\n       */\n      isViewProvider: boolean,\n      injectImplementation: null|(<T>(token: Type<T>|InjectionToken<T>, flags: InjectFlags) => T)) {\n    this.canSeeViewProviders = isViewProvider;\n    this.injectImpl = injectImplementation;\n  }\n}\n\nconst FactoryPrototype = NodeInjectorFactory.prototype;\nexport function isFactory(obj: any): obj is NodeInjectorFactory {\n  // See: https://jsperf.com/instanceof-vs-getprototypeof\n  return obj != null && typeof obj == 'object' && Object.getPrototypeOf(obj) == FactoryPrototype;\n}\n\n// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\nexport const unusedValueExportToPlacateAjd = 1;\n"]}