@discourse/types 2026.8.0-fb9247e0 → 2026.9.0-c0ef3a11

package/external-types/glimmer__syntax/index.d.ts

@@ -1,5 +1,5 @@
 declare module '@glimmer/syntax' {
-	import { Nullable, Maybe, PresentArray, GetContextualFreeOpcode, Dict, Core } from '@glimmer/interfaces';
+	import { Nullable, Maybe, PresentArray, GetContextualFreeOpcode, Dict, Core } from  '@glimmer/interfaces';
 
 	/**
 	 * @module
@@ -128,7 +128,9 @@ declare module '@glimmer/syntax' {
 	interface StripFlags$1 {
 	    open: boolean;
 	    close: boolean;
-	} const visitorKeys: {
+	}
+
+	 const visitorKeys: {
 	    readonly Template: readonly ["body"];
 	    readonly Block: readonly ["body"];
 	    readonly MustacheStatement: readonly ["path", "params", "hash"];
@@ -154,7 +156,9 @@ declare module '@glimmer/syntax' {
 	type VisitorKeys = {
 	    [P in keyof VisitorKeysMap]: VisitorKeysMap[P][number];
 	};
-	type VisitorKey<N extends Node> = VisitorKeys[N['type']] & keyof N; class WalkerPath<N extends Node> {
+	type VisitorKey<N extends Node> = VisitorKeys[N['type']] & keyof N;
+
+	 class WalkerPath<N extends Node> {
 	    node: N;
 	    parent: WalkerPath<Node> | null;
 	    parentKey: string | null;
@@ -193,9 +197,12 @@ declare module '@glimmer/syntax' {
 	     * @deprecated use Template or Block instead
 	     */
 	    Program?: KeyTraversal<Template$1 | Block$1, 'body'>;
-	}; function traverse(node: Node, visitor: NodeVisitor): void;
+	};
+
+	 function traverse(node: Node, visitor: NodeVisitor): void;
 
