@angular/compiler 14.0.0-next.8 → 14.0.0-rc.1

package/src/expression_parser/parser.d.ts

@@ -1,315 +0,0 @@
-/**
- * @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 { InterpolationConfig } from '../ml_parser/interpolation_config';
-import { InterpolatedAttributeToken, InterpolatedTextToken } from '../ml_parser/tokens';
-import { AbsoluteSourceSpan, AST, ASTWithSource, BindingPipe, LiteralMap, ParserError, ParseSpan, TemplateBinding, TemplateBindingIdentifier } from './ast';
-import { Lexer, Token } from './lexer';
-export interface InterpolationPiece {
-    text: string;
-    start: number;
-    end: number;
-}
-export declare class SplitInterpolation {
-    strings: InterpolationPiece[];
-    expressions: InterpolationPiece[];
-    offsets: number[];
-    constructor(strings: InterpolationPiece[], expressions: InterpolationPiece[], offsets: number[]);
-}
-export declare class TemplateBindingParseResult {
-    templateBindings: TemplateBinding[];
-    warnings: string[];
-    errors: ParserError[];
-    constructor(templateBindings: TemplateBinding[], warnings: string[], errors: ParserError[]);
-}
-/**
- * Represents the possible parse modes to be used as a bitmask.
- */
-export declare const enum ParseFlags {
-    None = 0,
-    /**
-     * Whether an output binding is being parsed.
-     */
-    Action = 1,
-    /**
-     * Whether an assignment event is being parsed, i.e. an expression originating from
-     * two-way-binding aka banana-in-a-box syntax.
-     */
-    AssignmentEvent = 2
-}
-export declare class Parser {
-    private _lexer;
-    private errors;
-    constructor(_lexer: Lexer);
-    parseAction(input: string, isAssignmentEvent: boolean, location: string, absoluteOffset: number, interpolationConfig?: InterpolationConfig): ASTWithSource;
-    parseBinding(input: string, location: string, absoluteOffset: number, interpolationConfig?: InterpolationConfig): ASTWithSource;
-    private checkSimpleExpression;
-    parseSimpleBinding(input: string, location: string, absoluteOffset: number, interpolationConfig?: InterpolationConfig): ASTWithSource;
-    private _reportError;
-    private _parseBindingAst;
-    /**
-     * Parse microsyntax template expression and return a list of bindings or
-     * parsing errors in case the given expression is invalid.
-     *
-     * For example,
-     * ```
-     *   <div *ngFor="let item of items">
-     *         ^      ^ absoluteValueOffset for `templateValue`
-     *         absoluteKeyOffset for `templateKey`
-     * ```
-     * contains three bindings:
-     * 1. ngFor -> null
-     * 2. item -> NgForOfContext.$implicit
-     * 3. ngForOf -> items
-     *
-     * This is apparent from the de-sugared template:
-     * ```
-     *   <ng-template ngFor let-item [ngForOf]="items">
-     * ```
-     *
-     * @param templateKey name of directive, without the * prefix. For example: ngIf, ngFor
-     * @param templateValue RHS of the microsyntax attribute
-     * @param templateUrl template filename if it's external, component filename if it's inline
-     * @param absoluteKeyOffset start of the `templateKey`
-     * @param absoluteValueOffset start of the `templateValue`
-     */
-    parseTemplateBindings(templateKey: string, templateValue: string, templateUrl: string, absoluteKeyOffset: number, absoluteValueOffset: number): TemplateBindingParseResult;
-    parseInterpolation(input: string, location: string, absoluteOffset: number, interpolatedTokens: InterpolatedAttributeToken[] | InterpolatedTextToken[] | null, interpolationConfig?: InterpolationConfig): ASTWithSource | null;
-    /**
-     * Similar to `parseInterpolation`, but treats the provided string as a single expression
-     * element that would normally appear within the interpolation prefix and suffix (`{{` and `}}`).
-     * This is used for parsing the switch expression in ICUs.
-     */
-    parseInterpolationExpression(expression: string, location: string, absoluteOffset: number): ASTWithSource;
-    private createInterpolationAst;
-    /**
-     * Splits a string of text into "raw" text segments and expressions present in interpolations in
-     * the string.
-     * Returns `null` if there are no interpolations, otherwise a
-     * `SplitInterpolation` with splits that look like
-     *   <raw text> <expression> <raw text> ... <raw text> <expression> <raw text>
-     */
-    splitInterpolation(input: string, location: string, interpolatedTokens: InterpolatedAttributeToken[] | InterpolatedTextToken[] | null, interpolationConfig?: InterpolationConfig): SplitInterpolation;
-    wrapLiteralPrimitive(input: string | null, location: string, absoluteOffset: number): ASTWithSource;
-    private _stripComments;
-    private _commentStart;
-    private _checkNoInterpolation;
-    /**
-     * Finds the index of the end of an interpolation expression
-     * while ignoring comments and quoted content.
-     */
-    private _getInterpolationEndIndex;
-    /**
-     * Generator used to iterate over the character indexes of a string that are outside of quotes.
-     * @param input String to loop through.
-     * @param start Index within the string at which to start.
-     */
-    private _forEachUnquotedChar;
-}
-export declare class _ParseAST {
-    input: string;
-    location: string;
-    absoluteOffset: number;
-    tokens: Token[];
-    parseFlags: ParseFlags;
-    private errors;
-    private offset;
-    private rparensExpected;
-    private rbracketsExpected;
-    private rbracesExpected;
-    private context;
-    private sourceSpanCache;
-    index: number;
-    constructor(input: string, location: string, absoluteOffset: number, tokens: Token[], parseFlags: ParseFlags, errors: ParserError[], offset: number);
-    peek(offset: number): Token;
-    get next(): Token;
-    /** Whether all the parser input has been processed. */
-    get atEOF(): boolean;
-    /**
-     * Index of the next token to be processed, or the end of the last token if all have been
-     * processed.
-     */
-    get inputIndex(): number;
-    /**
-     * End index of the last processed token, or the start of the first token if none have been
-     * processed.
-     */
-    get currentEndIndex(): number;
-    /**
-     * Returns the absolute offset of the start of the current token.
-     */
-    get currentAbsoluteOffset(): number;
-    /**
-     * Retrieve a `ParseSpan` from `start` to the current position (or to `artificialEndIndex` if
-     * provided).
-     *
-     * @param start Position from which the `ParseSpan` will start.
-     * @param artificialEndIndex Optional ending index to be used if provided (and if greater than the
-     *     natural ending index)
-     */
-    span(start: number, artificialEndIndex?: number): ParseSpan;
-    sourceSpan(start: number, artificialEndIndex?: number): AbsoluteSourceSpan;
-    advance(): void;
-    /**
-     * Executes a callback in the provided context.
-     */
-    private withContext;
-    consumeOptionalCharacter(code: number): boolean;
-    peekKeywordLet(): boolean;
-    peekKeywordAs(): boolean;
-    /**
-     * Consumes an expected character, otherwise emits an error about the missing expected character
-     * and skips over the token stream until reaching a recoverable point.
-     *
-     * See `this.error` and `this.skip` for more details.
-     */
-    expectCharacter(code: number): void;
-    consumeOptionalOperator(op: string): boolean;
-    expectOperator(operator: string): void;
-    prettyPrintToken(tok: Token): string;
-    expectIdentifierOrKeyword(): string | null;
-    expectIdentifierOrKeywordOrString(): string;
-    parseChain(): AST;
-    parsePipe(): AST;
-    parseExpression(): AST;
-    parseConditional(): AST;
-    parseLogicalOr(): AST;
-    parseLogicalAnd(): AST;
-    parseNullishCoalescing(): AST;
-    parseEquality(): AST;
-    parseRelational(): AST;
-    parseAdditive(): AST;
-    parseMultiplicative(): AST;
-    parsePrefix(): AST;
-    parseCallChain(): AST;
-    parsePrimary(): AST;
-    parseExpressionList(terminator: number): AST[];
-    parseLiteralMap(): LiteralMap;
-    parseAccessMember(readReceiver: AST, start: number, isSafe: boolean): AST;
-    parseCall(receiver: AST, start: number, isSafe: boolean): AST;
-    private consumeOptionalAssignment;
-    parseCallArguments(): BindingPipe[];
-    /**
-     * Parses an identifier, a keyword, a string with an optional `-` in between,
-     * and returns the string along with its absolute source span.
-     */
-    expectTemplateBindingKey(): TemplateBindingIdentifier;
-    /**
-     * Parse microsyntax template expression and return a list of bindings or
-     * parsing errors in case the given expression is invalid.
-     *
-     * For example,
-     * ```
-     *   <div *ngFor="let item of items; index as i; trackBy: func">
-     * ```
-     * contains five bindings:
-     * 1. ngFor -> null
-     * 2. item -> NgForOfContext.$implicit
-     * 3. ngForOf -> items
-     * 4. i -> NgForOfContext.index
-     * 5. ngForTrackBy -> func
-     *
-     * For a full description of the microsyntax grammar, see
-     * https://gist.github.com/mhevery/d3530294cff2e4a1b3fe15ff75d08855
-     *
-     * @param templateKey name of the microsyntax directive, like ngIf, ngFor,
-     * without the *, along with its absolute span.
-     */
-    parseTemplateBindings(templateKey: TemplateBindingIdentifier): TemplateBindingParseResult;
-    parseKeyedReadOrWrite(receiver: AST, start: number, isSafe: boolean): AST;
-    /**
-     * Parse a directive keyword, followed by a mandatory expression.
-     * For example, "of items", "trackBy: func".
-     * The bindings are: ngForOf -> items, ngForTrackBy -> func
-     * There could be an optional "as" binding that follows the expression.
-     * For example,
-     * ```
-     *   *ngFor="let item of items | slice:0:1 as collection".
-     *                    ^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^
-     *               keyword    bound target   optional 'as' binding
-     * ```
-     *
-     * @param key binding key, for example, ngFor, ngIf, ngForOf, along with its
-     * absolute span.
-     */
-    private parseDirectiveKeywordBindings;
-    /**
-     * Return the expression AST for the bound target of a directive keyword
-     * binding. For example,
-     * ```
-     *   *ngIf="condition | pipe"
-     *          ^^^^^^^^^^^^^^^^ bound target for "ngIf"
-     *   *ngFor="let item of items"
-     *                       ^^^^^ bound target for "ngForOf"
-     * ```
-     */
-    private getDirectiveBoundTarget;
-    /**
-     * Return the binding for a variable declared using `as`. Note that the order
-     * of the key-value pair in this declaration is reversed. For example,
-     * ```
-     *   *ngFor="let item of items; index as i"
-     *                              ^^^^^    ^
-     *                              value    key
-     * ```
-     *
-     * @param value name of the value in the declaration, "ngIf" in the example
-     * above, along with its absolute span.
-     */
-    private parseAsBinding;
-    /**
-     * Return the binding for a variable declared using `let`. For example,
-     * ```
-     *   *ngFor="let item of items; let i=index;"
-     *           ^^^^^^^^           ^^^^^^^^^^^
-     * ```
-     * In the first binding, `item` is bound to `NgForOfContext.$implicit`.
-     * In the second binding, `i` is bound to `NgForOfContext.index`.
-     */
-    private parseLetBinding;
-    /**
-     * Consume the optional statement terminator: semicolon or comma.
-     */
-    private consumeStatementTerminator;
-    /**
-     * Records an error and skips over the token stream until reaching a recoverable point. See
-     * `this.skip` for more details on token skipping.
-     */
-    error(message: string, index?: number | null): void;
-    private locationText;
-    /**
-     * Records an error for an unexpected private identifier being discovered.
-     * @param token Token representing a private identifier.
-     * @param extraMessage Optional additional message being appended to the error.
-     */
-    private _reportErrorForPrivateIdentifier;
-    /**
-     * Error recovery should skip tokens until it encounters a recovery point.
-     *
-     * The following are treated as unconditional recovery points:
-     *   - end of input
-     *   - ';' (parseChain() is always the root production, and it expects a ';')
-     *   - '|' (since pipes may be chained and each pipe expression may be treated independently)
-     *
-     * The following are conditional recovery points:
-     *   - ')', '}', ']' if one of calling productions is expecting one of these symbols
-     *     - This allows skip() to recover from errors such as '(a.) + 1' allowing more of the AST to
-     *       be retained (it doesn't skip any tokens as the ')' is retained because of the '(' begins
-     *       an '(' <expr> ')' production).
-     *       The recovery points of grouping symbols must be conditional as they must be skipped if
-     *       none of the calling productions are not expecting the closing token else we will never
-     *       make progress in the case of an extraneous group closing symbol (such as a stray ')').
-     *       That is, we skip a closing symbol if we are not in a grouping production.
-     *   - '=' in a `Writable` context
-     *     - In this context, we are able to recover after seeing the `=` operator, which
-     *       signals the presence of an independent rvalue expression following the `=` operator.
-     *
-     * If a production expects one of these token it increments the corresponding nesting count,
-     * and then decrements it just prior to checking if the token is in the input.
-     */
-    private skip;
-}

