@angular/compiler 16.0.0-next.4 → 16.0.0-next.6

package/esm2022/src/render3/view/i18n/meta.mjs

@@ -0,0 +1,243 @@
+/**
+ * @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 { computeDecimalDigest, computeDigest, decimalDigest } from '../../../i18n/digest';
+import * as i18n from '../../../i18n/i18n_ast';
+import { createI18nMessageFactory } from '../../../i18n/i18n_parser';
+import { I18nError } from '../../../i18n/parse_util';
+import * as html from '../../../ml_parser/ast';
+import { DEFAULT_INTERPOLATION_CONFIG } from '../../../ml_parser/interpolation_config';
+import { ParseTreeResult } from '../../../ml_parser/parser';
+import * as o from '../../../output/output_ast';
+import { isTrustedTypesSink } from '../../../schema/trusted_types_sinks';
+import { hasI18nAttrs, I18N_ATTR, I18N_ATTR_PREFIX, icuFromI18nMessage } from './util';
+const setI18nRefs = (htmlNode, i18nNode) => {
+    if (htmlNode instanceof html.NodeWithI18n) {
+        if (i18nNode instanceof i18n.IcuPlaceholder && htmlNode.i18n instanceof i18n.Message) {
+            // This html node represents an ICU but this is a second processing pass, and the legacy id
+            // was computed in the previous pass and stored in the `i18n` property as a message.
+            // We are about to wipe out that property so capture the previous message to be reused when
+            // generating the message for this ICU later. See `_generateI18nMessage()`.
+            i18nNode.previousMessage = htmlNode.i18n;
+        }
+        htmlNode.i18n = i18nNode;
+    }
+    return i18nNode;
+};
+/**
+ * This visitor walks over HTML parse tree and converts information stored in
+ * i18n-related attributes ("i18n" and "i18n-*") into i18n meta object that is
+ * stored with other element's and attribute's information.
+ */
+export class I18nMetaVisitor {
+    constructor(interpolationConfig = DEFAULT_INTERPOLATION_CONFIG, keepI18nAttrs = false, enableI18nLegacyMessageIdFormat = false) {
+        this.interpolationConfig = interpolationConfig;
+        this.keepI18nAttrs = keepI18nAttrs;
+        this.enableI18nLegacyMessageIdFormat = enableI18nLegacyMessageIdFormat;
+        // whether visited nodes contain i18n information
+        this.hasI18nMeta = false;
+        this._errors = [];
+    }
+    _generateI18nMessage(nodes, meta = '', visitNodeFn) {
+        const { meaning, description, customId } = this._parseMetadata(meta);
+        const createI18nMessage = createI18nMessageFactory(this.interpolationConfig);
+        const message = createI18nMessage(nodes, meaning, description, customId, visitNodeFn);
+        this._setMessageId(message, meta);
+        this._setLegacyIds(message, meta);
+        return message;
+    }
+    visitAllWithErrors(nodes) {
+        const result = nodes.map(node => node.visit(this, null));
+        return new ParseTreeResult(result, this._errors);
+    }
+    visitElement(element) {
+        let message = undefined;
+        if (hasI18nAttrs(element)) {
+            this.hasI18nMeta = true;
+            const attrs = [];
+            const attrsMeta = {};
+            for (const attr of element.attrs) {
+                if (attr.name === I18N_ATTR) {
+                    // root 'i18n' node attribute
+                    const i18n = element.i18n || attr.value;
+                    message = this._generateI18nMessage(element.children, i18n, setI18nRefs);
+                    if (message.nodes.length === 0) {
+                        // Ignore the message if it is empty.
+                        message = undefined;
+                    }
+                    // Store the message on the element
+                    element.i18n = message;
+                }
+                else if (attr.name.startsWith(I18N_ATTR_PREFIX)) {
+                    // 'i18n-*' attributes
+                    const name = attr.name.slice(I18N_ATTR_PREFIX.length);
+                    if (isTrustedTypesSink(element.name, name)) {
+                        this._reportError(attr, `Translating attribute '${name}' is disallowed for security reasons.`);
+                    }
+                    else {
+                        attrsMeta[name] = attr.value;
+                    }
+                }
+                else {
+                    // non-i18n attributes
+                    attrs.push(attr);
+                }
+            }
+            // set i18n meta for attributes
+            if (Object.keys(attrsMeta).length) {
+                for (const attr of attrs) {
+                    const meta = attrsMeta[attr.name];
+                    // do not create translation for empty attributes
+                    if (meta !== undefined && attr.value) {
+                        attr.i18n = this._generateI18nMessage([attr], attr.i18n || meta);
+                    }
+                }
+            }
+            if (!this.keepI18nAttrs) {
+                // update element's attributes,
+                // keeping only non-i18n related ones
+                element.attrs = attrs;
+            }
+        }
+        html.visitAll(this, element.children, message);
+        return element;
+    }
+    visitExpansion(expansion, currentMessage) {
+        let message;
+        const meta = expansion.i18n;
+        this.hasI18nMeta = true;
+        if (meta instanceof i18n.IcuPlaceholder) {
+            // set ICU placeholder name (e.g. "ICU_1"),
+            // generated while processing root element contents,
+            // so we can reference it when we output translation
+            const name = meta.name;
+            message = this._generateI18nMessage([expansion], meta);
+            const icu = icuFromI18nMessage(message);
+            icu.name = name;
+            if (currentMessage !== null) {
+                // Also update the placeholderToMessage map with this new message
+                currentMessage.placeholderToMessage[name] = message;
+            }
+        }
+        else {
+            // ICU is a top level message, try to use metadata from container element if provided via
+            // `context` argument. Note: context may not be available for standalone ICUs (without
+            // wrapping element), so fallback to ICU metadata in this case.
+            message = this._generateI18nMessage([expansion], currentMessage || meta);
+        }
+        expansion.i18n = message;
+        return expansion;
+    }
+    visitText(text) {
+        return text;
+    }
+    visitAttribute(attribute) {
+        return attribute;
+    }
+    visitComment(comment) {
+        return comment;
+    }
+    visitExpansionCase(expansionCase) {
+        return expansionCase;
+    }
+    /**
+     * Parse the general form `meta` passed into extract the explicit metadata needed to create a
+     * `Message`.
+     *
+     * There are three possibilities for the `meta` variable
+     * 1) a string from an `i18n` template attribute: parse it to extract the metadata values.
+     * 2) a `Message` from a previous processing pass: reuse the metadata values in the message.
+     * 4) other: ignore this and just process the message metadata as normal
+     *
+     * @param meta the bucket that holds information about the message
+     * @returns the parsed metadata.
+     */
+    _parseMetadata(meta) {
+        return typeof meta === 'string' ? parseI18nMeta(meta) :
+            meta instanceof i18n.Message ? meta :
+                {};
+    }
+    /**
+     * Generate (or restore) message id if not specified already.
+     */
+    _setMessageId(message, meta) {
+        if (!message.id) {
+            message.id = meta instanceof i18n.Message && meta.id || decimalDigest(message);
+        }
+    }
+    /**
+     * Update the `message` with a `legacyId` if necessary.
+     *
+     * @param message the message whose legacy id should be set
+     * @param meta information about the message being processed
+     */
+    _setLegacyIds(message, meta) {
+        if (this.enableI18nLegacyMessageIdFormat) {
+            message.legacyIds = [computeDigest(message), computeDecimalDigest(message)];
+        }
+        else if (typeof meta !== 'string') {
+            // This occurs if we are doing the 2nd pass after whitespace removal (see `parseTemplate()` in
+            // `packages/compiler/src/render3/view/template.ts`).
+            // In that case we want to reuse the legacy message generated in the 1st pass (see
+            // `setI18nRefs()`).
+            const previousMessage = meta instanceof i18n.Message ? meta :
+                meta instanceof i18n.IcuPlaceholder ? meta.previousMessage :
+                    undefined;
+            message.legacyIds = previousMessage ? previousMessage.legacyIds : [];
+        }
+    }
+    _reportError(node, msg) {
+        this._errors.push(new I18nError(node.sourceSpan, msg));
+    }
+}
+/** I18n separators for metadata **/
+const I18N_MEANING_SEPARATOR = '|';
+const I18N_ID_SEPARATOR = '@@';
+/**
+ * Parses i18n metas like:
+ *  - "@@id",
+ *  - "description[@@id]",
+ *  - "meaning|description[@@id]"
+ * and returns an object with parsed output.
+ *
+ * @param meta String that represents i18n meta
+ * @returns Object with id, meaning and description fields
+ */
+export function parseI18nMeta(meta = '') {
+    let customId;
+    let meaning;
+    let description;
+    meta = meta.trim();
+    if (meta) {
+        const idIndex = meta.indexOf(I18N_ID_SEPARATOR);
+        const descIndex = meta.indexOf(I18N_MEANING_SEPARATOR);
+        let meaningAndDesc;
+        [meaningAndDesc, customId] =
+            (idIndex > -1) ? [meta.slice(0, idIndex), meta.slice(idIndex + 2)] : [meta, ''];
+        [meaning, description] = (descIndex > -1) ?
+            [meaningAndDesc.slice(0, descIndex), meaningAndDesc.slice(descIndex + 1)] :
+            ['', meaningAndDesc];
+    }
+    return { customId, meaning, description };
+}
+// Converts i18n meta information for a message (id, description, meaning)
+// to a JsDoc statement formatted as expected by the Closure compiler.
+export function i18nMetaToJSDoc(meta) {
+    const tags = [];
+    if (meta.description) {
+        tags.push({ tagName: "desc" /* o.JSDocTagName.Desc */, text: meta.description });
+    }
+    else {
+        // Suppress the JSCompiler warning that a `@desc` was not given for this message.
+        tags.push({ tagName: "suppress" /* o.JSDocTagName.Suppress */, text: '{msgDescriptions}' });
+    }
+    if (meta.meaning) {
+        tags.push({ tagName: "meaning" /* o.JSDocTagName.Meaning */, text: meta.meaning });
+    }
+    return o.jsDocComment(tags);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"meta.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler/src/render3/view/i18n/meta.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {computeDecimalDigest, computeDigest, decimalDigest} from '../../../i18n/digest';\nimport * as i18n from '../../../i18n/i18n_ast';\nimport {createI18nMessageFactory, I18nMessageFactory, VisitNodeFn} from '../../../i18n/i18n_parser';\nimport {I18nError} from '../../../i18n/parse_util';\nimport * as html from '../../../ml_parser/ast';\nimport {DEFAULT_INTERPOLATION_CONFIG, InterpolationConfig} from '../../../ml_parser/interpolation_config';\nimport {ParseTreeResult} from '../../../ml_parser/parser';\nimport * as o from '../../../output/output_ast';\nimport {isTrustedTypesSink} from '../../../schema/trusted_types_sinks';\n\nimport {hasI18nAttrs, I18N_ATTR, I18N_ATTR_PREFIX, icuFromI18nMessage} from './util';\n\nexport type I18nMeta = {\n  id?: string,\n  customId?: string,\n  legacyIds?: string[],\n  description?: string,\n  meaning?: string\n};\n\n\nconst setI18nRefs: VisitNodeFn = (htmlNode, i18nNode) => {\n  if (htmlNode instanceof html.NodeWithI18n) {\n    if (i18nNode instanceof i18n.IcuPlaceholder && htmlNode.i18n instanceof i18n.Message) {\n      // This html node represents an ICU but this is a second processing pass, and the legacy id\n      // was computed in the previous pass and stored in the `i18n` property as a message.\n      // We are about to wipe out that property so capture the previous message to be reused when\n      // generating the message for this ICU later. See `_generateI18nMessage()`.\n      i18nNode.previousMessage = htmlNode.i18n;\n    }\n    htmlNode.i18n = i18nNode;\n  }\n  return i18nNode;\n};\n\n/**\n * This visitor walks over HTML parse tree and converts information stored in\n * i18n-related attributes (\"i18n\" and \"i18n-*\") into i18n meta object that is\n * stored with other element's and attribute's information.\n */\nexport class I18nMetaVisitor implements html.Visitor {\n  // whether visited nodes contain i18n information\n  public hasI18nMeta: boolean = false;\n  private _errors: I18nError[] = [];\n\n  constructor(\n      private interpolationConfig: InterpolationConfig = DEFAULT_INTERPOLATION_CONFIG,\n      private keepI18nAttrs = false, private enableI18nLegacyMessageIdFormat = false) {}\n\n  private _generateI18nMessage(\n      nodes: html.Node[], meta: string|i18n.I18nMeta = '',\n      visitNodeFn?: VisitNodeFn): i18n.Message {\n    const {meaning, description, customId} = this._parseMetadata(meta);\n    const createI18nMessage = createI18nMessageFactory(this.interpolationConfig);\n    const message = createI18nMessage(nodes, meaning, description, customId, visitNodeFn);\n    this._setMessageId(message, meta);\n    this._setLegacyIds(message, meta);\n    return message;\n  }\n\n  visitAllWithErrors(nodes: html.Node[]): ParseTreeResult {\n    const result = nodes.map(node => node.visit(this, null));\n    return new ParseTreeResult(result, this._errors);\n  }\n\n  visitElement(element: html.Element): any {\n    let message: i18n.Message|undefined = undefined;\n\n    if (hasI18nAttrs(element)) {\n      this.hasI18nMeta = true;\n      const attrs: html.Attribute[] = [];\n      const attrsMeta: {[key: string]: string} = {};\n\n      for (const attr of element.attrs) {\n        if (attr.name === I18N_ATTR) {\n          // root 'i18n' node attribute\n          const i18n = element.i18n || attr.value;\n          message = this._generateI18nMessage(element.children, i18n, setI18nRefs);\n          if (message.nodes.length === 0) {\n            // Ignore the message if it is empty.\n            message = undefined;\n          }\n          // Store the message on the element\n          element.i18n = message;\n        } else if (attr.name.startsWith(I18N_ATTR_PREFIX)) {\n          // 'i18n-*' attributes\n          const name = attr.name.slice(I18N_ATTR_PREFIX.length);\n          if (isTrustedTypesSink(element.name, name)) {\n            this._reportError(\n                attr, `Translating attribute '${name}' is disallowed for security reasons.`);\n          } else {\n            attrsMeta[name] = attr.value;\n          }\n        } else {\n          // non-i18n attributes\n          attrs.push(attr);\n        }\n      }\n\n      // set i18n meta for attributes\n      if (Object.keys(attrsMeta).length) {\n        for (const attr of attrs) {\n          const meta = attrsMeta[attr.name];\n          // do not create translation for empty attributes\n          if (meta !== undefined && attr.value) {\n            attr.i18n = this._generateI18nMessage([attr], attr.i18n || meta);\n          }\n        }\n      }\n\n      if (!this.keepI18nAttrs) {\n        // update element's attributes,\n        // keeping only non-i18n related ones\n        element.attrs = attrs;\n      }\n    }\n    html.visitAll(this, element.children, message);\n    return element;\n  }\n\n  visitExpansion(expansion: html.Expansion, currentMessage: i18n.Message|null): any {\n    let message;\n    const meta = expansion.i18n;\n    this.hasI18nMeta = true;\n    if (meta instanceof i18n.IcuPlaceholder) {\n      // set ICU placeholder name (e.g. \"ICU_1\"),\n      // generated while processing root element contents,\n      // so we can reference it when we output translation\n      const name = meta.name;\n      message = this._generateI18nMessage([expansion], meta);\n      const icu = icuFromI18nMessage(message);\n      icu.name = name;\n      if (currentMessage !== null) {\n        // Also update the placeholderToMessage map with this new message\n        currentMessage.placeholderToMessage[name] = message;\n      }\n    } else {\n      // ICU is a top level message, try to use metadata from container element if provided via\n      // `context` argument. Note: context may not be available for standalone ICUs (without\n      // wrapping element), so fallback to ICU metadata in this case.\n      message = this._generateI18nMessage([expansion], currentMessage || meta);\n    }\n    expansion.i18n = message;\n    return expansion;\n  }\n\n  visitText(text: html.Text): any {\n    return text;\n  }\n  visitAttribute(attribute: html.Attribute): any {\n    return attribute;\n  }\n  visitComment(comment: html.Comment): any {\n    return comment;\n  }\n  visitExpansionCase(expansionCase: html.ExpansionCase): any {\n    return expansionCase;\n  }\n\n  /**\n   * Parse the general form `meta` passed into extract the explicit metadata needed to create a\n   * `Message`.\n   *\n   * There are three possibilities for the `meta` variable\n   * 1) a string from an `i18n` template attribute: parse it to extract the metadata values.\n   * 2) a `Message` from a previous processing pass: reuse the metadata values in the message.\n   * 4) other: ignore this and just process the message metadata as normal\n   *\n   * @param meta the bucket that holds information about the message\n   * @returns the parsed metadata.\n   */\n  private _parseMetadata(meta: string|i18n.I18nMeta): I18nMeta {\n    return typeof meta === 'string'  ? parseI18nMeta(meta) :\n        meta instanceof i18n.Message ? meta :\n                                       {};\n  }\n\n  /**\n   * Generate (or restore) message id if not specified already.\n   */\n  private _setMessageId(message: i18n.Message, meta: string|i18n.I18nMeta): void {\n    if (!message.id) {\n      message.id = meta instanceof i18n.Message && meta.id || decimalDigest(message);\n    }\n  }\n\n  /**\n   * Update the `message` with a `legacyId` if necessary.\n   *\n   * @param message the message whose legacy id should be set\n   * @param meta information about the message being processed\n   */\n  private _setLegacyIds(message: i18n.Message, meta: string|i18n.I18nMeta): void {\n    if (this.enableI18nLegacyMessageIdFormat) {\n      message.legacyIds = [computeDigest(message), computeDecimalDigest(message)];\n    } else if (typeof meta !== 'string') {\n      // This occurs if we are doing the 2nd pass after whitespace removal (see `parseTemplate()` in\n      // `packages/compiler/src/render3/view/template.ts`).\n      // In that case we want to reuse the legacy message generated in the 1st pass (see\n      // `setI18nRefs()`).\n      const previousMessage = meta instanceof i18n.Message ? meta :\n          meta instanceof i18n.IcuPlaceholder              ? meta.previousMessage :\n                                                             undefined;\n      message.legacyIds = previousMessage ? previousMessage.legacyIds : [];\n    }\n  }\n\n  private _reportError(node: html.Node, msg: string): void {\n    this._errors.push(new I18nError(node.sourceSpan, msg));\n  }\n}\n\n/** I18n separators for metadata **/\nconst I18N_MEANING_SEPARATOR = '|';\nconst I18N_ID_SEPARATOR = '@@';\n\n/**\n * Parses i18n metas like:\n *  - \"@@id\",\n *  - \"description[@@id]\",\n *  - \"meaning|description[@@id]\"\n * and returns an object with parsed output.\n *\n * @param meta String that represents i18n meta\n * @returns Object with id, meaning and description fields\n */\nexport function parseI18nMeta(meta: string = ''): I18nMeta {\n  let customId: string|undefined;\n  let meaning: string|undefined;\n  let description: string|undefined;\n\n  meta = meta.trim();\n  if (meta) {\n    const idIndex = meta.indexOf(I18N_ID_SEPARATOR);\n    const descIndex = meta.indexOf(I18N_MEANING_SEPARATOR);\n    let meaningAndDesc: string;\n    [meaningAndDesc, customId] =\n        (idIndex > -1) ? [meta.slice(0, idIndex), meta.slice(idIndex + 2)] : [meta, ''];\n    [meaning, description] = (descIndex > -1) ?\n        [meaningAndDesc.slice(0, descIndex), meaningAndDesc.slice(descIndex + 1)] :\n        ['', meaningAndDesc];\n  }\n\n  return {customId, meaning, description};\n}\n\n// Converts i18n meta information for a message (id, description, meaning)\n// to a JsDoc statement formatted as expected by the Closure compiler.\nexport function i18nMetaToJSDoc(meta: I18nMeta): o.JSDocComment {\n  const tags: o.JSDocTag[] = [];\n  if (meta.description) {\n    tags.push({tagName: o.JSDocTagName.Desc, text: meta.description});\n  } else {\n    // Suppress the JSCompiler warning that a `@desc` was not given for this message.\n    tags.push({tagName: o.JSDocTagName.Suppress, text: '{msgDescriptions}'});\n  }\n  if (meta.meaning) {\n    tags.push({tagName: o.JSDocTagName.Meaning, text: meta.meaning});\n  }\n  return o.jsDocComment(tags);\n}\n"]}

