static-injector 1.0.8

package/transform/compiler-cli/src/ngtsc/reflection/src/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.io/license
+ */
+import * as ts from "typescript";
+import { ClassDeclaration } from "./host";
+export declare function isNamedClassDeclaration(node: ts.Node): node is ClassDeclaration<ts.ClassDeclaration>;
+export declare function isNamedFunctionDeclaration(node: ts.Node): node is ClassDeclaration<ts.FunctionDeclaration>;
+export declare function isNamedVariableDeclaration(node: ts.Node): node is ClassDeclaration<ts.VariableDeclaration>;

package/transform/compiler-cli/src/ngtsc/reflection/src/util.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * @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
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNamedVariableDeclaration = exports.isNamedFunctionDeclaration = exports.isNamedClassDeclaration = void 0;
+const ts = __importStar(require("typescript"));
+function isNamedClassDeclaration(node) {
+    return ts.isClassDeclaration(node) && isIdentifier(node.name);
+}
+exports.isNamedClassDeclaration = isNamedClassDeclaration;
+function isNamedFunctionDeclaration(node) {
+    return ts.isFunctionDeclaration(node) && isIdentifier(node.name);
+}
+exports.isNamedFunctionDeclaration = isNamedFunctionDeclaration;
+function isNamedVariableDeclaration(node) {
+    return ts.isVariableDeclaration(node) && isIdentifier(node.name);
+}
+exports.isNamedVariableDeclaration = isNamedVariableDeclaration;
+function isIdentifier(node) {
+    return node !== undefined && ts.isIdentifier(node);
+}

package/transform/compiler-cli/src/ngtsc/transform/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./src/api";
+export * from "./src/utils";

package/transform/compiler-cli/src/ngtsc/transform/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./src/api"), exports);
+__exportStar(require("./src/utils"), exports);

package/transform/compiler-cli/src/ngtsc/transform/src/api.d.ts

@@ -0,0 +1,115 @@
+/**
+ * @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 { Expression, Statement, Type } from "../../../../../compiler";
+import * as ts from "typescript";
+import { ClassDeclaration, Decorator } from "../../reflection";
+/**
+ * A set of options which can be passed to a `DecoratorHandler` by a consumer, to tailor the output
+ * of compilation beyond the decorators themselves.
+ */
+export declare enum HandlerFlags {
+    /**
+     * No flags set.
+     */
+    NONE = 0,
+    /**
+     * Indicates that this decorator is fully inherited from its parent at runtime. In addition to
+     * normally inherited aspects such as inputs and queries, full inheritance applies to every aspect
+     * of the component or directive, such as the template function itself.
+     *
+     * Its primary effect is to cause the `CopyDefinitionFeature` to be applied to the definition
+     * being compiled. See that class for more information.
+     */
+    FULL_INHERITANCE = 1
+}
+/**
+ * Provides the interface between a decorator compiler from @angular/compiler and the Typescript
+ * compiler/transform.
+ *
+ * The decorator compilers in @angular/compiler do not depend on Typescript. The handler is
+ * responsible for extracting the information required to perform compilation from the decorators
+ * and Typescript source, invoking the decorator compiler, and returning the result.
+ *
+ * @param `D` The type of decorator metadata produced by `detect`.
+ * @param `A` The type of analysis metadata produced by `analyze`.
+ * @param `R` The type of resolution metadata produced by `resolve`.
+ */
+export interface DecoratorHandler<D, A, S extends null, R> {
+    /**
+     * Scan a set of reflected decorators and determine if this handler is responsible for compilation
+     * of one of them.
+     */
+    detect(node: ClassDeclaration, decorators: Decorator[] | null): DetectResult<D> | undefined;
+    /**
+     * Asynchronously perform pre-analysis on the decorator/class combination.
+     *
+     * `preanalyze` is optional and is not guaranteed to be called through all compilation flows. It
+     * will only be called if asynchronicity is supported in the CompilerHost.
+     */
+    preanalyze?(node: ClassDeclaration, metadata: Readonly<D>): Promise<void> | undefined;
+    /**
+     * Perform analysis on the decorator/class combination, extracting information from the class
+     * required for compilation.
+     *
+     * Returns analyzed metadata if successful, or an array of diagnostic messages if the analysis
+     * fails or the decorator isn't valid.
+     *
+     * Analysis should always be a "pure" operation, with no side effects. This is because the
+     * detect/analysis steps might be skipped for files which have not changed during incremental
+     * builds. Any side effects required for compilation (e.g. registration of metadata) should happen
+     * in the `register` phase, which is guaranteed to run even for incremental builds.
+     */
+    analyze(node: ClassDeclaration, metadata: Readonly<D>, handlerFlags?: HandlerFlags): AnalysisOutput<A>;
+    /**
+     * Generate a description of the field which should be added to the class, including any
+     * initialization code to be generated.
+     *
+     * If the compilation mode is configured as partial, and an implementation of `compilePartial` is
+     * provided, then this method is not called.
+     */
+    compileFull(node: ClassDeclaration, analysis: Readonly<A>): CompileResult | CompileResult[];
+}
+/**
+ * The output of detecting a trait for a declaration as the result of the first phase of the
+ * compilation pipeline.
+ */
+export interface DetectResult<M> {
+    /**
+     * The node that triggered the match, which is typically a decorator.
+     */
+    trigger: ts.Node | null;
+    /**
+     * Refers to the decorator that was recognized for this detection, if any. This can be a concrete
+     * decorator that is actually present in a file, or a synthetic decorator as inserted
+     * programmatically.
+     */
+    decorator: Decorator | null;
+    /**
+     * An arbitrary object to carry over from the detection phase into the analysis phase.
+     */
+    metadata: Readonly<M>;
+}
+/**
+ * The output of an analysis operation, consisting of possibly an arbitrary analysis object (used as
+ * the input to code generation) and potentially diagnostics if there were errors uncovered during
+ * analysis.
+ */
+export interface AnalysisOutput<A> {
+    analysis?: Readonly<A>;
+    diagnostics?: ts.Diagnostic[];
+}
+/**
+ * A description of the static field to add to a class, including an initialization expression
+ * and a type for the .d.ts file.
+ */
+export interface CompileResult {
+    name: string;
+    initializer: Expression;
+    statements: Statement[];
+    type: Type;
+}