package/src/i18n/big_integer.d.ts

@@ -1,108 +0,0 @@
-/**
- * @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
- */
-/**
- * Represents a big integer using a buffer of its individual digits, with the least significant
- * digit stored at the beginning of the array (little endian).
- *
- * For performance reasons, each instance is mutable. The addition operation can be done in-place
- * to reduce memory pressure of allocation for the digits array.
- */
-export declare class BigInteger {
-    private readonly digits;
-    static zero(): BigInteger;
-    static one(): BigInteger;
-    /**
-     * Creates a big integer using its individual digits in little endian storage.
-     */
-    private constructor();
-    /**
-     * Creates a clone of this instance.
-     */
-    clone(): BigInteger;
-    /**
-     * Returns a new big integer with the sum of `this` and `other` as its value. This does not mutate
-     * `this` but instead returns a new instance, unlike `addToSelf`.
-     */
-    add(other: BigInteger): BigInteger;
-    /**
-     * Adds `other` to the instance itself, thereby mutating its value.
-     */
-    addToSelf(other: BigInteger): void;
-    /**
-     * Builds the decimal string representation of the big integer. As this is stored in
-     * little endian, the digits are concatenated in reverse order.
-     */
-    toString(): string;
-}
-/**
- * Represents a big integer which is optimized for multiplication operations, as its power-of-twos
- * are memoized. See `multiplyBy()` for details on the multiplication algorithm.
- */
-export declare class BigIntForMultiplication {
-    /**
-     * Stores all memoized power-of-twos, where each index represents `this.number * 2^index`.
-     */
-    private readonly powerOfTwos;
-    constructor(value: BigInteger);
-    /**
-     * Returns the big integer itself.
-     */
-    getValue(): BigInteger;
-    /**
-     * Computes the value for `num * b`, where `num` is a JS number and `b` is a big integer. The
-     * value for `b` is represented by a storage model that is optimized for this computation.
-     *
-     * This operation is implemented in N(log2(num)) by continuous halving of the number, where the
-     * least-significant bit (LSB) is tested in each iteration. If the bit is set, the bit's index is
-     * used as exponent into the power-of-two multiplication of `b`.
-     *
-     * As an example, consider the multiplication num=42, b=1337. In binary 42 is 0b00101010 and the
-     * algorithm unrolls into the following iterations:
-     *
-     *  Iteration | num        | LSB  | b * 2^iter | Add? | product
-     * -----------|------------|------|------------|------|--------
-     *  0         | 0b00101010 | 0    | 1337       | No   | 0
-     *  1         | 0b00010101 | 1    | 2674       | Yes  | 2674
-     *  2         | 0b00001010 | 0    | 5348       | No   | 2674
-     *  3         | 0b00000101 | 1    | 10696      | Yes  | 13370
-     *  4         | 0b00000010 | 0    | 21392      | No   | 13370
-     *  5         | 0b00000001 | 1    | 42784      | Yes  | 56154
-     *  6         | 0b00000000 | 0    | 85568      | No   | 56154
-     *
-     * The computed product of 56154 is indeed the correct result.
-     *
-     * The `BigIntForMultiplication` representation for a big integer provides memoized access to the
-     * power-of-two values to reduce the workload in computing those values.
-     */
-    multiplyBy(num: number): BigInteger;
-    /**
-     * See `multiplyBy()` for details. This function allows for the computed product to be added
-     * directly to the provided result big integer.
-     */
-    multiplyByAndAddTo(num: number, result: BigInteger): void;
-    /**
-     * Computes and memoizes the big integer value for `this.number * 2^exponent`.
-     */
-    private getMultipliedByPowerOfTwo;
-}
-/**
- * Represents an exponentiation operation for the provided base, of which exponents are computed and
- * memoized. The results are represented by a `BigIntForMultiplication` which is tailored for
- * multiplication operations by memoizing the power-of-twos. This effectively results in a matrix
- * representation that is lazily computed upon request.
- */
-export declare class BigIntExponentiation {
-    private readonly base;
-    private readonly exponents;
-    constructor(base: number);
-    /**
-     * Compute the value for `this.base^exponent`, resulting in a big integer that is optimized for
-     * further multiplication operations.
-     */
-    toThePowerOf(exponent: number): BigIntForMultiplication;
-}