package/esm2022/src/render3/view/style_parser.mjs

@@ -0,0 +1,86 @@
+/**
+ * @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
+ */
+/**
+ * Parses string representation of a style and converts it into object literal.
+ *
+ * @param value string representation of style as used in the `style` attribute in HTML.
+ *   Example: `color: red; height: auto`.
+ * @returns An array of style property name and value pairs, e.g. `['color', 'red', 'height',
+ * 'auto']`
+ */
+export function parse(value) {
+    // we use a string array here instead of a string map
+    // because a string-map is not guaranteed to retain the
+    // order of the entries whereas a string array can be
+    // constructed in a [key, value, key, value] format.
+    const styles = [];
+    let i = 0;
+    let parenDepth = 0;
+    let quote = 0 /* Char.QuoteNone */;
+    let valueStart = 0;
+    let propStart = 0;
+    let currentProp = null;
+    while (i < value.length) {
+        const token = value.charCodeAt(i++);
+        switch (token) {
+            case 40 /* Char.OpenParen */:
+                parenDepth++;
+                break;
+            case 41 /* Char.CloseParen */:
+                parenDepth--;
+                break;
+            case 39 /* Char.QuoteSingle */:
+                // valueStart needs to be there since prop values don't
+                // have quotes in CSS
+                if (quote === 0 /* Char.QuoteNone */) {
+                    quote = 39 /* Char.QuoteSingle */;
+                }
+                else if (quote === 39 /* Char.QuoteSingle */ && value.charCodeAt(i - 1) !== 92 /* Char.BackSlash */) {
+                    quote = 0 /* Char.QuoteNone */;
+                }
+                break;
+            case 34 /* Char.QuoteDouble */:
+                // same logic as above
+                if (quote === 0 /* Char.QuoteNone */) {
+                    quote = 34 /* Char.QuoteDouble */;
+                }
+                else if (quote === 34 /* Char.QuoteDouble */ && value.charCodeAt(i - 1) !== 92 /* Char.BackSlash */) {
+                    quote = 0 /* Char.QuoteNone */;
+                }
+                break;
+            case 58 /* Char.Colon */:
+                if (!currentProp && parenDepth === 0 && quote === 0 /* Char.QuoteNone */) {
+                    currentProp = hyphenate(value.substring(propStart, i - 1).trim());
+                    valueStart = i;
+                }
+                break;
+            case 59 /* Char.Semicolon */:
+                if (currentProp && valueStart > 0 && parenDepth === 0 && quote === 0 /* Char.QuoteNone */) {
+                    const styleVal = value.substring(valueStart, i - 1).trim();
+                    styles.push(currentProp, styleVal);
+                    propStart = i;
+                    valueStart = 0;
+                    currentProp = null;
+                }
+                break;
+        }
+    }
+    if (currentProp && valueStart) {
+        const styleVal = value.slice(valueStart).trim();
+        styles.push(currentProp, styleVal);
+    }
+    return styles;
+}
+export function hyphenate(value) {
+    return value
+        .replace(/[a-z][A-Z]/g, v => {
+        return v.charAt(0) + '-' + v.charAt(1);
+    })
+        .toLowerCase();
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3R5bGVfcGFyc2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29tcGlsZXIvc3JjL3JlbmRlcjMvdmlldy9zdHlsZV9wYXJzZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBaUJIOzs7Ozs7O0dBT0c7QUFDSCxNQUFNLFVBQVUsS0FBSyxDQUFDLEtBQWE7SUFDakMscURBQXFEO0lBQ3JELHVEQUF1RDtJQUN2RCxxREFBcUQ7SUFDckQsb0RBQW9EO0lBQ3BELE1BQU0sTUFBTSxHQUFhLEVBQUUsQ0FBQztJQUU1QixJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDVixJQUFJLFVBQVUsR0FBRyxDQUFDLENBQUM7SUFDbkIsSUFBSSxLQUFLLHlCQUF1QixDQUFDO0lBQ2pDLElBQUksVUFBVSxHQUFHLENBQUMsQ0FBQztJQUNuQixJQUFJLFNBQVMsR0FBRyxDQUFDLENBQUM7SUFDbEIsSUFBSSxXQUFXLEdBQWdCLElBQUksQ0FBQztJQUNwQyxPQUFPLENBQUMsR0FBRyxLQUFLLENBQUMsTUFBTSxFQUFFO1FBQ3ZCLE1BQU0sS0FBSyxHQUFHLEtBQUssQ0FBQyxVQUFVLENBQUMsQ0FBQyxFQUFFLENBQVMsQ0FBQztRQUM1QyxRQUFRLEtBQUssRUFBRTtZQUNiO2dCQUNFLFVBQVUsRUFBRSxDQUFDO2dCQUNiLE1BQU07WUFDUjtnQkFDRSxVQUFVLEVBQUUsQ0FBQztnQkFDYixNQUFNO1lBQ1I7Z0JBQ0UsdURBQXVEO2dCQUN2RCxxQkFBcUI7Z0JBQ3JCLElBQUksS0FBSywyQkFBbUIsRUFBRTtvQkFDNUIsS0FBSyw0QkFBbUIsQ0FBQztpQkFDMUI7cUJBQU0sSUFBSSxLQUFLLDhCQUFxQixJQUFJLEtBQUssQ0FBQyxVQUFVLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyw0QkFBbUIsRUFBRTtvQkFDbkYsS0FBSyx5QkFBaUIsQ0FBQztpQkFDeEI7Z0JBQ0QsTUFBTTtZQUNSO2dCQUNFLHNCQUFzQjtnQkFDdEIsSUFBSSxLQUFLLDJCQUFtQixFQUFFO29CQUM1QixLQUFLLDRCQUFtQixDQUFDO2lCQUMxQjtxQkFBTSxJQUFJLEtBQUssOEJBQXFCLElBQUksS0FBSyxDQUFDLFVBQVUsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLDRCQUFtQixFQUFFO29CQUNuRixLQUFLLHlCQUFpQixDQUFDO2lCQUN4QjtnQkFDRCxNQUFNO1lBQ1I7Z0JBQ0UsSUFBSSxDQUFDLFdBQVcsSUFBSSxVQUFVLEtBQUssQ0FBQyxJQUFJLEtBQUssMkJBQW1CLEVBQUU7b0JBQ2hFLFdBQVcsR0FBRyxTQUFTLENBQUMsS0FBSyxDQUFDLFNBQVMsQ0FBQyxTQUFTLEVBQUUsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLElBQUksRUFBRSxDQUFDLENBQUM7b0JBQ2xFLFVBQVUsR0FBRyxDQUFDLENBQUM7aUJBQ2hCO2dCQUNELE1BQU07WUFDUjtnQkFDRSxJQUFJLFdBQVcsSUFBSSxVQUFVLEdBQUcsQ0FBQyxJQUFJLFVBQVUsS0FBSyxDQUFDLElBQUksS0FBSywyQkFBbUIsRUFBRTtvQkFDakYsTUFBTSxRQUFRLEdBQUcsS0FBSyxDQUFDLFNBQVMsQ0FBQyxVQUFVLEVBQUUsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLElBQUksRUFBRSxDQUFDO29CQUMzRCxNQUFNLENBQUMsSUFBSSxDQUFDLFdBQVcsRUFBRSxRQUFRLENBQUMsQ0FBQztvQkFDbkMsU0FBUyxHQUFHLENBQUMsQ0FBQztvQkFDZCxVQUFVLEdBQUcsQ0FBQyxDQUFDO29CQUNmLFdBQVcsR0FBRyxJQUFJLENBQUM7aUJBQ3BCO2dCQUNELE1BQU07U0FDVDtLQUNGO0lBRUQsSUFBSSxXQUFXLElBQUksVUFBVSxFQUFFO1FBQzdCLE1BQU0sUUFBUSxHQUFHLEtBQUssQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDLENBQUMsSUFBSSxFQUFFLENBQUM7UUFDaEQsTUFBTSxDQUFDLElBQUksQ0FBQyxXQUFXLEVBQUUsUUFBUSxDQUFDLENBQUM7S0FDcEM7SUFFRCxPQUFPLE1BQU0sQ0FBQztBQUNoQixDQUFDO0FBRUQsTUFBTSxVQUFVLFNBQVMsQ0FBQyxLQUFhO0lBQ3JDLE9BQU8sS0FBSztTQUNQLE9BQU8sQ0FDSixhQUFhLEVBQ2IsQ0FBQyxDQUFDLEVBQUU7UUFDRixPQUFPLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLEdBQUcsR0FBRyxHQUFHLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDekMsQ0FBQyxDQUFDO1NBQ0wsV0FBVyxFQUFFLENBQUM7QUFDckIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG4vLyBBbnkgY2hhbmdlcyBoZXJlIHNob3VsZCBiZSBwb3J0ZWQgdG8gdGhlIEFuZ3VsYXIgRG9taW5vIGZvcmsuXG4vLyBodHRwczovL2dpdGh1Yi5jb20vYW5ndWxhci9kb21pbm8vYmxvYi9tYWluL2xpYi9zdHlsZV9wYXJzZXIuanNcblxuY29uc3QgZW51bSBDaGFyIHtcbiAgT3BlblBhcmVuID0gNDAsXG4gIENsb3NlUGFyZW4gPSA0MSxcbiAgQ29sb24gPSA1OCxcbiAgU2VtaWNvbG9uID0gNTksXG4gIEJhY2tTbGFzaCA9IDkyLFxuICBRdW90ZU5vbmUgPSAwLCAgLy8gaW5kaWNhdGluZyB3ZSBhcmUgbm90IGluc2lkZSBhIHF1b3RlXG4gIFF1b3RlRG91YmxlID0gMzQsXG4gIFF1b3RlU2luZ2xlID0gMzksXG59XG5cblxuLyoqXG4gKiBQYXJzZXMgc3RyaW5nIHJlcHJlc2VudGF0aW9uIG9mIGEgc3R5bGUgYW5kIGNvbnZlcnRzIGl0IGludG8gb2JqZWN0IGxpdGVyYWwuXG4gKlxuICogQHBhcmFtIHZhbHVlIHN0cmluZyByZXByZXNlbnRhdGlvbiBvZiBzdHlsZSBhcyB1c2VkIGluIHRoZSBgc3R5bGVgIGF0dHJpYnV0ZSBpbiBIVE1MLlxuICogICBFeGFtcGxlOiBgY29sb3I6IHJlZDsgaGVpZ2h0OiBhdXRvYC5cbiAqIEByZXR1cm5zIEFuIGFycmF5IG9mIHN0eWxlIHByb3BlcnR5IG5hbWUgYW5kIHZhbHVlIHBhaXJzLCBlLmcuIGBbJ2NvbG9yJywgJ3JlZCcsICdoZWlnaHQnLFxuICogJ2F1dG8nXWBcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHBhcnNlKHZhbHVlOiBzdHJpbmcpOiBzdHJpbmdbXSB7XG4gIC8vIHdlIHVzZSBhIHN0cmluZyBhcnJheSBoZXJlIGluc3RlYWQgb2YgYSBzdHJpbmcgbWFwXG4gIC8vIGJlY2F1c2UgYSBzdHJpbmctbWFwIGlzIG5vdCBndWFyYW50ZWVkIHRvIHJldGFpbiB0aGVcbiAgLy8gb3JkZXIgb2YgdGhlIGVudHJpZXMgd2hlcmVhcyBhIHN0cmluZyBhcnJheSBjYW4gYmVcbiAgLy8gY29uc3RydWN0ZWQgaW4gYSBba2V5LCB2YWx1ZSwga2V5LCB2YWx1ZV0gZm9ybWF0LlxuICBjb25zdCBzdHlsZXM6IHN0cmluZ1tdID0gW107XG5cbiAgbGV0IGkgPSAwO1xuICBsZXQgcGFyZW5EZXB0aCA9IDA7XG4gIGxldCBxdW90ZTogQ2hhciA9IENoYXIuUXVvdGVOb25lO1xuICBsZXQgdmFsdWVTdGFydCA9IDA7XG4gIGxldCBwcm9wU3RhcnQgPSAwO1xuICBsZXQgY3VycmVudFByb3A6IHN0cmluZ3xudWxsID0gbnVsbDtcbiAgd2hpbGUgKGkgPCB2YWx1ZS5sZW5ndGgpIHtcbiAgICBjb25zdCB0b2tlbiA9IHZhbHVlLmNoYXJDb2RlQXQoaSsrKSBhcyBDaGFyO1xuICAgIHN3aXRjaCAodG9rZW4pIHtcbiAgICAgIGNhc2UgQ2hhci5PcGVuUGFyZW46XG4gICAgICAgIHBhcmVuRGVwdGgrKztcbiAgICAgICAgYnJlYWs7XG4gICAgICBjYXNlIENoYXIuQ2xvc2VQYXJlbjpcbiAgICAgICAgcGFyZW5EZXB0aC0tO1xuICAgICAgICBicmVhaztcbiAgICAgIGNhc2UgQ2hhci5RdW90ZVNpbmdsZTpcbiAgICAgICAgLy8gdmFsdWVTdGFydCBuZWVkcyB0byBiZSB0aGVyZSBzaW5jZSBwcm9wIHZhbHVlcyBkb24ndFxuICAgICAgICAvLyBoYXZlIHF1b3RlcyBpbiBDU1NcbiAgICAgICAgaWYgKHF1b3RlID09PSBDaGFyLlF1b3RlTm9uZSkge1xuICAgICAgICAgIHF1b3RlID0gQ2hhci5RdW90ZVNpbmdsZTtcbiAgICAgICAgfSBlbHNlIGlmIChxdW90ZSA9PT0gQ2hhci5RdW90ZVNpbmdsZSAmJiB2YWx1ZS5jaGFyQ29kZUF0KGkgLSAxKSAhPT0gQ2hhci5CYWNrU2xhc2gpIHtcbiAgICAgICAgICBxdW90ZSA9IENoYXIuUXVvdGVOb25lO1xuICAgICAgICB9XG4gICAgICAgIGJyZWFrO1xuICAgICAgY2FzZSBDaGFyLlF1b3RlRG91YmxlOlxuICAgICAgICAvLyBzYW1lIGxvZ2ljIGFzIGFib3ZlXG4gICAgICAgIGlmIChxdW90ZSA9PT0gQ2hhci5RdW90ZU5vbmUpIHtcbiAgICAgICAgICBxdW90ZSA9IENoYXIuUXVvdGVEb3VibGU7XG4gICAgICAgIH0gZWxzZSBpZiAocXVvdGUgPT09IENoYXIuUXVvdGVEb3VibGUgJiYgdmFsdWUuY2hhckNvZGVBdChpIC0gMSkgIT09IENoYXIuQmFja1NsYXNoKSB7XG4gICAgICAgICAgcXVvdGUgPSBDaGFyLlF1b3RlTm9uZTtcbiAgICAgICAgfVxuICAgICAgICBicmVhaztcbiAgICAgIGNhc2UgQ2hhci5Db2xvbjpcbiAgICAgICAgaWYgKCFjdXJyZW50UHJvcCAmJiBwYXJlbkRlcHRoID09PSAwICYmIHF1b3RlID09PSBDaGFyLlF1b3RlTm9uZSkge1xuICAgICAgICAgIGN1cnJlbnRQcm9wID0gaHlwaGVuYXRlKHZhbHVlLnN1YnN0cmluZyhwcm9wU3RhcnQsIGkgLSAxKS50cmltKCkpO1xuICAgICAgICAgIHZhbHVlU3RhcnQgPSBpO1xuICAgICAgICB9XG4gICAgICAgIGJyZWFrO1xuICAgICAgY2FzZSBDaGFyLlNlbWljb2xvbjpcbiAgICAgICAgaWYgKGN1cnJlbnRQcm9wICYmIHZhbHVlU3RhcnQgPiAwICYmIHBhcmVuRGVwdGggPT09IDAgJiYgcXVvdGUgPT09IENoYXIuUXVvdGVOb25lKSB7XG4gICAgICAgICAgY29uc3Qgc3R5bGVWYWwgPSB2YWx1ZS5zdWJzdHJpbmcodmFsdWVTdGFydCwgaSAtIDEpLnRyaW0oKTtcbiAgICAgICAgICBzdHlsZXMucHVzaChjdXJyZW50UHJvcCwgc3R5bGVWYWwpO1xuICAgICAgICAgIHByb3BTdGFydCA9IGk7XG4gICAgICAgICAgdmFsdWVTdGFydCA9IDA7XG4gICAgICAgICAgY3VycmVudFByb3AgPSBudWxsO1xuICAgICAgICB9XG4gICAgICAgIGJyZWFrO1xuICAgIH1cbiAgfVxuXG4gIGlmIChjdXJyZW50UHJvcCAmJiB2YWx1ZVN0YXJ0KSB7XG4gICAgY29uc3Qgc3R5bGVWYWwgPSB2YWx1ZS5zbGljZSh2YWx1ZVN0YXJ0KS50cmltKCk7XG4gICAgc3R5bGVzLnB1c2goY3VycmVudFByb3AsIHN0eWxlVmFsKTtcbiAgfVxuXG4gIHJldHVybiBzdHlsZXM7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBoeXBoZW5hdGUodmFsdWU6IHN0cmluZyk6IHN0cmluZyB7XG4gIHJldHVybiB2YWx1ZVxuICAgICAgLnJlcGxhY2UoXG4gICAgICAgICAgL1thLXpdW0EtWl0vZyxcbiAgICAgICAgICB2ID0+IHtcbiAgICAgICAgICAgIHJldHVybiB2LmNoYXJBdCgwKSArICctJyArIHYuY2hhckF0KDEpO1xuICAgICAgICAgIH0pXG4gICAgICAudG9Mb3dlckNhc2UoKTtcbn1cbiJdfQ==

package/{esm2020 → esm2022}/src/version.mjs

@@ -11,5 +11,5 @@
  * Entry point for all public APIs of the compiler package.
  */
 import { Version } from './util';
-export const VERSION = new Version('16.0.0-next.4');
+export const VERSION = new Version('16.0.0-next.6');
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbXBpbGVyL3NyYy92ZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVIOzs7O0dBSUc7QUFFSCxPQUFPLEVBQUMsT0FBTyxFQUFDLE1BQU0sUUFBUSxDQUFDO0FBRS9CLE1BQU0sQ0FBQyxNQUFNLE9BQU8sR0FBRyxJQUFJLE9BQU8sQ0FBQyxtQkFBbUIsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbi8qKlxuICogQG1vZHVsZVxuICogQGRlc2NyaXB0aW9uXG4gKiBFbnRyeSBwb2ludCBmb3IgYWxsIHB1YmxpYyBBUElzIG9mIHRoZSBjb21waWxlciBwYWNrYWdlLlxuICovXG5cbmltcG9ydCB7VmVyc2lvbn0gZnJvbSAnLi91dGlsJztcblxuZXhwb3J0IGNvbnN0IFZFUlNJT04gPSBuZXcgVmVyc2lvbignMC4wLjAtUExBQ0VIT0xERVInKTtcbiJdfQ==