@angular/core 10.0.6 → 10.0.10

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

@@ -0,0 +1,170 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { assertNumber, assertString } from '../../util/assert';
+import { COMMENT_MARKER, ELEMENT_MARKER, getInstructionFromI18nMutateOpCode, getParentFromI18nMutateOpCode, getRefFromI18nMutateOpCode } from '../interfaces/i18n';
+/**
+ * Converts `I18nUpdateOpCodes` array into a human readable format.
+ *
+ * This function is attached to the `I18nUpdateOpCodes.debug` property if `ngDevMode` is enabled.
+ * This function provides a human readable view of the opcodes. This is useful when debugging the
+ * application as well as writing more readable tests.
+ *
+ * @param this `I18nUpdateOpCodes` if attached as a method.
+ * @param opcodes `I18nUpdateOpCodes` if invoked as a function.
+ */
+export function i18nUpdateOpCodesToString(opcodes) {
+    const parser = new OpCodeParser(opcodes || (Array.isArray(this) ? this : []));
+    let lines = [];
+    function consumeOpCode(value) {
+        const ref = value >>> 2 /* SHIFT_REF */;
+        const opCode = value & 3 /* MASK_OPCODE */;
+        switch (opCode) {
+            case 0 /* Text */:
+                return `(lView[${ref}] as Text).textContent = $$$`;
+            case 1 /* Attr */:
+                const attrName = parser.consumeString();
+                const sanitizationFn = parser.consumeFunction();
+                const value = sanitizationFn ? `(${sanitizationFn})($$$)` : '$$$';
+                return `(lView[${ref}] as Element).setAttribute('${attrName}', ${value})`;
+            case 2 /* IcuSwitch */:
+                return `icuSwitchCase(lView[${ref}] as Comment, ${parser.consumeNumber()}, $$$)`;
+            case 3 /* IcuUpdate */:
+                return `icuUpdateCase(lView[${ref}] as Comment, ${parser.consumeNumber()})`;
+        }
+        throw new Error('unexpected OpCode');
+    }
+    while (parser.hasMore()) {
+        let mask = parser.consumeNumber();
+        let size = parser.consumeNumber();
+        const end = parser.i + size;
+        const statements = [];
+        let statement = '';
+        while (parser.i < end) {
+            let value = parser.consumeNumberOrString();
+            if (typeof value === 'string') {
+                statement += value;
+            }
+            else if (value < 0) {
+                // Negative numbers are ref indexes
+                statement += '${lView[' + (0 - value) + ']}';
+            }
+            else {
+                // Positive numbers are operations.
+                const opCodeText = consumeOpCode(value);
+                statements.push(opCodeText.replace('$$$', '`' + statement + '`') + ';');
+                statement = '';
+            }
+        }
+        lines.push(`if (mask & 0b${mask.toString(2)}) { ${statements.join(' ')} }`);
+    }
+    return lines;
+}
+/**
+ * Converts `I18nMutableOpCodes` array into a human readable format.
+ *
+ * This function is attached to the `I18nMutableOpCodes.debug` if `ngDevMode` is enabled. This
+ * function provides a human readable view of the opcodes. This is useful when debugging the
+ * application as well as writing more readable tests.
+ *
+ * @param this `I18nMutableOpCodes` if attached as a method.
+ * @param opcodes `I18nMutableOpCodes` if invoked as a function.
+ */
+export function i18nMutateOpCodesToString(opcodes) {
+    const parser = new OpCodeParser(opcodes || (Array.isArray(this) ? this : []));
+    let lines = [];
+    function consumeOpCode(opCode) {
+        const parent = getParentFromI18nMutateOpCode(opCode);
+        const ref = getRefFromI18nMutateOpCode(opCode);
+        switch (getInstructionFromI18nMutateOpCode(opCode)) {
+            case 0 /* Select */:
+                lastRef = ref;
+                return '';
+            case 1 /* AppendChild */:
+                return `(lView[${parent}] as Element).appendChild(lView[${lastRef}])`;
+            case 3 /* Remove */:
+                return `(lView[${parent}] as Element).remove(lView[${ref}])`;
+            case 4 /* Attr */:
+                return `(lView[${ref}] as Element).setAttribute("${parser.consumeString()}", "${parser.consumeString()}")`;
+            case 5 /* ElementEnd */:
+                return `setPreviousOrParentTNode(tView.data[${ref}] as TNode)`;
+            case 6 /* RemoveNestedIcu */:
+                return `removeNestedICU(${ref})`;
+        }
+        throw new Error('Unexpected OpCode');
+    }
+    let lastRef = -1;
+    while (parser.hasMore()) {
+        let value = parser.consumeNumberStringOrMarker();
+        if (value === COMMENT_MARKER) {
+            const text = parser.consumeString();
+            lastRef = parser.consumeNumber();
+            lines.push(`lView[${lastRef}] = document.createComment("${text}")`);
+        }
+        else if (value === ELEMENT_MARKER) {
+            const text = parser.consumeString();
+            lastRef = parser.consumeNumber();
+            lines.push(`lView[${lastRef}] = document.createElement("${text}")`);
+        }
+        else if (typeof value === 'string') {
+            lastRef = parser.consumeNumber();
+            lines.push(`lView[${lastRef}] = document.createTextNode("${value}")`);
+        }
+        else if (typeof value === 'number') {
+            const line = consumeOpCode(value);
+            line && lines.push(line);
+        }
+        else {
+            throw new Error('Unexpected value');
+        }
+    }
+    return lines;
+}
+class OpCodeParser {
+    constructor(codes) {
+        this.i = 0;
+        this.codes = codes;
+    }
+    hasMore() {
+        return this.i < this.codes.length;
+    }
+    consumeNumber() {
+        let value = this.codes[this.i++];
+        assertNumber(value, 'expecting number in OpCode');
+        return value;
+    }
+    consumeString() {
+        let value = this.codes[this.i++];
+        assertString(value, 'expecting string in OpCode');
+        return value;
+    }
+    consumeFunction() {
+        let value = this.codes[this.i++];
+        if (value === null || typeof value === 'function') {
+            return value;
+        }
+        throw new Error('expecting function in OpCode');
+    }
+    consumeNumberOrString() {
+        let value = this.codes[this.i++];
+        if (typeof value === 'string') {
+            return value;
+        }
+        assertNumber(value, 'expecting number or string in OpCode');
+        return value;
+    }
+    consumeNumberStringOrMarker() {
+        let value = this.codes[this.i++];
+        if (typeof value === 'string' || typeof value === 'number' || value == COMMENT_MARKER ||
+            value == ELEMENT_MARKER) {
+            return value;
+        }
+        assertNumber(value, 'expecting number, string, COMMENT_MARKER or ELEMENT_MARKER in OpCode');
+        return value;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"i18n_debug.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/i18n/i18n_debug.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,YAAY,EAAE,YAAY,EAAC,MAAM,mBAAmB,CAAC;AAE7D,OAAO,EAAC,cAAc,EAAE,cAAc,EAAE,kCAAkC,EAAE,6BAA6B,EAAE,0BAA0B,EAA2E,MAAM,oBAAoB,CAAC;AAE3O;;;;;;;;;GASG;AACH,MAAM,UAAU,yBAAyB,CACP,OAA2B;IAC3D,MAAM,MAAM,GAAG,IAAI,YAAY,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC9E,IAAI,KAAK,GAAa,EAAE,CAAC;IAEzB,SAAS,aAAa,CAAC,KAAa;QAClC,MAAM,GAAG,GAAG,KAAK,sBAA+B,CAAC;QACjD,MAAM,MAAM,GAAG,KAAK,sBAA+B,CAAC;QACpD,QAAQ,MAAM,EAAE;YACd;gBACE,OAAO,UAAU,GAAG,8BAA8B,CAAC;YACrD;gBACE,MAAM,QAAQ,GAAG,MAAM,CAAC,aAAa,EAAE,CAAC;gBACxC,MAAM,cAAc,GAAG,MAAM,CAAC,eAAe,EAAE,CAAC;gBAChD,MAAM,KAAK,GAAG,cAAc,CAAC,CAAC,CAAC,IAAI,cAAc,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC;gBAClE,OAAO,UAAU,GAAG,+BAA+B,QAAQ,MAAM,KAAK,GAAG,CAAC;YAC5E;gBACE,OAAO,uBAAuB,GAAG,iBAAiB,MAAM,CAAC,aAAa,EAAE,QAAQ,CAAC;YACnF;gBACE,OAAO,uBAAuB,GAAG,iBAAiB,MAAM,CAAC,aAAa,EAAE,GAAG,CAAC;SAC/E;QACD,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC,CAAC;IACvC,CAAC;IAGD,OAAO,MAAM,CAAC,OAAO,EAAE,EAAE;QACvB,IAAI,IAAI,GAAG,MAAM,CAAC,aAAa,EAAE,CAAC;QAClC,IAAI,IAAI,GAAG,MAAM,CAAC,aAAa,EAAE,CAAC;QAClC,MAAM,GAAG,GAAG,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC;QAC5B,MAAM,UAAU,GAAa,EAAE,CAAC;QAChC,IAAI,SAAS,GAAG,EAAE,CAAC;QACnB,OAAO,MAAM,CAAC,CAAC,GAAG,GAAG,EAAE;YACrB,IAAI,KAAK,GAAG,MAAM,CAAC,qBAAqB,EAAE,CAAC;YAC3C,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;gBAC7B,SAAS,IAAI,KAAK,CAAC;aACpB;iBAAM,IAAI,KAAK,GAAG,CAAC,EAAE;gBACpB,mCAAmC;gBACnC,SAAS,IAAI,UAAU,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,GAAG,IAAI,CAAC;aAC9C;iBAAM;gBACL,mCAAmC;gBACnC,MAAM,UAAU,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;gBACxC,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,GAAG,SAAS,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC;gBACxE,SAAS,GAAG,EAAE,CAAC;aAChB;SACF;QACD,KAAK,CAAC,IAAI,CAAC,gBAAgB,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;KAC7E;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,yBAAyB,CACP,OAA2B;IAC3D,MAAM,MAAM,GAAG,IAAI,YAAY,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC9E,IAAI,KAAK,GAAa,EAAE,CAAC;IAEzB,SAAS,aAAa,CAAC,MAAc;QACnC,MAAM,MAAM,GAAG,6BAA6B,CAAC,MAAM,CAAC,CAAC;QACrD,MAAM,GAAG,GAAG,0BAA0B,CAAC,MAAM,CAAC,CAAC;QAC/C,QAAQ,kCAAkC,CAAC,MAAM,CAAC,EAAE;YAClD;gBACE,OAAO,GAAG,GAAG,CAAC;gBACd,OAAO,EAAE,CAAC;YACZ;gBACE,OAAO,UAAU,MAAM,mCAAmC,OAAO,IAAI,CAAC;YACxE;gBACE,OAAO,UAAU,MAAM,8BAA8B,GAAG,IAAI,CAAC;YAC/D;gBACE,OAAO,UAAU,GAAG,+BAA+B,MAAM,CAAC,aAAa,EAAE,OACrE,MAAM,CAAC,aAAa,EAAE,IAAI,CAAC;YACjC;gBACE,OAAO,uCAAuC,GAAG,aAAa,CAAC;YACjE;gBACE,OAAO,mBAAmB,GAAG,GAAG,CAAC;SACpC;QACD,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC,CAAC;IACvC,CAAC;IAED,IAAI,OAAO,GAAG,CAAC,CAAC,CAAC;IACjB,OAAO,MAAM,CAAC,OAAO,EAAE,EAAE;QACvB,IAAI,KAAK,GAAG,MAAM,CAAC,2BAA2B,EAAE,CAAC;QACjD,IAAI,KAAK,KAAK,cAAc,EAAE;YAC5B,MAAM,IAAI,GAAG,MAAM,CAAC,aAAa,EAAE,CAAC;YACpC,OAAO,GAAG,MAAM,CAAC,aAAa,EAAE,CAAC;YACjC,KAAK,CAAC,IAAI,CAAC,SAAS,OAAO,+BAA+B,IAAI,IAAI,CAAC,CAAC;SACrE;aAAM,IAAI,KAAK,KAAK,cAAc,EAAE;YACnC,MAAM,IAAI,GAAG,MAAM,CAAC,aAAa,EAAE,CAAC;YACpC,OAAO,GAAG,MAAM,CAAC,aAAa,EAAE,CAAC;YACjC,KAAK,CAAC,IAAI,CAAC,SAAS,OAAO,+BAA+B,IAAI,IAAI,CAAC,CAAC;SACrE;aAAM,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;YACpC,OAAO,GAAG,MAAM,CAAC,aAAa,EAAE,CAAC;YACjC,KAAK,CAAC,IAAI,CAAC,SAAS,OAAO,gCAAgC,KAAK,IAAI,CAAC,CAAC;SACvE;aAAM,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;YACpC,MAAM,IAAI,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;YAClC,IAAI,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;SAC1B;aAAM;YACL,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC;SACrC;KACF;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAGD,MAAM,YAAY;IAIhB,YAAY,KAAY;QAHxB,MAAC,GAAW,CAAC,CAAC;QAIZ,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IAED,OAAO;QACL,OAAO,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;IACpC,CAAC;IAED,aAAa;QACX,IAAI,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;QACjC,YAAY,CAAC,KAAK,EAAE,4BAA4B,CAAC,CAAC;QAClD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,aAAa;QACX,IAAI,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;QACjC,YAAY,CAAC,KAAK,EAAE,4BAA4B,CAAC,CAAC;QAClD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,eAAe;QACb,IAAI,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;QACjC,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,UAAU,EAAE;YACjD,OAAO,KAAK,CAAC;SACd;QACD,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC;IAClD,CAAC;IAED,qBAAqB;QACnB,IAAI,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;QACjC,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;YAC7B,OAAO,KAAK,CAAC;SACd;QACD,YAAY,CAAC,KAAK,EAAE,sCAAsC,CAAC,CAAC;QAC5D,OAAO,KAAK,CAAC;IACf,CAAC;IAED,2BAA2B;QACzB,IAAI,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;QACjC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,IAAI,cAAc;YACjF,KAAK,IAAI,cAAc,EAAE;YAC3B,OAAO,KAAK,CAAC;SACd;QACD,YAAY,CAAC,KAAK,EAAE,sEAAsE,CAAC,CAAC;QAC5F,OAAO,KAAK,CAAC;IACf,CAAC;CACF","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {assertNumber, assertString} from '../../util/assert';\n\nimport {COMMENT_MARKER, ELEMENT_MARKER, getInstructionFromI18nMutateOpCode, getParentFromI18nMutateOpCode, getRefFromI18nMutateOpCode, I18nMutateOpCode, I18nMutateOpCodes, I18nUpdateOpCode, I18nUpdateOpCodes} from '../interfaces/i18n';\n\n/**\n * Converts `I18nUpdateOpCodes` array into a human readable format.\n *\n * This function is attached to the `I18nUpdateOpCodes.debug` property if `ngDevMode` is enabled.\n * This function provides a human readable view of the opcodes. This is useful when debugging the\n * application as well as writing more readable tests.\n *\n * @param this `I18nUpdateOpCodes` if attached as a method.\n * @param opcodes `I18nUpdateOpCodes` if invoked as a function.\n */\nexport function i18nUpdateOpCodesToString(\n    this: I18nUpdateOpCodes|void, opcodes?: I18nUpdateOpCodes): string[] {\n  const parser = new OpCodeParser(opcodes || (Array.isArray(this) ? this : []));\n  let lines: string[] = [];\n\n  function consumeOpCode(value: number): string {\n    const ref = value >>> I18nUpdateOpCode.SHIFT_REF;\n    const opCode = value & I18nUpdateOpCode.MASK_OPCODE;\n    switch (opCode) {\n      case I18nUpdateOpCode.Text:\n        return `(lView[${ref}] as Text).textContent = $$$`;\n      case I18nUpdateOpCode.Attr:\n        const attrName = parser.consumeString();\n        const sanitizationFn = parser.consumeFunction();\n        const value = sanitizationFn ? `(${sanitizationFn})($$$)` : '$$$';\n        return `(lView[${ref}] as Element).setAttribute('${attrName}', ${value})`;\n      case I18nUpdateOpCode.IcuSwitch:\n        return `icuSwitchCase(lView[${ref}] as Comment, ${parser.consumeNumber()}, $$$)`;\n      case I18nUpdateOpCode.IcuUpdate:\n        return `icuUpdateCase(lView[${ref}] as Comment, ${parser.consumeNumber()})`;\n    }\n    throw new Error('unexpected OpCode');\n  }\n\n\n  while (parser.hasMore()) {\n    let mask = parser.consumeNumber();\n    let size = parser.consumeNumber();\n    const end = parser.i + size;\n    const statements: string[] = [];\n    let statement = '';\n    while (parser.i < end) {\n      let value = parser.consumeNumberOrString();\n      if (typeof value === 'string') {\n        statement += value;\n      } else if (value < 0) {\n        // Negative numbers are ref indexes\n        statement += '${lView[' + (0 - value) + ']}';\n      } else {\n        // Positive numbers are operations.\n        const opCodeText = consumeOpCode(value);\n        statements.push(opCodeText.replace('$$$', '`' + statement + '`') + ';');\n        statement = '';\n      }\n    }\n    lines.push(`if (mask & 0b${mask.toString(2)}) { ${statements.join(' ')} }`);\n  }\n  return lines;\n}\n\n/**\n * Converts `I18nMutableOpCodes` array into a human readable format.\n *\n * This function is attached to the `I18nMutableOpCodes.debug` if `ngDevMode` is enabled. This\n * function provides a human readable view of the opcodes. This is useful when debugging the\n * application as well as writing more readable tests.\n *\n * @param this `I18nMutableOpCodes` if attached as a method.\n * @param opcodes `I18nMutableOpCodes` if invoked as a function.\n */\nexport function i18nMutateOpCodesToString(\n    this: I18nMutateOpCodes|void, opcodes?: I18nMutateOpCodes): string[] {\n  const parser = new OpCodeParser(opcodes || (Array.isArray(this) ? this : []));\n  let lines: string[] = [];\n\n  function consumeOpCode(opCode: number): string {\n    const parent = getParentFromI18nMutateOpCode(opCode);\n    const ref = getRefFromI18nMutateOpCode(opCode);\n    switch (getInstructionFromI18nMutateOpCode(opCode)) {\n      case I18nMutateOpCode.Select:\n        lastRef = ref;\n        return '';\n      case I18nMutateOpCode.AppendChild:\n        return `(lView[${parent}] as Element).appendChild(lView[${lastRef}])`;\n      case I18nMutateOpCode.Remove:\n        return `(lView[${parent}] as Element).remove(lView[${ref}])`;\n      case I18nMutateOpCode.Attr:\n        return `(lView[${ref}] as Element).setAttribute(\"${parser.consumeString()}\", \"${\n            parser.consumeString()}\")`;\n      case I18nMutateOpCode.ElementEnd:\n        return `setPreviousOrParentTNode(tView.data[${ref}] as TNode)`;\n      case I18nMutateOpCode.RemoveNestedIcu:\n        return `removeNestedICU(${ref})`;\n    }\n    throw new Error('Unexpected OpCode');\n  }\n\n  let lastRef = -1;\n  while (parser.hasMore()) {\n    let value = parser.consumeNumberStringOrMarker();\n    if (value === COMMENT_MARKER) {\n      const text = parser.consumeString();\n      lastRef = parser.consumeNumber();\n      lines.push(`lView[${lastRef}] = document.createComment(\"${text}\")`);\n    } else if (value === ELEMENT_MARKER) {\n      const text = parser.consumeString();\n      lastRef = parser.consumeNumber();\n      lines.push(`lView[${lastRef}] = document.createElement(\"${text}\")`);\n    } else if (typeof value === 'string') {\n      lastRef = parser.consumeNumber();\n      lines.push(`lView[${lastRef}] = document.createTextNode(\"${value}\")`);\n    } else if (typeof value === 'number') {\n      const line = consumeOpCode(value);\n      line && lines.push(line);\n    } else {\n      throw new Error('Unexpected value');\n    }\n  }\n\n  return lines;\n}\n\n\nclass OpCodeParser {\n  i: number = 0;\n  codes: any[];\n\n  constructor(codes: any[]) {\n    this.codes = codes;\n  }\n\n  hasMore() {\n    return this.i < this.codes.length;\n  }\n\n  consumeNumber(): number {\n    let value = this.codes[this.i++];\n    assertNumber(value, 'expecting number in OpCode');\n    return value;\n  }\n\n  consumeString(): string {\n    let value = this.codes[this.i++];\n    assertString(value, 'expecting string in OpCode');\n    return value;\n  }\n\n  consumeFunction(): Function|null {\n    let value = this.codes[this.i++];\n    if (value === null || typeof value === 'function') {\n      return value;\n    }\n    throw new Error('expecting function in OpCode');\n  }\n\n  consumeNumberOrString(): number|string {\n    let value = this.codes[this.i++];\n    if (typeof value === 'string') {\n      return value;\n    }\n    assertNumber(value, 'expecting number or string in OpCode');\n    return value;\n  }\n\n  consumeNumberStringOrMarker(): number|string|COMMENT_MARKER|ELEMENT_MARKER {\n    let value = this.codes[this.i++];\n    if (typeof value === 'string' || typeof value === 'number' || value == COMMENT_MARKER ||\n        value == ELEMENT_MARKER) {\n      return value;\n    }\n    assertNumber(value, 'expecting number, string, COMMENT_MARKER or ELEMENT_MARKER in OpCode');\n    return value;\n  }\n}\n"]}

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

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { DEFAULT_LOCALE_ID } from '../../i18n/localization';
+import { assertDefined } from '../../util/assert';
+/**
+ * The locale id that the application is currently using (for translations and ICU expressions).
+ * This is the ivy version of `LOCALE_ID` that was defined as an injection token for the view engine
+ * but is now defined as a global value.
+ */
+let LOCALE_ID = DEFAULT_LOCALE_ID;
+/**
+ * Sets the locale id that will be used for translations and ICU expressions.
+ * This is the ivy version of `LOCALE_ID` that was defined as an injection token for the view engine
+ * but is now defined as a global value.
+ *
+ * @param localeId
+ */
+export function setLocaleId(localeId) {
+    assertDefined(localeId, `Expected localeId to be defined`);
+    if (typeof localeId === 'string') {
+        LOCALE_ID = localeId.toLowerCase().replace(/_/g, '-');
+    }
+}
+/**
+ * Gets the locale id that will be used for translations and ICU expressions.
+ * This is the ivy version of `LOCALE_ID` that was defined as an injection token for the view engine
+ * but is now defined as a global value.
+ */
+export function getLocaleId() {
+    return LOCALE_ID;
+}
+//# sourceMappingURL=data:application/json;base64,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