@idlizer/arktscgen 2.1.9-arktscgen-9 → 2.1.10-arktscgen-2

package/lib/index.js

@@ -3814,11 +3814,13 @@ var IDLEntity;
 var IDLExtendedAttributes;
 (function (IDLExtendedAttributes) {
     IDLExtendedAttributes["Accessor"] = "Accessor";
+    IDLExtendedAttributes["Annotations"] = "Annotations";
     IDLExtendedAttributes["Async"] = "Async";
     IDLExtendedAttributes["CallSignature"] = "CallSignature";
     IDLExtendedAttributes["CommonMethod"] = "CommonMethod";
     IDLExtendedAttributes["Component"] = "Component";
     IDLExtendedAttributes["ComponentInterface"] = "ComponentInterface";
+    IDLExtendedAttributes["ComponentModifier"] = "ComponentModifier";
     IDLExtendedAttributes["Deprecated"] = "Deprecated";
     IDLExtendedAttributes["Documentation"] = "Documentation";
     IDLExtendedAttributes["DtsName"] = "DtsName";
@@ -3839,11 +3841,14 @@ var IDLExtendedAttributes;
     IDLExtendedAttributes["Synthetic"] = "Synthetic";
     IDLExtendedAttributes["Throws"] = "Throws";
     IDLExtendedAttributes["TraceKey"] = "TraceKey";
+    IDLExtendedAttributes["TypeAnnotations"] = "TypeAnnotations";
     IDLExtendedAttributes["TypeArguments"] = "TypeArguments";
     IDLExtendedAttributes["TypeParameters"] = "TypeParameters";
     IDLExtendedAttributes["VerbatimDts"] = "VerbatimDts";
     IDLExtendedAttributes["HandWrittenImplementation"] = "HandWrittenImplementation";
     IDLExtendedAttributes["ExtraMethod"] = "ExtraMethod";
+    IDLExtendedAttributes["OverloadAlias"] = "OverloadAlias";
+    IDLExtendedAttributes["OverloadPriority"] = "OverloadPriority";
 })(IDLExtendedAttributes || (IDLExtendedAttributes = {}));
 var IDLAccessorAttribute;
 (function (IDLAccessorAttribute) {
@@ -3863,18 +3868,18 @@ function forEachChild(node, cbEnter, cbLeave) {
     const cleanup = cbEnter(node);
     switch (node.kind) {
         case IDLKind.File:
-            node.entries.forEach((value) => forEachChild(value, cbEnter));
+            node.entries.forEach((value) => forEachChild(value, cbEnter, cbLeave));
             break;
         case IDLKind.Namespace:
-            node.members.forEach((value) => forEachChild(value, cbEnter));
+            node.members.forEach((value) => forEachChild(value, cbEnter, cbLeave));
             break;
         case IDLKind.Interface: {
             let concrete = node;
-            concrete.inheritance.forEach((value) => forEachChild(value, cbEnter));
-            concrete.constructors.forEach((value) => forEachChild(value, cbEnter));
-            concrete.properties.forEach((value) => forEachChild(value, cbEnter));
-            concrete.methods.forEach((value) => forEachChild(value, cbEnter));
-            concrete.callables.forEach((value) => forEachChild(value, cbEnter));
+            concrete.inheritance.forEach((value) => forEachChild(value, cbEnter, cbLeave));
+            concrete.constructors.forEach((value) => forEachChild(value, cbEnter, cbLeave));
+            concrete.properties.forEach((value) => forEachChild(value, cbEnter, cbLeave));
+            concrete.methods.forEach((value) => forEachChild(value, cbEnter, cbLeave));
+            concrete.callables.forEach((value) => forEachChild(value, cbEnter, cbLeave));
             break;
         }
         case IDLKind.Method:
@@ -3882,53 +3887,53 @@ function forEachChild(node, cbEnter, cbLeave) {
         case IDLKind.Callback:
         case IDLKind.Constructor: {
             let concrete = node;
-            (_a = concrete.parameters) === null || _a === void 0 ? void 0 : _a.forEach((value) => forEachChild(value, cbEnter));
+            (_a = concrete.parameters) === null || _a === void 0 ? void 0 : _a.forEach((value) => forEachChild(value, cbEnter, cbLeave));
             if (concrete.returnType)
-                forEachChild(concrete.returnType, cbEnter);
+                forEachChild(concrete.returnType, cbEnter, cbLeave);
             break;
         }
         case IDLKind.UnionType: {
             let concrete = node;
-            (_b = concrete.types) === null || _b === void 0 ? void 0 : _b.forEach((value) => forEachChild(value, cbEnter));
+            (_b = concrete.types) === null || _b === void 0 ? void 0 : _b.forEach((value) => forEachChild(value, cbEnter, cbLeave));
             break;
         }
         case IDLKind.OptionalType: {
             let concrete = node;
-            forEachChild(concrete.type, cbEnter);
+            forEachChild(concrete.type, cbEnter, cbLeave);
             break;
         }
         case IDLKind.Const: {
-            forEachChild(node.type, cbEnter);
+            forEachChild(node.type, cbEnter, cbLeave);
             break;
         }
         case IDLKind.Enum: {
-            node.elements.forEach((value) => forEachChild(value, cbEnter));
+            node.elements.forEach((value) => forEachChild(value, cbEnter, cbLeave));
             break;
         }
         case IDLKind.Property: {
-            forEachChild(node.type, cbEnter);
+            forEachChild(node.type, cbEnter, cbLeave);
             break;
         }
         case IDLKind.Parameter: {
             const concrete = node;
             if (concrete.type)
-                forEachChild(concrete.type, cbEnter);
+                forEachChild(concrete.type, cbEnter, cbLeave);
             break;
         }
         case IDLKind.Typedef: {
-            forEachChild(node.type, cbEnter);
+            forEachChild(node.type, cbEnter, cbLeave);
             break;
         }
         case IDLKind.ContainerType: {
-            node.elementType.forEach((value) => forEachChild(value, cbEnter));
+            node.elementType.forEach((value) => forEachChild(value, cbEnter, cbLeave));
             break;
         }
         case IDLKind.UnspecifiedGenericType: {
-            node.typeArguments.forEach((value) => forEachChild(value, cbEnter));
+            node.typeArguments.forEach((value) => forEachChild(value, cbEnter, cbLeave));
             break;
         }
         case IDLKind.ReferenceType: {
-            (_c = node.typeArguments) === null || _c === void 0 ? void 0 : _c.forEach((value) => forEachChild(value, cbEnter));
+            (_c = node.typeArguments) === null || _c === void 0 ? void 0 : _c.forEach((value) => forEachChild(value, cbEnter, cbLeave));
             break;
         }
         case IDLKind.TypeParameterType:
@@ -3941,6 +3946,7 @@ function forEachChild(node, cbEnter, cbLeave) {
             throw new Error(`Unhandled ${node.kind}`);
         }
     }
+    cbLeave === null || cbLeave === void 0 ? void 0 : cbLeave(node);
     cleanup === null || cleanup === void 0 ? void 0 : cleanup();
 }
 /** Updates tree in place! */
@@ -4093,9 +4099,15 @@ function isInterface$1(node) {
 function isImport(type) {
     return type.kind == IDLKind.Import;
 }
+function isCallable(node) {
+    return node.kind === IDLKind.Callable;
+}
 function isMethod(node) {
     return node.kind === IDLKind.Method;
 }
+function isConstructor$1(node) {
+    return node.kind === IDLKind.Constructor;
+}
 function isProperty(node) {
     return node.kind === IDLKind.Property;
 }
@@ -6050,7 +6062,13 @@ class DiagnosticException extends Error {
 /**
  * Template for registering different kinds of messages
  */
-class DiagnosticMessageEntry {
+class DiagnosticMessageGroup {
+    /**
+     * Generated diagnostic messages belonging to _any_ group
+     */
+    static get allGroupsEntries() {
+        return DiagnosticMessageGroup.collectedResults.entries;
+    }
     constructor(severity, code, codeDescription, mainMessageTemplate, additionalMessageTemplate) {
         this.severity = severity;
         this.code = code;
@@ -6058,10 +6076,10 @@ class DiagnosticMessageEntry {
         // No cases of codeUri for now, can be embedded into codeDescription later if needed
         this.mainMessageTemplate = mainMessageTemplate !== null && mainMessageTemplate !== void 0 ? mainMessageTemplate : codeDescription;
         this.additionalMessageTemplate = additionalMessageTemplate !== null && additionalMessageTemplate !== void 0 ? additionalMessageTemplate : "See";
-        if (DiagnosticMessageEntry.diagnosticMessageByCode.has(code)) {
+        if (DiagnosticMessageGroup.diagnosticMessageByCode.has(code)) {
             throw new Error(`Duplicate message code ${code}`);
         }
-        DiagnosticMessageEntry.diagnosticMessageByCode.set(code, this);
+        DiagnosticMessageGroup.diagnosticMessageByCode.set(code, this);
     }
     generateDiagnosticMessage(locations, mainMessage, additionalMessage) {
         let msg = {
@@ -6079,24 +6097,928 @@ class DiagnosticMessageEntry {
         return msg;
     }
     reportDiagnosticMessage(locations, mainMessage, additionalMessage) {
-        DiagnosticMessageEntry.collectedResults.push(this.generateDiagnosticMessage(locations, mainMessage, additionalMessage));
+        const msg = this.generateDiagnosticMessage(locations, mainMessage, additionalMessage);
+        DiagnosticMessageGroup.collectedResults.push(msg);
+        return msg;
     }
     throwDiagnosticMessage(locations, mainMessage, additionalMessage) {
-        throw new DiagnosticException(this.generateDiagnosticMessage(locations, mainMessage, additionalMessage));
-    }
-    static reportCatched(diagnosticMessage) {
-        this.collectedResults.push(diagnosticMessage);
+        throw new DiagnosticException(this.reportDiagnosticMessage(locations, mainMessage, additionalMessage));
     }
 }
 /**
  * Index for DiagnosticMessageEntry by code
  */
-DiagnosticMessageEntry.diagnosticMessageByCode = new Map();
-DiagnosticMessageEntry.collectedResults = new DiagnosticResults();
-const UnknownErrorMessage = new DiagnosticMessageEntry("fatal", 0, "Unknown error");
-const LoadingErrorMessage = new DiagnosticMessageEntry("fatal", 100, "Loading error");
-const ParsingErrorMessage = new DiagnosticMessageEntry("fatal", 101, "Parsing error");
-new DiagnosticMessageEntry("fatal", 102, "Processing error");
+DiagnosticMessageGroup.diagnosticMessageByCode = new Map();
+/**
+ * Diagnostic results collected up until now
+ */
+DiagnosticMessageGroup.collectedResults = new DiagnosticResults();
+const InternalFatal = new DiagnosticMessageGroup("fatal", "InternalFatal", "Unknown error");
+const LoadingFatal = new DiagnosticMessageGroup("fatal", "LoadingFatal", "Loading error");
+const ParsingFatal = new DiagnosticMessageGroup("fatal", "ParsingFatal", "Parsing error");
+new DiagnosticMessageGroup("fatal", "ProcessingFatal", "Processing error");
+
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const DuplicateModifier = new DiagnosticMessageGroup("error", "DuplicateModifier", "Duplicate modifier", "Duplicate of");
+const NotApplicableModifier = new DiagnosticMessageGroup("error", "NotApplicableModifier", "Not applicable modifier");
+const DuplicatePackageDeclaration = new DiagnosticMessageGroup("error", "DuplicatePackageDeclaration", "Duplicate package declaration", "Duplicate of");
+const DuplicateExtendedAttribute = new DiagnosticMessageGroup("error", "DuplicateExtendedAttribute", "Duplicate extended attribute", "Duplicate of");
+const DuplicateArgumentName = new DiagnosticMessageGroup("error", "DuplicateArgumentName", "Duplicate argument name", "Duplicate of");
+const IncorrectLiteral = new DiagnosticMessageGroup("error", "IncorrectLiteral", "Incorrect literal");
+const IncorrectIdentifier = new DiagnosticMessageGroup("error", "IncorrectIdentifier", "Incorrect identifier");
+const UnexpectedToken = new DiagnosticMessageGroup("error", "UnexpectedToken", "Unexpected token");
+const UnexpectedEndOfFile = new DiagnosticMessageGroup("fatal", "UnexpectedEndOfFile", "Unexpected end of file");
+const UnsupportedSyntax = new DiagnosticMessageGroup("error", "UnsupportedSyntax", "Unsupported syntax");
+const WrongDeclarationPlacement = new DiagnosticMessageGroup("error", "WrongDeclarationPlacement", "Wrong declaration placement");
+const ExpectedPrimitiveType = new DiagnosticMessageGroup("error", "ExpectedPrimitiveType", "Expected primitive type");
+const ExpectedReferenceType = new DiagnosticMessageGroup("error", "ExpectedReferenceType", "Expected reference type");
+const ExpectedGenericArguments = new DiagnosticMessageGroup("error", "ExpectedGenericArguments", "Expected generic arguments");
+const UnexpectedGenericArguments = new DiagnosticMessageGroup("error", "UnexpectedGenericArguments", "Unexpected generic arguments");
+class FatalParserException extends Error {
+    constructor(diagnosticMessages) {
+        super();
+        this.diagnosticMessages = diagnosticMessages;
+    }
+}
+var TokenKind;
+(function (TokenKind) {
+    TokenKind["Words"] = "Words";
+    TokenKind["Literal"] = "Literal";
+    TokenKind["Symbol"] = "Symbol";
+    TokenKind["Comment"] = "Comment";
+    TokenKind["Whitespace"] = "Space";
+    TokenKind["End"] = "End";
+})(TokenKind || (TokenKind = {}));
+const supportedDeclarations = new Set(["attribute", "callback", "const", "constructor", "dictionary",
+    "enum", "import", "interface", "namespace", "package", "typedef", "version"]);
+const unsupportedDeclarations = new Set(["deleter", "getter", "includes", "inherit", "iterable", "maplike",
+    "mixin", "partial", "required", "setlike", "setter", "stringifier", "unrestricted"]);
+const interfaceContent = new Set([IDLKind.Constructor, IDLKind.Const, IDLKind.Property, IDLKind.Method, IDLKind.Callable]);
+const globalContent = new Set([IDLKind.Namespace, IDLKind.Interface, IDLKind.Enum, IDLKind.Method, IDLKind.Typedef, IDLKind.Callback, IDLKind.Import, IDLKind.Version, IDLKind.Const]);
+const havingBlocks = new Set([IDLKind.Namespace, IDLKind.Interface, IDLKind.Enum]);
+const modifierTokens = new Set(["static", "readonly", "async"]);
+// Uncomment in case of parser debugging
+function trac(s) {
+    // console.log(s)
+}
+class Parser {
+    constructor(fileName, content) {
+        var _a, _b;
+        this._curOffset = 0;
+        this._curLine = 0;
+        // TypeParameters support
+        this._generics = [];
+        // TypeArguments parsing support
+        this._enableInLiteralParsing = false;
+        // symTokens = ["(", ")", "[", "]", "{", "}", ",", "...", ":", ";", "<", "=", ">", "?"]
+        this._reDecimal = /-?(?=[0-9]*\.|[0-9]+[eE])(([0-9]+\.[0-9]*|[0-9]*\.[0-9]+)([Ee][-+]?[0-9]+)?|[0-9]+[Ee][-+]?[0-9]+)/y;
+        this._reInteger = /-?(0([Xx][0-9A-Fa-f]+|[0-7]*)|[1-9][0-9]*)/y;
+        this._reString = /"[^"]*"/y;
+        // -something is handled for -Infinity literal parsing, but rejected for identifiers later
+        this._reWords = /[-]?[_$A-Za-z][_$0-9A-Za-z]*([.][_$A-Za-z][_$0-9A-Za-z]*)*/y;
+        this._reSymbol = /\.\.\.|[()[\]{},:;<=>?]/y;
+        this._reWhitespace = /[\t\n\r ]+/y;
+        this._reComment = /\/\/.*|\/\*[\s\S]*?\*\//y;
+        // Note no sticky behavior.
+        this._reIsDocComment = /\/\/\/.*|\/\*\*[\s\S]*?\*\//;
+        this.currentModifiers = {};
+        this.fileName = fileName;
+        if (undefined === content) {
+            try {
+                content = fs__namespace.readFileSync(fileName).toString();
+            }
+            catch (e) {
+                content = "";
+                throw new FatalParserException([LoadingFatal.reportDiagnosticMessage([{ documentPath: fileName }], (_a = e.message) !== null && _a !== void 0 ? _a : "")]);
+            }
+        }
+        this.content = content;
+        const lines = (_b = content.match(/[^\r\n]*(\n|\r\n)?/g)) !== null && _b !== void 0 ? _b : [];
+        this.offsets = prepareOffsets$1(lines);
+        this.lines = lines.map((s) => s.replace(/(\n|\r\n)$/, ""));
+    }
+    parseIDL() {
+        var _a;
+        const previousDiagnosticsCount = DiagnosticMessageGroup.allGroupsEntries.length;
+        try {
+            trac("parseIDL");
+            this._lexerNext();
+            this._prevToken = this._curToken;
+            let file = this.parseFile();
+            file.text = this.content;
+            return file;
+        }
+        catch (e) {
+            if (!(e instanceof DiagnosticException) && !(e instanceof FatalParserException)) {
+                InternalFatal.reportDiagnosticMessage([{ documentPath: this.fileName }], (_a = e.message) !== null && _a !== void 0 ? _a : "");
+            }
+            throw new FatalParserException(DiagnosticMessageGroup.allGroupsEntries.slice(previousDiagnosticsCount));
+        }
+    }
+    _match(re, kind) {
+        re.lastIndex = this._curOffset;
+        const res = re.exec(this.content);
+        if (!res) {
+            return undefined;
+        }
+        const value = res[0];
+        const startLine = this._curLine + 1;
+        const startCharacter = this._curOffset - this.offsets[this._curLine] + 1;
+        this._curOffset = re.lastIndex;
+        this._curLine += (value.match(/\n/g) || []).length;
+        const endLine = this._curLine + 1;
+        const endCharacter = this._curOffset - this.offsets[this._curLine];
+        const location = { documentPath: this.fileName, lines: this.lines, range: { start: { line: startLine, character: startCharacter }, end: { line: endLine, character: endCharacter } } };
+        this._curToken = { kind, value, location };
+        return this._curToken;
+    }
+    _matchComment() {
+        const token = this._match(this._reComment, TokenKind.Comment);
+        // At any parsing moment `precedingComment` represents possible comment token just before`curToken`.
+        // It can be narrowed by `_reIsDocComment` if needed.
+        if (token) {
+            this.precedingComment = token;
+        }
+        return token;
+    }
+    _lexerNext() {
+        var _a, _b, _c, _d;
+        this._prevToken = this._curToken;
+        this._match(this._reWhitespace, TokenKind.Whitespace);
+        this.precedingComment = undefined;
+        while (this._matchComment()) {
+            this._match(this._reWhitespace, TokenKind.Whitespace);
+        }
+        if (this._curOffset == this.content.length) {
+            const pos = { line: this._curLine + 1, character: this._curOffset - this.offsets[this._curLine] + 1 };
+            this._curToken = { kind: TokenKind.End, value: "", location: { documentPath: this.fileName, lines: this.lines, range: { start: pos, end: pos } } };
+            return;
+        }
+        if (this._enableInLiteralParsing && this.content[this._curOffset] == "\"") {
+            // TypeArguments parsing support
+            const pos = { line: this._curLine + 1, character: this._curOffset - this.offsets[this._curLine] + 1 };
+            this._curToken = { kind: TokenKind.Symbol, value: "\"", location: { documentPath: this.fileName, lines: this.lines, range: { start: pos, end: pos } } };
+            this._curOffset += 1;
+            return;
+        }
+        const token = ((_d = (_c = (_b = (_a = this._match(this._reDecimal, TokenKind.Literal)) !== null && _a !== void 0 ? _a : this._match(this._reInteger, TokenKind.Literal)) !== null && _b !== void 0 ? _b : this._match(this._reString, TokenKind.Literal)) !== null && _c !== void 0 ? _c : this._match(this._reWords, TokenKind.Words)) !== null && _d !== void 0 ? _d : this._match(this._reSymbol, TokenKind.Symbol));
+        if (!token) {
+            const pos = { line: this._curLine + 1, character: this._curOffset - this.offsets[this._curLine] + 1 };
+            ParsingFatal.throwDiagnosticMessage([{ documentPath: this.fileName, lines: this.lines, range: { start: pos, end: pos } }], "Unrecognized symbols");
+        }
+        // Uncomment in case of parser debugging
+        // if (token) {
+        //     const visTok = {...token, location: {...token.location, lines: undefined, documentPath: undefined}}
+        //     console.log(`Token: ${JSON.stringify(visTok)}`)
+        // }
+    }
+    get curToken() {
+        return this._curToken;
+    }
+    get curKind() {
+        return this._curToken.kind;
+    }
+    get curValue() {
+        return this._curToken.value;
+    }
+    get curLocation() {
+        return this.curToken.location;
+    }
+    see(tok) {
+        return this.curValue == tok;
+    }
+    seeAndSkip(tok) {
+        if (this.curValue == tok) {
+            this._lexerNext();
+            return true;
+        }
+        return false;
+    }
+    seeEof() {
+        return this.curToken.kind == TokenKind.End;
+    }
+    skip(tok) {
+        if (this.curValue != tok) {
+            if (this.curKind == TokenKind.End) {
+                UnexpectedEndOfFile.throwDiagnosticMessage([this.curLocation], `Unexpected end of file, expected "${tok}"`);
+            }
+            UnexpectedToken.throwDiagnosticMessage([this.curLocation], `Unexpected token, expected "${tok}"`);
+        }
+        this._lexerNext();
+    }
+    skipToAfter(tok) {
+        while (!this.see(tok) && !this.seeEof()) {
+            this._lexerNext();
+        }
+        if (!this.seeEof()) {
+            this._lexerNext();
+        }
+    }
+    trackLocation() {
+        const start = this.curLocation;
+        return () => {
+            const end = this._prevToken.location;
+            return {
+                documentPath: this.fileName,
+                range: { start: start.range.start, end: end.range.end },
+                lines: this.lines
+            };
+        };
+    }
+    consumeCurrentExtended() {
+        const ext = this._internalCurrentExtended;
+        this._internalCurrentExtended = undefined;
+        return ext;
+    }
+    assertPossibleModifiers(...mods) {
+        for (const k of Object.keys(this.currentModifiers)) {
+            if (!mods.includes(k)) {
+                NotApplicableModifier.reportDiagnosticMessage([this.currentModifiers[k].location]);
+            }
+        }
+    }
+    parseSingleIdentifier() {
+        const token = this.parseFullIdentifier();
+        if (token.value.includes(".")) {
+            IncorrectIdentifier.throwDiagnosticMessage([this.curLocation]);
+        }
+        return token;
+    }
+    parseFullIdentifier() {
+        if (this.curKind != TokenKind.Words || literalTypes.has(this.curValue) && this.curValue != "undefined") {
+            UnexpectedToken.throwDiagnosticMessage([this.curLocation], "Unexpected token, expected identifier");
+        }
+        if (this.curValue.startsWith("-")) {
+            // Valid for identifiers in WebIDL, but not in Idlize
+            IncorrectIdentifier.throwDiagnosticMessage([this.curLocation]);
+        }
+        const token = this.curToken;
+        this._lexerNext();
+        return token;
+    }
+    parseFullIdentifierOrLiteral() {
+        if (this.curKind != TokenKind.Words && this.curKind != TokenKind.Literal) {
+            UnexpectedToken.throwDiagnosticMessage([this.curLocation], "Unexpected token, expected identifier or literal");
+        }
+        const token = this.curToken;
+        this._lexerNext();
+        return token;
+    }
+    parseLiteral() {
+        if (this.curKind != TokenKind.Literal && !literalTypes.has(this.curValue)) {
+            UnexpectedToken.throwDiagnosticMessage([this.curLocation], "Unexpected token, expected literal");
+        }
+        const token = this.curToken;
+        this._lexerNext();
+        return token;
+    }
+    parseAndPushGenerics(ext) {
+        var _a;
+        const gen = (_a = extractTypeParameters(ext)) !== null && _a !== void 0 ? _a : [];
+        if (this.seeAndSkip("<")) {
+            let next = false;
+            while (!this.seeAndSkip(">")) {
+                if (next) {
+                    this.skip(",");
+                }
+                next = true;
+                gen.push(this.parseSingleIdentifier().value);
+            }
+        }
+        // To be restored in parseDeclaration
+        this._generics.push(gen);
+        return gen;
+    }
+    hasGeneric(name) {
+        return this._generics.some(x => x.includes(name));
+    }
+    parseFile() {
+        var _a;
+        const entries = [];
+        while (!this.seeEof()) {
+            const entry = this.parseDeclaration(IDLKind.File);
+            if (entry) {
+                entries.push(entry);
+            }
+        }
+        return createFile(entries, this.fileName, (_a = this.currentPackage) === null || _a === void 0 ? void 0 : _a.split("."), { nodeLocation: { documentPath: this.fileName, lines: this.lines } });
+    }
+    parseDeclaration(scopeKind) {
+        const genericsLevel = this._generics.length;
+        try {
+            const decl = this.parseDeclarationUnsafe(scopeKind);
+            if (!decl) {
+                return;
+            }
+            if (scopeKind == IDLKind.Interface ? !interfaceContent.has(decl.kind) : !globalContent.has(decl.kind)) {
+                // Prefer shorter location ranges for blocks for now
+                const location = havingBlocks.has(decl.kind) ? decl.nameLocation : decl.nodeLocation;
+                WrongDeclarationPlacement.reportDiagnosticMessage([location], `Wrong declaration placement: ${decl.kind} not allowed in ${scopeKind}`);
+            }
+            return decl;
+        }
+        catch (e) {
+            if (e instanceof DiagnosticException && e.diagnosticMessage.severity != "fatal") {
+                this.skipToAfter(";");
+                return;
+            }
+            throw e;
+        }
+        finally {
+            while (this._generics.length > genericsLevel) {
+                this._generics.pop();
+            }
+        }
+    }
+    parseDeclarationUnsafe(scopeKind) {
+        this._internalCurrentExtended = this.parseExtendedAttributes();
+        this.currentModifiers = {};
+        while (modifierTokens.has(this.curValue)) {
+            if (this.currentModifiers[this.curValue]) {
+                DuplicateModifier.reportDiagnosticMessage([this.curLocation]);
+            }
+            this.currentModifiers[this.curValue] = this.curToken;
+            this._lexerNext();
+        }
+        if (unsupportedDeclarations.has(this.curValue)) {
+            UnsupportedSyntax.throwDiagnosticMessage([this.curLocation]);
+            return;
+        }
+        if (supportedDeclarations.has(this.curValue)) {
+            if (this.curValue != "attribute") {
+                this.assertPossibleModifiers();
+            }
+            switch (this.curValue) {
+                case "attribute":
+                    this.assertPossibleModifiers("static", "readonly");
+                    return this.parseAttribute();
+                case "callback":
+                    return this.parseCallback();
+                case "const":
+                    return this.parseConst();
+                case "constructor":
+                    return this.parseConstructor();
+                case "dictionary":
+                    return this.parseDictionary();
+                case "enum":
+                    return this.parseEnum();
+                case "import":
+                    return this.parseImport();
+                case "interface":
+                    return this.parseInterface();
+                case "namespace":
+                    return this.parseNamespace();
+                case "package":
+                    {
+                        const pack = this.parsePackage();
+                        if (this.currentPackage) {
+                            DuplicatePackageDeclaration.reportDiagnosticMessage([pack.location]);
+                        }
+                        this.currentPackage = pack.name;
+                        if (scopeKind != IDLKind.File) {
+                            WrongDeclarationPlacement.reportDiagnosticMessage([pack.location], `Wrong declaration placement: package is not allowed in ${scopeKind}`);
+                        }
+                        return;
+                    }
+                case "typedef":
+                    return this.parseTypedef();
+                case "version":
+                    return this.parseVersion();
+            }
+        }
+        else {
+            this.assertPossibleModifiers("static", "async");
+            return this.parseOperation();
+        }
+    }
+    parseNamespace() {
+        const sloc = this.trackLocation();
+        const ext = this.consumeCurrentExtended();
+        this.skip("namespace");
+        const name = this.parseSingleIdentifier();
+        const entries = [];
+        this.skip("{");
+        while (!this.seeAndSkip("}")) {
+            const entry = this.parseDeclaration(IDLKind.Namespace);
+            if (entry) {
+                entries.push(entry);
+            }
+        }
+        this.skip(";");
+        return createNamespace(name.value, entries, { extendedAttributes: ext, nodeLocation: sloc(), nameLocation: name.location });
+    }
+    parseInterface() {
+        const sloc = this.trackLocation();
+        const ext = this.consumeCurrentExtended();
+        this.skip("interface");
+        const typeParameters = this.parseAndPushGenerics(ext);
+        const name = this.parseSingleIdentifier();
+        let bases = [];
+        if (this.seeAndSkip(":")) {
+            const typeList = this.parseTypeList();
+            for (const type of typeList) {
+                if (isReferenceType(type)) {
+                    bases.push(type);
+                }
+                else {
+                    ExpectedReferenceType.reportDiagnosticMessage([type.nodeLocation]);
+                }
+            }
+        }
+        const entries = [];
+        this.skip("{");
+        while (!this.seeAndSkip("}")) {
+            const entry = this.parseDeclaration(IDLKind.Interface);
+            if (entry) {
+                if (isMethod(entry)) {
+                    entry.isFree = false;
+                }
+                entries.push(entry);
+            }
+        }
+        this.skip(";");
+        return createInterface(name.value, extractInterfaceSubkind(ext), bases, entries.filter(isConstructor$1), entries.filter(isConstant$1), entries.filter(isProperty), entries.filter(isMethod), entries.filter(isCallable), typeParameters, { extendedAttributes: ext, documentation: extractDocumentation(ext), nodeLocation: sloc(), nameLocation: name.location });
+    }
+    parseExtendedAttributes() {
+        // For future extensions: here is also a good point for doc comments handling
+        if (!this.seeAndSkip("[")) {
+            return;
+        }
+        const ext = [];
+        const names = new Set();
+        const duplicates = new Set();
+        let next = false;
+        while (!this.seeAndSkip("]")) {
+            if (next) {
+                this.skip(",");
+            }
+            next = true;
+            const name = this.parseSingleIdentifier();
+            if (names.has(name.value)) {
+                duplicates.add(name.value);
+            }
+            names.add(name.value);
+            if (name.value == IDLExtendedAttributes.TypeArguments) {
+                // TypeArguments parsing support
+                try {
+                    this._enableInLiteralParsing = true;
+                    this.skip("=");
+                    const vloc = this.trackLocation();
+                    const start = this._curOffset; // Already after first quote
+                    this.skip("\"");
+                    const types = this.parseTypeList();
+                    const end = this._curOffset - 1; // Already after second quote
+                    this._enableInLiteralParsing = false;
+                    this.skip("\"");
+                    const stringValue = this.content.slice(start, end);
+                    ext.push({ name: name.value, value: stringValue, typesValue: types, nameLocation: name.location, valueLocation: vloc() });
+                }
+                catch (e) {
+                    this.skipToAfter("\"");
+                    throw e;
+                }
+                finally {
+                    this._enableInLiteralParsing = false;
+                }
+            }
+            else {
+                let value;
+                if (this.seeAndSkip("=")) {
+                    value = this.parseFullIdentifierOrLiteral();
+                }
+                const converted = value ? valueFromIdentifierOrLiteral(value) : undefined;
+                ext.push({ name: name.value, value: converted, nameLocation: name.location, valueLocation: value === null || value === void 0 ? void 0 : value.location });
+            }
+        }
+        for (const dup of duplicates) {
+            DuplicateExtendedAttribute.reportDiagnosticMessage(ext.filter(x => x.name == dup).map(x => x.nameLocation));
+        }
+        return ext;
+    }
+    parseTypeList() {
+        const types = [this.parseType()];
+        while (this.seeAndSkip(",")) {
+            types.push(this.parseType());
+        }
+        return types;
+    }
+    parseType(outerExt) {
+        var _a;
+        const parsedExt = this.parseExtendedAttributes();
+        const ext = parsedExt ? (outerExt ? parsedExt.concat(outerExt) : parsedExt) : (outerExt ? [...outerExt] : undefined);
+        const sloc = this.trackLocation();
+        if (this.seeAndSkip("(")) {
+            let combinedTypes = [];
+            let next = false;
+            while (!this.seeAndSkip(")")) {
+                if (next) {
+                    this.skip("or");
+                }
+                next = true;
+                combinedTypes.push(this.parseType());
+            }
+            const isNullable = this.seeAndSkip("?") || combinedTypes.includes(IDLUndefinedType);
+            combinedTypes = combinedTypes.filter(x => x !== IDLUndefinedType);
+            const distilledType = combinedTypes.length == 1
+                ? combinedTypes[0]
+                : createUnionType(combinedTypes, undefined, { extendedAttributes: ext, nodeLocation: sloc() });
+            if (isNullable) {
+                return createOptionalType(distilledType, { extendedAttributes: ext, nodeLocation: sloc() });
+            }
+            return distilledType;
+        }
+        const name = this.parseFullIdentifier();
+        const genArgs = (_a = extractTypeArguments(ext)) !== null && _a !== void 0 ? _a : [];
+        if (this.seeAndSkip("<")) {
+            let next = false;
+            while (!this.seeAndSkip(">")) {
+                if (next) {
+                    this.skip(",");
+                }
+                next = true;
+                genArgs.push(this.parseType());
+            }
+        }
+        let type;
+        if (this.hasGeneric(name.value)) {
+            if (genArgs.length > 0) {
+                UnexpectedGenericArguments.reportDiagnosticMessage([name.location]);
+            }
+            type = createTypeParameterReference(name.value, { extendedAttributes: ext, nodeLocation: sloc(), nameLocation: name.location });
+        }
+        else if (builtinTypes.has(name.value)) {
+            if (genArgs.length > 0) {
+                UnexpectedGenericArguments.reportDiagnosticMessage([name.location]);
+            }
+            type = builtinTypes.get(name.value);
+        }
+        else if (builtinGenericTypeNames.has(name.value)) {
+            if (genArgs.length == 0) {
+                ExpectedGenericArguments.reportDiagnosticMessage([name.location]);
+            }
+            type = createContainerType(name.value, genArgs, { extendedAttributes: ext, nodeLocation: sloc(), nameLocation: name.location });
+        }
+        else {
+            type = createReferenceType(name.value, genArgs.length > 0 ? genArgs : undefined, { extendedAttributes: ext, nodeLocation: sloc(), nameLocation: name.location });
+        }
+        const isNullable = this.seeAndSkip("?");
+        if (isNullable) {
+            return createOptionalType(type, { extendedAttributes: ext, nodeLocation: sloc() });
+        }
+        else {
+            return type;
+        }
+    }
+    parseReferenceType() {
+        const type = this.parseType();
+        if (!isReferenceType(type)) {
+            ExpectedReferenceType.reportDiagnosticMessage([type.nodeLocation]);
+        }
+        return type;
+    }
+    parsePrimitiveType() {
+        const type = this.parseType();
+        if (!isPrimitiveType(type)) {
+            ExpectedPrimitiveType.reportDiagnosticMessage([type.nodeLocation]);
+        }
+        return type;
+    }
+    parseArgTuple() {
+        const args = [];
+        const names = new Set();
+        const duplicates = new Set();
+        this.skip("(");
+        let next = false;
+        while (!this.seeAndSkip(")")) {
+            if (next) {
+                this.skip(",");
+            }
+            next = true;
+            const arg = this.parseArg();
+            if (names.has(arg.name)) {
+                duplicates.add(arg.name);
+            }
+            names.add(arg.name);
+            args.push(arg);
+        }
+        for (const dup of duplicates) {
+            DuplicateArgumentName.reportDiagnosticMessage(args.filter(x => x.name == dup).map(x => x.nameLocation));
+        }
+        return args;
+    }
+    parseArg() {
+        const ext = this.parseExtendedAttributes();
+        const sloc = this.trackLocation();
+        const optional = this.seeAndSkip("optional");
+        // Note `extendedAttributes` forwarding
+        const type = this.parseType(ext);
+        const spread = this.seeAndSkip("...");
+        const name = this.parseSingleIdentifier();
+        // Note absense of `extendedAttributes`, they are only forwarded to `type`, as it was in the old parsing code
+        return createParameter(name.value, type, optional, spread, { nodeLocation: sloc(), nameLocation: name.location });
+    }
+    parseOperation() {
+        const sloc = this.trackLocation();
+        const ext = this.consumeCurrentExtended();
+        const isStatic = !!this.currentModifiers.static;
+        const isAsync = !!this.currentModifiers.async;
+        const isOptional = extractOptional(ext);
+        const isFree = true; // Will be set to false in parseInterface if method is declared within interface
+        const typeParameters = this.parseAndPushGenerics(ext);
+        // Note `extendedAttributes` forwarding
+        const retType = this.parseType(ext);
+        const name = this.parseSingleIdentifier();
+        const args = this.parseArgTuple();
+        this.skip(";");
+        if (ext === null || ext === void 0 ? void 0 : ext.some(x => x.name == IDLExtendedAttributes.CallSignature)) {
+            return createCallable(name.value, args, retType, { isStatic, isAsync }, { extendedAttributes: ext, documentation: extractDocumentation(ext), nodeLocation: sloc(), nameLocation: name.location }, typeParameters);
+        }
+        return createMethod(name.value, args, retType, { isStatic, isAsync, isOptional, isFree }, { extendedAttributes: ext, documentation: extractDocumentation(ext), nodeLocation: sloc(), nameLocation: name.location }, typeParameters);
+    }
+    parseConstructor() {
+        const sloc = this.trackLocation();
+        const ext = this.consumeCurrentExtended();
+        this.skip("constructor");
+        const args = this.parseArgTuple();
+        this.skip(";");
+        return createConstructor(args, undefined, { extendedAttributes: ext, documentation: extractDocumentation(ext), nodeLocation: sloc() });
+    }
+    parseConst() {
+        const sloc = this.trackLocation();
+        const ext = this.consumeCurrentExtended();
+        this.skip("const");
+        const type = this.parseType();
+        const name = this.parseSingleIdentifier();
+        this.skip("=");
+        const value = this.parseLiteral();
+        const extracted = extractLiteral(value);
+        this.skip(";");
+        return createConstant(name.value, type, extracted.extractedString, { extendedAttributes: ext, nodeLocation: sloc(), nameLocation: name.location, valueLocation: value.location });
+    }
+    parseAttribute() {
+        const sloc = this.trackLocation();
+        const ext = this.consumeCurrentExtended();
+        const isReadonly = !!this.currentModifiers.readonly;
+        const isStatic = !!this.currentModifiers.static;
+        const isOptional = extractOptional(ext);
+        this.skip("attribute");
+        const type = this.parseType();
+        const name = this.parseSingleIdentifier();
+        this.skip(";");
+        return createProperty(name.value, type, isReadonly, isStatic, isOptional, { extendedAttributes: ext, documentation: extractDocumentation(ext), nodeLocation: sloc(), nameLocation: name.location });
+    }
+    parseTypedef() {
+        const sloc = this.trackLocation();
+        const ext = this.consumeCurrentExtended();
+        this.skip("typedef");
+        const typeParameters = this.parseAndPushGenerics(ext);
+        const type = this.parseType();
+        const name = this.parseSingleIdentifier();
+        if (isUnionType(type)) {
+            type.name = name.value;
+        }
+        this.skip(";");
+        return createTypedef(name.value, type, typeParameters, { extendedAttributes: ext, documentation: extractDocumentation(ext), nodeLocation: sloc(), nameLocation: name.location });
+    }
+    parseCallback() {
+        const sloc = this.trackLocation();
+        const ext = this.consumeCurrentExtended();
+        this.skip("callback");
+        if (this.see("interface")) {
+            UnsupportedSyntax.throwDiagnosticMessage([this.curLocation], "Unsupported syntax: callback interface");
+        }
+        const typeParameters = this.parseAndPushGenerics(ext);
+        const name = this.parseSingleIdentifier();
+        this.skip("=");
+        const retType = this.parseType();
+        const args = this.parseArgTuple();
+        this.skip(";");
+        return createCallback(name.value, args, retType, { extendedAttributes: ext, documentation: extractDocumentation(ext), nodeLocation: sloc(), nameLocation: name.location }, typeParameters);
+    }
+    parseEnum() {
+        const sloc = this.trackLocation();
+        const ext = this.consumeCurrentExtended();
+        this.skip("enum");
+        const name = this.parseSingleIdentifier();
+        const items = [];
+        this.skip("{");
+        let next = false;
+        while (!this.seeAndSkip("}")) {
+            if (next) {
+                this.skip(",");
+                // Can have trailing comma
+                if (this.seeAndSkip("}")) {
+                    break;
+                }
+            }
+            next = true;
+            const ext = this.parseExtendedAttributes();
+            const entry = this.parseLiteral();
+            const member = createEnumMember(entry.value, undefined, IDLNumberType, undefined, { extendedAttributes: ext, nodeLocation: entry.location, nameLocation: entry.location });
+            items.push(member);
+        }
+        return createEnum(name.value, items, { extendedAttributes: ext, documentation: extractDocumentation(ext), nodeLocation: sloc(), nameLocation: name.location });
+    }
+    parseDictionary() {
+        const sloc = this.trackLocation();
+        const ext = this.consumeCurrentExtended();
+        this.skip("dictionary");
+        const name = this.parseSingleIdentifier();
+        const items = [];
+        this.skip("{");
+        while (!this.seeAndSkip("}")) {
+            items.push(this.parseDictionaryEntry());
+        }
+        this.skip(";");
+        return createEnum(name.value, items, { extendedAttributes: ext, documentation: extractDocumentation(ext), nodeLocation: sloc(), nameLocation: name.location });
+    }
+    parseDictionaryEntry() {
+        const ext = this.parseExtendedAttributes();
+        const sloc = this.trackLocation();
+        const type = this.parsePrimitiveType();
+        const name = this.parseSingleIdentifier();
+        this.skip("=");
+        const value = this.parseLiteral();
+        const extracted = extractLiteral(value);
+        this.skip(";");
+        return createEnumMember(name.value, undefined, type, extracted.extractedValue, { extendedAttributes: ext, nodeLocation: sloc(), nameLocation: name.location, valueLocation: value.location });
+    }
+    parsePackage() {
+        const sloc = this.trackLocation();
+        this.skip("package");
+        const packagePath = this.parseFullIdentifierOrLiteral();
+        this.skip(";");
+        return { location: sloc(), name: valueFromIdentifierOrLiteral(packagePath) };
+    }
+    parseImport() {
+        const sloc = this.trackLocation();
+        this.skip("import");
+        const importPath = this.parseFullIdentifierOrLiteral();
+        let alias;
+        if (this.seeAndSkip("as")) {
+            alias = this.parseSingleIdentifier();
+        }
+        this.skip(";");
+        return createImport(valueFromIdentifierOrLiteral(importPath).split("."), alias === null || alias === void 0 ? void 0 : alias.value, { nodeLocation: sloc(), nameLocation: alias === null || alias === void 0 ? void 0 : alias.location, valueLocation: importPath.location });
+    }
+    parseVersion() {
+        const sloc = this.trackLocation();
+        this.skip("version");
+        const versionLiteral = this.parseLiteral();
+        this.skip(";");
+        return createVersion(versionLiteral.value.split("."), { nodeLocation: sloc(), valueLocation: versionLiteral.location });
+    }
+}
+function prepareOffsets$1(lines) {
+    let offsets = [];
+    let offset = 0;
+    for (let line of lines) {
+        let plus = line.length;
+        offsets.push(offset);
+        offset += plus;
+    }
+    return offsets;
+}
+function valueFromIdentifierOrLiteral(token) {
+    if (token.kind == TokenKind.Words && !literalTypes.has(token.value)) {
+        return token.value;
+    }
+    return extractLiteral(token).extractedString;
+}
+const literalTypes = new Map([
+    ["true", "boolean"],
+    ["false", "boolean"],
+    ["Infinity", "number"],
+    ["-Infinity", "number"],
+    ["NaN", "number"],
+    ["null", "null"],
+    ["undefined", "undefined"],
+]);
+const extractedUndefined = { type: "undefined", extractedString: "undefined", extractedValue: "undefined" };
+function extractLiteral(token) {
+    if (token.kind == TokenKind.Words) {
+        if (!literalTypes.has(token.value)) {
+            IncorrectLiteral.reportDiagnosticMessage([token.location]);
+            return extractedUndefined;
+        }
+        const type = literalTypes.get(token.value);
+        const extractedString = token.value;
+        const extractedValue = type == "number" ? parseFloat(extractedString) : extractedString;
+        return { type, extractedString, extractedValue };
+    }
+    if (token.kind != TokenKind.Literal) {
+        IncorrectLiteral.reportDiagnosticMessage([token.location]);
+        return extractedUndefined;
+    }
+    if (token.value[0] == "\"") {
+        try {
+            const extractedString = unescapeString(token.value);
+            return { type: "string", extractedString, extractedValue: extractedString };
+        }
+        catch (e) {
+            IncorrectLiteral.reportDiagnosticMessage([token.location], `Incorrect literal: ${e.message}`);
+            return extractedUndefined;
+        }
+    }
+    const extractedValue = parseFloat(token.value);
+    if (Number.isNaN(extractedValue)) {
+        // Real NaNs are handled before that, so report an error
+        IncorrectLiteral.reportDiagnosticMessage([token.location]);
+    }
+    return { type: "number", extractedString: token.value, extractedValue };
+}
+// Taken from deserialize.ts as is
+function unescapeString(value) {
+    if (!value.length || value[0] !== '"')
+        return value;
+    value = value.slice(1, -1);
+    value = value.replace(/\\((['"\\bfnrtv])|([0-7]{1-3})|x([0-9a-fA-F]{2})|u([0-9a-fA-F]{4}))/g, (_, all, c, oct, h2, u4) => {
+        if (c !== undefined) {
+            switch (c) {
+                case "'": return "'";
+                case '"': return '"';
+                case "\\": return "\\";
+                case "b": return "\b";
+                case "f": return "\f";
+                case "n": return "\n";
+                case "r": return "\r";
+                case "t": return "\t";
+                case "v": return "\v";
+            }
+        }
+        else if (oct !== undefined) {
+            return String.fromCharCode(parseInt(oct, 8));
+        }
+        else if (h2 !== undefined) {
+            return String.fromCharCode(parseInt(h2, 16));
+        }
+        else if (u4 !== undefined) {
+            return String.fromCharCode(parseInt(u4, 16));
+        }
+        throw new Error(`unknown escape sequence: ${_}`);
+    });
+    return value;
+}
+function extractInterfaceSubkind(ext) {
+    var _a;
+    const ent = (_a = ext === null || ext === void 0 ? void 0 : ext.find(x => x.name == "Entity")) === null || _a === void 0 ? void 0 : _a.value;
+    switch (ent) {
+        case IDLEntity.Class: return IDLInterfaceSubkind.Class;
+        case IDLEntity.Literal: return IDLInterfaceSubkind.AnonymousInterface;
+        case IDLEntity.Tuple: return IDLInterfaceSubkind.Tuple;
+        default: return IDLInterfaceSubkind.Interface;
+    }
+}
+function extractDocumentation(ext) {
+    var _a;
+    return (_a = ext === null || ext === void 0 ? void 0 : ext.find(x => x.name == "Documentation")) === null || _a === void 0 ? void 0 : _a.value;
+}
+function extractOptional(ext) {
+    var _a;
+    return (_a = ext === null || ext === void 0 ? void 0 : ext.some(x => x.name.toLowerCase() == "optional")) !== null && _a !== void 0 ? _a : false;
+}
+function sanitizeTypeParameter(param) {
+    const extendsIdx = param.indexOf('extends');
+    if (extendsIdx !== -1) {
+        return param.substring(0, extendsIdx).trim();
+    }
+    const eqIdx = param.indexOf('=');
+    if (eqIdx !== -1) {
+        return param.substring(0, eqIdx).trim();
+    }
+    return param;
+}
+function extractTypeParameters(ext) {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = ext === null || ext === void 0 ? void 0 : ext.find(x => x.name == IDLExtendedAttributes.TypeParameters)) === null || _a === void 0 ? void 0 : _a.value) === null || _b === void 0 ? void 0 : _b.split(",")) === null || _c === void 0 ? void 0 : _c.map(sanitizeTypeParameter);
+}
+function extractTypeArguments(ext) {
+    var _a;
+    return (_a = ext === null || ext === void 0 ? void 0 : ext.find(x => x.name == IDLExtendedAttributes.TypeArguments)) === null || _a === void 0 ? void 0 : _a.typesValue;
+}
+const builtinTypesList = [IDLPointerType, IDLVoidType, IDLBooleanType,
+    IDLObjectType, IDLI8Type, IDLU8Type, IDLI16Type, IDLU16Type,
+    IDLI32Type, IDLU32Type, IDLI64Type, IDLU64Type, IDLF32Type,
+    IDLF64Type, IDLBigintType, IDLNumberType, IDLStringType, IDLAnyType,
+    IDLUndefinedType, IDLUnknownType, IDLObjectType, IDLThisType, IDLDate,
+    IDLBufferType, IDLSerializerBuffer
+];
+// Better solution will be to make it registry in idl.ts
+const builtinTypes = new Map(builtinTypesList.map(x => [x.name, x]));
+const builtinGenericTypeNames = new Set(["sequence", "record", "Promise"]);
 
 /*
  * Copyright (c) 2024 Huawei Device Co., Ltd.
@@ -6223,10 +7145,9 @@ class IDLDeserializer {
             }
             const implementations = [];
             node.inheritance.forEach(it => {
-                var _a;
                 const attributes = it.extAttrs;
                 const parentTypeArgs = this.extractTypeArguments(file, attributes !== null && attributes !== void 0 ? attributes : [], IDLExtendedAttributes.TypeArguments);
-                const attrs = (_a = this.toExtendedAttributes(attributes !== null && attributes !== void 0 ? attributes : [])) === null || _a === void 0 ? void 0 : _a.filter(it => it.name !== IDLExtendedAttributes.TypeArguments);
+                const attrs = this.toExtendedAttributes(attributes !== null && attributes !== void 0 ? attributes : []); // ?.filter(it => it.name !== idl.IDLExtendedAttributes.TypeArguments)
                 const ref = createReferenceType(it.inheritance, parentTypeArgs, {
                     extendedAttributes: attrs
                 });
@@ -6602,8 +7523,136 @@ class IDLDeserializer {
         return attr ? this.toExtendedAttributeValue(attr) : undefined;
     }
 }
+const DifferenceFound = new DiagnosticMessageGroup("error", "DifferenceFound", "Difference found");
+const noCompare = new Set(["parent", "fileName", "nodeLocation", "nameLocation", "valueLocation", "typesValue"]);
+const canContainMoreCompare = new Set(["extendedAttributes", "typeParameters", "typeArguments"]);
+function safeString(value) {
+    if (typeof value == "symbol") {
+        return String(value);
+    }
+    return JSON.stringify(value, (k, v) => { return noCompare.has(k) ? undefined : v; });
+}
+function joinPath(left, right) {
+    if (!right) {
+        return left;
+    }
+    return `${left}.${right}`;
+}
+function compareDeep(oldData, newData, paths) {
+    var _a;
+    const location = (newData === null || newData === void 0 ? void 0 : newData.kind) && ((_a = newData === null || newData === void 0 ? void 0 : newData.nameLocation) !== null && _a !== void 0 ? _a : newData === null || newData === void 0 ? void 0 : newData.nodeLocation);
+    const diffs = [];
+    if (typeof oldData != typeof newData) {
+        diffs.push({ path: "", oldValue: safeString(oldData), newValue: safeString(newData) });
+    }
+    else if (Array.isArray(oldData) && Array.isArray(newData)) {
+        const len = Math.max(oldData.length, newData.length);
+        if (oldData.length != newData.length) {
+            diffs.push({ path: "", oldValue: `(length=${oldData.length})`, newValue: `(length=${newData.length})` });
+        }
+        for (let i = 0; i < len; ++i) {
+            const deeperDiffs = compareDeep(oldData[i], newData[i], paths);
+            if (deeperDiffs.length > 0) {
+                diffs.push(...deeperDiffs.map(x => { x.path = joinPath("" + i, x.path); return x; }));
+            }
+        }
+    }
+    else if (typeof newData == "object") {
+        const keys = [...new Set([...Object.getOwnPropertyNames(oldData), ...Object.getOwnPropertyNames(newData)])].filter(x => !noCompare.has(x));
+        for (const k of keys) {
+            let oldValue = oldData[k];
+            let newValue = newData[k];
+            if (canContainMoreCompare.has(k)) {
+                if (newValue == null && Array.isArray(oldValue) && oldValue.length == 0) {
+                    continue;
+                }
+                if (oldValue == null && Array.isArray(newValue)) {
+                    continue;
+                }
+                if (Array.isArray(oldValue) && Array.isArray(newValue)) {
+                    if (newValue.length > oldValue.length) {
+                        // Cases when old parser takes attributes from outer declaration and ignores the right ones
+                        newValue = newValue.slice(newValue.length - oldValue.length);
+                    }
+                    else if (oldValue.length > newValue.length) {
+                        // Cases when types in parentheses have own attributes, but old parser adds attributes from outer declaration
+                        oldValue = oldValue.slice(0, newValue.length);
+                    }
+                }
+            }
+            const deeperDiffs = compareDeep(oldValue, newValue, paths);
+            if (deeperDiffs.length > 0) {
+                diffs.push(...deeperDiffs.map(x => { x.path = joinPath(k, x.path); return x; }));
+            }
+        }
+    }
+    else {
+        if (oldData != newData) {
+            diffs.push({ path: "", oldValue: safeString(oldData), newValue: safeString(newData) });
+        }
+    }
+    if (!location) {
+        return diffs;
+    }
+    for (const diff of diffs) {
+        paths.add(diff.path);
+        DifferenceFound.reportDiagnosticMessage([location], `path: ${diff.path} oldValue: ${diff.oldValue} newValue: ${diff.newValue}`);
+    }
+    return [];
+}
+function compareParsingResults(oldFile, newFile) {
+    const paths = new Set();
+    compareDeep(oldFile, newFile, paths);
+    if (paths.size > 0) {
+        DifferenceFound.reportDiagnosticMessage([newFile.nodeLocation], "Differences found in those paths:\n" + [...paths].join("\n"));
+    }
+}
+function parseIdlNew(fileName, content, registerSynthetics) {
+    let file = new Parser(fileName, content).parseIDL();
+    const ancestors = [];
+    const namespaces = [];
+    // Mimic old parser and deserialize.ts behavior:
+    // 1. Add `fileName`.
+    // 2. Add `parent`.
+    // 3. Possibly register node with `addSyntheticType` if "Synthetic" is in attributes
+    forEachChild(file, (node) => {
+        var _a;
+        if (isPrimitiveType(node)) {
+            return;
+        }
+        node.fileName = fileName;
+        if (registerSynthetics && isEntry(node) && ((_a = node.extendedAttributes) === null || _a === void 0 ? void 0 : _a.some(it => it.name === "Synthetic"))) {
+            const fqName = file.packageClause.concat(namespaces).concat([node.name]).join('.');
+            addSyntheticType(fqName, node);
+        }
+        if (ancestors.length) {
+            node.parent = ancestors[ancestors.length - 1];
+        }
+        if (isNamespace(node)) {
+            namespaces.push(node.name);
+        }
+        ancestors.push(node);
+    }, (node) => {
+        if (isPrimitiveType(node)) {
+            return;
+        }
+        if (isNamespace(node)) {
+            namespaces.pop();
+        }
+        ancestors.pop();
+    });
+    return file;
+}
 function toIDLFile(fileName, { content, inheritanceMode = 'multiple' } = {}) {
     var _a, _b, _c;
+    let newFile;
+    const mode = process.env.IDLPARSE;
+    if (mode == "compare" || mode == "new") {
+        newFile = parseIdlNew(fileName, content, mode == "new");
+        if (mode == "new") {
+            return [newFile, new Map()];
+        }
+    }
     const lexicalInfo = new Map();
     const deserializer = new IDLDeserializer(lexicalInfo, inheritanceMode);
     if (undefined === content) {
@@ -6612,7 +7661,7 @@ function toIDLFile(fileName, { content, inheritanceMode = 'multiple' } = {}) {
         }
         catch (e) {
             content = "";
-            LoadingErrorMessage.throwDiagnosticMessage([{ documentPath: fileName }], (_a = e.message) !== null && _a !== void 0 ? _a : "");
+            throw new FatalParserException([LoadingFatal.reportDiagnosticMessage([{ documentPath: fileName }], (_a = e.message) !== null && _a !== void 0 ? _a : "")]);
         }
     }
     let lines = (_b = content.match(/[^\r\n]*(\n|\r\n)?/g)) !== null && _b !== void 0 ? _b : [];
@@ -6628,9 +7677,9 @@ function toIDLFile(fileName, { content, inheritanceMode = 'multiple' } = {}) {
         if (e.name == "WebIDLParseError") {
             let tokens = e.tokens;
             let range = tokens.length > 0 ? rangeForToken(offsets, tokens[0]) : undefined;
-            ParsingErrorMessage.throwDiagnosticMessage([{ documentPath: fileName, range, lines }], e.bareMessage);
+            throw new FatalParserException([ParsingFatal.reportDiagnosticMessage([{ documentPath: fileName, range, lines }], e.bareMessage)]);
         }
-        UnknownErrorMessage.throwDiagnosticMessage([{ documentPath: fileName }], (_c = e.message) !== null && _c !== void 0 ? _c : "");
+        throw new FatalParserException([InternalFatal.reportDiagnosticMessage([{ documentPath: fileName, lines }], (_c = e.message) !== null && _c !== void 0 ? _c : "")]);
     }
     const entries = rawParsingResults
         .filter(it => {
@@ -6654,6 +7703,10 @@ function toIDLFile(fileName, { content, inheritanceMode = 'multiple' } = {}) {
             node.nameLocation = nameLocation;
         }
     });
+    if (mode == "compare") {
+        compareParsingResults(file, newFile);
+        return [newFile, new Map()];
+    }
     return [file, lexicalInfo];
 }
 function prepareOffsets(lines) {
@@ -8681,7 +9734,7 @@ function mk(typeName, check, config) {
         }
         return new ValidationBox({
             success: false,
-            errorMessage: `Expected "${typeName}"`
+            errorMessage: `Expected "${typeName}" but got "${typeof x}"`
         });
     }, () => {
         const base = {
@@ -8987,6 +10040,7 @@ const HookMethodSchema = D.object({
     replaceImplementation: D.boolean()
 });
 D.object({
+    ApiKind: D.number(),
     TypePrefix: D.string(),
     LibraryPrefix: D.string(),
     OptionalPrefix: D.string(),
@@ -9007,6 +10061,7 @@ D.object({
     globalPackages: T.stringArray()
 });
 const defaultCoreConfiguration = {
+    ApiKind: 0,
     TypePrefix: "",
     LibraryPrefix: "",
     OptionalPrefix: "",
@@ -10834,6 +11889,66 @@ const JSON5 = {
 
 var lib = JSON5;
 
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class Config {
+    constructor(ignore, nonNullable, irHack, fragments, parameters) {
+        this.ignore = ignore;
+        this.nonNullable = nonNullable;
+        this.irHack = irHack;
+        this.fragments = fragments;
+        this.parameters = parameters;
+    }
+    static get createPrefix() {
+        return `Create`;
+    }
+    static get updatePrefix() {
+        return `Update`;
+    }
+    static get constPostfix() {
+        return `Const`;
+    }
+    static get nodeTypeAttribute() {
+        return `Es2pandaAstNodeType`;
+    }
+    static get nodeNamespaceAttribute() {
+        return `cpp_namespace`;
+    }
+    static get uselessPrefix() {
+        return `Get`;
+    }
+    static get astNodeCommonAncestor() {
+        return `AstNode`;
+    }
+    static get context() {
+        return `Context`;
+    }
+    static get dataClassPrefix() {
+        return `es2panda_`;
+    }
+    static get defaultAncestor() {
+        return `ArktsObject`;
+    }
+    static get irNamespace() {
+        return `ir`;
+    }
+}
+Config.DoNotPrintPeers = [
+    'es2panda_Context', // useless
+];
+
 /*
  * Copyright (c) 2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -10859,7 +11974,11 @@ class BridgesConstructions {
         return `impl_${name}`;
     }
     static referenceType(name) {
-        return `es2panda_${name}*`;
+        // FIXME: Rewrite CastTypeConvertors using idl.CppInteropArgConverter
+        // and LanguageWriter constructions.
+        // Use c_type attribute from declaration.
+        const addPrefix = (n) => (n.startsWith(Config.dataClassPrefix) ? n : `${Config.dataClassPrefix}${n}`);
+        return `${addPrefix(name)}*`;
     }
     static get sequenceLengthDeclaration() {
         return `std::size_t length`;
@@ -10900,9 +12019,6 @@ class BridgesConstructions {
     static get stringCast() {
         return `getStringCopy`;
     }
-    static resultAssignment(value) {
-        return `auto ${BridgesConstructions.result} = ${value}`;
-    }
     static dropConstCast(value) {
         return `(void*)${value}`;
     }
@@ -10917,63 +12033,6 @@ class BridgesConstructions {
     }
 }
 
-/*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-class Config {
-    constructor(ignore, nonNullable, irHack, fragments, parameters) {
-        this.ignore = ignore;
-        this.nonNullable = nonNullable;
-        this.irHack = irHack;
-        this.fragments = fragments;
-        this.parameters = parameters;
-    }
-    static get createPrefix() {
-        return `Create`;
-    }
-    static get updatePrefix() {
-        return `Update`;
-    }
-    static get constPostfix() {
-        return `Const`;
-    }
-    static get nodeTypeAttribute() {
-        return `Es2pandaAstNodeType`;
-    }
-    static get nodeNamespaceAttribute() {
-        return `cpp_namespace`;
-    }
-    static get uselessPrefix() {
-        return `Get`;
-    }
-    static get astNodeCommonAncestor() {
-        return `AstNode`;
-    }
-    static get context() {
-        return `Context`;
-    }
-    static get dataClassPrefix() {
-        return `es2panda_`;
-    }
-    static get defaultAncestor() {
-        return `ArktsObject`;
-    }
-    static get irNamespace() {
-        return `ir`;
-    }
-}
-
 /*
  * Copyright (c) 2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -11126,7 +12185,7 @@ function isReal(node) {
     return nodeType(node) !== undefined;
 }
 function isDataClass(node) {
-    return parent(node) === Config.defaultAncestor;
+    return node.name.startsWith(Config.dataClassPrefix) || parent(node) === Config.defaultAncestor;
 }
 function isCreate(name) {
     return isCreateOrUpdate(name) && name.startsWith(Config.createPrefix);
@@ -11138,6 +12197,9 @@ function isCreateOrUpdate(sourceMethodName) {
     const { rest } = splitCreateOrUpdate(sourceMethodName);
     return rest.length <= 1;
 }
+function isImplInterface(name) {
+    return dropPrefix(name, Config.dataClassPrefix) === 'Impl';
+}
 function fixEnumPrefix(name) {
     if (name.startsWith(`es2panda_`)) {
         name = dropPrefix(name, `es2panda_`);
@@ -11225,6 +12287,9 @@ function nodeNamespace(node) {
     var _a;
     return (_a = getNamespacesPathFor(node)[0]) === null || _a === void 0 ? void 0 : _a.name;
 }
+function fqName(node) {
+    return getQualifiedName(node, "namespace.name");
+}
 function parent(node) {
     var _a;
     return (_a = node.inheritance[0]) === null || _a === void 0 ? void 0 : _a.name;
@@ -11232,14 +12297,6 @@ function parent(node) {
 function createDefaultTypescriptWriter() {
     return new TSLanguageWriter(new IndentedPrinter(), createEmptyReferenceResolver(), { convert: (node) => throwException(`unexpected type conversion`) });
 }
-function isIrNamespace(node) {
-    var _a, _b;
-    let cppNamespace = (_b = (_a = node.extendedAttributes) === null || _a === void 0 ? void 0 : _a.find(it => it.name == Config.nodeNamespaceAttribute)) === null || _b === void 0 ? void 0 : _b.value;
-    return nodeNamespace(node) === Config.irNamespace || cppNamespace == Config.irNamespace;
-}
-function createSequence(inner) {
-    return createContainerType(`sequence`, [inner]);
-}
 function innerType(node) {
     return node.elementType[0];
 }
@@ -11267,8 +12324,13 @@ function makeSignature(parameters, returnType) {
         .map(it => it.name)
         .map(mangleIfKeyword));
 }
-function flatParents(ref, idl) {
-    const resolveReference = (ref) => resolveNamedNode(ref.name.split('.'), undefined, [idl]);
+function makeExpression(writer, arg) {
+    return typeof arg === 'string' ? writer.makeString(arg) : arg;
+}
+function makeStatement(writer, arg) {
+    return typeof arg !== 'string' && 'write' in arg ? arg : writer.makeStatement(makeExpression(writer, arg));
+}
+function flatParentsImpl(ref, resolveReference) {
     if (isReferenceType(ref)) {
         const type = resolveReference(ref);
         if (!type || !isInterface$1(type)) {
@@ -11281,13 +12343,21 @@ function flatParents(ref, idl) {
     while (queue.length) {
         const node = queue.shift();
         result.push(node);
+        if (result.length > 1 && baseNameString(ref.name) === node.name) {
+            //console.warn(`Cyclic dependency: ${ref.name} -> ${node.name}`);
+            break;
+        }
         node.inheritance
-            .map(p => resolveReference(p))
+            .map(p => resolveReference(p, ref))
             .filter(p => p !== undefined && isInterface$1(p))
             .forEach(p => queue.push(p));
     }
     return result; // with self
 }
+function flatParents(ref, idl) {
+    const resolveReference = (ref, pov) => resolveNamedNode(ref.name.split('.'), pov, [idl]);
+    return flatParentsImpl(ref, resolveReference);
+}
 
 /*
  * Copyright (c) 2024 Huawei Device Co., Ltd.
@@ -11304,54 +12374,64 @@ function flatParents(ref, idl) {
  * limitations under the License.
  */
 class Typechecker {
-    constructor(idl) {
-        this.idl = idl;
-        this.idl = linearizeNamespaceMembers(idl);
+    constructor(file) {
+        this.file = file;
+        this.namespaces = this.file.entries.filter(e => isNamespace(e));
+    }
+    resolveReference(ref) {
+        const prefix = Config.dataClassPrefix;
+        // XXX: This is a temporary hack until duplicates will not be removed from idl
+        if (ref.name.startsWith(prefix)) {
+            const entry = this.resolveReference2(createReferenceType(ref.name.slice(prefix.length)));
+            if (entry) {
+                return entry;
+            }
+        }
+        return this.resolveReference2(ref);
     }
-    findRealDeclaration(name) {
-        // Poor man's namespace-aware resolve.
-        // TODO: REWORK IT ALL!
-        const declarations = this.idl.filter(it => (name === it.name) || (baseNameString(name) == baseNameString(it.name)));
-        if (declarations.length === 1) {
-            return declarations[0];
+    resolveReference2(ref, debugPrefix = '') {
+        const target = ref.name.split('.');
+        let entry = undefined;
+        if (target.length > 1) { // full-qualified
+            entry = resolveNamedNode(target, undefined, [this.file]);
         }
-        const ir = declarations
-            .filter(isInterface$1)
-            .filter(it => isIrNamespace(it));
-        if (ir.length > 0) {
-            return ir[0];
+        else {
+            if (ref.parent) {
+                entry = resolveNamedNode(target, ref.parent, [this.file]);
+            }
+            if (!entry) {
+                for (const pov of this.namespaces) {
+                    entry = resolveNamedNode(target, pov, [this.file]);
+                    if (entry)
+                        break;
+                }
+            }
         }
-        return undefined;
-    }
-    isHeir(name, ancestor) {
-        if (name === ancestor) {
-            return true;
+        if (debugPrefix.length) {
+            console.log(`RESOLVER: ${ref.name} => ${entry ? fqName(entry) : entry}`);
         }
-        const declaration = this.findRealDeclaration(name);
-        if (declaration === undefined || !isInterface$1(declaration)) {
+        return entry;
+    }
+    // All classes are consideres heirs of ArktsObject now
+    isHeir(ref, ancestor) {
+        const resolveReference = (r, _) => this.resolveReference(r);
+        const iface = isReferenceType(ref) ? resolveReference(ref) : ref;
+        if (!iface || !isInterface$1(iface)) {
             return false;
         }
-        let isHeir = declaration.name === ancestor;
-        declaration.inheritance.forEach(parent => {
-            isHeir || (isHeir = this.isHeir(parent.name, ancestor));
-        });
-        // TODO: Should be fixed or moved to config
-        const objects = [
-            "Program", "ArkTsConfig", "AstDumper", "SrcDumper",
-            "FunctionSignature", "ValidationInfo"
-        ];
-        if (!isHeir) {
-            if (ancestor === Config.defaultAncestor &&
-                objects.includes(declaration.name))
-                return true;
+        const parents = flatParentsImpl(iface, resolveReference);
+        if (parents.map(p => p.name).includes(ancestor)) {
+            return true;
         }
-        return isHeir;
+        return ancestor === Config.defaultAncestor;
     }
     isPeer(node) {
-        if (node === Config.astNodeCommonAncestor)
+        if (node.name === Config.astNodeCommonAncestor)
             return false; // TODO: is handwritten
-        if (node === Config.context)
+        if (node.name === Config.context)
             return false; // TODO: is handwritten
+        if (isImplInterface(node.name))
+            return false;
         if (this.isHeir(node, Config.astNodeCommonAncestor))
             return true;
         if (this.isHeir(node, Config.defaultAncestor))
@@ -11362,7 +12442,7 @@ class Typechecker {
         if (!isReferenceType(type)) {
             return false;
         }
-        const declaration = this.findRealDeclaration(type.name);
+        const declaration = this.resolveReference(type);
         return declaration !== undefined && isTarget(declaration);
     }
     isConstReturnValue(node) {
@@ -11372,35 +12452,13 @@ class Typechecker {
         return node.name.endsWith(Config.constPostfix);
     }
     nodeTypeName(node) {
-        var _a, _b;
+        var _a;
         const value = nodeType(node);
-        const idlEnum = this.idl
-            .filter(isEnum$1)
-            .find(it => it.name === Config.nodeTypeAttribute);
-        return (_b = (_a = idlEnum === null || idlEnum === void 0 ? void 0 : idlEnum.elements) === null || _a === void 0 ? void 0 : _a.find(it => { var _a; return ((_a = it.initializer) === null || _a === void 0 ? void 0 : _a.toString()) === value; })) === null || _b === void 0 ? void 0 : _b.name;
-    }
-    parent(node) {
-        const parentName = parent(node);
-        if (parentName === undefined)
-            return undefined;
-        const decl = this.findRealDeclaration(parentName);
-        if (decl === undefined)
-            return undefined;
-        if (!isInterface$1(decl))
-            return undefined;
-        return decl;
-    }
-    ancestry(node) {
-        let current = node;
-        const res = [];
-        while (true) {
-            res.push(current);
-            const parent = this.parent(current);
-            if (parent === undefined) {
-                return res;
-            }
-            current = parent;
-        }
+        const entry = this.resolveReference(createReferenceType(Config.nodeTypeAttribute));
+        const name = entry && isEnum$1(entry)
+            ? (_a = entry.elements.find(e => { var _a; return ((_a = e.initializer) === null || _a === void 0 ? void 0 : _a.toString()) === value; })) === null || _a === void 0 ? void 0 : _a.name
+            : undefined;
+        return name ? `${Config.nodeTypeAttribute}.${name}` : undefined; // value
     }
 }
 
@@ -11432,7 +12490,7 @@ class SingleFilePrinter extends AbstractVisitor {
     constructor(idl) {
         super();
         this.idl = idl;
-        this.typechecker = new Typechecker(this.idl.entries);
+        this.typechecker = new Typechecker(this.idl);
     }
     printEnum(node) { }
     visit(node) {
@@ -11479,7 +12537,7 @@ class InteropPrinter extends AbstractVisitor {
     constructor(file) {
         super();
         this.file = file;
-        this.typechecker = new Typechecker(this.file.entries);
+        this.typechecker = new Typechecker(this.file);
     }
     print() {
         this.file.entries.forEach(it => this.visit(it));
@@ -11569,9 +12627,6 @@ class BaseTypeConvertor {
         return convertType(this, type);
     }
 }
-function composedConvertType(result, effect, type) {
-    return result.convertType(effect.convertType(type));
-}
 
 /*
  * Copyright (c) 2024 Huawei Device Co., Ltd.
@@ -11725,7 +12780,7 @@ class CastToTypeConvertor extends BaseTypeConvertor {
             sequence: (type) => BridgesConstructions.arrayOf(this.convertType(innerType(type))),
             enum: (type) => type.name,
             reference: (type) => {
-                return BridgesConstructions.referenceType(typechecker.isHeir(type.name, Config.astNodeCommonAncestor)
+                return BridgesConstructions.referenceType(typechecker.isHeir(type, Config.astNodeCommonAncestor)
                     ? Config.astNodeCommonAncestor
                     : baseName(type));
             },
@@ -11769,6 +12824,8 @@ class BridgesPrinter extends InteropPrinter {
         this.config = config;
         this.castTypeConvertor = new CastTypeConvertor(this.typechecker);
         this.nativeTypeConvertor = new NativeTypeConvertor(this.typechecker);
+        this.returnTypeConvertor = new ReturnTypeConvertor$1(this.typechecker);
+        this.interopMacroConvertor = new InteropMacroTypeConvertor(this.typechecker);
         this.writer = new CppLanguageWriter(new IndentedPrinter(), createEmptyReferenceResolver(), { convert: (node) => this.nativeTypeConvertor.convertType(node) }, new class extends PrimitiveTypeList {
             constructor() {
                 super(...arguments);
@@ -11776,82 +12833,62 @@ class BridgesPrinter extends InteropPrinter {
                 this.Void = new PrimitiveType(`void`);
             }
         }());
-        this.returnTypeConvertor = new ReturnTypeConvertor$1(this.typechecker);
-        this.interopMacroConvertor = new InteropMacroTypeConvertor(this.typechecker);
-    }
-    printInteropMacro(methodName, signature) {
-        this.writer.writeExpressionStatement(this.writer.makeFunctionCall(BridgesConstructions.interopMacro(isVoidType(signature.returnType), signature.args.length), [methodName]
-            .concat((() => {
-            if (isVoidType(signature.returnType)) {
-                return [];
-            }
-            return [this.returnTypeConvertor.convertType(signature.returnType)];
-        })()
-            .concat(signature.args)
-            .map(it => this.interopMacroConvertor.convertType(it)))
-            .map(it => this.writer.makeString(it))));
     }
     printMethod(iface, node) {
+        if (this.config.ignore.isIgnoredMethod(iface.name, node.name))
+            return;
         const [methodName, signature] = BridgesPrinter.makeFunctionDeclaration(iface, node, this.returnTypeConvertor);
-        this.writer.writeFunctionImplementation(BridgesConstructions.implFunction(methodName), signature, (_) => this.printBody(iface, node, signature));
+        this.writer.writeFunctionImplementation(BridgesConstructions.implFunction(methodName), signature, (_) => {
+            let pandaMethodName = BridgesConstructions.callMethod(methodName);
+            if (this.config.irHack.isIrHackInterface(iface.name)) {
+                pandaMethodName = pandaMethodName.replace(iface.name, `${iface.name}Ir`);
+            }
+            this.printBody(node, signature, pandaMethodName);
+        });
         this.printInteropMacro(methodName, signature);
         this.writer.writeLines(``);
     }
+    printInteropMacro(methodName, signature) {
+        const isVoid = isVoidType(signature.returnType);
+        const args = (isVoid ? [] : [signature.returnType])
+            .concat(signature.args)
+            .map(a => this.interopMacroConvertor.convertType(a));
+        args.splice(0, 0, methodName);
+        this.writer.writeExpressionStatement(this.writer.makeFunctionCall(BridgesConstructions.interopMacro(isVoid, signature.args.length), args.map(it => this.writer.makeString(it))));
+    }
     static makeFunctionDeclaration(iface, node, converter) {
         var _a;
-        const signature = new MethodSignature(converter.convertType(node.returnType), node.parameters.map(it => it.type), undefined, node.parameters.map(it => it.isOptional ? ArgumentModifier.OPTIONAL : undefined), undefined, node.parameters.map(it => mangleIfKeyword(it.name)));
-        if (!isCreateOrUpdate(node.name)) {
+        const signature = makeSignature(node.parameters.map(p => ({
+            name: mangleIfKeyword(p.name),
+            type: p.type,
+            isOptional: p.isOptional
+        })), converter.convertType(node.returnType));
+        if (!isCreateOrUpdate(node.name) && !isImplInterface(iface.name)) {
             signature.args.splice(1, 0, createReferenceType(iface.name));
             signature.argNames.splice(1, 0, 'receiver');
         }
         const fixArgName = (name, prev) => name.endsWith('Len') ? (prev !== null && prev !== void 0 ? prev : name.slice(0, -3)) + 'SequenceLength' : name === 'ctx' ? 'context' : name;
         // Not necessary, just to keep old names
         signature.argNames = (_a = signature.argNames) === null || _a === void 0 ? void 0 : _a.map((v, i) => fixArgName(v, i === 0 ? undefined : signature.argNames[i - 1]));
-        return [InteropConstructions.method(iface.name, node.name), signature];
-    }
-    printBody(iface, node, signature) {
-        this.printParameters(signature);
-        this.printDeclarations(node);
-        this.printEs2pandaCall(iface, node, signature);
-        this.printReturn(node);
-    }
-    printParameters(signature) {
-        signature.args.forEach((type, index) => {
-            var _a, _b;
-            const name = (_b = (_a = signature.argNames) === null || _a === void 0 ? void 0 : _a.at(index)) !== null && _b !== void 0 ? _b : `arg${index}`;
-            this.writer.writeStatement(this.writer.makeAssign(BridgesConstructions.castedParameter(name), undefined, this.writer.makeFunctionCall(this.castTypeConvertor.convertType(type), [this.writer.makeString(name)])));
-        });
+        const methodName = isImplInterface(iface.name) ? node.name : InteropConstructions.method(iface.name, node.name);
+        return [methodName, signature];
     }
-    printDeclarations(node) {
+    printBody(node, signature, pandaMethodName) {
+        const writer = this.writer;
+        const argNames = signature.argNames.map(BridgesConstructions.castedParameter);
+        const statements = signature.args.map((type, index) => this.writer.makeAssign(BridgesConstructions.castedParameter(signature.argName(index)), undefined, writer.makeFunctionCall(this.castTypeConvertor.convertType(type), [writer.makeString(signature.argName(index))])));
         if (isSequence(node.returnType)) {
-            this.writer.writeExpressionStatement(this.writer.makeString(BridgesConstructions.sequenceLengthDeclaration));
+            argNames.push(BridgesConstructions.sequenceLengthPass);
+            statements.push(makeStatement(writer, BridgesConstructions.sequenceLengthDeclaration));
         }
-    }
-    printEs2pandaCall(iface, node, signature) {
+        const nativeCall = writer.makeFunctionCall(pandaMethodName, argNames.map(a => writer.makeString(a)));
+        writer.writeStatements(...statements);
         if (isVoidType(node.returnType)) {
-            this.writer.writeExpressionStatement(this.makeEs2pandaMethodCall(iface, node, signature));
-            return;
+            writer.writeStatements(writer.makeStatement(nativeCall), writer.makeReturn(writer.makeString('')));
         }
-        this.writer.writeExpressionStatement(this.writer.makeString(BridgesConstructions.resultAssignment(this.makeEs2pandaMethodCall(iface, node, signature).asString())));
-    }
-    makeEs2pandaMethodCall(iface, node, signature) {
-        let suffix = this.config.irHack.isIrHackInterface(iface.name) ? 'Ir' : '';
-        let method = BridgesConstructions.callMethod(InteropConstructions.method(iface.name, node.name));
-        method = method.replace(iface.name, iface.name + suffix);
-        return this.writer.makeFunctionCall(method, signature.argNames
-            .map(it => ({
-            asString: () => BridgesConstructions.castedParameter(it),
-        }))
-            .concat(isSequence(node.returnType) // XXX: original return type
-            ? this.writer.makeString(BridgesConstructions.sequenceLengthPass)
-            : []));
-    }
-    printReturn(node) {
-        if (isVoidType(node.returnType)) {
-            this.writer.writeStatement(this.writer.makeReturn(this.writer.makeString(``)));
-            return;
+        else {
+            writer.writeStatements(writer.makeAssign(BridgesConstructions.result, undefined, nativeCall, true, false), writer.makeReturn(writer.makeString(this.maybeDropConst(this.makeReturnExpression(node.returnType), node))));
         }
-        this.writer.writeStatement(this.writer.makeReturn(this.writer.makeString(this.maybeDropConst(this.makeReturnExpression(node.returnType), node))));
     }
     makeReturnExpression(returnType) {
         if (isSequence(returnType)) {
@@ -11948,10 +12985,10 @@ class IndexPrinter extends SingleFilePrinter {
         this.writer = createDefaultTypescriptWriter();
     }
     filterInterface(node) {
-        return !this.typechecker.isPeer(node.name);
+        return !this.typechecker.isPeer(node) || Config.DoNotPrintPeers.includes(fqName(node));
     }
     printInterface(node) {
-        this.writer.writeExpressionStatement(this.writer.makeString(`export * from "./peers/${node.name}"`));
+        this.writer.writeExpressionStatement(this.writer.makeString(`export * from "./peers/${dropPrefix(node.name, Config.dataClassPrefix)}"`));
     }
 }
 
@@ -12091,7 +13128,7 @@ class MultiFilePrinter extends AbstractVisitor {
     constructor(idl) {
         super();
         this.idl = idl;
-        this.typechecker = new Typechecker(this.idl.entries);
+        this.typechecker = new Typechecker(this.idl);
         this.output = [];
     }
     visit(node) {
@@ -12121,15 +13158,15 @@ class MultiFilePrinter extends AbstractVisitor {
  * limitations under the License.
  */
 class PeersConstructions {
+    static peerName(name) {
+        return dropPrefix(name, Config.dataClassPrefix);
+    }
     static fileName(node) {
-        return `${node}.ts`;
+        return `${this.peerName(node)}.ts`;
     }
     static get pointerParameter() {
         return `pointer`;
     }
-    static get validatePeer() {
-        return `assertValidPeer`;
-    }
     static get super() {
         return `super`;
     }
@@ -12148,8 +13185,8 @@ class PeersConstructions {
                 name: parameter,
                 type: `object | undefined`
             },
-            returnType: (type) => `${parameter} is ${type}`,
-            body: (type) => `${parameter} instanceof ${type}`
+            returnType: (type) => `${parameter} is ${PeersConstructions.peerName(type)}`,
+            body: (type) => `${parameter} instanceof ${PeersConstructions.peerName(type)}`
         };
     }
     static get unpackNullable() {
@@ -12204,13 +13241,13 @@ class PeersConstructions {
         return `setChildrenParentPtr`;
     }
     static newOf(iface) {
-        return `new ${iface}`;
+        return `new ${this.peerName(iface)}`;
     }
     static callPeerMethod(iface, method) {
         return `${iface}.${method}`;
     }
     static brand(iface) {
-        return `brand${capitalize(iface)}`;
+        return `brand${capitalize(this.peerName(iface))}`;
     }
 }
 
@@ -12245,9 +13282,8 @@ class Importer {
         if (this.seen.has(it)) {
             return it;
         }
-        if (!this.typechecker.isPeer(it)) {
-            return it;
-        }
+        // the 'it' parameter can be a modified peer name
+        // and therefor cannot be resolved here
         this.seen.add(it);
         this.import(it, it);
         return it;
@@ -12355,34 +13391,24 @@ class LibraryTypeConvertor extends TopLevelTypeConvertor {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-class ImporterTypeConvertor extends TopLevelTypeConvertor {
-    constructor(importer, typechecker) {
-        super(typechecker, {
-            optional: (type) => {
-                this.convertType(type.type);
-                return type;
-            },
-            sequence: (type) => {
-                this.convertType(type.elementType[0]);
-                return type;
-            },
-            enum: (type) => {
-                this.importer.withEnumImport(type.name);
-                return type;
-            },
-            reference: (type) => {
-                this.importer.withPeerImport(baseName(type));
-                return type;
-            },
-            string: (type) => type,
-            number: (type) => type,
-            boolean: (type) => type,
-            void: (type) => type,
-            pointer: (type) => type,
-            undefined: (type) => type
-        });
-        this.importer = importer;
+function convertAndImport(importer, converter, type) {
+    const result = converter.convertType(type);
+    if (isOptionalType(type)) {
+        convertAndImport(importer, converter, type.type);
     }
+    else if (isContainerType(type) && IDLContainerUtils.isSequence(type)) {
+        convertAndImport(importer, converter, type.elementType[0]);
+    }
+    else if (isReferenceType(type)) {
+        const node = converter.typechecker.resolveReference(type);
+        if (node && isEnum$1(node)) {
+            importer.withEnumImport(result);
+        }
+        else if (node && isInterface$1(node) && converter.typechecker.isPeer(node)) {
+            importer.withPeerImport(result);
+        }
+    }
+    return result;
 }
 
 /*
@@ -12445,12 +13471,12 @@ class BindingReturnValueTypeConvertor extends TopLevelTypeConvertor {
         super(typechecker, {
             sequence: (type) => wrap(PeersConstructions.arrayOfPointersToArrayOfPeers),
             string: (type) => wrap(PeersConstructions.receiveString),
-            reference: (type) => this.typechecker.isHeir(type.name, Config.astNodeCommonAncestor)
+            reference: (type) => this.typechecker.isHeir(type, Config.astNodeCommonAncestor)
                 ? wrap(PeersConstructions.unpackNonNullable)
                 : wrap(baseNameString(type.name)),
             optional: (type) => {
                 if (isReferenceType(type.type)) {
-                    if (this.typechecker.isHeir(type.type.name, Config.astNodeCommonAncestor)) {
+                    if (this.typechecker.isHeir(type.type, Config.astNodeCommonAncestor)) {
                         return wrap(PeersConstructions.unpackNullable);
                     }
                     return wrap(PeersConstructions.newOf(baseNameString(type.type.name)));
@@ -12501,16 +13527,20 @@ class PeerPrinter extends SingleFilePrinter {
         super(idl);
         this.config = config;
         this.node = node;
-        this.typechecker = new Typechecker(this.idl.entries);
+        this.typechecker = new Typechecker(this.idl);
         this.importer = new Importer(this.typechecker, `.`, this.node.name);
         this.bindingParameterTypeConvertor = new BindingParameterTypeConvertor(this.typechecker);
         this.bindingReturnValueTypeConvertor = new BindingReturnValueTypeConvertor(this.typechecker);
         this.parent = (_a = parent(this.node)) !== null && _a !== void 0 ? _a : Config.defaultAncestor;
-        this.writer = new TSLanguageWriter(new IndentedPrinter(), createEmptyReferenceResolver(), { convert: (node) => composedConvertType(new LibraryTypeConvertor(this.typechecker), new ImporterTypeConvertor(this.importer, this.typechecker), node)
-        });
+        this.writer = new TSLanguageWriter(new IndentedPrinter(), createEmptyReferenceResolver(), { convert: (node) => convertAndImport(this.importer, new class extends LibraryTypeConvertor {
+                convertTypeReference(type) {
+                    return dropPrefix(super.convertTypeReference(type), Config.dataClassPrefix);
+                }
+            }(this.typechecker), node) });
     }
     printPeer() {
-        this.writer.writeClass(this.node.name, () => this.printBody(), this.parent ? this.importer.withPeerImport(baseNameString(this.parent)) : undefined);
+        this.writer.writeClass(PeersConstructions.peerName(this.node.name), // XXX: Change peer name
+        () => this.printBody(), this.parent ? this.importer.withPeerImport(baseNameString(this.parent)) : undefined);
     }
     printBody() {
         this.printConstructor();
@@ -12519,21 +13549,16 @@ class PeerPrinter extends SingleFilePrinter {
         this.printBrand();
     }
     printConstructor() {
-        this.writer.writeConstructorImplementation(this.node.name, new MethodSignature(IDLVoidType, [
-            IDLPointerType
-        ], undefined, undefined, undefined, [
-            PeersConstructions.pointerParameter
-        ]), () => {
-            var _a;
-            if (isReal(this.node)) {
-                this.writer.writeExpressionStatement(this.writer.makeFunctionCall(PeersConstructions.validatePeer, [
-                    this.writer.makeString(PeersConstructions.pointerParameter),
-                    this.writer.makeString((_a = nodeType(this.node)) !== null && _a !== void 0 ? _a : throwException(`missing attribute node type: ${this.node.name}`)),
-                ]));
-            }
-            this.writer.writeExpressionStatements(this.writer.makeFunctionCall(PeersConstructions.super, [
-                this.writer.makeString(PeersConstructions.pointerParameter)
-            ]));
+        isReal(this.node);
+        const isAstNodeDescendant = this.typechecker.isHeir(this.node, Config.astNodeCommonAncestor);
+        const args = [IDLPointerType];
+        const argNames = [PeersConstructions.pointerParameter];
+        if (isAstNodeDescendant) {
+            args.push(createReferenceType(Config.nodeTypeAttribute));
+            argNames.push('astNodeType');
+        }
+        this.writer.writeConstructorImplementation(this.node.name, new MethodSignature(IDLVoidType, args, undefined, undefined, undefined, argNames), () => {
+            this.writer.writeExpressionStatements(this.writer.makeFunctionCall(PeersConstructions.super, argNames.map(n => this.writer.makeString(n))));
         });
     }
     printTypeGuard() {
@@ -12546,7 +13571,10 @@ class PeerPrinter extends SingleFilePrinter {
             if (isCreateOrUpdate(it.name)) {
                 // TODO: This condition is not clear - classes with c_type attribute
                 // is not abstract too, is it?
+                // The check for a native type allows types that is descendants of
+                // AstNode but have not type attribute, for example, varbinder.FunctionDecl
                 if (isAbstract(this.node) && nativeType(this.node) === undefined) {
+                    console.log(`Skipped ${this.node.name}.${it.name}`);
                     return;
                 }
                 return this.printCreateOrUpdate(it);
@@ -12651,18 +13679,19 @@ class PeerPrinter extends SingleFilePrinter {
         this.writer.writeMethodImplementation(makeMethod(PeersConstructions.createOrUpdate(this.node.name, node.name), node.parameters
             .map(it => createParameter(it.name, flattenType(it.type)))
             .concat(extraParameters), flattenType(node.returnType), [MethodModifier.STATIC]), (writer) => {
-            const newExpr = this.writer.makeNewObject(this.node.name, [
-                this.writer.makeFunctionCall(this.writer.makeString(PeersConstructions.callBinding(this.node.name, node.name, nodeNamespace(this.node))), this.makeBindingArguments(node.parameters)),
-            ]);
+            var _a;
+            const nativeCall = this.writer.makeFunctionCall(this.writer.makeString(PeersConstructions.callBinding(this.node.name, node.name, nodeNamespace(this.node))), this.makeBindingArguments(node.parameters));
             const varName = 'result';
             const makeStmt = (property) => PeerPrinter.makeExtraStatement(property, PeerPrinter.resolveProperty(property, this.node, this.idl), ['should_not_be_here', varName], this.writer);
             const extraStatements = this.config.parameters.getParameters(this.node.name)
                 .map(makeStmt);
             if (isReal(this.node)) {
+                const astNodeType = (_a = this.typechecker.nodeTypeName(this.node)) !== null && _a !== void 0 ? _a : throwException(`missing attribute node type: ${this.node.name}`);
+                const newExpr = writer.makeNewObject(this.node.name, [nativeCall, writer.makeString(astNodeType)]);
                 this.writer.writeStatements(this.writer.makeAssign(varName, createReferenceType(this.node.name), newExpr, true), ...extraStatements, this.writer.makeStatement(this.writer.makeMethodCall(varName, PeersConstructions.setChildrenParentPtrMethod, [])), this.writer.makeReturn(this.writer.makeString(varName)));
             }
             else {
-                this.writer.writeStatement(this.writer.makeReturn(newExpr));
+                writer.writeStatement(writer.makeReturn(writer.makeNewObject(this.node.name, [nativeCall])));
             }
         });
     }
@@ -12680,8 +13709,8 @@ class PeerPrinter extends SingleFilePrinter {
         if (enumValue === undefined) {
             return;
         }
-        const qualified = `${this.importer.withEnumImport(Config.nodeTypeAttribute)}.${enumValue}`;
-        this.writer.writeExpressionStatements(this.writer.makeString(`if (!nodeByType.has(${qualified})) {`), this.writer.makeString(`    nodeByType.set(${qualified}, (peer: KNativePointer) => new ${this.node.name}(peer))`), this.writer.makeString(`}`));
+        this.importer.withEnumImport(Config.nodeTypeAttribute);
+        this.writer.writeExpressionStatements(this.writer.makeString(`if (!nodeByType.has(${enumValue})) {`), this.writer.makeString(`    nodeByType.set(${enumValue}, (peer: KNativePointer) => new ${this.node.name}(peer, ${enumValue}))`), this.writer.makeString(`}`));
     }
     printBrand() {
         this.writer.writeProperty(PeersConstructions.brand(this.node.name), IDLUndefinedType, [FieldModifier.PROTECTED, FieldModifier.READONLY]);
@@ -12708,7 +13737,7 @@ class AllPeersPrinter extends MultiFilePrinter {
         this.config = config;
     }
     filterInterface(node) {
-        return !this.typechecker.isPeer(node.name);
+        return !this.typechecker.isPeer(node) || Config.DoNotPrintPeers.includes(fqName(node));
     }
     printInterface(node) {
         return {
@@ -12772,8 +13801,7 @@ class FactoryPrinter extends SingleFilePrinter {
         super(idl);
         this.config = config;
         this.importer = new Importer(this.typechecker, `peers`);
-        this.writer = new TSLanguageWriter(new IndentedPrinter(), createEmptyReferenceResolver(), { convert: (node) => composedConvertType(new LibraryTypeConvertor(this.typechecker), new ImporterTypeConvertor(this.importer, this.typechecker), node)
-        });
+        this.writer = new TSLanguageWriter(new IndentedPrinter(), createEmptyReferenceResolver(), { convert: (node) => convertAndImport(this.importer, new LibraryTypeConvertor(this.typechecker), node) });
     }
     prologue() {
         this.writer.writeExpressionStatements(this.writer.makeString(FactoryConstructions.prologue));
@@ -12784,7 +13812,7 @@ class FactoryPrinter extends SingleFilePrinter {
         this.writer.writeExpressionStatements(this.writer.makeString(FactoryConstructions.epilogue));
     }
     filterInterface(node) {
-        return !this.typechecker.isPeer(node.name) || FactoryPrinter.getUniversalCreate(node) == undefined;
+        return !this.typechecker.isPeer(node) || FactoryPrinter.getUniversalCreate(node) == undefined;
     }
     printInterface(node) {
         this.printCreate(node);
@@ -12915,7 +13943,7 @@ class Transformer {
 class BaseInterfaceFilterTransformer extends Transformer {
     constructor(file, removeNamespaces = false) {
         super(file, removeNamespaces);
-        this.typechecker = new Typechecker(this.file.entries);
+        this.typechecker = new Typechecker(this.file);
     }
     transformInterface(entry) {
         if (this.shouldFilterOutInterface(entry)) {
@@ -12933,7 +13961,7 @@ class BaseInterfaceFilterTransformer extends Transformer {
             .map(innerTypeIfContainer)
             .filter(it => {
             if (isReferenceType(it)) {
-                const decl = this.typechecker.findRealDeclaration(it.name);
+                const decl = this.typechecker.resolveReference(it);
                 if (!decl || isInterface$1(decl) && predicate(decl)) {
                     return true;
                 }
@@ -12975,77 +14003,6 @@ class OptionsFilterTransformer extends BaseInterfaceFilterTransformer {
     }
 }
 
-/*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-class AddContextDeclarationTransformer extends Transformer {
-    constructor(file) {
-        super(file);
-    }
-    transformInterface(entry) {
-        return entry;
-    }
-    transformed() {
-        let file = createFile(this.file.entries
-            .concat(createInterface(Config.context, IDLInterfaceSubkind.Class, undefined, undefined, undefined, undefined, undefined, undefined, undefined, {
-            extendedAttributes: [{
-                    name: Config.nodeNamespaceAttribute,
-                    value: Config.irNamespace
-                }]
-        })), this.file.fileName, this.file.packageClause);
-        return linkParentBack(file);
-    }
-}
-
-/*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-class MultipleDeclarationFilterTransformer extends Transformer {
-    constructor(file) {
-        super(file);
-        this.seen = new Map();
-        // TODO: namespaces
-        linearizeNamespaceMembers(this.file.entries).forEach(it => {
-            var _a;
-            let name = baseNameString(it.name);
-            const oldValue = (_a = this.seen.get(name)) !== null && _a !== void 0 ? _a : 0;
-            this.seen.set(name, oldValue + 1);
-        });
-    }
-    transformInterface(entry) {
-        var _a;
-        const occurence = (_a = this.seen.get(baseNameString(entry.name))) !== null && _a !== void 0 ? _a : 0;
-        if (occurence > 1 && !isIrNamespace(entry)) {
-            console.log(`FILTERED (MULTIPLE) ${entry.name}`);
-            this.seen.set(baseNameString(entry.name), occurence - 1);
-            return undefined;
-        }
-        return entry;
-    }
-}
-
 /*
  * Copyright (c) 2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -13087,120 +14044,6 @@ class ParameterTransformer extends Transformer {
     }
 }
 
-/*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-class TwinMergeTransformer extends Transformer {
-    constructor(file) {
-        super(file);
-        const all = linearizeNamespaceMembers(file.entries).filter(isInterface$1);
-        this.twins = new Set();
-        all
-            .filter(it => this.hasPrefix(it.name))
-            .forEach(it => {
-            const twin = all.find(candidate => this.withPrefix(baseNameString(candidate.name)) === it.name);
-            if (twin === undefined)
-                return;
-            if (!isIrNamespace(twin))
-                return;
-            this.twins.add(twin.name);
-        });
-    }
-    hasTwin(name) {
-        name = baseNameString(name);
-        if (this.hasPrefix(name)) {
-            return this.twins.has(this.withoutPrefix(name));
-        }
-        return this.twins.has(name);
-    }
-    transformInterface(node) {
-        if (node.name === Config.astNodeCommonAncestor) { // TODO: is handwritten
-            return createUpdatedInterface(node, node.methods.map(it => this.transformMethod(it)));
-        }
-        if (this.hasTwin(node.name) && this.hasPrefix(node.name)) {
-            return undefined;
-        }
-        if (this.hasTwin(node.name) || this.hasPrefix(node.name)) {
-            return createUpdatedInterface(node, node.methods.map(it => this.transformMethod(it)), this.withoutPrefix(node.name), [createReferenceType(Config.defaultAncestor)]);
-        }
-        return createUpdatedInterface(node, node.methods.map(it => this.transformMethod(it)));
-    }
-    transformMethod(node) {
-        return createUpdatedMethod(node, this.withoutPrefix(node.name), node.parameters.map(it => this.transformParameter(it)), this.transformType(node.returnType));
-    }
-    transformParameter(node) {
-        return createParameter(this.withoutPrefix(node.name), this.transformType(node.type), node.isOptional, node.isVariadic);
-    }
-    transformType(node) {
-        if (isContainerType(node)) {
-            if (isSequence(node)) {
-                return createSequence(this.transformType(innerType(node)));
-            }
-        }
-        if (isReferenceType(node)) {
-            return createReferenceType(this.withoutPrefix(node.name), node.typeArguments);
-        }
-        return node;
-    }
-    withoutPrefix(name) {
-        if (name.startsWith(Config.dataClassPrefix)) {
-            return name.slice(Config.dataClassPrefix.length);
-        }
-        return name;
-    }
-    withPrefix(name) {
-        return `${Config.dataClassPrefix}${name}`;
-    }
-    hasPrefix(name) {
-        return name.startsWith(Config.dataClassPrefix);
-    }
-}
-
-/*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-class AstNodeFilterTransformer extends BaseInterfaceFilterTransformer {
-    constructor(idl) {
-        super(idl, true);
-    }
-    shouldFilterOutInterface(node) {
-        if (this.typechecker.isHeir(node.name, Config.astNodeCommonAncestor))
-            return false;
-        if (this.typechecker.isHeir(node.name, Config.defaultAncestor))
-            return false;
-        console.log(`FILTERED (AST) ${node.name}`);
-        return true;
-    }
-    shouldFilterOutMethod(node, name) {
-        return false;
-    }
-    shouldFilterOutProperty(node, name) {
-        return false;
-    }
-}
-
 /*
  * Copyright (c) 2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -13219,7 +14062,7 @@ class NullabilityTransformer extends Transformer {
     constructor(file, config) {
         super(file);
         this.config = config;
-        this.typechecker = new Typechecker(this.file.entries);
+        this.typechecker = new Typechecker(this.file);
     }
     transformInterface(node) {
         return createUpdatedInterface(node, node.methods
@@ -13243,7 +14086,7 @@ class NullabilityTransformer extends Transformer {
         // TODO: maybe heirs of defaultAncestors aren't nullable
         // TODO: handwritten
         if (isReferenceType(type)) {
-            if (this.typechecker.isPeer(type.name) || type.name === Config.astNodeCommonAncestor) {
+            if (this.typechecker.isPeer(type) || type.name === Config.astNodeCommonAncestor) {
                 return createOptionalType(type);
             }
         }
@@ -13286,7 +14129,7 @@ function remove(array, value) {
 class AttributeTransformer extends Transformer {
     constructor(file) {
         super(file);
-        this.convertor = new LibraryTypeConvertor(new Typechecker(this.file.entries));
+        this.convertor = new LibraryTypeConvertor(new Typechecker(this.file));
     }
     convertToKey(type) {
         if (isOptionalType(type)) {
@@ -13482,10 +14325,10 @@ class DynamicEmitter {
         let idl = this.file;
         this.printFile(this.enumsPrinter, idl);
         idl = this.withLog(new OptionsFilterTransformer(this.config, idl));
-        idl = this.withLog(new AddContextDeclarationTransformer(idl));
-        idl = this.withLog(new TwinMergeTransformer(idl));
-        idl = this.withLog(new MultipleDeclarationFilterTransformer(idl));
-        idl = this.withLog(new AstNodeFilterTransformer(idl));
+        //idl = this.withLog(new AddContextDeclarationTransformer(idl))
+        //idl = this.withLog(new TwinMergeTransformer(idl))
+        //idl = this.withLog(new MultipleDeclarationFilterTransformer(idl))
+        //idl = this.withLog(new AstNodeFilterTransformer(idl))
         this.printPeers(idl);
         this.printInterop(idl);
     }
@@ -13583,8 +14426,8 @@ class IgnoreOptions {
                 this.ignored.set(ns, new Map());
             }
             const last = name.at(-1);
-            const key = last === '-' || last === '+' ? name.slice(0, -1) : name;
-            this.ignored.get(ns).set(key, last !== '+');
+            const key = last === '!' ? name.slice(0, -last.length) : name;
+            this.ignored.get(ns).set(key, last !== '!');
         });
     }
     isIgnoredMethod(iface, method) {
@@ -13595,9 +14438,13 @@ class IgnoreOptions {
         var _a;
         return (_a = this.partial) === null || _a === void 0 ? void 0 : _a.some(it => { var _a; return it.interface === iface && ((_a = it.properties) === null || _a === void 0 ? void 0 : _a.includes(name)); });
     }
-    isIgnoredInterface(name, ns = '') {
+    isIgnoredInterface(name, namespace = '') {
         var _a, _b;
-        return (_b = (_a = this.ignored.get(ns)) === null || _a === void 0 ? void 0 : _a.get(name)) !== null && _b !== void 0 ? _b : false;
+        const ns = this.ignored.get(namespace);
+        if (ns && ((_b = (_a = ns.get(name)) !== null && _a !== void 0 ? _a : ns.get('*')) !== null && _b !== void 0 ? _b : false)) {
+            return true;
+        }
+        return false;
     }
 }
 // TODO: remove when interfaces fixed!