@absolutejs/absolute 0.19.0-beta.852 → 0.19.0-beta.854

package/dist/src/dev/angular/vendor/translator/api/ast_factory.d.ts

@@ -0,0 +1,363 @@
+/**
+ * @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.dev/license
+ */
+/**
+ * Used to create transpiler specific AST nodes from Angular Output AST nodes in an abstract way.
+ *
+ * Note that the `AstFactory` makes no assumptions about the target language being generated.
+ * It is up to the caller to do this - e.g. only call `createTaggedTemplate()` or pass `let`|`const`
+ * to `createVariableDeclaration()` if the final JS will allow it.
+ */
+export interface AstFactory<TStatement, TExpression, TType> {
+    /**
+     * Attach the `leadingComments` to the given `statement` node.
+     *
+     * @param statement the statement where the comments are to be attached.
+     * @param leadingComments the comments to attach.
+     */
+    attachComments(statement: TStatement | TExpression, leadingComments: LeadingComment[]): void;
+    /**
+     * Create a literal array expression (e.g. `[expr1, expr2]`).
+     *
+     * @param elements a collection of the expressions to appear in each array slot.
+     */
+    createArrayLiteral(elements: TExpression[]): TExpression;
+    /**
+     * Create an assignment expression (e.g. `lhsExpr = rhsExpr`).
+     *
+     * @param target an expression that evaluates to the left side of the assignment.
+     * @param operator binary assignment operator that will be applied.
+     * @param value an expression that evaluates to the right side of the assignment.
+     */
+    createAssignment(target: TExpression, operator: BinaryOperator, value: TExpression): TExpression;
+    /**
+     * Create a binary expression (e.g. `lhs && rhs`).
+     *
+     * @param leftOperand an expression that will appear on the left of the operator.
+     * @param operator the binary operator that will be applied.
+     * @param rightOperand an expression that will appear on the right of the operator.
+     */
+    createBinaryExpression(leftOperand: TExpression, operator: BinaryOperator, rightOperand: TExpression): TExpression;
+    /**
+     * Create a block of statements (e.g. `{ stmt1; stmt2; }`).
+     *
+     * @param body an array of statements to be wrapped in a block.
+     */
+    createBlock(body: TStatement[]): TStatement;
+    /**
+     * Create an expression that is calling the `callee` with the given `args`.
+     *
+     * @param callee an expression that evaluates to a function to be called.
+     * @param args the arguments to be passed to the call.
+     * @param pure whether to mark the call as pure (having no side-effects).
+     */
+    createCallExpression(callee: TExpression, args: TExpression[], pure: boolean): TExpression;
+    /**
+     * Create a ternary expression (e.g. `testExpr ? trueExpr : falseExpr`).
+     *
+     * @param condition an expression that will be tested for truthiness.
+     * @param thenExpression an expression that is executed if `condition` is truthy.
+     * @param elseExpression an expression that is executed if `condition` is falsy.
+     */
+    createConditional(condition: TExpression, thenExpression: TExpression, elseExpression: TExpression): TExpression;
+    /**
+     * Create an element access (e.g. `obj[expr]`).
+     *
+     * @param expression an expression that evaluates to the object to be accessed.
+     * @param element an expression that evaluates to the element on the object.
+     */
+    createElementAccess(expression: TExpression, element: TExpression): TExpression;
+    /**
+     * Create a statement that is simply executing the given `expression` (e.g. `x = 10;`).
+     *
+     * @param expression the expression to be converted to a statement.
+     */
+    createExpressionStatement(expression: TExpression): TStatement;
+    /**
+     * Create a statement that declares a function (e.g. `function foo(param1, param2) { stmt; }`).
+     *
+     * @param functionName the name of the function.
+     * @param parameters the names of the function's parameters.
+     * @param body a statement (or a block of statements) that are the body of the function.
+     */
+    createFunctionDeclaration(functionName: string, parameters: Parameter<TType>[], body: TStatement): TStatement;
+    /**
+     * Create an expression that represents a function
+     * (e.g. `function foo(param1, param2) { stmt; }`).
+     *
+     * @param functionName the name of the function.
+     * @param parameters the names of the function's parameters.
+     * @param body a statement (or a block of statements) that are the body of the function.
+     */
+    createFunctionExpression(functionName: string | null, parameters: Parameter<TType>[], body: TStatement): TExpression;
+    /**
+     * Create an expression that represents an arrow function
+     * (e.g. `(param1, param2) => body`).
+     *
+     * @param parameters the names of the function's parameters.
+     * @param body an expression or block of statements that are the body of the function.
+     */
+    createArrowFunctionExpression(parameters: Parameter<TType>[], body: TExpression | TStatement): TExpression;
+    /**
+     * Creates an expression that represents a dynamic import
+     * (e.g. `import('./some/path')`)
+     *
+     * @param url the URL that should by used in the dynamic import
+     */
+    createDynamicImport(url: string | TExpression): TExpression;
+    /**
+     * Create an identifier.
+     *
+     * @param name the name of the identifier.
+     */
+    createIdentifier(name: string): TExpression;
+    /**
+     * Create an if statement (e.g. `if (testExpr) { trueStmt; } else { falseStmt; }`).
+     *
+     * @param condition an expression that will be tested for truthiness.
+     * @param thenStatement a statement (or block of statements) that is executed if `condition` is
+     *     truthy.
+     * @param elseStatement a statement (or block of statements) that is executed if `condition` is
+     *     falsy.
+     */
+    createIfStatement(condition: TExpression, thenStatement: TStatement, elseStatement: TStatement | null): TStatement;
+    /**
+     * Create a simple literal (e.g. `"string"`, `123`, `false`, etc).
+     *
+     * @param value the value of the literal.
+     */
+    createLiteral(value: string | number | boolean | null | undefined): TExpression;
+    /**
+     * Create an expression that is instantiating the `expression` as a class.
+     *
+     * @param expression an expression that evaluates to a constructor to be instantiated.
+     * @param args the arguments to be passed to the constructor.
+     */
+    createNewExpression(expression: TExpression, args: TExpression[]): TExpression;
+    /**
+     * Create a literal object expression (e.g. `{ prop1: expr1, prop2: expr2 }`).
+     *
+     * @param properties the properties (key and value) to appear in the object.
+     */
+    createObjectLiteral(properties: ObjectLiteralProperty<TExpression>[]): TExpression;
+    /**
+     * Wrap an expression in parentheses.
+     *
+     * @param expression the expression to wrap in parentheses.
+     */
+    createParenthesizedExpression(expression: TExpression): TExpression;
+    /**
+     * Create a property access (e.g. `obj.prop`).
+     *
+     * @param expression an expression that evaluates to the object to be accessed.
+     * @param propertyName the name of the property to access.
+     */
+    createPropertyAccess(expression: TExpression, propertyName: string): TExpression;
+    /**
+     * Create a return statement (e.g `return expr;`).
+     *
+     * @param expression the expression to be returned.
+     */
+    createReturnStatement(expression: TExpression | null): TStatement;
+    /**
+     * Create a tagged template literal string. E.g.
+     *
+     * ```
+     * tag`str1${expr1}str2${expr2}str3`
+     * ```
+     *
+     * @param tag an expression that is applied as a tag handler for this template string.
+     * @param template the collection of strings and expressions that constitute an interpolated
+     *     template literal.
+     */
+    createTaggedTemplate(tag: TExpression, template: TemplateLiteral<TExpression>): TExpression;
+    /**
+     * Create an untagged template literal
+     *
+     * ```
+     * `str1${expr1}str2${expr2}str3`
+     * ```
+     *
+     * @param template the collection of strings and expressions that constitute an interpolated
+     *     template literal.
+     */
+    createTemplateLiteral(template: TemplateLiteral<TExpression>): TExpression;
+    /**
+     * Create a throw statement (e.g. `throw expr;`).
+     *
+     * @param expression the expression to be thrown.
+     */
+    createThrowStatement(expression: TExpression): TStatement;
+    /**
+     * Create an expression that extracts the type of an expression (e.g. `typeof expr`).
+     *
+     * @param expression the expression whose type we want.
+     */
+    createTypeOfExpression(expression: TExpression): TExpression;
+    /**
+     * Create an expression that evaluates an expression and returns `undefined`.
+     *
+     * @param expression the expression whose type we want.
+     */
+    createVoidExpression(expression: TExpression): TExpression;
+    /**
+     * Prefix the `operand` with the given `operator` (e.g. `-expr`).
+     *
+     * @param operator the text of the operator to apply (e.g. `+`, `-` or `!`).
+     * @param operand the expression that the operator applies to.
+     */
+    createUnaryExpression(operator: UnaryOperator, operand: TExpression): TExpression;
+    /**
+     * Create an expression that declares a new variable, possibly initialized to `initializer`.
+     *
+     * @param variableName the name of the variable.
+     * @param initializer if not `null` then this expression is assigned to the declared variable.
+     * @param variableType whether this variable should be declared as `var`, `let` or `const`.
+     */
+    createVariableDeclaration(variableName: string, initializer: TExpression | null, variableType: VariableDeclarationType, type: TType | null): TStatement;
+    /**
+     * Create a regular expression literal (e.g. `/\d+/g`).
+     *
+     * @param body Body of the regex.
+     * @param flags Flags of the regex, if any.
+     */
+    createRegularExpressionLiteral(body: string, flags: string | null): TExpression;
+    /**
+     * Create a spread element, typically in an array or function call. E.g. `[...a]` or `fn(...b)`.
+     *
+     * @param target Expression of the spread element.
+     */
+    createSpreadElement(expression: TExpression): TExpression;
+    /**
+     * Create a type node for a built-in type.
+     * @param type Type that should be created.
+     */
+    createBuiltInType(type: BuiltInType): TType;
+    /**
+     * Create an expression type.
+     * @param expression Expression to be turned into a type node.
+     * @param typeParams Type parameters for the expression.
+     */
+    createExpressionType(expression: TExpression, typeParams: TType[] | null): TType;
+    /**
+     * Create an array type.
+     * @param elementType Type of the array elements.
+     */
+    createArrayType(elementType: TType): TType;
+    /**
+     * Create a map type.
+     * @param valueType Type of the map values.
+     */
+    createMapType(valueType: TType): TType;
+    /**
+     * Forward a transplanted type.
+     * @param type Type to be transplanted, if supported.
+     */
+    transplantType(type: TType): TType;
+    /**
+     * Attach a source map range to the given node.
+     *
+     * @param node the node to which the range should be attached.
+     * @param sourceMapRange the range to attach to the node, or null if there is no range to attach.
+     * @returns the `node` with the `sourceMapRange` attached.
+     */
+    setSourceMapRange<T extends TStatement | TExpression>(node: T, sourceMapRange: SourceMapRange | null): T;
+}
+/**
+ * The type of a variable declaration.
+ */
+export type VariableDeclarationType = 'const' | 'let' | 'var';
+/**
+ * The unary operators supported by the `AstFactory`.
+ */
+export type UnaryOperator = '+' | '-' | '!';
+/** Supported built-in types. */
+export type BuiltInType = 'any' | 'boolean' | 'number' | 'string' | 'function' | 'never' | 'unknown';
+export interface Parameter<TType> {
+    name: string;
+    type: TType | null;
+}
+/**
+ * The binary operators supported by the `AstFactory`.
+ */
+export type BinaryOperator = '&&' | '>' | '>=' | '&' | '|' | '/' | '==' | '===' | '<' | '<=' | '-' | '%' | '*' | '**' | '!=' | '!==' | '||' | '+' | '??' | '=' | '+=' | '-=' | '*=' | '/=' | '%=' | '**=' | '&&=' | '||=' | '??=' | 'in' | 'instanceof';
+/**
+ * The original location of the start or end of a node created by the `AstFactory`.
+ */
+export interface SourceMapLocation {
+    /** 0-based character position of the location in the original source file. */
+    offset: number;
+    /** 0-based line index of the location in the original source file. */
+    line: number;
+    /** 0-based column position of the location in the original source file. */
+    column: number;
+}
+/**
+ * The original range of a node created by the `AstFactory`.
+ */
+export interface SourceMapRange {
+    url: string;
+    content: string;
+    start: SourceMapLocation;
+    end: SourceMapLocation;
+}
+/**
+ * Information used by the `AstFactory` to create a property assignment
+ * on an object literal expression.
+ */
+export interface ObjectLiteralAssignment<TExpression> {
+    kind: 'property';
+    propertyName: string;
+    value: TExpression;
+    /**
+     * Whether the `propertyName` should be enclosed in quotes.
+     */
+    quoted: boolean;
+}
+/**
+ * Information used by the `AstFactory` to create a spread on an object literal expression.
+ */
+export interface ObjectLiteralSpread<TExpression> {
+    kind: 'spread';
+    expression: TExpression;
+}
+/** Possible properties in an object literal. */
+export type ObjectLiteralProperty<TExpression> = ObjectLiteralAssignment<TExpression> | ObjectLiteralSpread<TExpression>;
+/**
+ * Information used by the `AstFactory` to create a template literal string (i.e. a back-ticked
+ * string with interpolations).
+ */
+export interface TemplateLiteral<TExpression> {
+    /**
+     * A collection of the static string pieces of the interpolated template literal string.
+     */
+    elements: TemplateElement[];
+    /**
+     * A collection of the interpolated expressions that are interleaved between the elements.
+     */
+    expressions: TExpression[];
+}
+/**
+ * Information about a static string piece of an interpolated template literal string.
+ */
+export interface TemplateElement {
+    /** The raw string as it was found in the original source code. */
+    raw: string;
+    /** The parsed string, with escape codes etc processed. */
+    cooked: string;
+    /** The original location of this piece of the template literal string. */
+    range: SourceMapRange | null;
+}
+/**
+ * Information used by the `AstFactory` to prepend a comment to a statement that was created by the
+ * `AstFactory`.
+ */
+export interface LeadingComment {
+    toString(): string;
+    multiline: boolean;
+    trailingNewline: boolean;
+}