package/transform/compiler-cli/src/ngtsc/transform/src/api.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * @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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HandlerFlags = void 0;
+/**
+ * A set of options which can be passed to a `DecoratorHandler` by a consumer, to tailor the output
+ * of compilation beyond the decorators themselves.
+ */
+var HandlerFlags;
+(function (HandlerFlags) {
+    /**
+     * No flags set.
+     */
+    HandlerFlags[HandlerFlags["NONE"] = 0] = "NONE";
+    /**
+     * Indicates that this decorator is fully inherited from its parent at runtime. In addition to
+     * normally inherited aspects such as inputs and queries, full inheritance applies to every aspect
+     * of the component or directive, such as the template function itself.
+     *
+     * Its primary effect is to cause the `CopyDefinitionFeature` to be applied to the definition
+     * being compiled. See that class for more information.
+     */
+    HandlerFlags[HandlerFlags["FULL_INHERITANCE"] = 1] = "FULL_INHERITANCE";
+})(HandlerFlags = exports.HandlerFlags || (exports.HandlerFlags = {}));

package/transform/compiler-cli/src/ngtsc/transform/src/utils.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @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 ts from "typescript";
+import { ImportManager } from "../../translator";
+/**
+ * Adds extra imports in the import manage for this source file, after the existing imports
+ * and before the module body.
+ * Can optionally add extra statements (e.g. new constants) before the body as well.
+ */
+export declare function addImports(importManager: ImportManager, sf: ts.SourceFile, extraStatements?: ts.Statement[]): ts.SourceFile;

package/transform/compiler-cli/src/ngtsc/transform/src/utils.js