-	type NodeCallback<N extends Node> = (node: N, walker: Walker) => void; class Walker {
+	type NodeCallback<N extends Node> = (node: N, walker: Walker) => void;
+	 class Walker {
 	    order?: unknown | undefined;
 	    stack: unknown[];
 	    constructor(order?: unknown | undefined);
@@ -210,8 +217,14 @@ declare module '@glimmer/syntax' {
 	} | {
 	    name: string;
 	    selfClosing?: boolean;
-	}; function buildMustache(path: BuilderHead | Literal, params?: Expression[], hash?: Hash, trusting?: boolean, loc?: SourceLocation, strip?: StripFlags): MustacheStatement;
-	type PossiblyDeprecatedBlock = Block$1 | Template$1; function buildBlock(path: BuilderHead, params: Nullable<Expression[]>, hash: Nullable<Hash>, _defaultBlock: PossiblyDeprecatedBlock, _elseBlock?: Nullable<PossiblyDeprecatedBlock>, loc?: SourceLocation, openStrip?: StripFlags, inverseStrip?: StripFlags, closeStrip?: StripFlags): BlockStatement; function buildElementModifier(path: BuilderHead, params?: Expression[], hash?: Hash, loc?: Nullable<SourceLocation>): ElementModifierStatement; function buildComment(value: string, loc?: SourceLocation): CommentStatement; function buildMustacheComment(value: string, loc?: SourceLocation): MustacheCommentStatement; function buildConcat(parts: (TextNode | MustacheStatement)[], loc?: SourceLocation): ConcatStatement;
+	};
+	 function buildMustache(path: BuilderHead | Literal, params?: Expression[], hash?: Hash, trusting?: boolean, loc?: SourceLocation, strip?: StripFlags): MustacheStatement;
+	type PossiblyDeprecatedBlock = Block$1 | Template$1;
+	 function buildBlock(path: BuilderHead, params: Nullable<Expression[]>, hash: Nullable<Hash>, _defaultBlock: PossiblyDeprecatedBlock, _elseBlock?: Nullable<PossiblyDeprecatedBlock>, loc?: SourceLocation, openStrip?: StripFlags, inverseStrip?: StripFlags, closeStrip?: StripFlags): BlockStatement;
+	 function buildElementModifier(path: BuilderHead, params?: Expression[], hash?: Hash, loc?: Nullable<SourceLocation>): ElementModifierStatement;
+	 function buildComment(value: string, loc?: SourceLocation): CommentStatement;
+	 function buildMustacheComment(value: string, loc?: SourceLocation): MustacheCommentStatement;
+	 function buildConcat(parts: (TextNode | MustacheStatement)[], loc?: SourceLocation): ConcatStatement;
 	interface BuildElementOptions {
 	    attrs?: AttrNode$1[];
 	    modifiers?: ElementModifierStatement[];
@@ -221,10 +234,32 @@ declare module '@glimmer/syntax' {
 	    openTag?: SourceLocation;
 	    closeTag?: Maybe<SourceLocation>;
 	    loc?: SourceLocation;
-	} function buildElement(tag: TagDescriptor, options?: BuildElementOptions): ElementNode$1; function buildAttr(name: string, value: AttrValue, loc?: SourceLocation): AttrNode$1; function buildText(chars?: string, loc?: SourceLocation): TextNode; function buildSexpr(path: BuilderHead, params?: Expression[], hash?: Hash, loc?: SourceLocation): SubExpression; function buildThis(loc?: SourceLocation): ThisHead; function buildAtName(name: string, loc?: SourceLocation): AtHead; function buildVar(name: string, loc?: SourceLocation): VarHead; function buildHeadFromString(original: string, loc?: SourceLocation): PathHead; function buildCleanPath(head: PathHead, tail?: string[], loc?: SourceLocation): PathExpression$1; function buildPath(path: PathExpression$1 | string | {
+	}
+	 function buildElement(tag: TagDescriptor, options?: BuildElementOptions): ElementNode$1;
+	 function buildAttr(name: string, value: AttrValue, loc?: SourceLocation): AttrNode$1;
+	 function buildText(chars?: string, loc?: SourceLocation): TextNode;
+	 function buildSexpr(path: BuilderHead, params?: Expression[], hash?: Hash, loc?: SourceLocation): SubExpression;
+	 function buildThis(loc?: SourceLocation): ThisHead;
+	 function buildAtName(name: string, loc?: SourceLocation): AtHead;
+	 function buildVar(name: string, loc?: SourceLocation): VarHead;
+	 function buildHeadFromString(original: string, loc?: SourceLocation): PathHead;
+	 function buildCleanPath(head: PathHead, tail?: string[], loc?: SourceLocation): PathExpression$1;
+	 function buildPath(path: PathExpression$1 | string | {
 	    head: string;
 	    tail: string[];
-	}, loc?: SourceLocation): PathExpression$1; function buildPath(path: BuilderHead, loc?: SourceLocation): CallableExpression; function buildPath(path: BuilderHead | Literal | Expression, loc?: SourceLocation): Expression; function buildLiteral<T extends Literal>(type: T['type'], value: T['value'], loc?: SourceLocation): T; function buildHash(pairs?: HashPair[], loc?: SourceLocation): Hash; function buildPair(key: string, value: Expression, loc?: SourceLocation): HashPair; function buildProgram(body?: Statement[], blockParams?: string[], loc?: SourceLocation): Template$1 | Block$1; function buildBlockItself(body?: Statement[], params?: Array<VarHead | string>, chained?: boolean, loc?: SourceLocation): Block$1; function buildTemplate(body?: Statement[], blockParams?: string[], loc?: SourceLocation): Template$1; function buildPosition(line: number, column: number): SourcePosition; function buildLoc(loc: Nullable<SourceLocation>): SourceSpan; function buildLoc(startLine: number, startColumn: number, endLine?: number, endColumn?: number, source?: string): SourceSpan; const _default: {
+	}, loc?: SourceLocation): PathExpression$1;
+	 function buildPath(path: BuilderHead, loc?: SourceLocation): CallableExpression;
+	 function buildPath(path: BuilderHead | Literal | Expression, loc?: SourceLocation): Expression;
+	 function buildLiteral<T extends Literal>(type: T['type'], value: T['value'], loc?: SourceLocation): T;
+	 function buildHash(pairs?: HashPair[], loc?: SourceLocation): Hash;
+	 function buildPair(key: string, value: Expression, loc?: SourceLocation): HashPair;
+	 function buildProgram(body?: Statement[], blockParams?: string[], loc?: SourceLocation): Template$1 | Block$1;
+	 function buildBlockItself(body?: Statement[], params?: Array<VarHead | string>, chained?: boolean, loc?: SourceLocation): Block$1;
+	 function buildTemplate(body?: Statement[], blockParams?: string[], loc?: SourceLocation): Template$1;
+	 function buildPosition(line: number, column: number): SourcePosition;
+	 function buildLoc(loc: Nullable<SourceLocation>): SourceSpan;
+	 function buildLoc(startLine: number, startColumn: number, endLine?: number, endColumn?: number, source?: string): SourceSpan;
+	 const _default: {
 	    mustache: typeof buildMustache;
 	    block: typeof buildBlock;
 	    comment: typeof buildComment;
@@ -340,7 +375,10 @@ declare module '@glimmer/syntax' {
 	    print: typeof build;
 	    traverse: typeof traverse;
 	    Walker: typeof Walker;
-	} function preprocess(input: string | Source | Program$1, options?: PreprocessOptions): Template$1; class Source {
+	}
+	 function preprocess(input: string | Source | Program$1, options?: PreprocessOptions): Template$1;
+
+	 class Source {
 	    readonly source: string;
 	    readonly module: string;
 	    static from(source: string, options?: PrecompileOptions): Source;
@@ -392,7 +430,8 @@ declare module '@glimmer/syntax' {
 	type SerializedSourceSlice<Chars extends string = string> = [
 	    chars: Chars,
 	    span: SerializedSourceSpan
-	]; class SourceSlice<Chars extends string = string> {
+	];
+	 class SourceSlice<Chars extends string = string> {
 	    static synthetic<S extends string>(chars: S): SourceSlice<S>;
 	    static load(source: Source, slice: SerializedSourceSlice): SourceSlice;
 	    readonly chars: Chars;
@@ -446,7 +485,42 @@ declare module '@glimmer/syntax' {
 	     * context like AST Explorer. If you need a {@see SourceLocation}, use {@see toJSON}.
 	     */
 	    serialize(): SerializedSourceSpan;
-	} class SourceSpan implements SourceLocation {
+	}
+	/**
+	 * A `SourceSpan` object represents a span of characters inside of a template source.
+	 *
+	 * There are three kinds of `SourceSpan` objects:
+	 *
+	 * - `ConcreteSourceSpan`, which contains byte offsets
+	 * - `LazySourceSpan`, which contains `SourceLocation`s from the Handlebars AST, which can be
+	 *   converted to byte offsets on demand.
+	 * - `InvisibleSourceSpan`, which represent source strings that aren't present in the source,
+	 *   because:
+	 *     - they were created synthetically
+	 *     - their location is nonsensical (the span is broken)
+	 *     - they represent nothing in the source (this currently happens only when a bug in the
+	 *       upstream Handlebars parser fails to assign a location to empty blocks)
+	 *
+	 * At a high level, all `SourceSpan` objects provide:
+	 *
+	 * - byte offsets
+	 * - source in column and line format
+	 *
+	 * And you can do these operations on `SourceSpan`s:
+	 *
+	 * - collapse it to a `SourceSpan` representing its starting or ending position
+	 * - slice out some characters, optionally skipping some characters at the beginning or end
+	 * - create a new `SourceSpan` with a different starting or ending offset
+	 *
+	 * All SourceSpan objects implement `SourceLocation`, for compatibility. All SourceSpan
+	 * objects have a `toJSON` that emits `SourceLocation`, also for compatibility.
+	 *
+	 * For compatibility, subclasses of `AbstractSourceSpan` must implement `locDidUpdate`, which
+	 * happens when an AST plugin attempts to modify the `start` or `end` of a span directly.
+	 *
+	 * The goal is to avoid creating any problems for use-cases like AST Explorer.
+	 */
+	 class SourceSpan implements SourceLocation {
 	    private data;
 	    static get NON_EXISTENT(): SourceSpan;
 	    static load(source: Source, serialized: SerializedSourceSpan): SourceSpan;
@@ -531,7 +605,8 @@ declare module '@glimmer/syntax' {
 	        chars: number;
 	    }): SourceSpan;
 	}
-	type AnySpan = HbsSpan | CharPositionSpan | InvisibleSpan; class CharPositionSpan implements SpanData {
+	type AnySpan = HbsSpan | CharPositionSpan | InvisibleSpan;
+	 class CharPositionSpan implements SpanData {
 	    #private;
 	    readonly source: Source;
 	    readonly charPositions: {
@@ -552,7 +627,8 @@ declare module '@glimmer/syntax' {
 	    toHbsSpan(): HbsSpan | null;
 	    serialize(): SerializedSourceSpan;
 	    toCharPosSpan(): this;
-	} class HbsSpan implements SpanData {
+	}
+	 class HbsSpan implements SpanData {
 	    #private;
 	    readonly source: Source;
 	    readonly hbsPositions: {
@@ -578,7 +654,8 @@ declare module '@glimmer/syntax' {
 	    toHbsLoc(): SourceLocation;
 	    toHbsSpan(): this;
 	    toCharPosSpan(): CharPositionSpan | null;
-	} class InvisibleSpan implements SpanData {
+	}
+	 class InvisibleSpan implements SpanData {
 	    readonly kind: InvisibleKind;
 	    readonly loc: SourceLocation;
 	    readonly string: string | null;
@@ -609,10 +686,12 @@ declare module '@glimmer/syntax' {
 	    line: number;
 	    /** >= 0 */
 	    column: number;
-	} const UNKNOWN_POSITION: Readonly<{
+	}
+	 const UNKNOWN_POSITION: Readonly<{
 	    readonly line: 1;
 	    readonly column: 0;
-	}>; const SYNTHETIC_LOCATION: Readonly<{
+	}>;
+	 const SYNTHETIC_LOCATION: Readonly<{
 	    readonly source: "(synthetic)";
 	    readonly start: Readonly<{
 	        readonly line: 1;
@@ -622,7 +701,8 @@ declare module '@glimmer/syntax' {
 	        readonly line: 1;
 	        readonly column: 0;
 	    }>;
-	}>; const NON_EXISTENT_LOCATION: Readonly<{
+	}>;
+	 const NON_EXISTENT_LOCATION: Readonly<{
 	    readonly source: "(nonexistent)";
 	    readonly start: Readonly<{
 	        readonly line: 1;
@@ -642,9 +722,26 @@ declare module '@glimmer/syntax' {
 	    readonly kind: OffsetKind;
 	    toCharPos(): CharPosition | null;
 	    toJSON(): SourcePosition;
-	} const BROKEN = "BROKEN";
+	}
+	/**
+	 * Used to indicate that an attempt to convert a `SourcePosition` to a character offset failed. It
+	 * is separate from `null` so that `null` can be used to indicate that the computation wasn't yet
+	 * attempted (and therefore to cache the failure)
+	 */
+	 const BROKEN = "BROKEN";
 	type BROKEN = 'BROKEN';
-	type AnyPosition = HbsPosition | CharPosition | InvisiblePosition; class SourceOffset {
+	type AnyPosition = HbsPosition | CharPosition | InvisiblePosition;
+	/**
+	 * A `SourceOffset` represents a single position in the source.
+	 *
+	 * There are three kinds of backing data for `SourceOffset` objects:
+	 *
+	 * - `CharPosition`, which contains a character offset into the raw source string
+	 * - `HbsPosition`, which contains a `SourcePosition` from the Handlebars AST, which can be
+	 *   converted to a `CharPosition` on demand.
+	 * - `InvisiblePosition`, which represents a position not in source (@see {InvisiblePosition})
+	 */
+	 class SourceOffset {
 	    readonly data: PositionData & AnyPosition;
 	    /**
 	     * Create a `SourceOffset` from a Handlebars `SourcePosition`. It's stored as-is, and converted
@@ -698,7 +795,8 @@ declare module '@glimmer/syntax' {
 	     * existing plugins.
 	     */
 	    toJSON(): SourcePosition;
-	} class CharPosition implements PositionData {
+	}
+	 class CharPosition implements PositionData {
 	    readonly source: Source;
 	    readonly charPos: number;
 	    readonly kind: "CharPosition";
@@ -728,7 +826,8 @@ declare module '@glimmer/syntax' {
 	     * computing the `HbsPosition` should be a one-time operation.
 	     */
 	    toHbsPos(): HbsPosition | null;
-	} class HbsPosition implements PositionData {
+	}
+	 class HbsPosition implements PositionData {
 	    readonly source: Source;
 	    readonly hbsPos: SourcePosition;
 	    readonly kind: "HbsPosition";
@@ -753,7 +852,8 @@ declare module '@glimmer/syntax' {
 	     * {@see CharPosition} for the alternative.
 	     */
 	    toHbsPos(): this;
-	} class InvisiblePosition implements PositionData {
+	}
+	 class InvisiblePosition implements PositionData {
 	    readonly kind: BrokenKind | InternalSyntheticKind | NonExistentKind;
 	    readonly pos: SourcePosition;
 	    constructor(kind: BrokenKind | InternalSyntheticKind | NonExistentKind, pos: SourcePosition);
@@ -771,7 +871,9 @@ declare module '@glimmer/syntax' {
 	    toJSON(): SourcePosition;
 	    wrap(): SourceOffset;
 	    get offset(): null;
-	} class SpanList {
+	}
+
+	 class SpanList {
 	    static range(span: PresentArray<HasSourceSpan>): SourceSpan;
 	    static range(span: HasSourceSpan[], fallback: SourceSpan): SourceSpan;
 	    _span: SourceSpan[];
@@ -781,21 +883,36 @@ declare module '@glimmer/syntax' {
 	}
 	type HasSourceSpan = {
 	    loc: SourceSpan;
-	} | SourceSpan | [HasSourceSpan, ...HasSourceSpan[]]; function loc(span: HasSourceSpan): SourceSpan;
+	} | SourceSpan | [HasSourceSpan, ...HasSourceSpan[]];
+	 function loc(span: HasSourceSpan): SourceSpan;
 	type MaybeHasSourceSpan = {
 	    loc: SourceSpan;
-	} | SourceSpan | MaybeHasSourceSpan[]; function hasSpan(span: MaybeHasSourceSpan): span is HasSourceSpan; function maybeLoc(location: MaybeHasSourceSpan, fallback: SourceSpan): SourceSpan;
+	} | SourceSpan | MaybeHasSourceSpan[];
+	 function hasSpan(span: MaybeHasSourceSpan): span is HasSourceSpan;
+	 function maybeLoc(location: MaybeHasSourceSpan, fallback: SourceSpan): SourceSpan;
 
 	type api$2_HasSourceSpan = HasSourceSpan;
-	type api$2_MaybeHasSourceSpan = MaybeHasSourceSpan; const api$2_NON_EXISTENT_LOCATION: typeof NON_EXISTENT_LOCATION; const api$2_SYNTHETIC_LOCATION: typeof SYNTHETIC_LOCATION;
+	type api$2_MaybeHasSourceSpan = MaybeHasSourceSpan;
+	 const api$2_NON_EXISTENT_LOCATION: typeof NON_EXISTENT_LOCATION;
+	 const api$2_SYNTHETIC_LOCATION: typeof SYNTHETIC_LOCATION;
 	type api$2_SerializedSourceSpan = SerializedSourceSpan;
-	type api$2_Source = Source; const api$2_Source: typeof Source;
+	type api$2_Source = Source;
+	 const api$2_Source: typeof Source;
 	type api$2_SourceLocation = SourceLocation;
-	type api$2_SourceOffset = SourceOffset; const api$2_SourceOffset: typeof SourceOffset;
+	type api$2_SourceOffset = SourceOffset;
+	 const api$2_SourceOffset: typeof SourceOffset;
 	type api$2_SourcePosition = SourcePosition;
-	type api$2_SourceSlice<Chars extends string = string> = SourceSlice<Chars>; const api$2_SourceSlice: typeof SourceSlice;
-	type api$2_SourceSpan = SourceSpan; const api$2_SourceSpan: typeof SourceSpan;
-	type api$2_SpanList = SpanList; const api$2_SpanList: typeof SpanList; const api$2_UNKNOWN_POSITION: typeof UNKNOWN_POSITION; const api$2_hasSpan: typeof hasSpan; const api$2_loc: typeof loc; const api$2_maybeLoc: typeof maybeLoc; namespace api$2 {
+	type api$2_SourceSlice<Chars extends string = string> = SourceSlice<Chars>;
+	 const api$2_SourceSlice: typeof SourceSlice;
+	type api$2_SourceSpan = SourceSpan;
+	 const api$2_SourceSpan: typeof SourceSpan;
+	type api$2_SpanList = SpanList;
+	 const api$2_SpanList: typeof SpanList;
+	 const api$2_UNKNOWN_POSITION: typeof UNKNOWN_POSITION;
+	 const api$2_hasSpan: typeof hasSpan;
+	 const api$2_loc: typeof loc;
+	 const api$2_maybeLoc: typeof maybeLoc;
+	 namespace api$2 {
 	  export { type api$2_HasSourceSpan as HasSourceSpan, type api$2_MaybeHasSourceSpan as MaybeHasSourceSpan, api$2_NON_EXISTENT_LOCATION as NON_EXISTENT_LOCATION, api$2_SYNTHETIC_LOCATION as SYNTHETIC_LOCATION, type api$2_SerializedSourceSpan as SerializedSourceSpan, api$2_Source as Source, type api$2_SourceLocation as SourceLocation, api$2_SourceOffset as SourceOffset, type api$2_SourcePosition as SourcePosition, api$2_SourceSlice as SourceSlice, api$2_SourceSpan as SourceSpan, api$2_SpanList as SpanList, api$2_UNKNOWN_POSITION as UNKNOWN_POSITION, api$2_hasSpan as hasSpan, api$2_loc as loc, api$2_maybeLoc as maybeLoc };
 	}
 
@@ -1104,9 +1221,12 @@ declare module '@glimmer/syntax' {
 	type api$1_ThisHead = ThisHead;
 	type api$1_TopLevelStatement = TopLevelStatement;
 	type api$1_UndefinedLiteral = UndefinedLiteral;
-	type api$1_VarHead = VarHead; namespace api$1 {
+	type api$1_VarHead = VarHead;
+	 namespace api$1 {
 	  export type { api$1_AtHead as AtHead, AttrNode$1 as AttrNode, api$1_AttrPart as AttrPart, api$1_AttrValue as AttrValue, api$1_BaseNode as BaseNode, Block$1 as Block, api$1_BlockStatement as BlockStatement, api$1_BooleanLiteral as BooleanLiteral, CallNode$1 as CallNode, api$1_CallParts as CallParts, api$1_CallableExpression as CallableExpression, api$1_CommentStatement as CommentStatement, api$1_CommonProgram as CommonProgram, api$1_ConcatStatement as ConcatStatement, api$1_ElementModifierStatement as ElementModifierStatement, ElementNode$1 as ElementNode, api$1_EntityEncodingState as EntityEncodingState, api$1_Expression as Expression, api$1_ExpressionName as ExpressionName, api$1_Expressions as Expressions, api$1_Hash as Hash, api$1_HashPair as HashPair, api$1_Literal as Literal, api$1_LiteralName as LiteralName, api$1_MinimalPathExpression as MinimalPathExpression, api$1_MustacheCommentStatement as MustacheCommentStatement, api$1_MustacheStatement as MustacheStatement, api$1_Node as Node, api$1_NodeType as NodeType, api$1_Nodes as Nodes, api$1_NullLiteral as NullLiteral, api$1_NumberLiteral as NumberLiteral, api$1_ParentNode as ParentNode, PathExpression$1 as PathExpression, api$1_PathHead as PathHead, SourcePosition as Position, api$1_Program as Program, api$1_SourceLocation as SourceLocation, api$1_SourcePosition as SourcePosition, api$1_Statement as Statement, api$1_StatementName as StatementName, api$1_Statements as Statements, StringLiteral$1 as StringLiteral, api$1_StripFlags as StripFlags, api$1_SubExpression as SubExpression, api$1_SubNode as SubNode, api$1_SubNodeType as SubNodeType, api$1_SubNodes as SubNodes, Template$1 as Template, api$1_TextNode as TextNode, api$1_ThisHead as ThisHead, api$1_TopLevelStatement as TopLevelStatement, api$1_UndefinedLiteral as UndefinedLiteral, api$1_VarHead as VarHead };
-	} function getVoidTags(): string[];
+	}
+
+	 function getVoidTags(): string[];
 	interface PrinterOptions {
 	    entityEncoding: EntityEncodingState;
 	    /**
@@ -1124,15 +1244,41 @@ declare module '@glimmer/syntax' {
 	     * @param options the options specified during the print() invocation
 	     */
 	    override?(ast: Node, options: PrinterOptions): void | string;
-	} function isVoidTag(tag: string): boolean; function build(ast: Node, options?: PrinterOptions): string; function sortByLoc(a: Node, b: Node): -1 | 0 | 1;
+	}
+	/**
+	 * Examples when true:
+	 *  - link
+	 *  - liNK
+	 *
+	 * Examples when false:
+	 *  - Link (component)
+	 */
+	 function isVoidTag(tag: string): boolean;
+
+	 function build(ast: Node, options?: PrinterOptions): string;
+
+	 function sortByLoc(a: Node, b: Node): -1 | 0 | 1;
 
 	interface GetTemplateLocalsOptions {
 	    includeKeywords?: boolean;
 	    includeHtmlElements?: boolean;
-	} function getTemplateLocals(html: string, options?: GetTemplateLocalsOptions): string[];
+	}
+	/**
+	 * Parses and traverses a given handlebars html template to extract all template locals
+	 * referenced that could possible come from the parent scope. Can exclude known keywords
+	 * optionally.
+	 */
+	 function getTemplateLocals(html: string, options?: GetTemplateLocalsOptions): string[];
 
 	type Keywords = keyof typeof KEYWORDS_TYPES;
-	type KeywordType = 'Call' | 'Modifier' | 'Append' | 'Block'; function isKeyword(word: string): word is Keywords; function isKeyword(word: string, type: KeywordType): boolean; const KEYWORDS_TYPES: {
+	type KeywordType = 'Call' | 'Modifier' | 'Append' | 'Block';
+	 function isKeyword(word: string): word is Keywords;
+	 function isKeyword(word: string, type: KeywordType): boolean;
+	/**
+	 * This includes the full list of keywords currently in use in the template
+	 * language, and where their valid usages are.
+	 */
+	 const KEYWORDS_TYPES: {
 	    action: ("Call" | "Modifier")[];
 	    component: ("Block" | "Call" | "Append")[];
 	    debugger: "Append"[];
@@ -1157,9 +1303,38 @@ declare module '@glimmer/syntax' {
 
 	interface BaseNodeFields {
 	    loc: SourceSpan;
-	} function node(): {
+	}
+	/**
+	 * This is a convenience function for creating ASTv2 nodes, with an optional name and the node's
+	 * options.
+	 *
+	 * ```ts
+	 * export class HtmlText extends node('HtmlText').fields<{ chars: string }>() {}
+	 * ```
+	 *
+	 * This creates a new ASTv2 node with the name `'HtmlText'` and one field `chars: string` (in
+	 * addition to a `loc: SourceOffsets` field, which all nodes have).
+	 *
+	 * ```ts
+	 * export class Args extends node().fields<{
+	 *  positional: PositionalArguments;
+	 *  named: NamedArguments
+	 * }>() {}
+	 * ```
+	 *
+	 * This creates a new un-named ASTv2 node with two fields (`positional: Positional` and `named:
+	 * Named`, in addition to the generic `loc: SourceOffsets` field).
+	 *
+	 * Once you create a node using `node`, it is instantiated with all of its fields (including `loc`):
+	 *
+	 * ```ts
+	 * new HtmlText({ loc: offsets, chars: someString });
+	 * ```
+	 */
+	 function node(): {
 	    fields<Fields extends object>(): NodeConstructor<Fields & BaseNodeFields>;
-	}; function node<T extends string>(name: T): {
+	};
+	 function node<T extends string>(name: T): {
 	    fields<Fields extends object>(): TypedNodeConstructor<T, Fields & BaseNodeFields>;
 	};
 	interface NodeConstructor<Fields> {
@@ -1190,30 +1365,69 @@ declare module '@glimmer/syntax' {
 	 * "Attr Block" nodes are allowed inside an open element tag in templates. They interact with the
 	 * element (or component).
 	 */
-	type AttrBlockNode = AttrNode | ElementModifier; const HtmlAttr_base: TypedNodeConstructor<"HtmlAttr", AttrNodeOptions & BaseNodeFields>; class HtmlAttr extends HtmlAttr_base {
-	} const SplatAttr_base: TypedNodeConstructor<"SplatAttr", {
+	type AttrBlockNode = AttrNode | ElementModifier;
+	 const HtmlAttr_base: TypedNodeConstructor<"HtmlAttr", AttrNodeOptions & BaseNodeFields>;
+	/**
+	 * `HtmlAttr` nodes are valid HTML attributes, with or without a value.
+	 *
+	 * Exceptions:
+	 *
+	 * - `...attributes` is `SplatAttr`
+	 * - `@x=<value>` is `ComponentArg`
+	 */
+	 class HtmlAttr extends HtmlAttr_base {
+	}
+	 const SplatAttr_base: TypedNodeConstructor<"SplatAttr", {
 	    symbol: number;
-	} & BaseNodeFields>; class SplatAttr extends SplatAttr_base {
-	} const ComponentArg_base: NodeConstructor<AttrNodeOptions & BaseNodeFields>; class ComponentArg extends ComponentArg_base {
+	} & BaseNodeFields>;
+	 class SplatAttr extends SplatAttr_base {
+	}
+	 const ComponentArg_base: NodeConstructor<AttrNodeOptions & BaseNodeFields>;
+	/**
+	 * Corresponds to an argument passed by a component (`@x=<value>`)
+	 */
+	 class ComponentArg extends ComponentArg_base {
 	    /**
 	     * Convert the component argument into a named argument node
 	     */
 	    toNamedArgument(): NamedArgument;
-	} const ElementModifier_base: TypedNodeConstructor<"ElementModifier", CallFields & BaseNodeFields>; class ElementModifier extends ElementModifier_base {
+	}
+	 const ElementModifier_base: TypedNodeConstructor<"ElementModifier", CallFields & BaseNodeFields>;
+	/**
+	 * An `ElementModifier` is just a normal call node in modifier position.
+	 */
+	 class ElementModifier extends ElementModifier_base {
 	}
 	interface AttrNodeOptions {
 	    name: SourceSlice;
 	    value: ExpressionNode;
 	    trusting: boolean;
-	} const Template_base: NodeConstructor<{
+	}
+
+	 const Template_base: NodeConstructor<{
 	    table: ProgramSymbolTable;
-	} & GlimmerParentNodeOptions & BaseNodeFields>; class Template extends Template_base {
-	} const Block_base: NodeConstructor<{
+	} & GlimmerParentNodeOptions & BaseNodeFields>;
+	/**
+	 * Corresponds to an entire template.
+	 */
+	 class Template extends Template_base {
+	}
+	 const Block_base: NodeConstructor<{
 	    scope: BlockSymbolTable;
-	} & GlimmerParentNodeOptions & BaseNodeFields>; class Block extends Block_base {
-	} const NamedBlocks_base: NodeConstructor<{
+	} & GlimmerParentNodeOptions & BaseNodeFields>;
+	/**
+	 * Represents a block. In principle this could be merged with `NamedBlock`, because all cases
+	 * involving blocks have at least a notional name.
+	 */
+	 class Block extends Block_base {
+	}
+	 const NamedBlocks_base: NodeConstructor<{
 	    blocks: readonly NamedBlock[];
-	} & BaseNodeFields>; class NamedBlocks extends NamedBlocks_base {
+	} & BaseNodeFields>;
+	/**
+	 * Corresponds to a collection of named blocks.
+	 */
+	 class NamedBlocks extends NamedBlocks_base {
 	    /**
 	     * Get the `NamedBlock` for a given name.
 	     */
@@ -1226,7 +1440,13 @@ declare module '@glimmer/syntax' {
 	    attrs: readonly HtmlOrSplatAttr[];
 	    componentArgs: readonly ComponentArg[];
 	    modifiers: readonly ElementModifier[];
-	} const NamedBlock_base: NodeConstructor<NamedBlockFields & BaseNodeFields>; class NamedBlock extends NamedBlock_base {
+	}
+	 const NamedBlock_base: NodeConstructor<NamedBlockFields & BaseNodeFields>;
+	/**
+	 * Corresponds to a single named block. This is used for anonymous named blocks (`default` and
+	 * `else`).
+	 */
+	 class NamedBlock extends NamedBlock_base {
 	    get args(): Args;
 	}
 
@@ -1236,25 +1456,35 @@ declare module '@glimmer/syntax' {
 	 *
 	 * [data]: https://html.spec.whatwg.org/multipage/parsing.html#data-state
 	 */
-	type ContentNode = HtmlText | HtmlComment | AppendContent | InvokeBlock | InvokeComponent | SimpleElement | GlimmerComment; const GlimmerComment_base: TypedNodeConstructor<"GlimmerComment", {
+	type ContentNode = HtmlText | HtmlComment | AppendContent | InvokeBlock | InvokeComponent | SimpleElement | GlimmerComment;
+	 const GlimmerComment_base: TypedNodeConstructor<"GlimmerComment", {
 	    text: SourceSlice;
-	} & BaseNodeFields>; class GlimmerComment extends GlimmerComment_base {
-	} const HtmlText_base: TypedNodeConstructor<"HtmlText", {
+	} & BaseNodeFields>;
+	 class GlimmerComment extends GlimmerComment_base {
+	}
+	 const HtmlText_base: TypedNodeConstructor<"HtmlText", {
 	    chars: string;
-	} & BaseNodeFields>; class HtmlText extends HtmlText_base {
-	} const HtmlComment_base: TypedNodeConstructor<"HtmlComment", {
+	} & BaseNodeFields>;
+	 class HtmlText extends HtmlText_base {
+	}
+	 const HtmlComment_base: TypedNodeConstructor<"HtmlComment", {
 	    text: SourceSlice;
-	} & BaseNodeFields>; class HtmlComment extends HtmlComment_base {
-	} const AppendContent_base: TypedNodeConstructor<"AppendContent", {
+	} & BaseNodeFields>;
+	 class HtmlComment extends HtmlComment_base {
+	}
+	 const AppendContent_base: TypedNodeConstructor<"AppendContent", {
 	    value: ExpressionNode;
 	    trusting: boolean;
 	    table: SymbolTable;
-	} & BaseNodeFields>; class AppendContent extends AppendContent_base {
+	} & BaseNodeFields>;
+	 class AppendContent extends AppendContent_base {
 	    get callee(): ExpressionNode;
 	    get args(): Args;
-	} const InvokeBlock_base: TypedNodeConstructor<"InvokeBlock", CallFields & {
+	}
+	 const InvokeBlock_base: TypedNodeConstructor<"InvokeBlock", CallFields & {
 	    blocks: NamedBlocks;
-	} & BaseNodeFields>; class InvokeBlock extends InvokeBlock_base {
+	} & BaseNodeFields>;
+	 class InvokeBlock extends InvokeBlock_base {
 	}
 	interface InvokeComponentFields {
 	    callee: ExpressionNode;
@@ -1262,7 +1492,14 @@ declare module '@glimmer/syntax' {
 	    attrs: readonly HtmlOrSplatAttr[];
 	    componentArgs: readonly ComponentArg[];
 	    modifiers: readonly ElementModifier[];
-	} const InvokeComponent_base: TypedNodeConstructor<"InvokeComponent", InvokeComponentFields & BaseNodeFields>; class InvokeComponent extends InvokeComponent_base {
+	}
+	 const InvokeComponent_base: TypedNodeConstructor<"InvokeComponent", InvokeComponentFields & BaseNodeFields>;
+	/**
+	 * Corresponds to a component invocation. When the content of a component invocation contains no
+	 * named blocks, `blocks` contains a single named block named `"default"`. When a component
+	 * invocation is self-closing, `blocks` is empty.
+	 */
+	 class InvokeComponent extends InvokeComponent_base {
 	    get args(): Args;
 	}
 	interface SimpleElementOptions extends BaseNodeFields {
@@ -1271,7 +1508,13 @@ declare module '@glimmer/syntax' {
 	    attrs: readonly HtmlOrSplatAttr[];
 	    componentArgs: readonly ComponentArg[];
 	    modifiers: readonly ElementModifier[];
-	} const SimpleElement_base: TypedNodeConstructor<"SimpleElement", SimpleElementOptions & BaseNodeFields>; class SimpleElement extends SimpleElement_base {
+	}
+	 const SimpleElement_base: TypedNodeConstructor<"SimpleElement", SimpleElementOptions & BaseNodeFields>;
+	/**
+	 * Corresponds to a simple HTML element. The AST allows component arguments and modifiers to support
+	 * future extensions.
+	 */
+	 class SimpleElement extends SimpleElement_base {
 	    get args(): Args;
 	}
 	type ElementNode = NamedBlock | InvokeComponent | SimpleElement;
@@ -1289,20 +1532,47 @@ declare module '@glimmer/syntax' {
 	type CalleeNode = KeywordExpression | PathExpression | CallExpression;
 	type CallNode = CallExpression | InvokeBlock | AppendContent | InvokeComponent | ElementModifier;
 
-	type HELPER_VAR_NS = 'Helper'; const HELPER_VAR_NS: HELPER_VAR_NS;
-	type MODIFIER_VAR_NS = 'Modifier'; const MODIFIER_VAR_NS: MODIFIER_VAR_NS;
-	type COMPONENT_VAR_NS = 'Component'; const COMPONENT_VAR_NS: COMPONENT_VAR_NS;
-	type FreeVarNamespace = HELPER_VAR_NS | MODIFIER_VAR_NS | COMPONENT_VAR_NS; const STRICT_RESOLUTION: {
+	type HELPER_VAR_NS = 'Helper';
+	 const HELPER_VAR_NS: HELPER_VAR_NS;
+	type MODIFIER_VAR_NS = 'Modifier';
+	 const MODIFIER_VAR_NS: MODIFIER_VAR_NS;
+	type COMPONENT_VAR_NS = 'Component';
+	 const COMPONENT_VAR_NS: COMPONENT_VAR_NS;
+	type FreeVarNamespace = HELPER_VAR_NS | MODIFIER_VAR_NS | COMPONENT_VAR_NS;
+
+	/**
+	 * A free variable is resolved according to a resolution rule:
+	 *
+	 * 1. Strict resolution
+	 * 2. Namespaced resolution
+	 */
+
+	/**
+	 * Strict resolution is used:
+	 *
+	 * 1. in a strict mode template
+	 * 2. in an local variable invocation with dot paths
+	 */
+	 const STRICT_RESOLUTION: {
 	    resolution: () => GetContextualFreeOpcode;
 	    serialize: () => SerializedResolution;
 	    isAngleBracket: false;
 	};
-	type StrictResolution = typeof STRICT_RESOLUTION; const HTML_RESOLUTION: {
+	type StrictResolution = typeof STRICT_RESOLUTION;
+	 const HTML_RESOLUTION: {
 	    isAngleBracket: true;
 	    resolution: () => GetContextualFreeOpcode;
 	    serialize: () => SerializedResolution;
 	};
-	type HtmlResolution = typeof HTML_RESOLUTION; function isStrictResolution(value: unknown): value is StrictResolution; class LooseModeResolution {
+	type HtmlResolution = typeof HTML_RESOLUTION;
+	 function isStrictResolution(value: unknown): value is StrictResolution;
+	/**
+	 * A `LooseModeResolution` includes one or more namespaces to resolve the variable in
+	 *
+	 * In practice, there are a limited number of possible combinations of these degrees of freedom,
+	 * and they are captured by the `Namespaces` union below.
+	 */
+	 class LooseModeResolution {
 	    readonly namespaces: Namespaces;
 	    readonly isAngleBracket: boolean;
 	    /**
@@ -1347,7 +1617,10 @@ declare module '@glimmer/syntax' {
 	    constructor(namespaces: Namespaces, isAngleBracket?: boolean);
 	    resolution(): GetContextualFreeOpcode;
 	    serialize(): SerializedResolution;
-	} const HELPER_NAMESPACE: "Helper"; const MODIFIER_NAMESPACE: "Modifier"; const COMPONENT_NAMESPACE: "Component";
+	}
+	 const HELPER_NAMESPACE: "Helper";
+	 const MODIFIER_NAMESPACE: "Modifier";
+	 const COMPONENT_NAMESPACE: "Component";
 	/**
 	 * A `Namespaced` must be resolved in one or more namespaces.
 	 *
@@ -1371,21 +1644,50 @@ declare module '@glimmer/syntax' {
 	 */
 	type Namespaces = [HELPER_VAR_NS] | [MODIFIER_VAR_NS] | [COMPONENT_VAR_NS] | [COMPONENT_VAR_NS, HELPER_VAR_NS];
 	type FreeVarResolution = StrictResolution | HtmlResolution | LooseModeResolution;
-	type SerializedResolution = 'Strict' | 'Helper' | 'Modifier' | 'Component' | 'ComponentOrHelper'; function loadResolution(resolution: SerializedResolution): FreeVarResolution; const ThisReference_base: TypedNodeConstructor<"This", object & BaseNodeFields>; class ThisReference extends ThisReference_base {
-	} const ArgReference_base: TypedNodeConstructor<"Arg", {
+	type SerializedResolution = 'Strict' | 'Helper' | 'Modifier' | 'Component' | 'ComponentOrHelper';
+	 function loadResolution(resolution: SerializedResolution): FreeVarResolution;
+
+	 const ThisReference_base: TypedNodeConstructor<"This", object & BaseNodeFields>;
+	/**
+	 * Corresponds to `this` at the head of an expression.
+	 */
+	 class ThisReference extends ThisReference_base {
+	}
+	 const ArgReference_base: TypedNodeConstructor<"Arg", {
 	    name: SourceSlice;
 	    symbol: number;
-	} & BaseNodeFields>; class ArgReference extends ArgReference_base {
-	} const LocalVarReference_base: TypedNodeConstructor<"Local", {
+	} & BaseNodeFields>;
+	/**
+	 * Corresponds to `@<ident>` at the beginning of an expression.
+	 */
+	 class ArgReference extends ArgReference_base {
+	}
+	 const LocalVarReference_base: TypedNodeConstructor<"Local", {
 	    name: string;
 	    isTemplateLocal: boolean;
 	    symbol: number;
-	} & BaseNodeFields>; class LocalVarReference extends LocalVarReference_base {
-	} const FreeVarReference_base: TypedNodeConstructor<"Free", {
+	} & BaseNodeFields>;
+	/**
+	 * Corresponds to `<ident>` at the beginning of an expression, when `<ident>` is in the current
+	 * block's scope.
+	 */
+	 class LocalVarReference extends LocalVarReference_base {
+	}
+	 const FreeVarReference_base: TypedNodeConstructor<"Free", {
 	    name: string;
 	    resolution: FreeVarResolution;
 	    symbol: number;
-	} & BaseNodeFields>; class FreeVarReference extends FreeVarReference_base {
+	} & BaseNodeFields>;
+	/**
+	 * Corresponds to `<ident>` at the beginning of an expression, when `<ident>` is *not* in the
+	 * current block's scope.
+	 *
+	 * The `resolution: FreeVarResolution` field describes how to resolve the free variable.
+	 *
+	 * Note: In strict mode, it must always be a variable that is in a concrete JavaScript scope that
+	 * the template will be installed into.
+	 */
+	 class FreeVarReference extends FreeVarReference_base {
 	}
 	type VariableReference = ThisReference | ArgReference | LocalVarReference | FreeVarReference;
 
@@ -1401,50 +1703,145 @@ declare module '@glimmer/syntax' {
 	    number: number;
 	    null: null;
 	    undefined: undefined;
-	} const LiteralExpression_base: TypedNodeConstructor<"Literal", {
+	}
+	 const LiteralExpression_base: TypedNodeConstructor<"Literal", {
 	    value: LiteralValue;
-	} & BaseNodeFields>; class LiteralExpression extends LiteralExpression_base {
+	} & BaseNodeFields>;
+	/**
+	 * Corresponds to a Handlebars literal.
+	 *
+	 * @see {LiteralValue}
+	 */
+	 class LiteralExpression extends LiteralExpression_base {
 	    toSlice(this: StringLiteral): SourceSlice;
 	}
 	type StringLiteral = LiteralExpression & {
 	    value: string;
-	}; function isLiteral<K extends keyof LiteralTypes = keyof LiteralTypes>(node: ExpressionNode, kind?: K): node is StringLiteral; const PathExpression_base: TypedNodeConstructor<"Path", {
+	};
+	/**
+	 * Returns true if an input {@see ExpressionNode} is a literal.
+	 */
+	 function isLiteral<K extends keyof LiteralTypes = keyof LiteralTypes>(node: ExpressionNode, kind?: K): node is StringLiteral;
+	 const PathExpression_base: TypedNodeConstructor<"Path", {
 	    ref: VariableReference;
 	    tail: readonly SourceSlice[];
-	} & BaseNodeFields>; class PathExpression extends PathExpression_base {
-	} const KeywordExpression_base: TypedNodeConstructor<"Keyword", {
+	} & BaseNodeFields>;
+	/**
+	 * Corresponds to a path in expression position.
+	 *
+	 * ```hbs
+	 * this
+	 * this.x
+	 * @x
+	 * @x.y
+	 * x
+	 * x.y
+	 * ```
+	 */
+	 class PathExpression extends PathExpression_base {
+	}
+	 const KeywordExpression_base: TypedNodeConstructor<"Keyword", {
 	    name: string;
 	    symbol: number;
-	} & BaseNodeFields>; class KeywordExpression extends KeywordExpression_base {
-	} const CallExpression_base: TypedNodeConstructor<"Call", CallFields & BaseNodeFields>; class CallExpression extends CallExpression_base {
-	} const InterpolateExpression_base: TypedNodeConstructor<"Interpolate", {
+	} & BaseNodeFields>;
+	/**
+	 * Corresponds to a known strict-mode keyword. It behaves similarly to a
+	 * PathExpression with a FreeVarReference, but implies StrictResolution and
+	 * is guaranteed to not have a tail, since `{{outlet.foo}}` would have been
+	 * illegal.
+	 */
+	 class KeywordExpression extends KeywordExpression_base {
+	}
+	 const CallExpression_base: TypedNodeConstructor<"Call", CallFields & BaseNodeFields>;
+	/**
+	 * Corresponds to a parenthesized call expression.
+	 *
+	 * ```hbs
+	 * (x)
+	 * (x.y)
+	 * (x y)
+	 * (x.y z)
+	 * ```
+	 */
+	 class CallExpression extends CallExpression_base {
+	}
+	 const InterpolateExpression_base: TypedNodeConstructor<"Interpolate", {
 	    parts: PresentArray<ExpressionNode>;
-	} & BaseNodeFields>; class InterpolateExpression extends InterpolateExpression_base {
+	} & BaseNodeFields>;
+	/**
+	 * Corresponds to an interpolation in attribute value position.
+	 *
+	 * ```hbs
+	 * <a href="{{url}}.html"
+	 * ```
+	 */
+	 class InterpolateExpression extends InterpolateExpression_base {
 	}
-	type ExpressionNode = LiteralExpression | PathExpression | KeywordExpression | CallExpression | InterpolateExpression; const Args_base: NodeConstructor<{
+	type ExpressionNode = LiteralExpression | PathExpression | KeywordExpression | CallExpression | InterpolateExpression;
+
+	 const Args_base: NodeConstructor<{
 	    positional: PositionalArguments;
 	    named: NamedArguments;
-	} & BaseNodeFields>; class Args extends Args_base {
+	} & BaseNodeFields>;
+	/**
+	 * Corresponds to syntaxes with positional and named arguments:
+	 *
+	 * - SubExpression
+	 * - Invoking Append
+	 * - Invoking attributes
+	 * - InvokeBlock
+	 *
+	 * If `Args` is empty, the `SourceOffsets` for this node should be the collapsed position
+	 * immediately after the parent call node's `callee`.
+	 */
+	 class Args extends Args_base {
 	    static empty(loc: SourceSpan): Args;
 	    static named(named: NamedArguments): Args;
 	    nth(offset: number): ExpressionNode | null;
 	    get(name: string): ExpressionNode | null;
 	    isEmpty(): boolean;
-	} const PositionalArguments_base: NodeConstructor<{
+	}
+	 const PositionalArguments_base: NodeConstructor<{
 	    exprs: readonly ExpressionNode[];
-	} & BaseNodeFields>; class PositionalArguments extends PositionalArguments_base {
+	} & BaseNodeFields>;
+	/**
+	 * Corresponds to positional arguments.
+	 *
+	 * If `PositionalArguments` is empty, the `SourceOffsets` for this node should be the collapsed
+	 * position immediately after the parent call node's `callee`.
+	 */
+	 class PositionalArguments extends PositionalArguments_base {
 	    static empty(loc: SourceSpan): PositionalArguments;
 	    get size(): number;
 	    nth(offset: number): ExpressionNode | null;
 	    isEmpty(): boolean;
-	} const NamedArguments_base: NodeConstructor<{
+	}
+	 const NamedArguments_base: NodeConstructor<{
 	    entries: readonly NamedArgument[];
-	} & BaseNodeFields>; class NamedArguments extends NamedArguments_base {
+	} & BaseNodeFields>;
+	/**
+	 * Corresponds to named arguments.
+	 *
+	 * If `PositionalArguments` and `NamedArguments` are empty, the `SourceOffsets` for this node should
+	 * be the same as the `Args` node that contains this node.
+	 *
+	 * If `PositionalArguments` is not empty but `NamedArguments` is empty, the `SourceOffsets` for this
+	 * node should be the collapsed position immediately after the last positional argument.
+	 */
+	 class NamedArguments extends NamedArguments_base {
 	    static empty(loc: SourceSpan): NamedArguments;
 	    get size(): number;
 	    get(name: string): ExpressionNode | null;
 	    isEmpty(): boolean;
-	} class NamedArgument {
+	}
+	/**
+	 * Corresponds to a single named argument.
+	 *
+	 * ```hbs
+	 * x=<expr>
+	 * ```
+	 */
+	 class NamedArgument {
 	    readonly loc: SourceSpan;
 	    readonly name: SourceSlice;
 	    readonly value: ExpressionNode;
@@ -1454,66 +1851,106 @@ declare module '@glimmer/syntax' {
 	    });
 	}
 
-	type api_AppendContent = AppendContent; const api_AppendContent: typeof AppendContent;
-	type api_ArgReference = ArgReference; const api_ArgReference: typeof ArgReference;
-	type api_Args = Args; const api_Args: typeof Args;
+	type api_AppendContent = AppendContent;
+	 const api_AppendContent: typeof AppendContent;
+	type api_ArgReference = ArgReference;
+	 const api_ArgReference: typeof ArgReference;
+	type api_Args = Args;
+	 const api_Args: typeof Args;
 	type api_AttrBlockNode = AttrBlockNode;
 	type api_AttrNode = AttrNode;
 	type api_AttrNodeOptions = AttrNodeOptions;
 	type api_BaseNodeFields = BaseNodeFields;
-	type api_Block = Block; const api_Block: typeof Block; const api_COMPONENT_NAMESPACE: typeof COMPONENT_NAMESPACE;
-	type api_CallExpression = CallExpression; const api_CallExpression: typeof CallExpression;
+	type api_Block = Block;
+	 const api_Block: typeof Block;
+	 const api_COMPONENT_NAMESPACE: typeof COMPONENT_NAMESPACE;
+	type api_CallExpression = CallExpression;
+	 const api_CallExpression: typeof CallExpression;
 	type api_CallFields = CallFields;
 	type api_CallNode = CallNode;
 	type api_CalleeNode = CalleeNode;
-	type api_ComponentArg = ComponentArg; const api_ComponentArg: typeof ComponentArg;
+	type api_ComponentArg = ComponentArg;
+	 const api_ComponentArg: typeof ComponentArg;
 	type api_ContentNode = ContentNode;
-	type api_ElementModifier = ElementModifier; const api_ElementModifier: typeof ElementModifier;
+	type api_ElementModifier = ElementModifier;
+	 const api_ElementModifier: typeof ElementModifier;
 	type api_ElementNode = ElementNode;
 	type api_ExpressionNode = ExpressionNode;
-	type api_FreeVarReference = FreeVarReference; const api_FreeVarReference: typeof FreeVarReference;
+	type api_FreeVarReference = FreeVarReference;
+	 const api_FreeVarReference: typeof FreeVarReference;
 	type api_FreeVarResolution = FreeVarResolution;
-	type api_GlimmerComment = GlimmerComment; const api_GlimmerComment: typeof GlimmerComment;
-	type api_GlimmerParentNodeOptions = GlimmerParentNodeOptions; const api_HELPER_NAMESPACE: typeof HELPER_NAMESPACE; const api_HTML_RESOLUTION: typeof HTML_RESOLUTION;
-	type api_HtmlAttr = HtmlAttr; const api_HtmlAttr: typeof HtmlAttr;
-	type api_HtmlComment = HtmlComment; const api_HtmlComment: typeof HtmlComment;
+	type api_GlimmerComment = GlimmerComment;
+	 const api_GlimmerComment: typeof GlimmerComment;
+	type api_GlimmerParentNodeOptions = GlimmerParentNodeOptions;
+	 const api_HELPER_NAMESPACE: typeof HELPER_NAMESPACE;
+	 const api_HTML_RESOLUTION: typeof HTML_RESOLUTION;
+	type api_HtmlAttr = HtmlAttr;
+	 const api_HtmlAttr: typeof HtmlAttr;
+	type api_HtmlComment = HtmlComment;
+	 const api_HtmlComment: typeof HtmlComment;
 	type api_HtmlOrSplatAttr = HtmlOrSplatAttr;
 	type api_HtmlResolution = HtmlResolution;
-	type api_HtmlText = HtmlText; const api_HtmlText: typeof HtmlText;
-	type api_InterpolateExpression = InterpolateExpression; const api_InterpolateExpression: typeof InterpolateExpression;
-	type api_InvokeBlock = InvokeBlock; const api_InvokeBlock: typeof InvokeBlock;
-	type api_InvokeComponent = InvokeComponent; const api_InvokeComponent: typeof InvokeComponent;
-	type api_KeywordExpression = KeywordExpression; const api_KeywordExpression: typeof KeywordExpression;
-	type api_LiteralExpression = LiteralExpression; const api_LiteralExpression: typeof LiteralExpression;
+	type api_HtmlText = HtmlText;
+	 const api_HtmlText: typeof HtmlText;
+	type api_InterpolateExpression = InterpolateExpression;
+	 const api_InterpolateExpression: typeof InterpolateExpression;
+	type api_InvokeBlock = InvokeBlock;
+	 const api_InvokeBlock: typeof InvokeBlock;
+	type api_InvokeComponent = InvokeComponent;
+	 const api_InvokeComponent: typeof InvokeComponent;
+	type api_KeywordExpression = KeywordExpression;
+	 const api_KeywordExpression: typeof KeywordExpression;
+	type api_LiteralExpression = LiteralExpression;
+	 const api_LiteralExpression: typeof LiteralExpression;
 	type api_LiteralTypes = LiteralTypes;
 	type api_LiteralValue = LiteralValue;
-	type api_LocalVarReference = LocalVarReference; const api_LocalVarReference: typeof LocalVarReference;
-	type api_LooseModeResolution = LooseModeResolution; const api_LooseModeResolution: typeof LooseModeResolution; const api_MODIFIER_NAMESPACE: typeof MODIFIER_NAMESPACE;
-	type api_NamedArgument = NamedArgument; const api_NamedArgument: typeof NamedArgument;
-	type api_NamedArguments = NamedArguments; const api_NamedArguments: typeof NamedArguments;
-	type api_NamedBlock = NamedBlock; const api_NamedBlock: typeof NamedBlock;
+	type api_LocalVarReference = LocalVarReference;
+	 const api_LocalVarReference: typeof LocalVarReference;
+	type api_LooseModeResolution = LooseModeResolution;
+	 const api_LooseModeResolution: typeof LooseModeResolution;
+	 const api_MODIFIER_NAMESPACE: typeof MODIFIER_NAMESPACE;
+	type api_NamedArgument = NamedArgument;
+	 const api_NamedArgument: typeof NamedArgument;
+	type api_NamedArguments = NamedArguments;
+	 const api_NamedArguments: typeof NamedArguments;
+	type api_NamedBlock = NamedBlock;
+	 const api_NamedBlock: typeof NamedBlock;
 	type api_NamedBlockFields = NamedBlockFields;
-	type api_NamedBlocks = NamedBlocks; const api_NamedBlocks: typeof NamedBlocks;
+	type api_NamedBlocks = NamedBlocks;
+	 const api_NamedBlocks: typeof NamedBlocks;
 	type api_NodeConstructor<Fields> = NodeConstructor<Fields>;
-	type api_PathExpression = PathExpression; const api_PathExpression: typeof PathExpression;
-	type api_PositionalArguments = PositionalArguments; const api_PositionalArguments: typeof PositionalArguments; const api_STRICT_RESOLUTION: typeof STRICT_RESOLUTION;
+	type api_PathExpression = PathExpression;
+	 const api_PathExpression: typeof PathExpression;
+	type api_PositionalArguments = PositionalArguments;
+	 const api_PositionalArguments: typeof PositionalArguments;
+	 const api_STRICT_RESOLUTION: typeof STRICT_RESOLUTION;
 	type api_SerializedBaseNode = SerializedBaseNode;
 	type api_SerializedResolution = SerializedResolution;
-	type api_SimpleElement = SimpleElement; const api_SimpleElement: typeof SimpleElement;
-	type api_SplatAttr = SplatAttr; const api_SplatAttr: typeof SplatAttr;
+	type api_SimpleElement = SimpleElement;
+	 const api_SimpleElement: typeof SimpleElement;
+	type api_SplatAttr = SplatAttr;
+	 const api_SplatAttr: typeof SplatAttr;
 	type api_StrictResolution = StrictResolution;
 	type api_StringLiteral = StringLiteral;
-	type api_Template = Template; const api_Template: typeof Template;
-	type api_ThisReference = ThisReference; const api_ThisReference: typeof ThisReference;
+	type api_Template = Template;
+	 const api_Template: typeof Template;
+	type api_ThisReference = ThisReference;
+	 const api_ThisReference: typeof ThisReference;
 	type api_TypedNodeConstructor<T extends string, Fields> = TypedNodeConstructor<T, Fields>;
-	type api_VariableReference = VariableReference; const api_isLiteral: typeof isLiteral; const api_isStrictResolution: typeof isStrictResolution; const api_loadResolution: typeof loadResolution; const api_node: typeof node; namespace api {
+	type api_VariableReference = VariableReference;
+	 const api_isLiteral: typeof isLiteral;
+	 const api_isStrictResolution: typeof isStrictResolution;
+	 const api_loadResolution: typeof loadResolution;
+	 const api_node: typeof node;
+	 namespace api {
 	  export { api_AppendContent as AppendContent, api_ArgReference as ArgReference, api_Args as Args, type api_AttrBlockNode as AttrBlockNode, type api_AttrNode as AttrNode, type api_AttrNodeOptions as AttrNodeOptions, type api_BaseNodeFields as BaseNodeFields, api_Block as Block, api_COMPONENT_NAMESPACE as COMPONENT_NAMESPACE, api_CallExpression as CallExpression, type api_CallFields as CallFields, type api_CallNode as CallNode, type api_CalleeNode as CalleeNode, api_ComponentArg as ComponentArg, type api_ContentNode as ContentNode, api_ElementModifier as ElementModifier, type api_ElementNode as ElementNode, type api_ExpressionNode as ExpressionNode, api_FreeVarReference as FreeVarReference, type api_FreeVarResolution as FreeVarResolution, api_GlimmerComment as GlimmerComment, type api_GlimmerParentNodeOptions as GlimmerParentNodeOptions, api_HELPER_NAMESPACE as HELPER_NAMESPACE, api_HTML_RESOLUTION as HTML_RESOLUTION, api_HtmlAttr as HtmlAttr, api_HtmlComment as HtmlComment, type api_HtmlOrSplatAttr as HtmlOrSplatAttr, type api_HtmlResolution as HtmlResolution, api_HtmlText as HtmlText, api_InterpolateExpression as InterpolateExpression, api_InvokeBlock as InvokeBlock, api_InvokeComponent as InvokeComponent, api_KeywordExpression as KeywordExpression, api_LiteralExpression as LiteralExpression, type api_LiteralTypes as LiteralTypes, type api_LiteralValue as LiteralValue, api_LocalVarReference as LocalVarReference, api_LooseModeResolution as LooseModeResolution, api_MODIFIER_NAMESPACE as MODIFIER_NAMESPACE, api_NamedArgument as NamedArgument, api_NamedArguments as NamedArguments, api_NamedBlock as NamedBlock, type api_NamedBlockFields as NamedBlockFields, api_NamedBlocks as NamedBlocks, type api_NodeConstructor as NodeConstructor, api_PathExpression as PathExpression, api_PositionalArguments as PositionalArguments, api_STRICT_RESOLUTION as STRICT_RESOLUTION, type api_SerializedBaseNode as SerializedBaseNode, type api_SerializedResolution as SerializedResolution, api_SimpleElement as SimpleElement, api_SplatAttr as SplatAttr, type api_StrictResolution as StrictResolution, type api_StringLiteral as StringLiteral, api_Template as Template, api_ThisReference as ThisReference, type api_TypedNodeConstructor as TypedNodeConstructor, type api_VariableReference as VariableReference, api_isLiteral as isLiteral, api_isStrictResolution as isStrictResolution, api_loadResolution as loadResolution, api_node as node };
 	}
 
 	interface SymbolTableOptions {
 	    customizeComponentName: (input: string) => string;
 	    lexicalScope: (variable: string) => boolean;
-	} abstract class SymbolTable {
+	}
+	 abstract class SymbolTable {
 	    static top(locals: readonly string[], keywords: readonly string[], options: SymbolTableOptions): ProgramSymbolTable;
 	    abstract root(): ProgramSymbolTable;
 	    abstract has(name: string): boolean;
@@ -1528,7 +1965,8 @@ declare module '@glimmer/syntax' {
 	    abstract allocateBlock(name: string): number;
 	    abstract allocate(identifier: string): number;
 	    child(locals: string[]): BlockSymbolTable;
-	} class ProgramSymbolTable extends SymbolTable {
+	}
+	 class ProgramSymbolTable extends SymbolTable {
 	    private templateLocals;
 	    private keywords;
 	    private options;
@@ -1552,7 +1990,8 @@ declare module '@glimmer/syntax' {
 	    allocateNamed(name: string): number;
 	    allocateBlock(name: string): number;
 	    allocate(identifier: string): number;
-	} class BlockSymbolTable extends SymbolTable {
+	}
+	 class BlockSymbolTable extends SymbolTable {
 	    #private;
 	    private parent;
 	    symbols: string[];
@@ -1576,7 +2015,8 @@ declare module '@glimmer/syntax' {
 	interface GlimmerSyntaxError extends Error {
 	    location: SourceSpan | null;
 	    code: string | null;
-	} function generateSyntaxError(message: string, location: SourceSpan): GlimmerSyntaxError;
+	}
+	 function generateSyntaxError(message: string, location: SourceSpan): GlimmerSyntaxError;
 
 	interface TraversalErrorConstructor {
 	    new (message: string, node: Node, parent: Nullable<Node>, key: string): TraversalError;
@@ -1588,7 +2028,13 @@ declare module '@glimmer/syntax' {
 	    node: Node;
 	    parent: Nullable<Node>;
 	    stack?: string;
-	} const TraversalError: TraversalErrorConstructor; function cannotRemoveNode(node: Node, parent: Node, key: string): TraversalError; function cannotReplaceNode(node: Node, parent: Node, key: string): TraversalError; function normalize(source: Source, options?: PrecompileOptionsWithLexicalScope): [ast: Template, locals: string[]];
+	}
+	 const TraversalError: TraversalErrorConstructor;
+
+	 function cannotRemoveNode(node: Node, parent: Node, key: string): TraversalError;
+	 function cannotReplaceNode(node: Node, parent: Node, key: string): TraversalError;
+
+	 function normalize(source: Source, options?: PrecompileOptionsWithLexicalScope): [ast: Template, locals: string[]];
 
 	export { api$1 as AST, type ASTPlugin, type ASTPluginBuilder, type ASTPluginEnvironment, api$1 as ASTv1, api as ASTv2, BlockSymbolTable, type GlimmerSyntaxError, type HasSourceSpan, KEYWORDS_TYPES, type KeywordType, type MaybeHasSourceSpan, type NodeVisitor, Walker as Path, type PrecompileOptions, type PrecompileOptionsWithLexicalScope, type PreprocessOptions, ProgramSymbolTable, SourceSlice, SpanList, SymbolTable, type Syntax, type TemplateIdFn, Walker, WalkerPath, _default as builders, cannotRemoveNode, cannotReplaceNode, generateSyntaxError, getTemplateLocals, getVoidTags, hasSpan, isKeyword, isVoidTag, loc, maybeLoc, node, normalize, preprocess, build as print, sortByLoc, api$2 as src, traverse, visitorKeys };