package/dist/src/dev/angular/vendor/translator/api/import_generator.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @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.dev/license
+ */
+/**
+ * A request to import a given symbol from the given module.
+ */
+export interface ImportRequest<TFile> {
+    /**
+     * Name of the export to be imported.
+     * May be `null` if a namespace import is requested.
+     */
+    exportSymbolName: string | null;
+    /**
+     * Module specifier to be imported.
+     * May be a module name, or a file-relative path.
+     */
+    exportModuleSpecifier: string;
+    /**
+     * File for which the import is requested for. This may
+     * be used by import generators to re-use existing imports.
+     *
+     * Import managers may also allow this to be nullable if
+     * imports are never re-used. E.g. in the linker generator.
+     */
+    requestedFile: TFile;
+    /**
+     * Specifies an alias under which the symbol can be referenced within
+     * the file (e.g. `import { symbol as alias } from 'module'`).
+     *
+     * !!!Warning!!! passing in this alias is considered unsafe, because the import manager won't
+     * try to avoid conflicts with existing identifiers in the file if it is specified. As such,
+     * this option should only be used if the caller has verified that the alias won't conflict
+     * with anything in the file.
+     */
+    unsafeAliasOverride?: string;
+}
+/**
+ * Generate import information based on the context of the code being generated.
+ *
+ * Implementations of these methods return a specific identifier that corresponds to the imported
+ * module.
+ */
+export interface ImportGenerator<TFile, TExpression> {
+    addImport(request: ImportRequest<TFile>): TExpression;
+}