@@ -0,0 +1,84 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addImports = void 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
+ */
+const ts = __importStar(require("typescript"));
+/**
+ * Adds extra imports in the import manage for this source file, after the existing imports
+ * and before the module body.
+ * Can optionally add extra statements (e.g. new constants) before the body as well.
+ */
+function addImports(importManager, sf, extraStatements = []) {
+    // Generate the import statements to prepend.
+    const addedImports = importManager.getAllImports(sf.fileName).map((i) => {
+        const qualifier = ts.createIdentifier(i.qualifier.text);
+        const importClause = ts.createImportClause(
+        /* name */ undefined, 
+        /* namedBindings */ ts.createNamespaceImport(qualifier));
+        const decl = ts.createImportDeclaration(
+        /* decorators */ undefined, 
+        /* modifiers */ undefined, 
+        /* importClause */ importClause, 
+        /* moduleSpecifier */ ts.createLiteral(i.specifier));
+        // Set the qualifier's original TS node to the `ts.ImportDeclaration`. This allows downstream
+        // transforms such as tsickle to properly process references to this import.
+        //
+        // This operation is load-bearing in g3 as some imported modules contain special metadata
+        // generated by clutz, which tsickle uses to transform imports and references to those imports.
+        //
+        // TODO(alxhub): add a test for this when tsickle is updated externally to depend on this
+        // behavior.
+        ts.setOriginalNode(i.qualifier, decl);
+        return decl;
+    });
+    // Filter out the existing imports and the source file body. All new statements
+    // will be inserted between them.
+    const existingImports = sf.statements.filter((stmt) => isImportStatement(stmt));
+    const body = sf.statements.filter((stmt) => !isImportStatement(stmt));
+    // Prepend imports if needed.
+    if (addedImports.length > 0) {
+        // If we prepend imports, we also prepend NotEmittedStatement to use it as an anchor
+        // for @fileoverview Closure annotation. If there is no @fileoverview annotations, this
+        // statement would be a noop.
+        const fileoverviewAnchorStmt = ts.createNotEmittedStatement(sf);
+        return ts.updateSourceFileNode(sf, ts.createNodeArray([
+            fileoverviewAnchorStmt,
+            ...existingImports,
+            ...addedImports,
+            ...extraStatements,
+            ...body,
+        ]));
+    }
+    return sf;
+}
+exports.addImports = addImports;
+function isImportStatement(stmt) {
+    return (ts.isImportDeclaration(stmt) ||
+        ts.isImportEqualsDeclaration(stmt) ||
+        ts.isNamespaceImport(stmt));
+}

package/transform/compiler-cli/src/ngtsc/translator/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./src/context";
+export * from "./src/translator";
+export * from "./src/typescript_ast_factory";
+export * from "./src/typescript_translator";
+export * from "./src/import_manager";

package/transform/compiler-cli/src/ngtsc/translator/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./src/context"), exports);
+__exportStar(require("./src/translator"), exports);
+__exportStar(require("./src/typescript_ast_factory"), exports);
+__exportStar(require("./src/typescript_translator"), exports);
+__exportStar(require("./src/import_manager"), exports);

package/transform/compiler-cli/src/ngtsc/translator/src/api/ast_factory.d.ts

@@ -0,0 +1,274 @@
+/**
+ * @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
+ */
+/**
+ * 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> {
+    /**
+     * 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, leadingComments: LeadingComment[]): void;
+    /**
+     * Create a literal array expresion (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 value an expression that evaluates to the right side of the assignment.
+     */
+    createAssignment(target: TExpression, 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 arugments 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: string[], 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: string[], body: TStatement): 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 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;
+    /**
+     * 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 type whether this variable should be declared as `var`, `let` or `const`.
+     */
+    createVariableDeclaration(variableName: string, initializer: TExpression | null, type: VariableDeclarationType): TStatement;
+    /**
+     * 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 declare type VariableDeclarationType = "const" | "let" | "var";
+/**
+ * The unary operators supported by the `AstFactory`.
+ */
+export declare type UnaryOperator = "+" | "-" | "!";
+/**
+ * The binary operators supported by the `AstFactory`.
+ */
+export declare type BinaryOperator = "&&" | ">" | ">=" | "&" | "/" | "==" | "===" | "<" | "<=" | "-" | "%" | "*" | "!=" | "!==" | "||" | "+" | "??";
+/**
+ * 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 on an object literal expression.
+ */
+export interface ObjectLiteralProperty<TExpression> {
+    propertyName: string;
+    value: TExpression;
+    /**
+     * Whether the `propertyName` should be enclosed in quotes.
+     */
+    quoted: boolean;
+}
+/**
+ * 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;
+}