@abapify/aclass 0.0.0 → 0.4.5

package/dist/index.mjs

@@ -0,0 +1,1593 @@
+import { t as __exportAll } from "./rolldown-runtime-w6R9maHv.mjs";
+import { Lexer, createToken } from "chevrotain";
+
+//#region src/tokens.ts
+/**
+* Chevrotain Token Definitions for the ABAP OO surface grammar.
+*
+* Scope: everything `@abapify/aclass` needs to tokenise a `.clas.abap` or
+* `.intf.abap` source file up to the point where method bodies become
+* opaque text. Method-body statements are NOT tokenised here — they are
+* captured verbatim by a dedicated body-capture token.
+*
+* ABAP is case-insensitive. All keywords use `/i` patterns so `CLASS`,
+* `Class`, and `class` all tokenise the same way.
+*
+* Keyword order inside `allTokens` matters:
+*   1. Multi-char operators before their single-char prefixes.
+*   2. Longer keywords before their prefixes (e.g. `CLASS-DATA` before
+*      `CLASS`, `INTERFACES` before `INTERFACE`, `NON-UNIQUE` before
+*      `UNIQUE`).
+*   3. `ABAPDocLine` BEFORE `LineComment` so `"! foo` is captured as
+*      documentation instead of as a regular line comment.
+*   4. `Identifier` must come last among the word-shaped tokens so that
+*      keywords win their matches via `longer_alt`.
+*/
+var tokens_exports = /* @__PURE__ */ __exportAll({
+	ABAPDocLine: () => ABAPDocLine,
+	Abstract: () => Abstract,
+	AclassLexer: () => AclassLexer,
+	Aliases: () => Aliases,
+	Ampersand: () => Ampersand,
+	Arrow: () => Arrow,
+	As: () => As,
+	At: () => At,
+	BacktickLiteral: () => BacktickLiteral,
+	Begin: () => Begin,
+	Changing: () => Changing,
+	Class: () => Class,
+	ClassData: () => ClassData,
+	ClassEvents: () => ClassEvents,
+	ClassMethods: () => ClassMethods,
+	Colon: () => Colon,
+	ColonColon: () => ColonColon,
+	Comma: () => Comma,
+	Constants: () => Constants,
+	Create: () => Create,
+	Data: () => Data,
+	Default: () => Default,
+	Deferred: () => Deferred,
+	Definition: () => Definition,
+	Dot: () => Dot,
+	Duration: () => Duration,
+	Empty: () => Empty,
+	End: () => End,
+	EndClass: () => EndClass,
+	EndInterface: () => EndInterface,
+	EndMethod: () => EndMethod,
+	Eq: () => Eq,
+	Events: () => Events,
+	Exporting: () => Exporting,
+	FatArrow: () => FatArrow,
+	Final: () => Final,
+	For: () => For,
+	From: () => From,
+	Gt: () => Gt,
+	Hash: () => Hash,
+	Hashed: () => Hashed,
+	Identifier: () => Identifier,
+	Implementation: () => Implementation,
+	Importing: () => Importing,
+	Inheriting: () => Inheriting,
+	IntegerLiteral: () => IntegerLiteral,
+	Interface: () => Interface,
+	Interfaces: () => Interfaces,
+	Key: () => Key,
+	LBrace: () => LBrace,
+	LBracket: () => LBracket,
+	LParen: () => LParen,
+	Level: () => Level,
+	Like: () => Like,
+	LineComment: () => LineComment,
+	Load: () => Load,
+	Lt: () => Lt,
+	Method: () => Method,
+	Methods: () => Methods,
+	Minus: () => Minus,
+	Newline: () => Newline,
+	NonUnique: () => NonUnique,
+	Of: () => Of,
+	Optional: () => Optional,
+	Pipe: () => Pipe,
+	Plus: () => Plus,
+	Private: () => Private,
+	Protected: () => Protected,
+	Public: () => Public,
+	Question: () => Question,
+	RBrace: () => RBrace,
+	RBracket: () => RBracket,
+	RParen: () => RParen,
+	Raising: () => Raising,
+	ReadOnly: () => ReadOnly,
+	Redefinition: () => Redefinition,
+	Ref: () => Ref,
+	Returning: () => Returning,
+	Risk: () => Risk,
+	Section: () => Section,
+	Slash: () => Slash,
+	Sorted: () => Sorted,
+	Standard: () => Standard,
+	Star: () => Star,
+	StarComment: () => StarComment,
+	StringLiteral: () => StringLiteral,
+	Table: () => Table,
+	Testing: () => Testing,
+	Tilde: () => Tilde,
+	To: () => To,
+	Type: () => Type,
+	Types: () => Types,
+	Unique: () => Unique,
+	Value: () => Value,
+	WhiteSpace: () => WhiteSpace,
+	With: () => With,
+	allTokens: () => allTokens
+});
+const WhiteSpace = createToken({
+	name: "WhiteSpace",
+	pattern: /[ \t]+/,
+	group: Lexer.SKIPPED
+});
+const Newline = createToken({
+	name: "Newline",
+	pattern: /\r?\n/,
+	group: Lexer.SKIPPED
+});
+/**
+* ABAPDoc line: `"! …` up to end of line. MUST come before LineComment
+* because `"!` is a prefix of `"`.
+*/
+const ABAPDocLine = createToken({
+	name: "ABAPDocLine",
+	pattern: /"![^\r\n]*/
+});
+/** Regular line comment: `" …` up to end of line. */
+const LineComment = createToken({
+	name: "LineComment",
+	pattern: /"[^\r\n]*/,
+	group: Lexer.SKIPPED
+});
+const starCommentPattern = {
+	line_breaks: false,
+	exec: (text, offset) => {
+		if (offset !== 0 && text.charCodeAt(offset - 1) !== 10) return null;
+		if (text.charCodeAt(offset) !== 42) return null;
+		let end = offset;
+		while (end < text.length) {
+			const c = text.charCodeAt(end);
+			if (c === 10 || c === 13) break;
+			end++;
+		}
+		return [text.slice(offset, end)];
+	}
+};
+const StarComment = createToken({
+	name: "StarComment",
+	pattern: starCommentPattern,
+	line_breaks: false,
+	group: Lexer.SKIPPED
+});
+/** Single-quoted ABAP text literal: `'...'` with doubled `''` for escaping. */
+const StringLiteral = createToken({
+	name: "StringLiteral",
+	pattern: /'(?:[^']|'')*'/
+});
+/** Backtick string literal: \`...\`. */
+const BacktickLiteral = createToken({
+	name: "BacktickLiteral",
+	pattern: /`(?:[^`]|``)*`/
+});
+const IntegerLiteral = createToken({
+	name: "IntegerLiteral",
+	pattern: /-?\d+/
+});
+/**
+* ABAP identifier: starts with letter or underscore; may contain letters,
+* digits, underscores, slash (for namespaces like `/ui2/cl_json`), and
+* tilde (for qualified names like `zif_foo~method`) — but tilde is
+* reserved for qualified references, so at the lexer level we only allow
+* the "simple" form here. Qualified `~` and `=>` are handled in the
+* parser via separate tokens.
+*
+* Note: the `=>` operator (static scope) is tokenised as a distinct
+* symbol, not as part of the identifier.
+*/
+const Identifier = createToken({
+	name: "Identifier",
+	pattern: /[A-Za-z_][A-Za-z0-9_/]*/
+});
+const REGEX_META = /[.*+?^${}()|[\]\\/-]/g;
+function kw(name, word) {
+	const pattern = new RegExp(word.replace(REGEX_META, "\\$&"), "i");
+	return createToken({
+		name,
+		pattern,
+		longer_alt: Identifier
+	});
+}
+const ClassMethods = kw("ClassMethods", "class-methods");
+const ClassData = kw("ClassData", "class-data");
+const ClassEvents = kw("ClassEvents", "class-events");
+const NonUnique = kw("NonUnique", "non-unique");
+const Class = kw("Class", "class");
+const Interfaces = kw("Interfaces", "interfaces");
+const Interface = kw("Interface", "interface");
+const EndClass = kw("EndClass", "endclass");
+const EndInterface = kw("EndInterface", "endinterface");
+const EndMethod = kw("EndMethod", "endmethod");
+const Definition = kw("Definition", "definition");
+const Implementation = kw("Implementation", "implementation");
+const Deferred = kw("Deferred", "deferred");
+const Load = kw("Load", "load");
+const Public = kw("Public", "public");
+const Protected = kw("Protected", "protected");
+const Private = kw("Private", "private");
+const Section = kw("Section", "section");
+const Methods = kw("Methods", "methods");
+const Method = kw("Method", "method");
+const Data = kw("Data", "data");
+const Types = kw("Types", "types");
+const Constants = kw("Constants", "constants");
+const Events = kw("Events", "events");
+const Aliases = kw("Aliases", "aliases");
+const Inheriting = kw("Inheriting", "inheriting");
+const From = kw("From", "from");
+const For = kw("For", "for");
+const Testing = kw("Testing", "testing");
+const Risk = kw("Risk", "risk");
+const Level = kw("Level", "level");
+const Duration = kw("Duration", "duration");
+const Final = kw("Final", "final");
+const Abstract = kw("Abstract", "abstract");
+const Create = kw("Create", "create");
+const Importing = kw("Importing", "importing");
+const Exporting = kw("Exporting", "exporting");
+const Changing = kw("Changing", "changing");
+const Returning = kw("Returning", "returning");
+const Raising = kw("Raising", "raising");
+const Value = kw("Value", "value");
+const Optional = kw("Optional", "optional");
+const Default = kw("Default", "default");
+const Redefinition = kw("Redefinition", "redefinition");
+const Type = kw("Type", "type");
+const Ref = kw("Ref", "ref");
+const To = kw("To", "to");
+const Like = kw("Like", "like");
+const Begin = kw("Begin", "begin");
+const End = kw("End", "end");
+const Of = kw("Of", "of");
+const Standard = kw("Standard", "standard");
+const Sorted = kw("Sorted", "sorted");
+const Hashed = kw("Hashed", "hashed");
+const Table = kw("Table", "table");
+const With = kw("With", "with");
+const Key = kw("Key", "key");
+const Empty = kw("Empty", "empty");
+const Unique = kw("Unique", "unique");
+const As = kw("As", "as");
+const ReadOnly = kw("ReadOnly", "read-only");
+/** Static scope operator: `=>` */
+const FatArrow = createToken({
+	name: "FatArrow",
+	pattern: /=>/
+});
+/** Instance member operator: `->` */
+const Arrow = createToken({
+	name: "Arrow",
+	pattern: /->/
+});
+/** Component selector inside generic reference: `::` (rare, reserved). */
+const ColonColon = createToken({
+	name: "ColonColon",
+	pattern: /::/
+});
+const Dot = createToken({
+	name: "Dot",
+	pattern: /\./
+});
+const Comma = createToken({
+	name: "Comma",
+	pattern: /,/
+});
+const Colon = createToken({
+	name: "Colon",
+	pattern: /:/
+});
+const Tilde = createToken({
+	name: "Tilde",
+	pattern: /~/
+});
+const LParen = createToken({
+	name: "LParen",
+	pattern: /\(/
+});
+const RParen = createToken({
+	name: "RParen",
+	pattern: /\)/
+});
+const LBracket = createToken({
+	name: "LBracket",
+	pattern: /\[/
+});
+const RBracket = createToken({
+	name: "RBracket",
+	pattern: /\]/
+});
+const Eq = createToken({
+	name: "Eq",
+	pattern: /=/
+});
+const Hash = createToken({
+	name: "Hash",
+	pattern: /#/
+});
+const Pipe = createToken({
+	name: "Pipe",
+	pattern: /\|/
+});
+const LBrace = createToken({
+	name: "LBrace",
+	pattern: /\{/
+});
+const RBrace = createToken({
+	name: "RBrace",
+	pattern: /\}/
+});
+const Plus = createToken({
+	name: "Plus",
+	pattern: /\+/
+});
+const Minus = createToken({
+	name: "Minus",
+	pattern: /-/
+});
+const Star = createToken({
+	name: "Star",
+	pattern: /\*/
+});
+const Slash = createToken({
+	name: "Slash",
+	pattern: /\//
+});
+const Lt = createToken({
+	name: "Lt",
+	pattern: /</
+});
+const Gt = createToken({
+	name: "Gt",
+	pattern: />/
+});
+const Question = createToken({
+	name: "Question",
+	pattern: /\?/
+});
+const At = createToken({
+	name: "At",
+	pattern: /@/
+});
+const Ampersand = createToken({
+	name: "Ampersand",
+	pattern: /&/
+});
+const allTokens = [
+	WhiteSpace,
+	Newline,
+	StarComment,
+	ABAPDocLine,
+	LineComment,
+	FatArrow,
+	Arrow,
+	ColonColon,
+	StringLiteral,
+	BacktickLiteral,
+	IntegerLiteral,
+	ClassMethods,
+	ClassData,
+	ClassEvents,
+	NonUnique,
+	ReadOnly,
+	Class,
+	Interfaces,
+	Interface,
+	EndClass,
+	EndInterface,
+	EndMethod,
+	Definition,
+	Implementation,
+	Deferred,
+	Load,
+	Public,
+	Protected,
+	Private,
+	Section,
+	Methods,
+	Method,
+	Data,
+	Types,
+	Constants,
+	Events,
+	Aliases,
+	Inheriting,
+	From,
+	For,
+	Testing,
+	Risk,
+	Level,
+	Duration,
+	Final,
+	Abstract,
+	Create,
+	Importing,
+	Exporting,
+	Changing,
+	Returning,
+	Raising,
+	Value,
+	Optional,
+	Default,
+	Redefinition,
+	Type,
+	Ref,
+	To,
+	Like,
+	As,
+	Begin,
+	End,
+	Of,
+	Standard,
+	Sorted,
+	Hashed,
+	Table,
+	With,
+	Key,
+	Empty,
+	Unique,
+	Identifier,
+	Dot,
+	Comma,
+	Colon,
+	Tilde,
+	LParen,
+	RParen,
+	LBracket,
+	RBracket,
+	Eq,
+	Hash,
+	Pipe,
+	LBrace,
+	RBrace,
+	Plus,
+	Minus,
+	Star,
+	Slash,
+	Lt,
+	Gt,
+	Question,
+	At,
+	Ampersand
+];
+const AclassLexer = new Lexer(allTokens, { positionTracking: "full" });
+
+//#endregion
+//#region src/errors.ts
+function fromLexError(err) {
+	return {
+		severity: "error",
+		message: err.message,
+		line: err.line ?? 1,
+		column: err.column ?? 1,
+		offset: err.offset,
+		length: err.length
+	};
+}
+function fromParseError(err) {
+	const token = err.token;
+	return {
+		severity: "error",
+		message: err.message,
+		line: token.startLine ?? 1,
+		column: token.startColumn ?? 1,
+		offset: token.startOffset,
+		length: (token.endOffset ?? token.startOffset) - token.startOffset + 1
+	};
+}
+
+//#endregion
+//#region src/lex.ts
+/**
+* Wave 0 entry point: tokenise an ABAP OO source string and return the
+* resulting token list along with any lex errors, normalised to
+* `ParseError`.
+*
+* Wave 1 replaces this with a full `parse()` that feeds the token list
+* into a Chevrotain `CstParser` and yields a typed AST. This function
+* stays around as the low-level primitive.
+*/
+function tokenize(source) {
+	const result = AclassLexer.tokenize(source);
+	return {
+		tokens: result.tokens,
+		errors: result.errors.map(fromLexError)
+	};
+}
+
+//#endregion
+//#region src/parser.ts
+/**
+* Parse an ABAP OO source file into a typed AST plus any diagnostics.
+* Returns a `{ ast, errors }` shape; never throws for malformed input.
+*/
+function parse(source) {
+	const errors = [];
+	const { tokens, errors: lexErrors } = tokenize(source);
+	errors.push(...lexErrors);
+	const definitions = [];
+	const cursor = new Cursor(tokens, source, errors);
+	try {
+		while (!cursor.eof()) {
+			const def = parseTopLevel(cursor);
+			if (def) definitions.push(def);
+		}
+	} catch (err) {
+		errors.push({
+			severity: "error",
+			message: `internal parser error: ${err instanceof Error ? err.message : String(err)}`,
+			line: 1,
+			column: 1,
+			offset: 0,
+			length: 0
+		});
+	}
+	return {
+		ast: {
+			kind: "AbapSourceFile",
+			source,
+			definitions
+		},
+		errors
+	};
+}
+var Cursor = class {
+	tokens;
+	source;
+	errors;
+	position = 0;
+	constructor(tokens, source, errors) {
+		this.tokens = tokens;
+		this.source = source;
+		this.errors = errors;
+	}
+	eof() {
+		return this.position >= this.tokens.length;
+	}
+	peek(offset = 0) {
+		return this.tokens[this.position + offset];
+	}
+	current() {
+		const t = this.tokens[this.position];
+		if (!t) throw new Error("Cursor.current() called past end of stream");
+		return t;
+	}
+	advance() {
+		const t = this.current();
+		this.position += 1;
+		return t;
+	}
+	matches(name, offset = 0) {
+		return this.peek(offset)?.tokenType.name === name;
+	}
+	/** Collect tokens up to (not including) the next `Dot` at top level. */
+	collectStatement() {
+		const collected = [];
+		const start = this.peek()?.startOffset ?? 0;
+		while (!this.eof()) {
+			const t = this.current();
+			if (t.tokenType.name === "Dot") {
+				this.advance();
+				return {
+					tokens: collected,
+					terminator: t,
+					startOffset: start,
+					endOffset: t.endOffset ?? t.startOffset
+				};
+			}
+			collected.push(t);
+			this.advance();
+		}
+		return {
+			tokens: collected,
+			startOffset: start,
+			endOffset: collected[collected.length - 1]?.endOffset ?? start
+		};
+	}
+	/** Accumulate consecutive ABAPDoc lines at the current position. */
+	consumeAbapDoc() {
+		const doc = [];
+		while (this.matches("ABAPDocLine")) {
+			const t = this.advance();
+			doc.push(t.image.replace(/^"!\s?/, ""));
+		}
+		return doc.length > 0 ? doc : void 0;
+	}
+	report(message, at, severity = "error") {
+		this.errors.push({
+			severity,
+			message,
+			line: at.startLine ?? 1,
+			column: at.startColumn ?? 1,
+			offset: at.startOffset,
+			length: (at.endOffset ?? at.startOffset) - at.startOffset + 1
+		});
+	}
+	sliceSource(startOffset, endOffset) {
+		return this.source.slice(startOffset, endOffset + 1);
+	}
+	/**
+	* Return the first token whose start offset is greater than or equal
+	* to the given offset. Useful for recovering line/column metadata for
+	* a source-slice boundary that doesn't land on a token (e.g. the
+	* start of a method body, which is usually whitespace).
+	*/
+	firstTokenAtOrAfter(offset) {
+		for (const t of this.tokens) if (t.startOffset >= offset) return t;
+	}
+};
+function parseTopLevel(c) {
+	const abapDoc = c.consumeAbapDoc();
+	if (c.eof()) return null;
+	const t = c.current();
+	const name = t.tokenType.name;
+	if (name === "Class") return parseClassOrImpl(c, abapDoc);
+	if (name === "Interface") return parseInterface(c, abapDoc);
+	c.report(`unexpected top-level token "${t.image}"`, t);
+	c.collectStatement();
+	return null;
+}
+function parseClassOrImpl(c, abapDoc) {
+	const classTok = c.current();
+	const startOffset = classTok.startOffset;
+	const startLine = classTok.startLine ?? 1;
+	const startColumn = classTok.startColumn ?? 1;
+	const header = c.collectStatement();
+	const tokens = header.tokens;
+	if (tokens[0]?.tokenType.name !== "Class") {
+		c.report("expected CLASS keyword", classTok);
+		return null;
+	}
+	const nameTok = tokens[1];
+	if (!nameTok || nameTok.tokenType.name !== "Identifier") {
+		c.report("expected class name after CLASS", nameTok ?? classTok);
+		return null;
+	}
+	const kindTok = tokens[2];
+	if (!kindTok) {
+		c.report("expected DEFINITION or IMPLEMENTATION after class name", nameTok);
+		return null;
+	}
+	if (kindTok.tokenType.name === "Implementation") return parseClassImpl(c, nameTok.image, {
+		startOffset,
+		endOffset: header.endOffset,
+		startLine,
+		startColumn
+	});
+	if (kindTok.tokenType.name !== "Definition") {
+		c.report(`expected DEFINITION or IMPLEMENTATION, got "${kindTok.image}"`, kindTok);
+		return null;
+	}
+	return parseClassDef(c, tokens, abapDoc, {
+		startOffset,
+		endOffset: header.endOffset,
+		startLine,
+		startColumn
+	});
+}
+function parseClassDef(c, headerTokens, abapDoc, headerSpan) {
+	const name = headerTokens[1].image;
+	const mods = headerTokens.slice(3);
+	if (mods.some((t) => t.tokenType.name === "Deferred" || t.tokenType.name === "Load")) return {
+		kind: "ClassDef",
+		name,
+		abapDoc,
+		isFinal: false,
+		isAbstract: false,
+		isForTesting: false,
+		createVisibility: "public",
+		sections: [],
+		span: headerSpan
+	};
+	let isFinal = false;
+	let isAbstract = false;
+	let isForTesting = false;
+	let createVisibility = "public";
+	let superClass;
+	for (let i = 0; i < mods.length; i++) switch (mods[i].tokenType.name) {
+		case "Public": break;
+		case "Final":
+			isFinal = true;
+			break;
+		case "Abstract":
+			isAbstract = true;
+			break;
+		case "Inheriting": {
+			const from = mods[i + 1];
+			const sup = mods[i + 2];
+			if (from?.tokenType.name === "From" && sup) {
+				superClass = sup.image;
+				i += 2;
+			}
+			break;
+		}
+		case "Create": {
+			const v = mods[i + 1];
+			if (v?.tokenType.name === "Private") createVisibility = "private";
+			else if (v?.tokenType.name === "Protected") createVisibility = "protected";
+			else createVisibility = "public";
+			i += 1;
+			break;
+		}
+		case "For": if (mods[i + 1]?.tokenType.name === "Testing") isForTesting = true;
+	}
+	const sections = [];
+	while (!c.eof() && !c.matches("EndClass")) {
+		const sec = parseSection(c);
+		if (sec) sections.push(sec);
+		else break;
+	}
+	if (c.matches("EndClass")) c.collectStatement();
+	else c.report(`unterminated CLASS ${name} DEFINITION — expected ENDCLASS`, headerTokens[0]);
+	return {
+		kind: "ClassDef",
+		name,
+		abapDoc,
+		isFinal,
+		isAbstract,
+		isForTesting,
+		createVisibility,
+		superClass,
+		sections,
+		span: headerSpan
+	};
+}
+function parseClassImpl(c, name, headerSpan) {
+	const methods = [];
+	while (!c.eof() && !c.matches("EndClass")) {
+		c.consumeAbapDoc();
+		if (c.eof() || c.matches("EndClass")) break;
+		if (!c.matches("Method")) {
+			if (c.collectStatement().tokens.length === 0) break;
+			continue;
+		}
+		const mi = parseMethodImpl(c);
+		if (mi) methods.push(mi);
+	}
+	if (c.matches("EndClass")) c.collectStatement();
+	else c["errors"].push({
+		severity: "error",
+		message: `unterminated CLASS ${name} IMPLEMENTATION — expected ENDCLASS`,
+		line: headerSpan.startLine,
+		column: headerSpan.startColumn,
+		offset: headerSpan.startOffset,
+		length: headerSpan.endOffset - headerSpan.startOffset + 1
+	});
+	return {
+		kind: "ClassImpl",
+		name,
+		methods,
+		span: headerSpan
+	};
+}
+function parseMethodImpl(c) {
+	const methodTok = c.current();
+	const header = c.collectStatement();
+	const qual = readQualifiedName(header.tokens, 1);
+	if (!qual) {
+		c.report("expected method name after METHOD", header.tokens[1] ?? methodTok);
+		return null;
+	}
+	const bodyStart = header.endOffset + 1;
+	while (!c.eof()) {
+		if (c.matches("EndMethod")) {
+			const endMethodStart = c.current().startOffset;
+			const stmt = c.collectStatement();
+			const bodyEnd = endMethodStart - 1;
+			const totalEnd = stmt.endOffset;
+			const body = c["sliceSource"](bodyStart, bodyEnd);
+			const firstBodyTok = c.firstTokenAtOrAfter(bodyStart);
+			const bodyLine = firstBodyTok?.startLine ?? methodTok.startLine ?? 1;
+			const bodyCol = firstBodyTok?.startColumn ?? 1;
+			return {
+				kind: "MethodImpl",
+				name: qual.name,
+				body,
+				bodySpan: {
+					startOffset: bodyStart,
+					endOffset: bodyEnd,
+					startLine: bodyLine,
+					startColumn: bodyCol
+				},
+				span: {
+					startOffset: methodTok.startOffset,
+					endOffset: totalEnd,
+					startLine: methodTok.startLine ?? 1,
+					startColumn: methodTok.startColumn ?? 1
+				}
+			};
+		}
+		c.advance();
+	}
+	c.report("ENDMETHOD not found for METHOD block", methodTok);
+	return null;
+}
+function parseInterface(c, abapDoc) {
+	const ifaceTok = c.current();
+	const header = c.collectStatement();
+	const tokens = header.tokens;
+	if (tokens[0]?.tokenType.name !== "Interface") {
+		c.report("expected INTERFACE keyword", ifaceTok);
+		return null;
+	}
+	const nameTok = tokens[1];
+	if (!nameTok || nameTok.tokenType.name !== "Identifier") {
+		c.report("expected interface name after INTERFACE", nameTok ?? ifaceTok);
+		return null;
+	}
+	const isPublic = tokens.slice(2).some((t) => t.tokenType.name === "Public");
+	const members = [];
+	while (!c.eof() && !c.matches("EndInterface")) {
+		const m = parseMember(c);
+		if (m) members.push(m);
+		else break;
+	}
+	if (c.matches("EndInterface")) c.collectStatement();
+	return {
+		kind: "InterfaceDef",
+		name: nameTok.image,
+		abapDoc,
+		isPublic,
+		members,
+		span: {
+			startOffset: ifaceTok.startOffset,
+			endOffset: header.endOffset,
+			startLine: ifaceTok.startLine ?? 1,
+			startColumn: ifaceTok.startColumn ?? 1
+		}
+	};
+}
+function parseSection(c) {
+	c.consumeAbapDoc();
+	if (c.eof()) return null;
+	const first = c.current();
+	let visibility;
+	if (first.tokenType.name === "Public") visibility = "public";
+	else if (first.tokenType.name === "Protected") visibility = "protected";
+	else if (first.tokenType.name === "Private") visibility = "private";
+	else return null;
+	const header = c.collectStatement();
+	const sectionStart = header.startOffset;
+	const members = [];
+	while (!c.eof() && !isSectionBoundary(c)) {
+		const m = parseMember(c);
+		if (m) members.push(m);
+		else break;
+	}
+	const end = members.length > 0 ? members[members.length - 1].span.endOffset : header.endOffset;
+	return {
+		kind: "Section",
+		visibility,
+		members,
+		span: {
+			startOffset: sectionStart,
+			endOffset: end,
+			startLine: first.startLine ?? 1,
+			startColumn: first.startColumn ?? 1
+		}
+	};
+}
+function isSectionBoundary(c) {
+	if (c.matches("EndClass")) return true;
+	if (c.matches("EndInterface")) return true;
+	const t = c.peek();
+	if (!t) return true;
+	if (t.tokenType.name === "Public" || t.tokenType.name === "Protected" || t.tokenType.name === "Private") return c.peek(1)?.tokenType.name === "Section";
+	return false;
+}
+function parseMember(c) {
+	const abapDoc = c.consumeAbapDoc();
+	if (c.eof()) return null;
+	const head = c.current();
+	switch (head.tokenType.name) {
+		case "Methods":
+		case "ClassMethods": return parseMethodDecl(c, abapDoc);
+		case "Data":
+		case "ClassData": return parseAttributeDecl(c, abapDoc);
+		case "Types": return parseTypeDecl(c, abapDoc);
+		case "Constants": return parseConstantDecl(c, abapDoc);
+		case "Events":
+		case "ClassEvents": return parseEventDecl(c, abapDoc);
+		case "Interfaces": return parseInterfaceStmt(c, abapDoc);
+		case "Aliases": return parseAliasDecl(c, abapDoc);
+		default: {
+			const stmt = c.collectStatement();
+			return {
+				kind: "RawMember",
+				source: c["sliceSource"](stmt.startOffset, stmt.endOffset),
+				abapDoc,
+				span: {
+					startOffset: stmt.startOffset,
+					endOffset: stmt.endOffset,
+					startLine: head.startLine ?? 1,
+					startColumn: head.startColumn ?? 1
+				}
+			};
+		}
+	}
+}
+function parseMethodDecl(c, abapDoc) {
+	const head = c.current();
+	const isClassMethod = head.tokenType.name === "ClassMethods";
+	const stmt = c.collectStatement();
+	const toks = stmt.tokens;
+	const qual = readQualifiedName(toks, 1);
+	if (!qual) {
+		c.report("expected method name", toks[1] ?? head);
+		return null;
+	}
+	const importing = [];
+	const exporting = [];
+	const changing = [];
+	let returning;
+	const raising = [];
+	let isAbstract = false;
+	let isFinal = false;
+	let isRedefinition = false;
+	let isForTesting = false;
+	let section = "none";
+	let i = qual.lastIdx + 1;
+	while (i < toks.length) {
+		const t = toks[i];
+		const tn = t.tokenType.name;
+		if (tn === "Abstract") {
+			isAbstract = true;
+			i += 1;
+			continue;
+		}
+		if (tn === "Final") {
+			isFinal = true;
+			i += 1;
+			continue;
+		}
+		if (tn === "Redefinition") {
+			isRedefinition = true;
+			i += 1;
+			continue;
+		}
+		if (tn === "For" && toks[i + 1]?.tokenType.name === "Testing") {
+			isForTesting = true;
+			i += 2;
+			continue;
+		}
+		if (tn === "Importing") {
+			section = "importing";
+			i += 1;
+			continue;
+		}
+		if (tn === "Exporting") {
+			section = "exporting";
+			i += 1;
+			continue;
+		}
+		if (tn === "Changing") {
+			section = "changing";
+			i += 1;
+			continue;
+		}
+		if (tn === "Returning") {
+			section = "returning";
+			i += 1;
+			continue;
+		}
+		if (tn === "Raising") {
+			section = "raising";
+			i += 1;
+			continue;
+		}
+		if (section === "raising") {
+			if (tn === "Identifier") {
+				raising.push(t.image);
+				i += 1;
+				continue;
+			}
+			i += 1;
+			continue;
+		}
+		if (section === "none") {
+			i += 1;
+			continue;
+		}
+		const consumed = consumeMethodParam(toks, i, c);
+		if (!consumed) break;
+		const { param, nextIndex } = consumed;
+		if (section === "importing") importing.push(param);
+		else if (section === "exporting") exporting.push(param);
+		else if (section === "changing") changing.push(param);
+		else if (section === "returning") returning = param;
+		i = nextIndex;
+	}
+	return {
+		kind: "MethodDecl",
+		name: qual.name,
+		abapDoc,
+		isClassMethod,
+		isAbstract,
+		isFinal,
+		isRedefinition,
+		isForTesting,
+		importing,
+		exporting,
+		changing,
+		returning,
+		raising,
+		span: spanFromStmt(stmt, head)
+	};
+}
+function consumeMethodParam(toks, start, c) {
+	let i = start;
+	let isValue = false;
+	if (toks[i]?.tokenType.name === "Value" && toks[i + 1]?.tokenType.name === "LParen") {
+		isValue = true;
+		const nameTok = toks[i + 2];
+		if (!isNameLike(nameTok)) return null;
+		if (toks[i + 3]?.tokenType.name !== "RParen") return null;
+		i += 4;
+		const paramName = nameTok.image;
+		return parseParamTail(toks, i, c, paramName, isValue);
+	}
+	const nameTok = toks[i];
+	if (!isNameLike(nameTok)) return null;
+	i += 1;
+	return parseParamTail(toks, i, c, nameTok.image, isValue);
+}
+function parseParamTail(toks, start, c, name, isValue) {
+	let i = start;
+	if (toks[i]?.tokenType.name !== "Type") {
+		c.report("expected TYPE in parameter declaration", toks[i] ?? toks[start - 1]);
+		return null;
+	}
+	i += 1;
+	const typeRes = consumeTypeRef(toks, i, c);
+	if (!typeRes) return null;
+	const type = typeRes.type;
+	i = typeRes.nextIndex;
+	let isOptional = false;
+	let defaultValue;
+	while (i < toks.length) {
+		const tn = toks[i].tokenType.name;
+		if (tn === "Optional") {
+			isOptional = true;
+			i += 1;
+			continue;
+		}
+		if (tn === "Default") {
+			i += 1;
+			const startTok = toks[i];
+			if (!startTok) break;
+			const valStart = startTok.startOffset;
+			let valEnd = startTok.endOffset ?? startTok.startOffset;
+			while (i < toks.length) {
+				const nt = toks[i]?.tokenType.name;
+				if (nt === "Optional" || nt === "Importing" || nt === "Exporting" || nt === "Changing" || nt === "Returning" || nt === "Raising") break;
+				valEnd = toks[i].endOffset ?? valEnd;
+				i += 1;
+				if (i < toks.length && toks[i]?.tokenType.name === "Identifier") break;
+			}
+			defaultValue = c["sliceSource"](valStart, valEnd);
+			continue;
+		}
+		break;
+	}
+	const startTok = toks[start - (isValue ? 4 : 1)];
+	const endTok = toks[i - 1] ?? startTok;
+	return {
+		param: {
+			kind: "MethodParam",
+			name,
+			type,
+			isValue,
+			isOptional,
+			defaultValue,
+			span: {
+				startOffset: startTok.startOffset,
+				endOffset: endTok.endOffset ?? endTok.startOffset,
+				startLine: startTok.startLine ?? 1,
+				startColumn: startTok.startColumn ?? 1
+			}
+		},
+		nextIndex: i
+	};
+}
+/**
+* Shared body for member declarations shaped like `<head> <name> TYPE
+* <typeref> [rest…]`. Returns `{ nameTok, typeRes, toks, stmt, tailIdx }`
+* where `tailIdx` is the index of the first token AFTER the type-ref so
+* callers can inspect modifiers such as `READ-ONLY` / `VALUE <lit>`.
+*/
+function parseNameTypeStatement(c, expectation) {
+	const head = c.current();
+	const stmt = c.collectStatement();
+	const toks = stmt.tokens;
+	const nameTok = toks[1];
+	if (!nameTok || nameTok.tokenType.name !== "Identifier") {
+		c.report(`expected ${expectation.name}`, nameTok ?? head);
+		return null;
+	}
+	if (toks[2]?.tokenType.name !== "Type") {
+		c.report(`expected TYPE in ${expectation.type}`, toks[2] ?? head);
+		return null;
+	}
+	const typeRes = consumeTypeRef(toks, 3, c);
+	if (!typeRes) return null;
+	return {
+		nameTok,
+		typeRes,
+		toks,
+		stmt,
+		tailIdx: typeRes.nextIndex
+	};
+}
+function parseAttributeDecl(c, abapDoc) {
+	const head = c.current();
+	const isClassData = head.tokenType.name === "ClassData";
+	const parsed = parseNameTypeStatement(c, {
+		name: "attribute name",
+		type: "attribute declaration"
+	});
+	if (!parsed) return null;
+	const { nameTok, typeRes, toks, stmt, tailIdx } = parsed;
+	const isReadOnly = toks[tailIdx]?.tokenType.name === "ReadOnly";
+	return {
+		kind: "AttributeDecl",
+		name: nameTok.image,
+		abapDoc,
+		isClassData,
+		isReadOnly,
+		type: typeRes.type,
+		span: spanFromStmt(stmt, head)
+	};
+}
+function parseTypeDecl(c, abapDoc) {
+	const head = c.current();
+	const first = c.peek(1);
+	const second = c.peek(2);
+	const third = c.peek(3);
+	if (first?.tokenType.name === "Colon" && second?.tokenType.name === "Begin" && third?.tokenType.name === "Of") return parseStructureTypes(c, abapDoc);
+	const parsed = parseNameTypeStatement(c, {
+		name: "type name after TYPES",
+		type: "TYPES declaration"
+	});
+	if (!parsed) return null;
+	const { nameTok, typeRes, stmt } = parsed;
+	return {
+		kind: "TypeDecl",
+		name: nameTok.image,
+		abapDoc,
+		shape: {
+			kind: "alias",
+			type: typeRes.type
+		},
+		span: spanFromStmt(stmt, head)
+	};
+}
+function parseStructureTypes(c, abapDoc) {
+	const head = c.current();
+	const stmt = c.collectStatement();
+	const toks = stmt.tokens;
+	const nameTok = toks[4];
+	if (!nameTok || nameTok.tokenType.name !== "Identifier") {
+		c.report("expected struct name in BEGIN OF", nameTok ?? head);
+		return null;
+	}
+	const structName = nameTok.image;
+	let endIdx = -1;
+	for (let k = 5; k < toks.length - 1; k++) if (toks[k].tokenType.name === "End" && toks[k + 1]?.tokenType.name === "Of") {
+		endIdx = k;
+		break;
+	}
+	const fieldsEnd = endIdx >= 0 ? endIdx : toks.length;
+	const fields = [];
+	parseFieldRun(toks.slice(5, fieldsEnd), fields, c);
+	return {
+		kind: "TypeDecl",
+		name: structName,
+		abapDoc,
+		shape: {
+			kind: "structure",
+			fields
+		},
+		span: {
+			startOffset: head.startOffset,
+			endOffset: stmt.endOffset,
+			startLine: head.startLine ?? 1,
+			startColumn: head.startColumn ?? 1
+		}
+	};
+}
+function parseFieldRun(toks, out, c) {
+	let i = 0;
+	while (i < toks.length) {
+		if (toks[i]?.tokenType.name === "Comma") {
+			i += 1;
+			continue;
+		}
+		const nameTok = toks[i];
+		if (!isNameLike(nameTok)) {
+			while (i < toks.length && toks[i].tokenType.name !== "Comma") i += 1;
+			continue;
+		}
+		if (toks[i + 1]?.tokenType.name !== "Type") {
+			i += 1;
+			continue;
+		}
+		let j = i + 2;
+		const typeStart = j;
+		while (j < toks.length && toks[j].tokenType.name !== "Comma") j += 1;
+		const typeRes = consumeTypeRef(toks, typeStart, c, j);
+		if (typeRes) {
+			const last = toks[j - 1] ?? nameTok;
+			out.push({
+				kind: "StructureField",
+				name: nameTok.image,
+				type: typeRes.type,
+				span: {
+					startOffset: nameTok.startOffset,
+					endOffset: last.endOffset ?? last.startOffset,
+					startLine: nameTok.startLine ?? 1,
+					startColumn: nameTok.startColumn ?? 1
+				}
+			});
+		}
+		i = j;
+	}
+}
+function parseConstantDecl(c, abapDoc) {
+	const head = c.current();
+	const stmt = c.collectStatement();
+	const toks = stmt.tokens;
+	const nameTok = toks[1];
+	if (!nameTok || nameTok.tokenType.name !== "Identifier") {
+		c.report("expected constant name", nameTok ?? head);
+		return null;
+	}
+	if (toks[2]?.tokenType.name !== "Type") {
+		c.report("expected TYPE in CONSTANTS", toks[2] ?? head);
+		return null;
+	}
+	let vIdx = -1;
+	for (let k = 3; k < toks.length; k++) if (toks[k].tokenType.name === "Value") {
+		vIdx = k;
+		break;
+	}
+	if (vIdx < 0) {
+		c.report("expected VALUE in CONSTANTS", head);
+		return null;
+	}
+	const typeRes = consumeTypeRef(toks, 3, c, vIdx);
+	if (!typeRes) return null;
+	const valueStart = toks[vIdx + 1]?.startOffset ?? 0;
+	const valueEnd = toks[toks.length - 1]?.endOffset ?? valueStart;
+	const value = c["sliceSource"](valueStart, valueEnd);
+	return {
+		kind: "ConstantDecl",
+		name: nameTok.image,
+		abapDoc,
+		type: typeRes.type,
+		value,
+		span: spanFromStmt(stmt, head)
+	};
+}
+function parseEventDecl(c, abapDoc) {
+	const head = c.current();
+	const isClassEvent = head.tokenType.name === "ClassEvents";
+	const stmt = c.collectStatement();
+	const toks = stmt.tokens;
+	const nameTok = toks[1];
+	if (!isNameLike(nameTok)) {
+		c.report("expected event name", nameTok ?? head);
+		return null;
+	}
+	const exporting = [];
+	if (toks[2]?.tokenType.name === "Exporting") {
+		let i = 3;
+		while (i < toks.length) {
+			const consumed = consumeMethodParam(toks, i, c);
+			if (!consumed) break;
+			exporting.push(consumed.param);
+			i = consumed.nextIndex;
+		}
+	}
+	return {
+		kind: "EventDecl",
+		name: nameTok.image,
+		abapDoc,
+		isClassEvent,
+		exporting,
+		span: spanFromStmt(stmt, head)
+	};
+}
+function parseInterfaceStmt(c, abapDoc) {
+	const head = c.current();
+	const stmt = c.collectStatement();
+	const nameTok = stmt.tokens[1];
+	if (!nameTok || nameTok.tokenType.name !== "Identifier") {
+		c.report("expected interface name after INTERFACES", nameTok ?? head);
+		return null;
+	}
+	return {
+		kind: "InterfaceStmt",
+		name: nameTok.image,
+		abapDoc,
+		span: spanFromStmt(stmt, head)
+	};
+}
+function parseAliasDecl(c, abapDoc) {
+	const head = c.current();
+	const stmt = c.collectStatement();
+	const toks = stmt.tokens;
+	const nameTok = toks[1];
+	if (!nameTok || nameTok.tokenType.name !== "Identifier") {
+		c.report("expected alias name", nameTok ?? head);
+		return null;
+	}
+	if (toks[2]?.tokenType.name !== "For") {
+		c.report("expected FOR in ALIASES", toks[2] ?? head);
+		return null;
+	}
+	const targetStart = toks[3]?.startOffset ?? 0;
+	const targetEnd = toks[toks.length - 1]?.endOffset ?? targetStart;
+	const target = c["sliceSource"](targetStart, targetEnd);
+	return {
+		kind: "AliasDecl",
+		name: nameTok.image,
+		target,
+		abapDoc,
+		span: spanFromStmt(stmt, head)
+	};
+}
+function consumeTypeRef(toks, start, c, endBound) {
+	const limit = endBound ?? toks.length;
+	const i = start;
+	if (i >= limit) {
+		c.report("expected type reference", toks[i - 1] ?? toks[0]);
+		return null;
+	}
+	if (toks[i]?.tokenType.name === "Ref" && toks[i + 1]?.tokenType.name === "To") {
+		const inner = consumeTypeRef(toks, i + 2, c, limit);
+		if (!inner) return null;
+		const startTok = toks[i];
+		const lastTok = toks[inner.nextIndex - 1] ?? startTok;
+		return {
+			type: {
+				kind: "RefToTypeRef",
+				target: inner.type,
+				source: c["sliceSource"](startTok.startOffset, lastTok.endOffset ?? lastTok.startOffset)
+			},
+			nextIndex: inner.nextIndex
+		};
+	}
+	const tableKind = peekTableKind(toks, i);
+	if (tableKind) return consumeTableTypeRef(toks, i, c, limit, tableKind);
+	const startTok = toks[i];
+	if (!isNameLike(startTok)) {
+		const at = toks[i] ?? toks[i - 1] ?? toks[0];
+		const label = at ? at.image : "<eof>";
+		c.report(`expected type name, got "${label}"`, at);
+		return null;
+	}
+	let lastIdx = i;
+	const nameParts = [startTok.image];
+	let j = i + 1;
+	while (j < limit) {
+		const t = toks[j]?.tokenType.name;
+		if (t === "FatArrow" || t === "Tilde") {
+			const next = toks[j + 1];
+			if (!isNameLike(next)) break;
+			nameParts.push(t === "FatArrow" ? "=>" : "~", next.image);
+			lastIdx = j + 1;
+			j += 2;
+			continue;
+		}
+		break;
+	}
+	const lastTok = toks[lastIdx];
+	const source = c["sliceSource"](startTok.startOffset, lastTok.endOffset ?? lastTok.startOffset);
+	const fullName = nameParts.join("");
+	return {
+		type: isBuiltinName(fullName) ? {
+			kind: "BuiltinTypeRef",
+			name: fullName,
+			source
+		} : {
+			kind: "NamedTypeRef",
+			name: fullName,
+			source
+		},
+		nextIndex: lastIdx + 1
+	};
+}
+function peekTableKind(toks, i) {
+	const t = toks[i]?.tokenType.name;
+	if (t === "Standard" && toks[i + 1]?.tokenType.name === "Table") return "standard";
+	if (t === "Sorted" && toks[i + 1]?.tokenType.name === "Table") return "sorted";
+	if (t === "Hashed" && toks[i + 1]?.tokenType.name === "Table") return "hashed";
+	return null;
+}
+function consumeTableTypeRef(toks, start, c, limit, tableKind) {
+	let i = start + 2;
+	if (toks[i]?.tokenType.name !== "Of") {
+		c.report("expected OF in TABLE OF", toks[i] ?? toks[start]);
+		return fallbackTable(toks, start, i, tableKind, c);
+	}
+	i += 1;
+	const rowRes = consumeTypeRef(toks, i, c, limit);
+	if (!rowRes) return fallbackTable(toks, start, i, tableKind, c);
+	i = rowRes.nextIndex;
+	const keyStart = i;
+	while (i < limit) i += 1;
+	const keyTokens = toks.slice(keyStart, limit);
+	const keyClause = keyTokens.length > 0 ? c["sliceSource"](keyTokens[0].startOffset, keyTokens[keyTokens.length - 1].endOffset ?? keyTokens[keyTokens.length - 1].startOffset) : "";
+	const startTok = toks[start];
+	const lastTok = toks[limit - 1] ?? startTok;
+	return {
+		type: {
+			kind: "TableTypeRef",
+			tableKind,
+			row: rowRes.type,
+			keyClause,
+			source: c["sliceSource"](startTok.startOffset, lastTok.endOffset ?? lastTok.startOffset)
+		},
+		nextIndex: i
+	};
+}
+function fallbackTable(toks, start, i, tableKind, c) {
+	const startTok = toks[start];
+	const lastTok = toks[i - 1] ?? startTok;
+	return {
+		type: {
+			kind: "TableTypeRef",
+			tableKind,
+			row: {
+				kind: "NamedTypeRef",
+				name: "?",
+				source: "?"
+			},
+			keyClause: "",
+			source: c["sliceSource"](startTok.startOffset, lastTok.endOffset ?? lastTok.startOffset)
+		},
+		nextIndex: i
+	};
+}
+function spanFromStmt(stmt, anchor) {
+	return {
+		startOffset: stmt.startOffset,
+		endOffset: stmt.endOffset,
+		startLine: anchor.startLine ?? 1,
+		startColumn: anchor.startColumn ?? 1
+	};
+}
+/**
+* True when the token can legally appear in a position that expects an
+* ABAP identifier (type name, field name, parameter name, qualified part).
+*
+* The ABAP grammar allows many reserved words to be reused as names in
+* declaration positions — e.g. `DATA data TYPE i.`, `METHODS foo IMPORTING
+* type TYPE string.`, `TYPES: BEGIN OF x, data TYPE i, END OF x.`.
+* At the lexer level those tokens are classified as keywords; the parser
+* has to reinterpret them contextually.
+*
+* We accept: `Identifier`, plus any token whose `image` is a plain ABAP
+* identifier (starts with letter/underscore, only contains the chars a
+* real identifier would). This keeps the rule cheap (no huge keyword
+* allowlist) and catches every keyword that can legally be a name.
+*/
+/**
+* Read a possibly-qualified ABAP name starting at `start`: a chain of
+* identifier-shaped tokens separated by `~` (interface member) or `=>`
+* (static scope). Returns the joined `image` plus the last-consumed
+* index, or `null` if the head token is not name-like.
+*
+*   `zif_foo~bar`   → `{ name: 'zif_foo~bar', lastIdx: start + 2 }`
+*   `zcl_x=>method` → `{ name: 'zcl_x=>method', lastIdx: start + 2 }`
+*   `plain_name`    → `{ name: 'plain_name',  lastIdx: start }`
+*/
+function readQualifiedName(toks, start) {
+	const head = toks[start];
+	if (!isNameLike(head)) return null;
+	const parts = [head.image];
+	let lastIdx = start;
+	let j = start + 1;
+	while (j < toks.length) {
+		const sep = toks[j]?.tokenType.name;
+		if (sep !== "Tilde" && sep !== "FatArrow") break;
+		const next = toks[j + 1];
+		if (!isNameLike(next)) break;
+		parts.push(sep === "Tilde" ? "~" : "=>", next.image);
+		lastIdx = j + 1;
+		j += 2;
+	}
+	return {
+		name: parts.join(""),
+		lastIdx
+	};
+}
+function isNameLike(t) {
+	if (!t) return false;
+	if (t.tokenType.name === "Identifier") return true;
+	return /^[A-Za-z_][A-Za-z0-9_/]*$/.test(t.image);
+}
+const BUILTIN_ABAP_TYPES = /* @__PURE__ */ new Set([
+	"string",
+	"xstring",
+	"i",
+	"int8",
+	"int4",
+	"int2",
+	"int1",
+	"f",
+	"p",
+	"c",
+	"n",
+	"d",
+	"t",
+	"decfloat16",
+	"decfloat34",
+	"timestampl",
+	"timestamp",
+	"abap_bool",
+	"abap_boolean",
+	"abap_true",
+	"abap_false",
+	"sy-subrc",
+	"sy-tabix"
+]);
+function isBuiltinName(name) {
+	return BUILTIN_ABAP_TYPES.has(name.toLowerCase());
+}
+
+//#endregion
+//#region src/assert.ts
+/**
+* Assertions derived from `parse()`. Useful for downstream consumers
+* (generators, linters, CI gates) that want to guarantee their output
+* stays inside the structural subset of ABAP OO that `aclass`
+* understands, without writing the same filtering logic each time.
+*/
+var AclassParseError = class extends Error {
+	source;
+	errors;
+	constructor(fileLabel, errors, source) {
+		super(`aclass: ${errors.length} parse error${errors.length === 1 ? "" : "s"} in ${fileLabel}:\n` + errors.slice(0, 10).map((e) => `  [${e.line}:${e.column}] ${e.message}`).join("\n"));
+		this.name = "AclassParseError";
+		this.source = source;
+		this.errors = errors;
+	}
+};
+/**
+* Throw `AclassParseError` if the source has any lex / parse errors.
+* `fileLabel` is included in the message so CI output points at the
+* offending file without the caller having to format it.
+*
+* Intended use in test suites:
+*
+* ```ts
+* for (const f of generated) {
+*   assertCleanParse(readFileSync(f, 'utf8'), f);
+* }
+* ```
+*/
+function assertCleanParse(source, fileLabel = "<source>") {
+	const { errors } = parse(source);
+	if (errors.length === 0) return;
+	throw new AclassParseError(fileLabel, errors, source);
+}
+
+//#endregion
+export { AclassLexer, AclassParseError, allTokens, assertCleanParse, fromLexError, fromParseError, parse, tokenize, tokens_exports as tokens };
+//# sourceMappingURL=index.mjs.map