package/dist/src/dev/angular/vendor/translator/context.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @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.dev/license
+ */
+/**
+ * The current context of a translator visitor as it traverses the AST tree.
+ *
+ * It tracks whether we are in the process of outputting a statement or an expression.
+ */
+export declare class Context {
+    readonly isStatement: boolean;
+    constructor(isStatement: boolean);
+    get withExpressionMode(): Context;
+    get withStatementMode(): Context;
+}

package/dist/src/dev/angular/vendor/translator/translator.d.ts

@@ -0,0 +1,75 @@
+/**
+ * @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.dev/license
+ */
+import * as o from '@angular/compiler';
+import { AstFactory } from './api/ast_factory';
+import { ImportGenerator } from './api/import_generator';
+import { Context } from './context';
+export type RecordWrappedNodeFn<TExpression> = (node: o.WrappedNodeExpr<TExpression>) => void;
+export interface TranslatorOptions<TExpression> {
+    downlevelTaggedTemplates?: boolean;
+    downlevelVariableDeclarations?: boolean;
+    recordWrappedNode?: RecordWrappedNodeFn<TExpression>;
+    annotateForClosureCompiler?: boolean;
+}
+export declare class ExpressionTranslatorVisitor<TFile, TStatement, TExpression, TType> implements o.ExpressionVisitor, o.StatementVisitor, o.TypeVisitor {
+    private factory;
+    private imports;
+    private contextFile;
+    private downlevelTaggedTemplates;
+    private downlevelVariableDeclarations;
+    private recordWrappedNode;
+    constructor(factory: AstFactory<TStatement, TExpression, TType>, imports: ImportGenerator<TFile, TExpression>, contextFile: TFile, options: TranslatorOptions<TExpression>);
+    visitDeclareVarStmt(stmt: o.DeclareVarStmt, context: Context): TStatement;
+    visitDeclareFunctionStmt(stmt: o.DeclareFunctionStmt, context: Context): TStatement;
+    visitExpressionStmt(stmt: o.ExpressionStatement, context: Context): TStatement;
+    visitReturnStmt(stmt: o.ReturnStatement, context: Context): TStatement;
+    visitIfStmt(stmt: o.IfStmt, context: Context): TStatement;
+    visitReadVarExpr(ast: o.ReadVarExpr, _context: Context): TExpression;
+    visitInvokeFunctionExpr(ast: o.InvokeFunctionExpr, context: Context): TExpression;
+    visitTaggedTemplateLiteralExpr(ast: o.TaggedTemplateLiteralExpr, context: Context): TExpression;
+    visitTemplateLiteralExpr(ast: o.TemplateLiteralExpr, context: Context): TExpression;
+    visitInstantiateExpr(ast: o.InstantiateExpr, context: Context): TExpression;
+    visitLiteralExpr(ast: o.LiteralExpr, _context: Context): TExpression;
+    visitRegularExpressionLiteral(ast: o.RegularExpressionLiteralExpr, context: any): TExpression;
+    visitLocalizedString(ast: o.LocalizedString, context: Context): TExpression;
+    visitBuiltinType(ast: o.BuiltinType): TType | null;
+    visitExpressionType(ast: o.ExpressionType, context: Context): TType;
+    visitArrayType(ast: o.ArrayType, context: Context): TType;
+    visitMapType(ast: o.MapType, context: Context): TType;
+    visitTransplantedType(type: o.TransplantedType<TType>): TType;
+    private createTaggedTemplateExpression;
+    /**
+     * Translate the tagged template literal into a call that is compatible with ES5, using the
+     * imported `__makeTemplateObject` helper for ES5 formatted output.
+     */
+    private createES5TaggedTemplateFunctionCall;
+    visitExternalExpr(ast: o.ExternalExpr, _context: Context): TExpression;
+    visitConditionalExpr(ast: o.ConditionalExpr, context: Context): TExpression;
+    visitDynamicImportExpr(ast: o.DynamicImportExpr, context: any): TExpression;
+    visitNotExpr(ast: o.NotExpr, context: Context): TExpression;
+    visitFunctionExpr(ast: o.FunctionExpr, context: Context): TExpression;
+    visitArrowFunctionExpr(ast: o.ArrowFunctionExpr, context: any): TExpression;
+    visitBinaryOperatorExpr(ast: o.BinaryOperatorExpr, context: Context): TExpression;
+    visitReadPropExpr(ast: o.ReadPropExpr, context: Context): TExpression;
+    visitReadKeyExpr(ast: o.ReadKeyExpr, context: Context): TExpression;
+    visitLiteralArrayExpr(ast: o.LiteralArrayExpr, context: Context): TExpression;
+    visitLiteralMapExpr(ast: o.LiteralMapExpr, context: Context): TExpression;
+    visitCommaExpr(ast: o.CommaExpr, context: Context): never;
+    visitTemplateLiteralElementExpr(ast: o.TemplateLiteralElementExpr, context: any): void;
+    visitSpreadElementExpr(ast: o.outputAst.SpreadElementExpr, context: any): TExpression;
+    visitWrappedNodeExpr(ast: o.WrappedNodeExpr<any>, _context: Context): any;
+    visitTypeofExpr(ast: o.TypeofExpr, context: Context): TExpression;
+    visitVoidExpr(ast: o.VoidExpr, context: Context): TExpression;
+    visitUnaryOperatorExpr(ast: o.UnaryOperatorExpr, context: Context): TExpression;
+    visitParenthesizedExpr(ast: o.ParenthesizedExpr, context: any): TExpression;
+    private visitStatements;
+    private setSourceMapRange;
+    private attachComments;
+    private getTemplateLiteralFromAst;
+    private translateParams;
+}

