@idlizer/arktscgen 2.1.10-arktscgen-3a → 2.1.10-arktscgen-5

package/lib/index.js

@@ -22,7 +22,6 @@
 var path$1 = require('node:path');
 var path = require('path');
 var fs = require('fs');
-var ts = require('typescript');
 require('console');
 require('node:os');
 var fs$1 = require('node:fs');
@@ -50,7 +49,6 @@ function _interopNamespaceDefault(e) {
 var path__namespace$1 = /*#__PURE__*/_interopNamespaceDefault(path$1);
 var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
 var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
-var ts__namespace = /*#__PURE__*/_interopNamespaceDefault(ts);
 var fs__namespace$1 = /*#__PURE__*/_interopNamespaceDefault(fs$1);
 var ps__namespace = /*#__PURE__*/_interopNamespaceDefault(ps);
 
@@ -3657,7 +3655,6 @@ class Language {
     static fromString(name) {
         switch (name) {
             case "arkts": return Language.ARKTS;
-            case "java": return Language.JAVA;
             case "ts": return Language.TS;
             case "cangjie": return Language.CJ;
             case "cpp": return Language.CPP;
@@ -3668,7 +3665,6 @@ class Language {
 }
 Language.TS = new Language("TS", ".ts");
 Language.ARKTS = new Language("ArkTS", ".ts"); // using .ts for ArkTS until we get rit of tsc preprocessing
-Language.JAVA = new Language("Java", ".java");
 Language.CPP = new Language("C++", ".cc");
 Language.CJ = new Language("CangJie", ".cj");
 Language.KOTLIN = new Language("Kotlin", ".kt");
@@ -3847,11 +3843,13 @@ var IDLExtendedAttributes;
     IDLExtendedAttributes["TypeAnnotations"] = "TypeAnnotations";
     IDLExtendedAttributes["TypeArguments"] = "TypeArguments";
     IDLExtendedAttributes["TypeParameters"] = "TypeParameters";
+    IDLExtendedAttributes["TypeParametersDefaults"] = "TypeParametersDefaults";
     IDLExtendedAttributes["VerbatimDts"] = "VerbatimDts";
     IDLExtendedAttributes["HandWrittenImplementation"] = "HandWrittenImplementation";
     IDLExtendedAttributes["ExtraMethod"] = "ExtraMethod";
     IDLExtendedAttributes["OverloadAlias"] = "OverloadAlias";
     IDLExtendedAttributes["OverloadPriority"] = "OverloadPriority";
+    IDLExtendedAttributes["TransformOnSerialize"] = "TransformOnSerialize";
 })(IDLExtendedAttributes || (IDLExtendedAttributes = {}));
 var IDLAccessorAttribute;
 (function (IDLAccessorAttribute) {
@@ -4138,6 +4136,10 @@ function isEntry(node) {
 function isNamespace(node) {
     return node.kind === IDLKind.Namespace;
 }
+function isSyntheticEntry(node) {
+    var _a;
+    return isDefined((_a = node.extendedAttributes) === null || _a === void 0 ? void 0 : _a.find(it => it.name === IDLExtendedAttributes.Synthetic));
+}
 function isOptionalType(type) {
     return type.kind === IDLKind.OptionalType;
 }
@@ -4190,6 +4192,7 @@ const IDLSerializerBuffer = createPrimitiveType('SerializerBuffer');
 const IDLFunctionType = createPrimitiveType('Function');
 const IDLCustomObjectType = createPrimitiveType('CustomObject');
 createPrimitiveType('InteropReturnBuffer');
+const IDLNullTypeName = "idlize.stdlib.Null";
 function createNamespace(name, members, nodeInitializer) {
     return Object.assign(Object.assign({ kind: IDLKind.Namespace, members: members !== null && members !== void 0 ? members : [], name: name }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
 }
@@ -4226,6 +4229,7 @@ function getNamespacesPathFor(node) {
     }
     return result;
 }
+const nodesWithoutIDLFiles = new Set();
 function getFileFor(node) {
     let iterator = node;
     while (iterator) {
@@ -4233,7 +4237,11 @@ function getFileFor(node) {
             return iterator;
         iterator = iterator.parent;
     }
-    console.warn(`Node ${getQualifiedName(node, "namespace.name")} does not have IDLFile in parents`);
+    const name = getQualifiedName(node, "namespace.name");
+    if (!nodesWithoutIDLFiles.has(name)) {
+        console.warn(`Node ${name} does not have IDLFile in parents`);
+        nodesWithoutIDLFiles.add(name);
+    }
     return undefined;
 }
 function getPackageClause(node) {
@@ -4561,23 +4569,29 @@ function escapeIDLKeyword(name) {
 const printedIndentInc = "[[indent-inc]]";
 const printedIndentDec = "[[indent-dec]]";
 function printType(type, options) {
+    var _a;
     if (!type)
         throw new Error("Missing type");
     if (isInterface$1(type))
         return type.name;
-    if (isOptionalType(type))
-        return `(${printType(type.type)} or ${IDLUndefinedType.name})`;
+    if (isOptionalType(type)) {
+        if (hasExtAttribute(type, IDLExtendedAttributes.UnionOnlyNull))
+            return `(${printType(type.type)} or ${IDLNullTypeName})`;
+        else if (hasExtAttribute(type, IDLExtendedAttributes.UnionWithNull))
+            return `(${printType(type.type)} or ${IDLUndefinedType.name} or${IDLNullTypeName})`;
+        else
+            return `(${printType(type.type)} or ${IDLUndefinedType.name})`;
+    }
     if (isPrimitiveType(type))
         return type.name;
     if (isContainerType(type))
         return `${type.containerKind}<${type.elementType.map(it => printType(it)).join(", ")}>`;
     if (isReferenceType(type)) {
-        const extAttrs = type.extendedAttributes ? Array.from(type.extendedAttributes) : [];
         if (type.typeArguments)
-            extAttrs.push({ name: IDLExtendedAttributes.TypeArguments, value: type.typeArguments.map(it => printType(it)).join(",") });
-        if (!extAttrs.length)
+            updateExtAttribute(type, IDLExtendedAttributes.TypeArguments, type.typeArguments.map(it => printType(it)).join(","));
+        if (!((_a = type.extendedAttributes) === null || _a === void 0 ? void 0 : _a.length))
             return type.name;
-        let res = `[${quoteAttributeValues(extAttrs)}] ${type.name}`;
+        let res = `[${quoteAttributeValues(type.extendedAttributes)}] ${type.name}`;
         if (options === null || options === void 0 ? void 0 : options.bracketsAroundReferenceTypeWithExtAttrs)
             return `(${res})`;
         return res;
@@ -4647,18 +4661,31 @@ function printExtendedAttributes(idl, indentLevel) {
             break;
     }
     const attributes = Array.from(idl.extendedAttributes || []);
-    if (typeParameters === null || typeParameters === void 0 ? void 0 : typeParameters.length)
+    if ((typeParameters === null || typeParameters === void 0 ? void 0 : typeParameters.length) && !attributes.find(x => x.name === IDLExtendedAttributes.TypeParameters))
         attributes.push({ name: IDLExtendedAttributes.TypeParameters, value: typeParameters.join(",") });
-    if (typeArguments === null || typeArguments === void 0 ? void 0 : typeArguments.length)
+    if ((typeArguments === null || typeArguments === void 0 ? void 0 : typeArguments.length) && !attributes.find(x => x.name === IDLExtendedAttributes.TypeArguments))
         attributes.push({ name: IDLExtendedAttributes.TypeArguments, value: typeArguments.map(it => printType(it)).join(",") });
     if (idl.documentation) {
         let docs = {
             name: IDLExtendedAttributes.Documentation,
             value: idl.documentation
         };
-        attributes.push(docs);
+        attributes.unshift(docs);
+    }
+    // Deduplicate
+    const names = new Set();
+    const actualAttributes = [];
+    for (const attr of attributes) {
+        if (names.has(attr.name)) {
+            continue;
+        }
+        names.add(attr.name);
+        actualAttributes.push(attr);
     }
-    const attrSpec = quoteAttributeValues(attributes);
+    if (actualAttributes.length == 0) {
+        return [];
+    }
+    const attrSpec = quoteAttributeValues(actualAttributes);
     return attrSpec ? [`[${attrSpec}]`] : [];
 }
 const attributesToQuote = new Set([
@@ -4670,6 +4697,7 @@ const attributesToQuote = new Set([
     IDLExtendedAttributes.TraceKey,
     IDLExtendedAttributes.TypeArguments,
     IDLExtendedAttributes.TypeParameters,
+    IDLExtendedAttributes.TypeParametersDefaults,
 ]);
 function quoteAttributeValues(attributes) {
     return attributes === null || attributes === void 0 ? void 0 : attributes.map(it => {
@@ -4858,6 +4886,17 @@ function getExtAttribute(node, name) {
     var _a, _b;
     return (_b = (_a = node.extendedAttributes) === null || _a === void 0 ? void 0 : _a.find(it => it.name === name)) === null || _b === void 0 ? void 0 : _b.value;
 }
+function removeExtAttribute(node, name) {
+    if (node.extendedAttributes) {
+        node.extendedAttributes = node.extendedAttributes.filter(it => it.name !== name);
+    }
+}
+function updateExtAttribute(node, name, value) {
+    var _a;
+    removeExtAttribute(node, name);
+    (_a = node.extendedAttributes) !== null && _a !== void 0 ? _a : (node.extendedAttributes = []);
+    node.extendedAttributes.push({ name, value });
+}
 const IDLContainerUtils = {
     isRecord: (x) => isContainerType(x) && x.containerKind === 'record',
     isSequence: (x) => isContainerType(x) && x.containerKind === 'sequence',
@@ -4906,6 +4945,13 @@ function linearizeNamespaceMembers(entries) {
     return linearized;
 }
 
+const stdlibModule = {
+    name: "__stdlib",
+    packages: [""],
+    useFoldersLayout: false,
+    external: true,
+    tsLikePackage: "__stdlib"
+};
 const modulesCache = new Map();
 /**
  * Is source submodule of target.
@@ -4945,7 +4991,7 @@ function getApplicableModuleFor(packageName) {
     if (applicableModules.length === 0) {
         if (packageName === '') {
             console.error("WARNING: use current module for empty package");
-            return currentModule();
+            return stdlibModule;
         }
         if (packageName.startsWith(`idlize.`)) {
             return currentModule();
@@ -5270,8 +5316,11 @@ class LambdaExpression {
         if (this.body) {
             writer.writeStatement(new BlockStatement(this.body, isScoped, false));
         }
-        writer.features.forEach(([feature, module]) => {
-            this.originalWriter.addFeature(feature, module);
+        writer.features.forEach((feature) => {
+            if (feature.type === "raw")
+                this.originalWriter.addFeature(feature.feature, feature.module);
+            else
+                this.originalWriter.addFeature(feature.node);
         });
         return writer.getOutput()
             .map(line => (line.endsWith('{') || line.endsWith('}') || line.endsWith(';')) ? line : `${line};`)
@@ -5296,6 +5345,8 @@ var FieldModifier;
     FieldModifier[FieldModifier["VOLATILE"] = 6] = "VOLATILE";
     FieldModifier[FieldModifier["INTERNAL"] = 7] = "INTERNAL";
     FieldModifier[FieldModifier["OVERRIDE"] = 8] = "OVERRIDE";
+    FieldModifier[FieldModifier["GET"] = 9] = "GET";
+    FieldModifier[FieldModifier["SET"] = 10] = "SET";
 })(FieldModifier || (FieldModifier = {}));
 var MethodModifier;
 (function (MethodModifier) {
@@ -5406,8 +5457,11 @@ class LanguageWriter {
         return this.printer.indentDepth();
     }
     maybeSemicolon() { return ";"; }
-    addFeature(feature, module) {
-        this.features.push([feature, module]);
+    addFeature(featureOrNode, module) {
+        if (typeof featureOrNode === "string")
+            this.features.push({ type: "raw", feature: featureOrNode, module: module });
+        else
+            this.features.push({ type: "idl", node: featureOrNode });
     }
     // version of makeCast which uses TypeCheck.typeCast<T>(value) call for ETS language writer
     // Use it only if TypeChecker class is added as import to the generated file
@@ -5893,6 +5947,70 @@ function convertDeclaration(convertor, decl) {
     throw new Error(`Unknown declaration type ${decl.kind ? IDLKind[decl.kind] : "(undefined kind)"}`);
 }
 
+const findTopLevelConflicts_cache = new Map();
+function findTopLevelConflicts(library, language) {
+    if (!findTopLevelConflicts_cache.has(library))
+        findTopLevelConflicts_cache.set(library, new Map);
+    const libraryCache = findTopLevelConflicts_cache.get(library);
+    if (!libraryCache.has(language))
+        libraryCache.set(language, findTopLevelConflictsUncached(library, language));
+    return libraryCache.get(language);
+}
+function findTopLevelConflictsUncached(library, language) {
+    const foundNames = new Set();
+    const conflictingNames = new Set();
+    const ignoreTypedefs = language === Language.CPP;
+    for (const file of library.files) {
+        for (const entry of file.entries) {
+            if (isSyntheticEntry(entry))
+                continue;
+            if (ignoreTypedefs && isTypedef$1(entry))
+                // for redefinitions like `typedef _Resource Resource;` - in CPP than anyway will be expanded to Resource declaration
+                continue;
+            if (isCallback$1(entry) || isInterface$1(entry) || isTypedef$1(entry) || isEnum$1(entry)) {
+                if (foundNames.has(entry.name)) {
+                    conflictingNames.add(entry.name);
+                }
+                else {
+                    foundNames.add(entry.name);
+                }
+            }
+        }
+    }
+    return Array.from(conflictingNames);
+}
+function isTopLevelConflicted(library, language, node) {
+    const topLevelConflicts = findTopLevelConflicts(library, language);
+    while (node.parent && isNamespace(node.parent)) {
+        node = node.parent;
+    }
+    return node.parent !== undefined
+        && isFile(node.parent) && isEntry(node) && topLevelConflicts.includes(node.name);
+}
+
+/*
+ * 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.
+ */
+var LayoutNodeRole;
+(function (LayoutNodeRole) {
+    LayoutNodeRole[LayoutNodeRole["PEER"] = 0] = "PEER";
+    LayoutNodeRole[LayoutNodeRole["INTERFACE"] = 1] = "INTERFACE";
+    LayoutNodeRole[LayoutNodeRole["GLOBAL"] = 2] = "GLOBAL";
+    LayoutNodeRole[LayoutNodeRole["COMPONENT"] = 3] = "COMPONENT";
+    LayoutNodeRole[LayoutNodeRole["SERIALIZER"] = 4] = "SERIALIZER";
+})(LayoutNodeRole || (LayoutNodeRole = {}));
+
 /*
  * Copyright (c) 2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -6158,12 +6276,14 @@ const IncorrectLiteral = new DiagnosticMessageGroup("error", "IncorrectLiteral",
 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 UnrecognizedSymbols = new DiagnosticMessageGroup("fatal", "UnrecognizedSymbols", "Unrecognized symbols");
 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");
+const InlineParsingDepthExceeded = new DiagnosticMessageGroup("fatal", "InlineParsingDepthExceeded", "Inline parsing depth exceeded");
 class FatalParserException extends Error {
     constructor(diagnosticMessages) {
         super();
@@ -6195,7 +6315,7 @@ class Parser {
         // TypeParameters support
         this._generics = [];
         // TypeArguments parsing support
-        this._enableInLiteralParsing = false;
+        this._inLiteralParsingLevel = 0;
         // 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;
@@ -6283,17 +6403,17 @@ class Parser {
             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] == "\"") {
+        if (this._inLiteralParsingLevel && (this.content[this._curOffset] == "\"" || 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._curToken = { kind: TokenKind.Symbol, value: this.content[this._curOffset], 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");
+            UnrecognizedSymbols.throwDiagnosticMessage([{ documentPath: this.fileName, lines: this.lines, range: { start: pos, end: pos } }]);
         }
         // Uncomment in case of parser debugging
         // if (token) {
@@ -6587,28 +6707,32 @@ class Parser {
                 duplicates.add(name.value);
             }
             names.add(name.value);
-            if (name.value == IDLExtendedAttributes.TypeArguments) {
+            if (name.value == IDLExtendedAttributes.TypeArguments || name.value == IDLExtendedAttributes.TypeParametersDefaults) {
                 // TypeArguments parsing support
                 try {
-                    this._enableInLiteralParsing = true;
+                    this._inLiteralParsingLevel += 1;
+                    if (this._inLiteralParsingLevel > 2) {
+                        InlineParsingDepthExceeded.throwDiagnosticMessage([this.curLocation]);
+                    }
                     this.skip("=");
                     const vloc = this.trackLocation();
                     const start = this._curOffset; // Already after first quote
-                    this.skip("\"");
+                    this.skip(this._inLiteralParsingLevel == 2 ? "'" : "\"");
                     const types = this.parseTypeList();
                     const end = this._curOffset - 1; // Already after second quote
-                    this._enableInLiteralParsing = false;
-                    this.skip("\"");
+                    this._inLiteralParsingLevel -= 1;
+                    // Note that second this._inLiteralParsingLevel comparison happens after decrement
+                    this.skip(this._inLiteralParsingLevel == 1 ? "'" : "\"");
                     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("\"");
+                    if (e instanceof DiagnosticException && e.diagnosticMessage.severity != "fatal") {
+                        this.skipToAfter("\"");
+                    }
+                    this._inLiteralParsingLevel = 0;
                     throw e;
                 }
-                finally {
-                    this._enableInLiteralParsing = false;
-                }
             }
             else {
                 let value;
@@ -6780,9 +6904,9 @@ class Parser {
         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 });
+        // Note that raw value (with quoted strings) is used here, that provides compatibility with older code (while being different from `dictionary` processing)
+        return createConstant(name.value, type, value.value, { extendedAttributes: ext, nodeLocation: sloc(), nameLocation: name.location, valueLocation: value.location });
     }
     parseAttribute() {
         const sloc = this.trackLocation();
@@ -6866,11 +6990,14 @@ class Parser {
         const sloc = this.trackLocation();
         const type = this.parsePrimitiveType();
         const name = this.parseSingleIdentifier();
-        this.skip("=");
-        const value = this.parseLiteral();
-        const extracted = extractLiteral(value);
+        let value;
+        let extracted;
+        if (this.seeAndSkip("=")) {
+            value = this.parseLiteral();
+            extracted = extractLiteral(value);
+        }
         this.skip(";");
-        return createEnumMember(name.value, undefined, type, extracted.extractedValue, { extendedAttributes: ext, nodeLocation: sloc(), nameLocation: name.location, valueLocation: value.location });
+        return createEnumMember(name.value, undefined, type, extracted === null || extracted === void 0 ? void 0 : extracted.extractedValue, { extendedAttributes: ext, nodeLocation: sloc(), nameLocation: name.location, valueLocation: value === null || value === void 0 ? void 0 : value.location });
     }
     parsePackage() {
         const sloc = this.trackLocation();
@@ -7036,6 +7163,93 @@ const builtinTypesList = [IDLPointerType, IDLVoidType, IDLBooleanType,
 const builtinTypes = new Map(builtinTypesList.map(x => [x.name, x]));
 const builtinGenericTypeNames = new Set(["sequence", "record", "Promise"]);
 
+/*
+ * 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.
+ */
+function lineDigitCount(message) {
+    let count = 0;
+    for (let part of message.parts) {
+        let range = part.location.range;
+        if (range == null) {
+            continue;
+        }
+        count = Math.max(count, range.start.line.toString().length, range.end.line.toString().length);
+    }
+    return count;
+}
+function paddedLineNo(digits, line) {
+    let s = line.toString();
+    if (s.length < digits) {
+        return " ".repeat(digits - s.length) + s;
+    }
+    return s;
+}
+function formatLine(digits, lines, lineNo) {
+    return `${paddedLineNo(digits, lineNo)} | ${lines[lineNo - 1]}`;
+}
+function formatUnderline(indent, lines, lineNo, range, edgeChar, midChar, message) {
+    if (lineNo == range.start.line && lineNo == range.end.line) {
+        let len = range.end.character - range.start.character + 1;
+        return `${indent} | ${" ".repeat(range.start.character - 1)}${edgeChar}${len > 2 ? midChar.repeat(len - 2) : ""}${len > 1 ? edgeChar : ""} ${message}`;
+    }
+    if (lineNo == range.start.line) {
+        let len = lines[lineNo - 1].length - range.start.character;
+        return `${indent} | ${" ".repeat(range.start.character - 1)}${edgeChar}${len > 1 ? midChar.repeat(len - 1) : ""}`;
+    }
+    if (lineNo == range.end.line) {
+        let len = range.end.character;
+        return `${indent} | ${len > 1 ? midChar.repeat(len - 1) : ""}${edgeChar} ${message}`;
+    }
+    return `${indent} | ${midChar.repeat(lines[lineNo - 1].length)}`;
+}
+function outputDiagnosticMessageFormatted(message) {
+    if (message.parts.length == 0) {
+        return;
+    }
+    console.log(`${message.severity}[${message.code}]: ${message.codeDescription}`);
+    let digits = lineDigitCount(message);
+    let indent = " ".repeat(digits);
+    let first = true;
+    let lastPath = "";
+    for (let part of message.parts) {
+        const location = part.location;
+        if (location.range != null && location.lines != null) {
+            let range = location.range;
+            let lines = location.lines;
+            console.log(`${indent}${lastPath != part.location.documentPath ? "-->" : ":::"} ${part.location.documentPath}:${range.start.line}:${range.start.character}`);
+            console.log(`${indent} |`);
+            const last = Math.min(range.end.line + 1, lines.length - 1);
+            for (let i = Math.max(range.start.line - 1, 1); i <= last; ++i) {
+                console.log(formatLine(digits, lines, i));
+                if (i >= range.start.line && i <= range.end.line) {
+                    console.log(formatUnderline(indent, lines, i, range, "^", first ? "-" : "~", part.message));
+                }
+            }
+        }
+        else {
+            console.log(`${indent}--> ${part.location.documentPath}`);
+            if (message.parts.length > 1) {
+                console.log(`${indent} # ${part.message}`);
+            }
+        }
+        first = false;
+        lastPath = part.location.documentPath;
+    }
+    console.log(`${indent} = ${message.parts[0].message}`);
+    console.log();
+}
+
 /*
  * Copyright (c) 2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -7053,6 +7267,10 @@ const builtinGenericTypeNames = new Set(["sequence", "record", "Promise"]);
 function getTokens(node) {
     return node.tokens;
 }
+const extendedAttributesWithTypesValue = [
+    IDLExtendedAttributes.TypeArguments,
+    IDLExtendedAttributes.TypeParametersDefaults,
+];
 const syntheticTypes = new Map();
 function addSyntheticType(name, type) {
     if (syntheticTypes.has(name)) {
@@ -7064,9 +7282,8 @@ class IDLDeserializer {
     enterGenericScope(generics) {
         this.genericsScopes.push(new Set(generics !== null && generics !== void 0 ? generics : []));
     }
-    constructor(info, inheritanceMode = 'multiple') {
+    constructor(info) {
         this.info = info;
-        this.inheritanceMode = inheritanceMode;
         this.namespacePathNames = [];
         this.currentPackage = [];
         this.genericsScopes = [];
@@ -7163,7 +7380,7 @@ class IDLDeserializer {
             node.inheritance.forEach(it => {
                 const attributes = it.extAttrs;
                 const parentTypeArgs = this.extractTypeArguments(file, attributes !== null && attributes !== void 0 ? attributes : [], IDLExtendedAttributes.TypeArguments);
-                const attrs = this.toExtendedAttributes(attributes !== null && attributes !== void 0 ? attributes : []); // ?.filter(it => it.name !== idl.IDLExtendedAttributes.TypeArguments)
+                const attrs = this.toExtendedAttributes(file, attributes !== null && attributes !== void 0 ? attributes : []); // ?.filter(it => it.name !== idl.IDLExtendedAttributes.TypeArguments)
                 const ref = createReferenceType(it.inheritance, parentTypeArgs, {
                     extendedAttributes: attrs
                 });
@@ -7183,7 +7400,7 @@ class IDLDeserializer {
             .map(it => this.toIDLCallable(file, it)), generics, {
             fileName: file,
             documentation: this.makeDocs(node),
-            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs),
         });
         this.genericsScopes.pop();
         this.info.set(result, getTokens(node));
@@ -7199,6 +7416,8 @@ class IDLDeserializer {
             // is it IDLStringType?
             const refType = createReferenceType(type);
             refType.fileName = file;
+            // Here is a bug: type.extAttrs are ignored, so typeArguments on ([TypeArguments="T"] Something) are always lost
+            // That must be fixed together with fixing non-generic placeholders on generic types in pipelines (like WrappedBuilder)
             refType.typeArguments = this.extractTypeArguments(file, extAttrs, IDLExtendedAttributes.TypeArguments);
             return refType;
         }
@@ -7256,7 +7475,7 @@ class IDLDeserializer {
                 idlRefType = ref;
             }
             idlRefType.fileName = file;
-            idlRefType.extendedAttributes = this.toExtendedAttributes(combinedExtAttrs);
+            idlRefType.extendedAttributes = this.toExtendedAttributes(file, combinedExtAttrs);
             return this.withInfo(type, idlRefType);
         }
         if (isSequenceTypeDescription(type) || isPromiseTypeDescription(type) || isRecordTypeDescription(type)) {
@@ -7284,7 +7503,7 @@ class IDLDeserializer {
             isAsync: node.async,
         }, {
             documentation: this.makeDocs(node),
-            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs),
         }, generics));
         this.genericsScopes.pop();
         return result;
@@ -7297,8 +7516,6 @@ class IDLDeserializer {
         const generics = this.extractGenerics(node.extAttrs);
         this.enterGenericScope(generics);
         const returnType = this.toIDLType(file, node.idlType, node.extAttrs);
-        if (isReferenceType(returnType))
-            returnType.typeArguments = this.extractTypeArguments(file, node.extAttrs, IDLExtendedAttributes.TypeArguments);
         const result = this.withInfo(node, createMethod((_a = node.name) !== null && _a !== void 0 ? _a : "", node.arguments.map(it => this.toIDLParameter(file, it !== null && it !== void 0 ? it : new Map())), returnType, {
             isStatic: node.special === "static",
             isAsync: node.async,
@@ -7306,7 +7523,7 @@ class IDLDeserializer {
             isFree
         }, {
             documentation: this.makeDocs(node),
-            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs),
         }, generics));
         this.genericsScopes.pop();
         return result;
@@ -7314,7 +7531,7 @@ class IDLDeserializer {
     toIDLConstructor(file, node) {
         return this.withInfo(node, createConstructor(node.arguments.map(it => this.toIDLParameter(file, it)), undefined, {
             documentation: this.makeDocs(node),
-            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs),
         }));
     }
     toIDLParameter(file, node) {
@@ -7327,7 +7544,7 @@ class IDLDeserializer {
         this.enterGenericScope(generics);
         const result = createCallback(node.name, node.arguments.map(it => this.toIDLParameter(file, it)), this.toIDLType(file, node.idlType, undefined), {
             fileName: file,
-            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs),
             documentation: this.makeDocs(node),
         }, generics);
         if (node.extAttrs.find(it => it.name === "Synthetic")) {
@@ -7341,7 +7558,7 @@ class IDLDeserializer {
         const generics = this.extractGenerics(node.extAttrs);
         this.enterGenericScope(generics);
         const result = this.withInfo(node, createTypedef(node.name, this.toIDLType(file, node.idlType, undefined, node.name), generics, {
-            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs),
             documentation: this.makeDocs(node),
             fileName: file,
         }));
@@ -7354,7 +7571,7 @@ class IDLDeserializer {
     toIDLDictionary(file, node) {
         const result = createEnum(node.name, [], {
             documentation: this.makeDocs(node),
-            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs),
             fileName: file,
         });
         result.elements = node.members.map(it => this.toIDLEnumMember(file, it, result));
@@ -7362,7 +7579,7 @@ class IDLDeserializer {
     }
     toIDLNamespace(file, node) {
         const namespace = createNamespace(node.name, [], {
-            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs),
             fileName: file
         });
         this.namespacePathNames.push(node.name);
@@ -7372,7 +7589,7 @@ class IDLDeserializer {
     }
     toIDLVersion(file, node) {
         return this.withInfo(node, createVersion(node.value, {
-            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs),
             fileName: file
         }));
     }
@@ -7380,7 +7597,7 @@ class IDLDeserializer {
         return this.withInfo(node, createProperty(node.name, this.toIDLType(file, node.idlType, undefined), node.readonly, node.special === "static", isOptional(node), {
             documentation: this.makeDocs(node),
             fileName: file,
-            extendedAttributes: this.toExtendedAttributes(node.extAttrs)
+            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs)
         }));
     }
     toIDLEnumMember(file, node, parent) {
@@ -7399,12 +7616,18 @@ class IDLDeserializer {
             throw new Error(`Not representable enum initializer: ${JSON.stringify(node.default)}. Found in ${file}`);
         }
         return this.withInfo(node, createEnumMember(node.name, parent, this.toIDLType(file, node.idlType, undefined), initializer, {
-            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs),
         }));
     }
-    toExtendedAttributes(extAttrs) {
+    toExtendedAttributes(file, extAttrs) {
         return extAttrs.map(it => {
-            return this.withInfo(it, { name: it.name, value: this.toExtendedAttributeValue(it) });
+            return this.withInfo(it, {
+                name: it.name,
+                value: this.toExtendedAttributeValue(it),
+                typesValue: extendedAttributesWithTypesValue.includes(it.name)
+                    ? this.extractTypeArguments(file, extAttrs, it.name)
+                    : undefined
+            });
         });
     }
     toExtendedAttributeValue(attr) {
@@ -7420,7 +7643,7 @@ class IDLDeserializer {
         const result = createEnum(node.name, [], {
             fileName: file,
             documentation: this.makeDocs(node),
-            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+            extendedAttributes: this.toExtendedAttributes(file, node.extAttrs),
         });
         result.elements = node.values.map((it) => createEnumMember(it.value, result, IDLNumberType, undefined));
         return this.withInfo(node, result);
@@ -7541,7 +7764,7 @@ class IDLDeserializer {
     }
 }
 const DifferenceFound = new DiagnosticMessageGroup("error", "DifferenceFound", "Difference found");
-const noCompare = new Set(["parent", "fileName", "nodeLocation", "nameLocation", "valueLocation", "typesValue"]);
+const noCompare = new Set(["parent", "fileName", "nodeLocation", "nameLocation", "valueLocation", "typesValue", "text"]);
 const canContainMoreCompare = new Set(["extendedAttributes", "typeParameters", "typeArguments"]);
 function safeString(value) {
     if (typeof value == "symbol") {
@@ -7623,8 +7846,36 @@ function compareParsingResults(oldFile, newFile) {
     if (paths.size > 0) {
         DifferenceFound.reportDiagnosticMessage([newFile.nodeLocation], "Differences found in those paths:\n" + [...paths].join("\n"));
     }
+    return paths.size == 0;
 }
-function parseIdlNew(fileName, content, registerSynthetics) {
+function parseIDLFile(fileName, content, quiet) {
+    const previousDiagnosticsCount = DiagnosticMessageGroup.allGroupsEntries.length;
+    try {
+        let newFile;
+        // Temporarily is set to use old parser by default
+        // Old parser has a bug, it ignores extended attributes on return types, but some pipelines depend on that behavior
+        // So pipelines and old parser must be fixed before permanent switch to a new parser
+        const mode = process.env.IDLPARSE;
+        if (mode === "compare" || mode === "old") {
+            newFile = parseIDLFileOld(fileName, content);
+            if (mode === "old") {
+                return newFile;
+            }
+        }
+        const file = parseIDLFileNew(fileName, content, mode !== "compare");
+        if (mode === "compare") {
+            compareParsingResults(file, newFile);
+            return newFile;
+        }
+        return file;
+    }
+    finally {
+        if (DiagnosticMessageGroup.allGroupsEntries.length != previousDiagnosticsCount) {
+            DiagnosticMessageGroup.allGroupsEntries.slice(previousDiagnosticsCount).map(it => outputDiagnosticMessageFormatted(it));
+        }
+    }
+}
+function parseIDLFileNew(fileName, content, registerSynthetics) {
     let file = new Parser(fileName, content).parseIDL();
     const ancestors = [];
     const namespaces = [];
@@ -7660,18 +7911,10 @@ function parseIdlNew(fileName, content, registerSynthetics) {
     });
     return file;
 }
-function toIDLFile(fileName, { content, inheritanceMode = 'multiple' } = {}) {
+function parseIDLFileOld(fileName, content) {
     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);
+    const deserializer = new IDLDeserializer(lexicalInfo);
     if (undefined === content) {
         try {
             content = fs__namespace.readFileSync(fileName).toString();
@@ -7720,11 +7963,7 @@ function toIDLFile(fileName, { content, inheritanceMode = 'multiple' } = {}) {
             node.nameLocation = nameLocation;
         }
     });
-    if (mode == "compare") {
-        compareParsingResults(file, newFile);
-        return [newFile, new Map()];
-    }
-    return [file, lexicalInfo];
+    return file;
 }
 function prepareOffsets(lines) {
     let offsets = [];
@@ -8075,6 +8314,9 @@ class CppLanguageWriter extends CLikeLanguageWriter {
         var _a;
         return new CppLanguageWriter(new IndentedPrinter([], this.indentDepth()), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.primitivesTypes);
     }
+    get interopModule() {
+        throw new Error(`Modules are not supported in C++`);
+    }
     writeDeclaration(name, signature, modifiers, postfix) {
         const realName = this.classMode === 'normal' ? name : `${this.currentClass.at(0)}::${name}`;
         const newModifiers = this.classMode === 'normal'
@@ -8147,6 +8389,9 @@ class CppLanguageWriter extends CLikeLanguageWriter {
     writeConstant(constName, constType, constVal) {
         this.print(`${this.getNodeName(constType)} ${constName}${constVal ? ' = ' + constVal : ''};`);
     }
+    writeImports(moduleName, importedFeatures, aliases) {
+        throw new Error(`Imports are not supported in C++`);
+    }
     /**
      * Writes multiline comments decorated with stars
      */
@@ -8501,6 +8746,9 @@ class TSLanguageWriter extends LanguageWriter {
     pushNamespace(namespace, options) {
         this.namespaceStack.push(namespace);
         const declaredPrefix = options.isDeclared ? "declare " : "";
+        if (options.isDefault) {
+            this.print(`export default ${namespace}`);
+        }
         this.print(`export ${declaredPrefix}namespace ${namespace} {`);
         if (options.ident)
             this.pushIndent();
@@ -8519,6 +8767,9 @@ class TSLanguageWriter extends LanguageWriter {
         }
         return this.typeConvertor.convert(type);
     }
+    get interopModule() {
+        return "@koalaui/interop";
+    }
     writeClass(name, op, superClass, interfaces, generics, isDeclared, isAbstract) {
         let extendsClause = superClass ? ` extends ${superClass}` : '';
         let implementsClause = interfaces ? ` implements ${interfaces.join(",")}` : '';
@@ -8578,11 +8829,22 @@ class TSLanguageWriter extends LanguageWriter {
         this.printer.print("}");
     }
     writeFieldDeclaration(name, type, modifiers, optional, initExpr) {
-        const init = initExpr != undefined ? ` = ${initExpr.asString()}` : ``;
         let prefix = this.makeFieldModifiersList(modifiers);
         if (prefix)
             prefix += " ";
-        this.printer.print(`${prefix}${name}${optional ? "?" : ""}: ${this.getNodeName(type)}${init}`);
+        const typeName = this.getNodeName(type);
+        const isGetter = modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(FieldModifier.GET);
+        const isSetter = modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(FieldModifier.SET);
+        if (isGetter) {
+            this.printer.print(`${prefix}get ${name}(): ${typeName}`);
+        }
+        if (isSetter) {
+            this.printer.print(`${prefix}set ${name}(value: ${typeName})`);
+        }
+        if (isGetter || isSetter)
+            return;
+        const init = initExpr != undefined ? ` = ${initExpr.asString()}` : ``;
+        this.printer.print(`${prefix}${name}${optional ? "?" : ""}: ${typeName}${init}`);
     }
     writeNativeMethodDeclaration(method) {
         let name = method.name;
@@ -8619,7 +8881,6 @@ class TSLanguageWriter extends LanguageWriter {
     }
     writeProperty(propName, propType, modifiers, getter, setter, initExpr) {
         let isStatic = modifiers.includes(FieldModifier.STATIC);
-        let isMutable = !modifiers.includes(FieldModifier.READONLY);
         let containerName = propName.concat("_container");
         if (getter) {
             if (!getter.op) {
@@ -8629,17 +8890,17 @@ class TSLanguageWriter extends LanguageWriter {
                 (writer) => {
                     writer.print(`return ${containerName}`);
                 });
-            if (isMutable) {
-                const setSignature = new NamedMethodSignature(IDLVoidType, [propType], [propName]);
-                this.writeSetterImplementation(new Method(propName, setSignature, isStatic ? [MethodModifier.STATIC] : []), setter ? setter.op :
-                    (writer) => {
-                        writer.print(`${containerName} = ${propName}`);
-                    });
-            }
         }
-        else {
-            this.writeFieldDeclaration(propName, propType, modifiers, isOptionalType(propType), initExpr);
+        if (setter) {
+            const setSignature = new NamedMethodSignature(IDLVoidType, [propType], [propName]);
+            this.writeSetterImplementation(new Method(propName, setSignature, isStatic ? [MethodModifier.STATIC] : []), setter ? setter.op :
+                (writer) => {
+                    writer.print(`${containerName} = ${propName}`);
+                });
         }
+        if (getter || setter)
+            return;
+        this.writeFieldDeclaration(propName, propType, modifiers, isOptionalType(propType), initExpr);
     }
     writeTypeDeclaration(decl) {
         var _a;
@@ -8650,6 +8911,16 @@ class TSLanguageWriter extends LanguageWriter {
     writeConstant(constName, constType, constVal) {
         this.print(`export const ${constName}: ${this.getNodeName(constType)}${constVal ? ' = ' + constVal : ''}`);
     }
+    writeImports(moduleName, importedFeatures, aliases) {
+        if (importedFeatures.length !== aliases.length) {
+            throw new Error(`Inconsistent imports from ${moduleName}`);
+        }
+        const importNodes = [];
+        for (let i = 0; i < importedFeatures.length; i++) {
+            importNodes.push(importedFeatures[i] + (aliases[i] ? ` as ${aliases[i]}` : ``));
+        }
+        this.writeExpressionStatement(this.makeString(`import { ${importNodes.join(', ')} } from "${moduleName}"`));
+    }
     writeDeclaration(name, signature, needReturn, needBracket, modifiers, generics) {
         let prefix = !modifiers ? undefined : this.supportedModifiers
             .filter(it => modifiers.includes(it))
@@ -8871,6 +9142,15 @@ class CJDeclarationNameConvertor extends DeclarationNameConvertor {
     }
 }
 CJDeclarationNameConvertor.I = new CJDeclarationNameConvertor();
+class KotlinDeclarationNameConvertor extends DeclarationNameConvertor {
+    convertInterface(decl) {
+        return removePoints(getQualifiedName(decl, "namespace.name"));
+    }
+    convertEnum(decl) {
+        return removePoints(getQualifiedName(decl, "namespace.name"));
+    }
+}
+KotlinDeclarationNameConvertor.I = new KotlinDeclarationNameConvertor();
 class ETSFeatureNameConvertor extends DeclarationNameConvertor {
     convertEnum(decl) {
         const namespace = getNamespacesPathFor(decl).map(it => it.name);
@@ -8887,18 +9167,20 @@ class CJFeatureNameConvertor extends DeclarationNameConvertor {
 }
 CJFeatureNameConvertor.I = new CJFeatureNameConvertor();
 class KotlinFeatureNameConvertor extends DeclarationNameConvertor {
+    convertInterface(decl) {
+        return removePoints(getQualifiedName(decl, "namespace.name"));
+    }
     convertEnum(decl) {
-        return decl.name;
+        return removePoints(getQualifiedName(decl, "namespace.name"));
     }
 }
 KotlinFeatureNameConvertor.I = new KotlinFeatureNameConvertor();
 function createDeclarationNameConvertor(language) {
     switch (language) {
         case Language.ARKTS: return ETSDeclarationNameConvertor.I;
-        case Language.JAVA:
         case Language.CPP:
         case Language.TS: return DeclarationNameConvertor.I;
-        case Language.CJ:        default: throw new Error(`Language ${language.toString()} is not supported`);
+        case Language.CJ:        case Language.KOTLIN:        default: throw new Error(`Language ${language.toString()} is not supported`);
     }
 }
 
@@ -9066,12 +9348,6 @@ class ETSLanguageWriter extends TSLanguageWriter {
         super(printer, resolver, typeConvertor, Language.ARKTS);
         this.arrayConvertor = arrayConvertor;
     }
-    pushNamespace(namespace, options) {
-        if (options.isDefault) {
-            this.print(`export default ${namespace}`);
-        }
-        super.pushNamespace(namespace, options);
-    }
     fork(options) {
         var _a;
         return new ETSLanguageWriter(new IndentedPrinter([], this.indentDepth()), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.arrayConvertor);
@@ -9232,31 +9508,10 @@ ETSLanguageWriter._isUseTypeChecker = true;
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var LayoutNodeRole;
-(function (LayoutNodeRole) {
-    LayoutNodeRole[LayoutNodeRole["PEER"] = 0] = "PEER";
-    LayoutNodeRole[LayoutNodeRole["INTERFACE"] = 1] = "INTERFACE";
-    LayoutNodeRole[LayoutNodeRole["GLOBAL"] = 2] = "GLOBAL";
-    LayoutNodeRole[LayoutNodeRole["COMPONENT"] = 3] = "COMPONENT";
-    LayoutNodeRole[LayoutNodeRole["SERIALIZER"] = 4] = "SERIALIZER";
-})(LayoutNodeRole || (LayoutNodeRole = {}));
-
-/*
- * 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.
- */
-function getSerializerName(declaration) {
-    return `${getQualifiedName(declaration, "namespace.name").split('.').join('_')}_serializer`;
+function getSerializerName(library, language, declaration) {
+    const qualifier = isTopLevelConflicted(library, language, declaration)
+        ? "package.namespace.name" : "namespace.name";
+    return `${getQualifiedName(declaration, qualifier).split('.').join('_')}_serializer`;
 }
 class BaseArgConvertor {
     constructor(idlType, runtimeTypes, isScoped, useArray, param) {
@@ -9404,12 +9659,12 @@ class InterfaceConvertor extends BaseArgConvertor {
         throw new Error("Must never be used");
     }
     convertorSerialize(param, value, writer) {
-        const accessor = getSerializerName(this.declaration);
+        const accessor = getSerializerName(this.library, writer.language, this.declaration);
         writer.addFeature(accessor, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
-        return writer.makeStatement(writer.makeStaticMethodCall(accessor, 'write', [writer.makeString(`${param}Serializer`), writer.makeString(value)]));
+        return writer.makeStatement(writer.makeStaticMethodCall(accessor, 'write', [writer.makeString(`${param}Serializer`), writer.makeString(writer.escapeKeyword(value))]));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
-        const accessor = getSerializerName(this.declaration);
+        const accessor = getSerializerName(this.library, writer.language, this.declaration);
         writer.addFeature(accessor, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
         return assigneer(writer.makeStaticMethodCall(accessor, 'read', [writer.makeString(deserializerName)]));
     }
@@ -9497,11 +9752,10 @@ class MaterializedClassConvertor extends BaseArgConvertor {
         this.declaration = declaration;
     }
     convertorArg(param, writer) {
+        const nameConvertor = this.library.createTypeNameConvertor(Language.CPP);
         switch (writer.language) {
             case Language.CPP:
-                return `static_cast<${generatorTypePrefix()}${qualifiedName(this.declaration, "_", "namespace.name")}>(${param})`;
-            case Language.JAVA:
-            case Language.KOTLIN:
+                return `static_cast<${nameConvertor.convert(this.declaration)}>(${param})`;
             case Language.CJ:
                 return `MaterializedBase.toPeerPtr(${writer.escapeKeyword(param)})`;
             default:
@@ -9513,12 +9767,12 @@ class MaterializedClassConvertor extends BaseArgConvertor {
         }
     }
     convertorSerialize(param, value, printer) {
-        const accessorRoot = getSerializerName(this.declaration);
+        const accessorRoot = getSerializerName(this.library, printer.language, this.declaration);
         printer.addFeature(accessorRoot, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
         return printer.makeStatement(printer.makeStaticMethodCall(accessorRoot, 'write', [printer.makeString(`${param}Serializer`), printer.makeString(value)]));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
-        const accessorRoot = getSerializerName(this.declaration);
+        const accessorRoot = getSerializerName(this.library, writer.language, this.declaration);
         writer.addFeature(accessorRoot, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
         const readStatement = writer.makeCast(writer.makeStaticMethodCall(accessorRoot, "read", [writer.makeString(deserializerName)]), this.declaration);
         return assigneer(readStatement);
@@ -9620,9 +9874,6 @@ function zip(left, right) {
         throw new Error("Arrays of different length");
     return left.map((_, i) => [left[i], right[i]]);
 }
-({
-    target: ts__namespace.ScriptTarget.ES5,
-    module: ts__namespace.ModuleKind.CommonJS});
 function throwException(message) {
     throw new Error(message);
 }
@@ -9671,6 +9922,9 @@ function getExtractor(target, lang, toPtr = true) {
     const method = toPtr ? `to${extractorClass}Ptr` : `from${extractorClass}Ptr`;
     return { receiver, method };
 }
+function removePoints(s) {
+    return s.split(/[\.\-]/g).join('_');
+}
 
 /*
  * Copyright (c) 2025 Huawei Device Co., Ltd.
@@ -10067,16 +10321,22 @@ const ModuleConfigurationSchema = D.object({
     external: D.maybe(D.boolean()),
     packages: T.stringArray(),
     useFoldersLayout: D.maybe(D.boolean()),
+    tsLikePackage: D.maybe(D.string()),
 });
 const HookMethodSchema = D.object({
     hookName: D.string(),
     replaceImplementation: D.boolean()
 });
+const TransformOnSerializeSchema = D.object({
+    from: D.string(),
+    to: D.string(),
+});
 D.object({
     ApiKind: D.number(),
     TypePrefix: D.string(),
     LibraryPrefix: D.string(),
     OptionalPrefix: D.string(),
+    transformOnSerialize: D.array(TransformOnSerializeSchema),
     rootComponents: T.stringArray(),
     standaloneComponents: T.stringArray(),
     parameterized: T.stringArray(),
@@ -10098,6 +10358,7 @@ const defaultCoreConfiguration = {
     TypePrefix: "",
     LibraryPrefix: "",
     OptionalPrefix: "",
+    transformOnSerialize: [],
     rootComponents: [],
     standaloneComponents: [],
     parameterized: [],
@@ -10118,10 +10379,6 @@ let currentConfig = defaultCoreConfiguration;
 function generatorConfiguration() {
     return currentConfig;
 }
-function generatorTypePrefix() {
-    const conf = generatorConfiguration();
-    return `${conf.TypePrefix}${conf.LibraryPrefix}`;
-}
 
 /*
  * Copyright (c) 2024 Huawei Device Co., Ltd.
@@ -11978,9 +12235,6 @@ class Config {
         return `ir`;
     }
 }
-Config.DoNotPrintPeers = [
-    'es2panda_Context', // useless
-];
 
 /*
  * Copyright (c) 2024 Huawei Device Co., Ltd.
@@ -12052,6 +12306,9 @@ class BridgesConstructions {
     static get stringCast() {
         return `getStringCopy`;
     }
+    static get stringArrayCast() {
+        return `getStringArray`;
+    }
     static dropConstCast(value) {
         return `(void*)${value}`;
     }
@@ -12763,7 +13020,7 @@ class InteropTypeConvertor extends BaseTypeConvertor {
 class InteropMacroTypeConvertor extends InteropTypeConvertor {
     constructor(typechecker) {
         super(typechecker, {
-            sequence: (type) => `KNativePointerArray`,
+            sequence: (type) => isString(type.elementType[0]) ? `KStringArray` : `KNativePointerArray`,
             string: (type) => `KStringPtr`,
         });
     }
@@ -12786,7 +13043,7 @@ class InteropMacroTypeConvertor extends InteropTypeConvertor {
 class NativeTypeConvertor extends InteropTypeConvertor {
     constructor(typechecker) {
         super(typechecker, {
-            sequence: (type) => `KNativePointerArray`,
+            sequence: (type) => isString(type.elementType[0]) ? `KStringArray&` : `KNativePointerArray`,
             string: (type) => `KStringPtr&`,
         });
     }
@@ -12810,7 +13067,9 @@ class CastTypeConvertor extends BaseTypeConvertor {
     constructor(typechecker) {
         const primitive = (type) => BridgesConstructions.primitiveTypeCast(this.castToTypeConvertor.convertType(type));
         super(typechecker, {
-            sequence: (type) => BridgesConstructions.referenceTypeCast(this.castToTypeConvertor.convertType(type)),
+            sequence: (type) => isString(type.elementType[0]) ?
+                BridgesConstructions.stringArrayCast :
+                BridgesConstructions.referenceTypeCast(this.castToTypeConvertor.convertType(type)),
             enum: (type) => BridgesConstructions.enumCast(this.castToTypeConvertor.convertType(type)),
             reference: (type) => BridgesConstructions.referenceTypeCast(this.castToTypeConvertor.convertType(type)),
             i8: primitive,
@@ -13042,12 +13301,13 @@ class EnumsPrinter extends SingleFilePrinter {
  * limitations under the License.
  */
 class IndexPrinter extends SingleFilePrinter {
-    constructor() {
-        super(...arguments);
+    constructor(config, idl) {
+        super(idl);
+        this.config = config;
         this.writer = createDefaultTypescriptWriter();
     }
     filterInterface(node) {
-        return !this.typechecker.isPeer(node) || Config.DoNotPrintPeers.includes(fqName(node));
+        return !this.typechecker.isPeer(node) || this.config.ignore.isIgnoredPeer(fqName(node));
     }
     printInterface(node) {
         this.writer.writeExpressionStatement(this.writer.makeString(`export * from "./peers/${dropPrefix(node.name, Config.dataClassPrefix)}"`));
@@ -13097,7 +13357,7 @@ class BindingsConstructions {
 class BindingsTypeConvertor extends InteropTypeConvertor {
     constructor(typechecker) {
         super(typechecker, {
-            sequence: (type) => `BigUint64Array`,
+            sequence: (type) => isString(type.elementType[0]) ? `KStringArrayPtr` : `BigUint64Array`,
             string: (type) => `KStringPtr`,
         });
     }
@@ -13266,6 +13526,9 @@ class PeersConstructions {
     static passNode(name) {
         return `passNode(${name})`;
     }
+    static passStringArray(name) {
+        return `passStringArray(${name})`;
+    }
     static passNodeArray(name) {
         return `passNodeArray(${name})`;
     }
@@ -13363,7 +13626,7 @@ class Importer {
             return it;
         }
         this.seen.add(it);
-        this.import(it, "../../reexport-for-generated");
+        this.import(it, "../../src/reexport-for-generated");
         return it;
     }
     import(name, from) {
@@ -13491,7 +13754,8 @@ class BindingParameterTypeConvertor extends TopLevelTypeConvertor {
     constructor(typechecker) {
         super(typechecker, {
             sequence: (type) => (parameter) => [
-                PeersConstructions.passNodeArray(parameter),
+                isString(type.elementType[0]) ?
+                    PeersConstructions.passStringArray(parameter) : PeersConstructions.passNodeArray(parameter),
                 PeersConstructions.arrayLength(parameter)
             ],
             string: (type) => (parameter) => parameter,
@@ -13814,7 +14078,7 @@ class AllPeersPrinter extends MultiFilePrinter {
         this.config = config;
     }
     filterInterface(node) {
-        return !this.typechecker.isPeer(node) || Config.DoNotPrintPeers.includes(fqName(node));
+        return !this.typechecker.isPeer(node) || this.config.ignore.isIgnoredPeer(fqName(node));
     }
     printInterface(node) {
         return {
@@ -14372,12 +14636,12 @@ class DynamicEmitter {
         this.generatorVersion = `Unknown`;
         this.logDir = `./out/log-idl`;
         this.logCount = 0;
-        this.bridgesPrinter = new SingleFileEmitter((idl) => new BridgesPrinter(this.config, idl).print(), `libarkts/native/src/generated/bridges.cc`, `bridges.cc`, true);
-        this.bindingsPrinter = new SingleFileEmitter((idl) => new BindingsPrinter(idl).print(), `libarkts/src/generated/Es2pandaNativeModule.ts`, `Es2pandaNativeModule.ts`, true);
-        this.enumsPrinter = new SingleFileEmitter((idl) => new EnumsPrinter(idl).print(), `libarkts/src/generated/Es2pandaEnums.ts`, `Es2pandaEnums.ts`, true);
-        this.indexPrinter = new SingleFileEmitter((idl) => new IndexPrinter(idl).print(), `libarkts/src/generated/index.ts`, `index.ts`, true);
-        this.peersPrinter = new MultiFileEmitter((idl) => new AllPeersPrinter(this.config, idl).print(), `libarkts/src/generated/peers`, `peer.ts`, true);
-        this.factoryPrinter = new SingleFileEmitter((idl) => new FactoryPrinter(this.config, idl).print(), `libarkts/src/generated/factory.ts`, `factory.ts`, true);
+        this.bridgesPrinter = new SingleFileEmitter((idl) => new BridgesPrinter(this.config, idl).print(), `libarkts/generated/native/bridges.cc`, `bridges.cc`, true);
+        this.bindingsPrinter = new SingleFileEmitter((idl) => new BindingsPrinter(idl).print(), `libarkts/generated/Es2pandaNativeModule.ts`, `Es2pandaNativeModule.ts`, true);
+        this.enumsPrinter = new SingleFileEmitter((idl) => new EnumsPrinter(idl).print(), `libarkts/generated/Es2pandaEnums.ts`, `Es2pandaEnums.ts`, true);
+        this.indexPrinter = new SingleFileEmitter((idl) => new IndexPrinter(this.config, idl).print(), `libarkts/generated/index.ts`, `index.ts`, true);
+        this.peersPrinter = new MultiFileEmitter((idl) => new AllPeersPrinter(this.config, idl).print(), `libarkts/generated/peers`, `peer.ts`, true);
+        this.factoryPrinter = new SingleFileEmitter((idl) => new FactoryPrinter(this.config, idl).print(), `libarkts/generated/factory.ts`, `factory.ts`, true);
         const myJson = path__namespace$1.resolve(__dirname, '..', 'package.json');
         if (fs__namespace$1.existsSync(myJson)) {
             this.generatorVersion = (_b = (_a = lib.parse(fs__namespace$1.readFileSync(myJson).toString())) === null || _a === void 0 ? void 0 : _a.version) !== null && _b !== void 0 ? _b : `Unknown`;
@@ -14487,7 +14751,8 @@ class DynamicEmitter {
  */
 class IgnoreOptions {
     constructor(filePath) {
-        var _a, _b;
+        var _a, _b, _c;
+        this.peers = [];
         this.partial = [];
         this.ignored = new Map();
         if (filePath === undefined) {
@@ -14495,7 +14760,8 @@ class IgnoreOptions {
         }
         const ignore = lib.parse(fs__namespace$1.readFileSync(filePath).toString()).ignore;
         this.partial = (_a = ignore === null || ignore === void 0 ? void 0 : ignore.partial) !== null && _a !== void 0 ? _a : [];
-        const full = (_b = ignore === null || ignore === void 0 ? void 0 : ignore.full) !== null && _b !== void 0 ? _b : [];
+        this.peers = (_b = ignore === null || ignore === void 0 ? void 0 : ignore.peers) !== null && _b !== void 0 ? _b : ['es2panda_Context'];
+        const full = (_c = ignore === null || ignore === void 0 ? void 0 : ignore.full) !== null && _c !== void 0 ? _c : [];
         full.forEach((fqName) => {
             const parts = fqName.split('.');
             const [ns, name] = parts.length === 1 ? ['', parts.at(0)] : parts;
@@ -14507,6 +14773,9 @@ class IgnoreOptions {
             this.ignored.get(ns).set(key, last !== '!');
         });
     }
+    isIgnoredPeer(name) {
+        return this.peers.includes(name);
+    }
     isIgnoredMethod(iface, method) {
         var _a;
         return (_a = this.partial) === null || _a === void 0 ? void 0 : _a.some(it => { var _a; return it.interface === iface && ((_a = it.methods) === null || _a === void 0 ? void 0 : _a.includes(method)); });
@@ -14771,7 +15040,7 @@ function main() {
     if (options.initialize) {
         new StaticEmitter(options.outputDir, options.pandaSdkPath).emit();
     }
-    new DynamicEmitter(options.outputDir, options.pandaSdkPath, toIDLFile(path__namespace$1.join(options.pandaSdkPath, pandaSdkIdlFilePath), { inheritanceMode: 'single' })[0], new Config(new IgnoreOptions(options.optionsFile), new NonNullableOptions(options.optionsFile), new IrHackOptions(options.optionsFile), new CodeFragmentOptions(options.optionsFile), new ExtraParameters(options.optionsFile)), options.debug).emit();
+    new DynamicEmitter(options.outputDir, options.pandaSdkPath, parseIDLFile(path__namespace$1.join(options.pandaSdkPath, pandaSdkIdlFilePath)), new Config(new IgnoreOptions(options.optionsFile), new NonNullableOptions(options.optionsFile), new IrHackOptions(options.optionsFile), new CodeFragmentOptions(options.optionsFile), new ExtraParameters(options.optionsFile)), options.debug).emit();
 }
 main();
 //# sourceMappingURL=index.js.map