package/src/i18n/digest.d.ts

@@ -1,44 +0,0 @@
-/**
- * @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 * as i18n from './i18n_ast';
-/**
- * Return the message id or compute it using the XLIFF1 digest.
- */
-export declare function digest(message: i18n.Message): string;
-/**
- * Compute the message id using the XLIFF1 digest.
- */
-export declare function computeDigest(message: i18n.Message): string;
-/**
- * Return the message id or compute it using the XLIFF2/XMB/$localize digest.
- */
-export declare function decimalDigest(message: i18n.Message): string;
-/**
- * Compute the message id using the XLIFF2/XMB/$localize digest.
- */
-export declare function computeDecimalDigest(message: i18n.Message): string;
-export declare function serializeNodes(nodes: i18n.Node[]): string[];
-/**
- * Compute the SHA1 of the given string
- *
- * see https://csrc.nist.gov/publications/fips/fips180-4/fips-180-4.pdf
- *
- * WARNING: this function has not been designed not tested with security in mind.
- *          DO NOT USE IT IN A SECURITY SENSITIVE CONTEXT.
- */
-export declare function sha1(str: string): string;
-/**
- * Compute the fingerprint of the given string
- *
- * The output is 64 bit number encoded as a decimal string
- *
- * based on:
- * https://github.com/google/closure-compiler/blob/master/src/com/google/javascript/jscomp/GoogleJsMessageIdGenerator.java
- */
-export declare function fingerprint(str: string): [number, number];
-export declare function computeMsgId(msg: string, meaning?: string): string;

