static-injector 1.0.8

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

@@ -0,0 +1,9 @@
+"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 });

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

@@ -0,0 +1,27 @@
+/**
+ * @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
+ */
+/**
+ * The symbol name and import namespace of an imported symbol,
+ * which has been registered through the ImportGenerator.
+ */
+export interface NamedImport<TExpression> {
+    /** The import namespace containing this imported symbol. */
+    moduleImport: TExpression | null;
+    /** The (possibly rewritten) name of the imported symbol. */
+    symbol: 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<TExpression> {
+    generateNamespaceImport(moduleName: string): TExpression;
+    generateNamedImport(moduleName: string, originalSymbol: string): NamedImport<TExpression>;
+}

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

@@ -0,0 +1,9 @@
+"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 });

package/transform/compiler-cli/src/ngtsc/translator/src/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.io/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/transform/compiler-cli/src/ngtsc/translator/src/context.js

@@ -0,0 +1,27 @@
+"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.Context = void 0;
+/**
+ * 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.
+ */
+class Context {
+    constructor(isStatement) {
+        this.isStatement = isStatement;
+    }
+    get withExpressionMode() {
+        return this.isStatement ? new Context(false) : this;
+    }
+    get withStatementMode() {
+        return !this.isStatement ? new Context(true) : this;
+    }
+}
+exports.Context = Context;

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

@@ -0,0 +1,29 @@
+/**
+ * @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 { ImportRewriter } from "../../imports";
+import { ImportGenerator, NamedImport } from "./api/import_generator";
+/**
+ * Information about an import that has been added to a module.
+ */
+export interface Import {
+    /** The name of the module that has been imported. */
+    specifier: string;
+    /** The `ts.Identifer` by which the imported module is known. */
+    qualifier: ts.Identifier;
+}
+export declare class ImportManager implements ImportGenerator<ts.Identifier> {
+    protected rewriter: ImportRewriter;
+    private prefix;
+    private specifierToIdentifier;
+    private nextIndex;
+    constructor(rewriter?: ImportRewriter, prefix?: string);
+    generateNamespaceImport(moduleName: string): ts.Identifier;
+    generateNamedImport(moduleName: string, originalSymbol: string): NamedImport<ts.Identifier>;
+    getAllImports(contextPath: string): Import[];
+}

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

@@ -0,0 +1,70 @@
+"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.ImportManager = 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"));
+const imports_1 = require("../../imports");
+class ImportManager {
+    constructor(rewriter = new imports_1.NoopImportRewriter(), prefix = "i") {
+        this.rewriter = rewriter;
+        this.prefix = prefix;
+        this.specifierToIdentifier = new Map();
+        this.nextIndex = 0;
+    }
+    generateNamespaceImport(moduleName) {
+        if (!this.specifierToIdentifier.has(moduleName)) {
+            this.specifierToIdentifier.set(moduleName, ts.createIdentifier(`${this.prefix}${this.nextIndex++}`));
+        }
+        return this.specifierToIdentifier.get(moduleName);
+    }
+    generateNamedImport(moduleName, originalSymbol) {
+        // First, rewrite the symbol name.
+        const symbol = this.rewriter.rewriteSymbol(originalSymbol, moduleName);
+        // Ask the rewriter if this symbol should be imported at all. If not, it can be referenced
+        // directly (moduleImport: null).
+        if (!this.rewriter.shouldImportSymbol(symbol, moduleName)) {
+            // The symbol should be referenced directly.
+            return { moduleImport: null, symbol };
+        }
+        // If not, this symbol will be imported using a generated namespace import.
+        const moduleImport = this.generateNamespaceImport(moduleName);
+        return { moduleImport, symbol };
+    }
+    getAllImports(contextPath) {
+        const imports = [];
+        for (const [originalSpecifier, qualifier] of this.specifierToIdentifier) {
+            const specifier = this.rewriter.rewriteSpecifier(originalSpecifier, contextPath);
+            imports.push({
+                specifier,
+                qualifier,
+            });
+        }
+        return imports;
+    }
+}
+exports.ImportManager = ImportManager;

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