package/dist/src/dev/angular/vendor/translator/ts_util.d.ts

@@ -0,0 +1,12 @@
+/*!
+ * @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.dev/license
+ */
+import ts from 'typescript';
+/**
+ * Creates a TypeScript node representing a numeric value.
+ */
+export declare function tsNumericExpression(value: number): ts.NumericLiteral | ts.PrefixUnaryExpression;

package/dist/src/dev/angular/vendor/translator/typescript_ast_factory.d.ts

@@ -0,0 +1,66 @@
+/**
+ * @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.dev/license
+ */
+import ts from 'typescript';
+import { AstFactory, BinaryOperator, BuiltInType, LeadingComment, ObjectLiteralProperty, Parameter, SourceMapRange, TemplateLiteral, UnaryOperator, VariableDeclarationType } from './api/ast_factory';
+/**
+ * A TypeScript flavoured implementation of the AstFactory.
+ */
+export declare class TypeScriptAstFactory implements AstFactory<ts.Statement, ts.Expression, ts.TypeNode> {
+    private annotateForClosureCompiler;
+    private externalSourceFiles;
+    private readonly UNARY_OPERATORS;
+    private readonly BINARY_OPERATORS;
+    private readonly VAR_TYPES;
+    constructor(annotateForClosureCompiler: boolean);
+    attachComments: typeof attachComments;
+    createArrayLiteral: (elements?: readonly ts.Expression[], multiLine?: boolean) => ts.ArrayLiteralExpression;
+    createAssignment(target: ts.Expression, operator: BinaryOperator, value: ts.Expression): ts.Expression;
+    createBinaryExpression(leftOperand: ts.Expression, operator: BinaryOperator, rightOperand: ts.Expression): ts.Expression;
+    createBlock(body: ts.Statement[]): ts.Statement;
+    createCallExpression(callee: ts.Expression, args: ts.Expression[], pure: boolean): ts.Expression;
+    createConditional(condition: ts.Expression, whenTrue: ts.Expression, whenFalse: ts.Expression): ts.Expression;
+    createElementAccess: (expression: ts.Expression, index: number | ts.Expression) => ts.ElementAccessExpression;
+    createExpressionStatement: (expression: ts.Expression) => ts.ExpressionStatement;
+    createDynamicImport(url: string | ts.Expression): ts.CallExpression;
+    createFunctionDeclaration(functionName: string, parameters: Parameter<ts.TypeNode>[], body: ts.Statement): ts.Statement;
+    createFunctionExpression(functionName: string | null, parameters: Parameter<ts.TypeNode>[], body: ts.Statement): ts.Expression;
+    createArrowFunctionExpression(parameters: Parameter<ts.TypeNode>[], body: ts.Statement | ts.Expression): ts.Expression;
+    private createParameter;
+    createIdentifier: (text: string) => ts.Identifier;
+    createIfStatement(condition: ts.Expression, thenStatement: ts.Statement, elseStatement: ts.Statement | null): ts.Statement;
+    createLiteral(value: string | number | boolean | null | undefined): ts.Expression;
+    createNewExpression(expression: ts.Expression, args: ts.Expression[]): ts.Expression;
+    createObjectLiteral(properties: ObjectLiteralProperty<ts.Expression>[]): ts.Expression;
+    createParenthesizedExpression: (expression: ts.Expression) => ts.ParenthesizedExpression;
+    createPropertyAccess: (expression: ts.Expression, name: string | ts.MemberName) => ts.PropertyAccessExpression;
+    createSpreadElement: (expression: ts.Expression) => ts.SpreadElement;
+    createReturnStatement(expression: ts.Expression | null): ts.Statement;
+    createTaggedTemplate(tag: ts.Expression, template: TemplateLiteral<ts.Expression>): ts.Expression;
+    createTemplateLiteral(template: TemplateLiteral<ts.Expression>): ts.TemplateLiteral;
+    createThrowStatement: (expression: ts.Expression) => ts.ThrowStatement;
+    createTypeOfExpression: (expression: ts.Expression) => ts.TypeOfExpression;
+    createVoidExpression: (expression: ts.Expression) => ts.VoidExpression;
+    createUnaryExpression(operator: UnaryOperator, operand: ts.Expression): ts.Expression;
+    createVariableDeclaration(variableName: string, initializer: ts.Expression | null, variableType: VariableDeclarationType, type: ts.TypeNode | null): ts.Statement;
+    createRegularExpressionLiteral(body: string, flags: string | null): ts.Expression;
+    setSourceMapRange<T extends ts.Node>(node: T, sourceMapRange: SourceMapRange | null): T;
+    createBuiltInType(type: BuiltInType): ts.TypeNode;
+    createExpressionType(expression: ts.Expression, typeParams: ts.TypeNode[] | null): ts.TypeNode;
+    createArrayType(elementType: ts.TypeNode): ts.TypeNode;
+    createMapType(valueType: ts.TypeNode): ts.TypeNode;
+    transplantType(type: ts.TypeNode): ts.TypeNode;
+}
+export declare function createTemplateMiddle(cooked: string, raw: string): ts.TemplateMiddle;
+export declare function createTemplateTail(cooked: string, raw: string): ts.TemplateTail;
+/**
+ * Attach the given `leadingComments` to the `statement` node.
+ *
+ * @param statement The statement that will have comments attached.
+ * @param leadingComments The comments to attach to the statement.
+ */
+export declare function attachComments(statement: ts.Statement | ts.Expression, leadingComments: LeadingComment[]): void;