package/src/i18n/extractor_merger.d.ts

@@ -1,27 +0,0 @@
-/**
- * @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 * as html from '../ml_parser/ast';
-import { InterpolationConfig } from '../ml_parser/interpolation_config';
-import { ParseTreeResult } from '../ml_parser/parser';
-import * as i18n from './i18n_ast';
-import { I18nError } from './parse_util';
-import { TranslationBundle } from './translation_bundle';
-/**
- * Extract translatable messages from an html AST
- */
-export declare function extractMessages(nodes: html.Node[], interpolationConfig: InterpolationConfig, implicitTags: string[], implicitAttrs: {
-    [k: string]: string[];
-}): ExtractionResult;
-export declare function mergeTranslations(nodes: html.Node[], translations: TranslationBundle, interpolationConfig: InterpolationConfig, implicitTags: string[], implicitAttrs: {
-    [k: string]: string[];
-}): ParseTreeResult;
-export declare class ExtractionResult {
-    messages: i18n.Message[];
-    errors: I18nError[];
-    constructor(messages: i18n.Message[], errors: I18nError[]);
-}

package/src/i18n/i18n_ast.d.ts

@@ -1,148 +0,0 @@
-/**
- * @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 { ParseSourceSpan } from '../parse_util';
-/**
- * Describes the text contents of a placeholder as it appears in an ICU expression, including its
- * source span information.
- */
-export interface MessagePlaceholder {
-    /** The text contents of the placeholder */
-    text: string;
-    /** The source span of the placeholder */
-    sourceSpan: ParseSourceSpan;
-}
-export declare class Message {
-    nodes: Node[];
-    placeholders: {
-        [phName: string]: MessagePlaceholder;
-    };
-    placeholderToMessage: {
-        [phName: string]: Message;
-    };
-    meaning: string;
-    description: string;
-    customId: string;
-    sources: MessageSpan[];
-    id: string;
-    /** The ids to use if there are no custom id and if `i18nLegacyMessageIdFormat` is not empty */
-    legacyIds: string[];
-    messageString: string;
-    /**
-     * @param nodes message AST
-     * @param placeholders maps placeholder names to static content and their source spans
-     * @param placeholderToMessage maps placeholder names to messages (used for nested ICU messages)
-     * @param meaning
-     * @param description
-     * @param customId
-     */
-    constructor(nodes: Node[], placeholders: {
-        [phName: string]: MessagePlaceholder;
-    }, placeholderToMessage: {
-        [phName: string]: Message;
-    }, meaning: string, description: string, customId: string);
-}
-export interface MessageSpan {
-    filePath: string;
-    startLine: number;
-    startCol: number;
-    endLine: number;
-    endCol: number;
-}
-export interface Node {
-    sourceSpan: ParseSourceSpan;
-    visit(visitor: Visitor, context?: any): any;
-}
-export declare class Text implements Node {
-    value: string;
-    sourceSpan: ParseSourceSpan;
-    constructor(value: string, sourceSpan: ParseSourceSpan);
-    visit(visitor: Visitor, context?: any): any;
-}
-export declare class Container implements Node {
-    children: Node[];
-    sourceSpan: ParseSourceSpan;
-    constructor(children: Node[], sourceSpan: ParseSourceSpan);
-    visit(visitor: Visitor, context?: any): any;
-}
-export declare class Icu implements Node {
-    expression: string;
-    type: string;
-    cases: {
-        [k: string]: Node;
-    };
-    sourceSpan: ParseSourceSpan;
-    expressionPlaceholder: string;
-    constructor(expression: string, type: string, cases: {
-        [k: string]: Node;
-    }, sourceSpan: ParseSourceSpan);
-    visit(visitor: Visitor, context?: any): any;
-}
-export declare class TagPlaceholder implements Node {
-    tag: string;
-    attrs: {
-        [k: string]: string;
-    };
-    startName: string;
-    closeName: string;
-    children: Node[];
-    isVoid: boolean;
-    sourceSpan: ParseSourceSpan;
-    startSourceSpan: ParseSourceSpan | null;
-    endSourceSpan: ParseSourceSpan | null;
-    constructor(tag: string, attrs: {
-        [k: string]: string;
-    }, startName: string, closeName: string, children: Node[], isVoid: boolean, sourceSpan: ParseSourceSpan, startSourceSpan: ParseSourceSpan | null, endSourceSpan: ParseSourceSpan | null);
-    visit(visitor: Visitor, context?: any): any;
-}
-export declare class Placeholder implements Node {
-    value: string;
-    name: string;
-    sourceSpan: ParseSourceSpan;
-    constructor(value: string, name: string, sourceSpan: ParseSourceSpan);
-    visit(visitor: Visitor, context?: any): any;
-}
-export declare class IcuPlaceholder implements Node {
-    value: Icu;
-    name: string;
-    sourceSpan: ParseSourceSpan;
-    /** Used to capture a message computed from a previous processing pass (see `setI18nRefs()`). */
-    previousMessage?: Message;
-    constructor(value: Icu, name: string, sourceSpan: ParseSourceSpan);
-    visit(visitor: Visitor, context?: any): any;
-}
-/**
- * Each HTML node that is affect by an i18n tag will also have an `i18n` property that is of type
- * `I18nMeta`.
- * This information is either a `Message`, which indicates it is the root of an i18n message, or a
- * `Node`, which indicates is it part of a containing `Message`.
- */
-export declare type I18nMeta = Message | Node;
-export interface Visitor {
-    visitText(text: Text, context?: any): any;
-    visitContainer(container: Container, context?: any): any;
-    visitIcu(icu: Icu, context?: any): any;
-    visitTagPlaceholder(ph: TagPlaceholder, context?: any): any;
-    visitPlaceholder(ph: Placeholder, context?: any): any;
-    visitIcuPlaceholder(ph: IcuPlaceholder, context?: any): any;
-}
-export declare class CloneVisitor implements Visitor {
-    visitText(text: Text, context?: any): Text;
-    visitContainer(container: Container, context?: any): Container;
-    visitIcu(icu: Icu, context?: any): Icu;
-    visitTagPlaceholder(ph: TagPlaceholder, context?: any): TagPlaceholder;
-    visitPlaceholder(ph: Placeholder, context?: any): Placeholder;
-    visitIcuPlaceholder(ph: IcuPlaceholder, context?: any): IcuPlaceholder;
-}
-export declare class RecurseVisitor implements Visitor {
-    visitText(text: Text, context?: any): any;
-    visitContainer(container: Container, context?: any): any;
-    visitIcu(icu: Icu, context?: any): any;
-    visitTagPlaceholder(ph: TagPlaceholder, context?: any): any;
-    visitPlaceholder(ph: Placeholder, context?: any): any;
-    visitIcuPlaceholder(ph: IcuPlaceholder, context?: any): any;
-}