@@ -0,0 +1,58 @@
+/**
+ * @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 o from '../../../../../compiler';
+import { AstFactory } from './api/ast_factory';
+import { ImportGenerator } from './api/import_generator';
+import { Context } from './context';
+export declare 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<TStatement, TExpression> implements o.ExpressionVisitor, o.StatementVisitor {
+    private factory;
+    private imports;
+    private downlevelTaggedTemplates;
+    private downlevelVariableDeclarations;
+    private recordWrappedNode;
+    constructor(factory: AstFactory<TStatement, TExpression>, imports: ImportGenerator<TExpression>, 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;
+    visitDeclareClassStmt(_stmt: o.ClassStmt, _context: Context): never;
+    visitIfStmt(stmt: o.IfStmt, context: Context): TStatement;
+    visitReadVarExpr(ast: o.ReadVarExpr, _context: Context): TExpression;
+    visitWriteVarExpr(expr: o.WriteVarExpr, context: Context): TExpression;
+    visitWriteKeyExpr(expr: o.WriteKeyExpr, context: Context): TExpression;
+    visitWritePropExpr(expr: o.WritePropExpr, context: Context): TExpression;
+    visitInvokeMethodExpr(ast: o.InvokeMethodExpr, context: Context): TExpression;
+    visitInvokeFunctionExpr(ast: o.InvokeFunctionExpr, context: Context): TExpression;
+    visitInstantiateExpr(ast: o.InstantiateExpr, context: Context): TExpression;
+    visitLiteralExpr(ast: o.LiteralExpr, _context: Context): TExpression;
+    visitExternalExpr(ast: o.ExternalExpr, _context: Context): TExpression;
+    visitConditionalExpr(ast: o.ConditionalExpr, context: Context): TExpression;
+    visitNotExpr(ast: o.NotExpr, context: Context): TExpression;
+    visitAssertNotNullExpr(ast: o.AssertNotNull, context: Context): TExpression;
+    visitCastExpr(ast: o.CastExpr, context: Context): TExpression;
+    visitFunctionExpr(ast: o.FunctionExpr, context: Context): 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;
+    visitWrappedNodeExpr(ast: o.WrappedNodeExpr<any>, _context: Context): any;
+    visitTypeofExpr(ast: o.TypeofExpr, context: Context): TExpression;
+    visitUnaryOperatorExpr(ast: o.UnaryOperatorExpr, context: Context): TExpression;
+    private visitStatements;
+    private setSourceMapRange;
+    private attachComments;
+}

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

@@ -0,0 +1,270 @@
+"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.ExpressionTranslatorVisitor = 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 o = __importStar(require("../../../../../compiler"));
+const UNARY_OPERATORS = new Map([
+    [o.UnaryOperator.Minus, '-'],
+    [o.UnaryOperator.Plus, '+'],
+]);
+const BINARY_OPERATORS = new Map([
+    [o.BinaryOperator.And, '&&'],
+    [o.BinaryOperator.Bigger, '>'],
+    [o.BinaryOperator.BiggerEquals, '>='],
+    [o.BinaryOperator.BitwiseAnd, '&'],
+    [o.BinaryOperator.Divide, '/'],
+    [o.BinaryOperator.Equals, '=='],
+    [o.BinaryOperator.Identical, '==='],
+    [o.BinaryOperator.Lower, '<'],
+    [o.BinaryOperator.LowerEquals, '<='],
+    [o.BinaryOperator.Minus, '-'],
+    [o.BinaryOperator.Modulo, '%'],
+    [o.BinaryOperator.Multiply, '*'],
+    [o.BinaryOperator.NotEquals, '!='],
+    [o.BinaryOperator.NotIdentical, '!=='],
+    [o.BinaryOperator.Or, '||'],
+    [o.BinaryOperator.Plus, '+'],
+    [o.BinaryOperator.NullishCoalesce, '??'],
+]);
+class ExpressionTranslatorVisitor {
+    constructor(factory, imports, options) {
+        this.factory = factory;
+        this.imports = imports;
+        this.downlevelTaggedTemplates = options.downlevelTaggedTemplates === true;
+        this.downlevelVariableDeclarations =
+            options.downlevelVariableDeclarations === true;
+        this.recordWrappedNode = options.recordWrappedNode || (() => { });
+    }
+    visitDeclareVarStmt(stmt, context) {
+        var _a;
+        const varType = this.downlevelVariableDeclarations
+            ? 'var'
+            : stmt.hasModifier(o.StmtModifier.Final)
+                ? 'const'
+                : 'let';
+        return this.attachComments(this.factory.createVariableDeclaration(stmt.name, (_a = stmt.value) === null || _a === void 0 ? void 0 : _a.visitExpression(this, context.withExpressionMode), varType), stmt.leadingComments);
+    }
+    visitDeclareFunctionStmt(stmt, context) {
+        return this.attachComments(this.factory.createFunctionDeclaration(stmt.name, stmt.params.map((param) => param.name), this.factory.createBlock(this.visitStatements(stmt.statements, context.withStatementMode))), stmt.leadingComments);
+    }
+    visitExpressionStmt(stmt, context) {
+        return this.attachComments(this.factory.createExpressionStatement(stmt.expr.visitExpression(this, context.withStatementMode)), stmt.leadingComments);
+    }
+    visitReturnStmt(stmt, context) {
+        return this.attachComments(this.factory.createReturnStatement(stmt.value.visitExpression(this, context.withExpressionMode)), stmt.leadingComments);
+    }
+    visitDeclareClassStmt(_stmt, _context) {
+        throw new Error('Method not implemented.');
+    }
+    visitIfStmt(stmt, context) {
+        return this.attachComments(this.factory.createIfStatement(stmt.condition.visitExpression(this, context), this.factory.createBlock(this.visitStatements(stmt.trueCase, context.withStatementMode)), stmt.falseCase.length > 0
+            ? this.factory.createBlock(this.visitStatements(stmt.falseCase, context.withStatementMode))
+            : null), stmt.leadingComments);
+    }
+    visitReadVarExpr(ast, _context) {
+        const identifier = this.factory.createIdentifier(ast.name);
+        this.setSourceMapRange(identifier, ast.sourceSpan);
+        return identifier;
+    }
+    visitWriteVarExpr(expr, context) {
+        const assignment = this.factory.createAssignment(this.setSourceMapRange(this.factory.createIdentifier(expr.name), expr.sourceSpan), expr.value.visitExpression(this, context));
+        return context.isStatement
+            ? assignment
+            : this.factory.createParenthesizedExpression(assignment);
+    }
+    visitWriteKeyExpr(expr, context) {
+        const exprContext = context.withExpressionMode;
+        const target = this.factory.createElementAccess(expr.receiver.visitExpression(this, exprContext), expr.index.visitExpression(this, exprContext));
+        const assignment = this.factory.createAssignment(target, expr.value.visitExpression(this, exprContext));
+        return context.isStatement
+            ? assignment
+            : this.factory.createParenthesizedExpression(assignment);
+    }
+    visitWritePropExpr(expr, context) {
+        const target = this.factory.createPropertyAccess(expr.receiver.visitExpression(this, context), expr.name);
+        return this.factory.createAssignment(target, expr.value.visitExpression(this, context));
+    }
+    visitInvokeMethodExpr(ast, context) {
+        const target = ast.receiver.visitExpression(this, context);
+        return this.setSourceMapRange(this.factory.createCallExpression(ast.name !== null
+            ? this.factory.createPropertyAccess(target, ast.name)
+            : target, ast.args.map((arg) => arg.visitExpression(this, context)), 
+        /* pure */ false), ast.sourceSpan);
+    }
+    visitInvokeFunctionExpr(ast, context) {
+        return this.setSourceMapRange(this.factory.createCallExpression(ast.fn.visitExpression(this, context), ast.args.map((arg) => arg.visitExpression(this, context)), ast.pure), ast.sourceSpan);
+    }
+    visitInstantiateExpr(ast, context) {
+        return this.factory.createNewExpression(ast.classExpr.visitExpression(this, context), ast.args.map((arg) => arg.visitExpression(this, context)));
+    }
+    visitLiteralExpr(ast, _context) {
+        return this.setSourceMapRange(this.factory.createLiteral(ast.value), ast.sourceSpan);
+    }
+    visitExternalExpr(ast, _context) {
+        if (ast.value.name === null) {
+            if (ast.value.moduleName === null) {
+                throw new Error('Invalid import without name nor moduleName');
+            }
+            return this.imports.generateNamespaceImport(ast.value.moduleName);
+        }
+        // If a moduleName is specified, this is a normal import. If there's no module name, it's a
+        // reference to a global/ambient symbol.
+        if (ast.value.moduleName !== null) {
+            // This is a normal import. Find the imported module.
+            const { moduleImport, symbol } = this.imports.generateNamedImport(ast.value.moduleName, ast.value.name);
+            if (moduleImport === null) {
+                // The symbol was ambient after all.
+                return this.factory.createIdentifier(symbol);
+            }
+            else {
+                return this.factory.createPropertyAccess(moduleImport, symbol);
+            }
+        }
+        else {
+            // The symbol is ambient, so just reference it.
+            return this.factory.createIdentifier(ast.value.name);
+        }
+    }
+    visitConditionalExpr(ast, context) {
+        let cond = ast.condition.visitExpression(this, context);
+        // Ordinarily the ternary operator is right-associative. The following are equivalent:
+        //   `a ? b : c ? d : e` => `a ? b : (c ? d : e)`
+        //
+        // However, occasionally Angular needs to produce a left-associative conditional, such as in
+        // the case of a null-safe navigation production: `{{a?.b ? c : d}}`. This template produces
+        // a ternary of the form:
+        //   `a == null ? null : rest of expression`
+        // If the rest of the expression is also a ternary though, this would produce the form:
+        //   `a == null ? null : a.b ? c : d`
+        // which, if left as right-associative, would be incorrectly associated as:
+        //   `a == null ? null : (a.b ? c : d)`
+        //
+        // In such cases, the left-associativity needs to be enforced with parentheses:
+        //   `(a == null ? null : a.b) ? c : d`
+        //
+        // Such parentheses could always be included in the condition (guaranteeing correct behavior) in
+        // all cases, but this has a code size cost. Instead, parentheses are added only when a
+        // conditional expression is directly used as the condition of another.
+        //
+        // TODO(alxhub): investigate better logic for precendence of conditional operators
+        if (ast.condition instanceof o.ConditionalExpr) {
+            // The condition of this ternary needs to be wrapped in parentheses to maintain
+            // left-associativity.
+            cond = this.factory.createParenthesizedExpression(cond);
+        }
+        return this.factory.createConditional(cond, ast.trueCase.visitExpression(this, context), ast.falseCase.visitExpression(this, context));
+    }
+    visitNotExpr(ast, context) {
+        return this.factory.createUnaryExpression('!', ast.condition.visitExpression(this, context));
+    }
+    visitAssertNotNullExpr(ast, context) {
+        return ast.condition.visitExpression(this, context);
+    }
+    visitCastExpr(ast, context) {
+        return ast.value.visitExpression(this, context);
+    }
+    visitFunctionExpr(ast, context) {
+        var _a;
+        return this.factory.createFunctionExpression((_a = ast.name) !== null && _a !== void 0 ? _a : null, ast.params.map((param) => param.name), this.factory.createBlock(this.visitStatements(ast.statements, context)));
+    }
+    visitBinaryOperatorExpr(ast, context) {
+        if (!BINARY_OPERATORS.has(ast.operator)) {
+            throw new Error(`Unknown binary operator: ${o.BinaryOperator[ast.operator]}`);
+        }
+        return this.factory.createBinaryExpression(ast.lhs.visitExpression(this, context), BINARY_OPERATORS.get(ast.operator), ast.rhs.visitExpression(this, context));
+    }
+    visitReadPropExpr(ast, context) {
+        return this.factory.createPropertyAccess(ast.receiver.visitExpression(this, context), ast.name);
+    }
+    visitReadKeyExpr(ast, context) {
+        return this.factory.createElementAccess(ast.receiver.visitExpression(this, context), ast.index.visitExpression(this, context));
+    }
+    visitLiteralArrayExpr(ast, context) {
+        return this.factory.createArrayLiteral(ast.entries.map((expr) => this.setSourceMapRange(expr.visitExpression(this, context), ast.sourceSpan)));
+    }
+    visitLiteralMapExpr(ast, context) {
+        const properties = ast.entries.map((entry) => {
+            return {
+                propertyName: entry.key,
+                quoted: entry.quoted,
+                value: entry.value.visitExpression(this, context),
+            };
+        });
+        return this.setSourceMapRange(this.factory.createObjectLiteral(properties), ast.sourceSpan);
+    }
+    visitCommaExpr(ast, context) {
+        throw new Error('Method not implemented.');
+    }
+    visitWrappedNodeExpr(ast, _context) {
+        this.recordWrappedNode(ast);
+        return ast.node;
+    }
+    visitTypeofExpr(ast, context) {
+        return this.factory.createTypeOfExpression(ast.expr.visitExpression(this, context));
+    }
+    visitUnaryOperatorExpr(ast, context) {
+        if (!UNARY_OPERATORS.has(ast.operator)) {
+            throw new Error(`Unknown unary operator: ${o.UnaryOperator[ast.operator]}`);
+        }
+        return this.factory.createUnaryExpression(UNARY_OPERATORS.get(ast.operator), ast.expr.visitExpression(this, context));
+    }
+    visitStatements(statements, context) {
+        return statements
+            .map((stmt) => stmt.visitStatement(this, context))
+            .filter((stmt) => stmt !== undefined);
+    }
+    setSourceMapRange(ast, span) {
+        return this.factory.setSourceMapRange(ast, createRange(span));
+    }
+    attachComments(statement, leadingComments) {
+        if (leadingComments !== undefined) {
+            this.factory.attachComments(statement, leadingComments);
+        }
+        return statement;
+    }
+}
+exports.ExpressionTranslatorVisitor = ExpressionTranslatorVisitor;
+/**
+ * Convert an OutputAST source-span into a range that can be used by the AST factories.
+ */
+function createRange(span) {
+    if (span === null) {
+        return null;
+    }
+    const { start, end } = span;
+    const { url, content } = start.file;
+    if (!url) {
+        return null;
+    }
+    return {
+        url,
+        content,
+        start: { offset: start.offset, line: start.line, column: start.col },
+        end: { offset: end.offset, line: end.line, column: end.col },
+    };
+}