package/dist/src/dev/angular/vendor/translator/typescript_translator.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @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.dev/license
+ */
+import * as o from '@angular/compiler';
+import ts from 'typescript';
+import { ImportGenerator } from './api/import_generator';
+import { TranslatorOptions } from './translator';
+export declare function translateExpression(contextFile: ts.SourceFile, expression: o.Expression, imports: ImportGenerator<ts.SourceFile, ts.Expression>, options?: TranslatorOptions<ts.Expression>): ts.Expression;
+export declare function translateStatement(contextFile: ts.SourceFile, statement: o.Statement, imports: ImportGenerator<ts.SourceFile, ts.Expression>, options?: TranslatorOptions<ts.Expression>): ts.Statement;

package/dist/src/dev/rebuildTrigger.d.ts

@@ -4,6 +4,7 @@ export declare const queueFileChange: (state: HMRState, filePath: string, config
     manifest: Record<string, string>;
     hmrState: HMRState;
 }) => void) => Promise<void>;
+export type AngularHmrTier = 0 | 1 | 2;
 export declare const triggerRebuild: (state: HMRState, config: BuildConfig, onRebuildComplete: (result: {
     manifest: Record<string, string>;
     hmrState: HMRState;

package/dist/src/plugins/hmr.d.ts

@@ -90,6 +90,31 @@ export declare const hmr: (hmrState: HMRState, manifest: Record<string, string>,
             };
         };
     };
+} & {
+    "@ng": {
+        "*": {
+            get: {
+                body: unknown;
+                params: {
+                    "*": string;
+                } & {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
 } & {
     hmr: {
         subscribe: {

package/dist/src/vue/components/Image.d.ts

@@ -59,6 +59,7 @@ export declare const Image: import("vue").DefineComponent<{
     height: number;
     width: number;
     onLoad: Function;
+    className: string;
     sizes: string;
     priority: boolean;
     unoptimized: boolean;
@@ -67,7 +68,6 @@ export declare const Image: import("vue").DefineComponent<{
     overrideSrc: string;
     placeholder: string;
     blurDataURL: string;
-    className: string;
     fetchPriority: string;
     referrerPolicy: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/svelte/index.js

@@ -1890,6 +1890,8 @@ var colors2, frameworkColors, formatPath = (filePath) => {
   console.error(`${timestamp} ${tag} ${fullMessage}`);
 }, logHmrUpdate = (path, framework, duration) => {
   log("hmr update", { duration, framework, path });
+}, logInfo = (message) => {
+  log(message);
 }, logScriptUpdate = (path, framework, duration) => {
   log("script update", { duration, framework, path });
 }, logServerReload = () => {
@@ -3816,5 +3818,5 @@ export {
   createTypedIsland
 };
 
-//# debugId=56694EE8B35B170664756E2164756E21
+//# debugId=38FA8C216FCABC4464756E2164756E21
 //# sourceMappingURL=index.js.map