package/src/i18n/i18n_html_parser.d.ts

@@ -1,19 +0,0 @@
-/**
- * @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 { MissingTranslationStrategy } from '../core';
-import { HtmlParser } from '../ml_parser/html_parser';
-import { TokenizeOptions } from '../ml_parser/lexer';
-import { ParseTreeResult } from '../ml_parser/parser';
-import { Console } from '../util';
-export declare class I18NHtmlParser implements HtmlParser {
-    private _htmlParser;
-    getTagDefinition: any;
-    private _translationBundle;
-    constructor(_htmlParser: HtmlParser, translations?: string, translationsFormat?: string, missingTranslation?: MissingTranslationStrategy, console?: Console);
-    parse(source: string, url: string, options?: TokenizeOptions): ParseTreeResult;
-}

package/src/i18n/i18n_parser.d.ts

@@ -1,18 +0,0 @@
-/**
- * @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 * as html from '../ml_parser/ast';
-import { InterpolationConfig } from '../ml_parser/interpolation_config';
-import * as i18n from './i18n_ast';
-export declare type VisitNodeFn = (html: html.Node, i18n: i18n.Node) => i18n.Node;
-export interface I18nMessageFactory {
-    (nodes: html.Node[], meaning: string | undefined, description: string | undefined, customId: string | undefined, visitNodeFn?: VisitNodeFn): i18n.Message;
-}
-/**
- * Returns a function converting html nodes to an i18n Message given an interpolationConfig
- */
-export declare function createI18nMessageFactory(interpolationConfig: InterpolationConfig): I18nMessageFactory;