@idlizer/core 2.1.10-arktscgen-4 → 2.1.10-arktscgen-6

package/build/lib/src/util.d.ts

@@ -1,31 +1,7 @@
-import * as ts from "typescript";
 import * as idl from "./idl";
 import { Language } from './Language';
 import { LibraryInterface } from './LibraryInterface';
-export interface NameWithType {
-    name?: ts.DeclarationName;
-    type?: ts.TypeNode;
-}
-/** True if this is visible outside this file, false otherwise */
-export declare function isNodePublic(node: ts.Node): boolean;
-export declare function nameOrNull(name: ts.EntityName | ts.DeclarationName | undefined): string | undefined;
-export declare function isNamedDeclaration(node: ts.Node): node is ts.NamedDeclaration;
-export declare function asString(node: ts.Node | undefined): string;
 export declare function arrayAt<T>(array: T[] | undefined, index: number): T | undefined;
-export declare function getComment(sourceFile: ts.SourceFile, node: ts.Node): string;
-export declare function getSymbolByNode(typechecker: ts.TypeChecker, node: ts.Node): ts.Symbol | undefined;
-export declare function getDeclarationsByNode(typechecker: ts.TypeChecker, node: ts.Node): ts.Declaration[];
-export declare function findRealDeclarations(typechecker: ts.TypeChecker, node: ts.Node): ts.Declaration[];
-export declare function getExportedDeclarationNameByDecl(declaration: ts.NamedDeclaration): string | undefined;
-export declare function getExportedDeclarationNameByNode(typechecker: ts.TypeChecker, node: ts.Node): string | undefined;
-export declare function isReadonly(modifierLikes: ts.NodeArray<ts.ModifierLike> | undefined): boolean;
-export declare function isExport(modifierLikes: ts.NodeArray<ts.ModifierLike> | undefined): boolean;
-export declare function isAbstract(modifierLikes: ts.NodeArray<ts.ModifierLike> | undefined): boolean;
-export declare function isStatic(modifierLikes: ts.NodeArray<ts.ModifierLike> | undefined): boolean;
-export declare function isAsync(modifierLikes: ts.NodeArray<ts.ModifierLike> | readonly ts.Modifier[] | undefined): boolean;
-export declare function isPrivate(modifierLikes: ts.NodeArray<ts.ModifierLike> | undefined): boolean;
-export declare function isProtected(modifierLikes: ts.NodeArray<ts.ModifierLike> | undefined): boolean;
-export declare function getLineNumberString(sourceFile: ts.SourceFile, position: number): string;
 export declare function isDefined<T>(value: T | null | undefined): value is T;
 export declare function capitalize(string: string): string;
 export declare function capitalizeConstantName(string: string): string;
@@ -35,22 +11,9 @@ export type stringOrNone = string | undefined;
 export declare function toSet(option: string | undefined): Set<string>;
 export declare function getOrPut<K, V>(map: Map<K, V>, key: K, create: (key: K) => V): V;
 export declare function indentedBy(input: string, indentedBy: number): string;
-export declare function typeOrUndefined(type: ts.TypeNode): ts.TypeNode;
 export declare function forEachExpanding<T>(array: T[], action: (element: T) => void): void;
-export declare function isTypeParamSuitableType(type: ts.TypeNode): boolean;
-export declare function heritageTypes(typechecker: ts.TypeChecker, clause: ts.HeritageClause): ts.TypeReferenceNode[];
-export declare function heritageDeclarations(typechecker: ts.TypeChecker, clause: ts.HeritageClause): ts.NamedDeclaration[];
-export declare function typeName(type: ts.TypeReferenceNode | ts.TypeQueryNode | ts.ImportTypeNode): string | undefined;
-export declare function typeEntityName(type: ts.TypeReferenceNode | ts.TypeQueryNode | ts.ImportTypeNode): ts.EntityName | undefined;
 export declare function zip<A, B>(left: readonly A[], right: readonly B[]): [A, B][];
 export declare function zipStrip<A, B>(left: readonly A[], right: readonly B[]): [A, B][];
-export declare function identNameWithNamespace(node: ts.Node, language: Language): string;
-export declare function identName(node: ts.Node | undefined): string | undefined;
-export declare function identString(node: ts.Identifier | ts.PrivateIdentifier | ts.StringLiteral | ts.QualifiedName | ts.NumericLiteral | ts.ComputedPropertyName | ts.BindingName | undefined): string | undefined;
-export declare const defaultCompilerOptions: ts.CompilerOptions;
-export declare function serializerBaseMethods(): string[];
-export declare function getNameWithoutQualifiersRight(node: ts.EntityName | undefined): string | undefined;
-export declare function getNameWithoutQualifiersLeft(node: ts.EntityName | undefined): string | undefined;
 export declare function snakeCaseToCamelCase(input: string, tailToLowerCase?: boolean): string;
 export declare function toCamelCase(input: string): string;
 export declare function isUpperCase(s: string): boolean;
@@ -61,9 +24,7 @@ export declare function renameDtsToComponent(fileName: string, language: Languag
 export declare function renameDtsToInterfaces(fileName: string, language: Language, withFileExtension?: boolean): string;
 export declare function renameClassToBuilderClass(className: string, language: Language, withFileExtension?: boolean): string;
 export declare function renameClassToMaterialized(className: string, language: Language, withFileExtension?: boolean): string;
-export declare function importTypeName(type: ts.ImportTypeNode, asType?: boolean): string;
 export declare function throwException(message: string): never;
-export declare function className(node: ts.ClassDeclaration | ts.InterfaceDeclaration): string;
 /**
  * Add a prefix to an enum value which camel case name coincidence
  * with the the same upper case name for an another enum value
@@ -96,9 +57,18 @@ export declare function getExtractor(target: idl.IDLInterface, lang: Language, t
     receiver?: string;
     method: string;
 };
+export declare function getInitializerFeature(lang: Language): string;
+export declare function getInitializerDefaultValue(decl: idl.IDLEntry, lang: Language): string;
+export declare function getSyntheticTypesFileName(): string;
 export declare function getTransformer(library: LibraryInterface, from: idl.IDLNode, to: idl.IDLNode): {
     receiver?: string;
     method: string;
 };
+export declare function removePoints(s: string): string;
+export declare function scanDirectory(dir: string, fileFilter: (file: string) => boolean, recursive?: boolean): string[];
+export declare function scanInputDirs(inputDirs: string[]): string[];
+export declare function scanInputDirs(inputDirs: string[], fileExtension: string): string[];
+export declare function scanInputDirs(inputDirs: string[], fileFilter: (file: string) => boolean, recursive: boolean): string[];
+export declare function consoleWarn(message: string): void;
 export {};
 //# sourceMappingURL=util.d.ts.map

package/build/lib/src/util.js

@@ -14,137 +14,13 @@
  */
 import * as path from 'path';
 import * as fs from "fs";
-import * as ts from "typescript";
 import * as idl from "./idl";
 import { Language } from './Language';
 import { getModuleFor, isInExternalModule } from './peer-generation/modules';
 import { getInternalClassName, getInternalClassQualifiedName } from './peer-generation/Materialized';
-/** True if this is visible outside this file, false otherwise */
-export function isNodePublic(node) {
-    return (ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Public) !== 0;
-}
-export function nameOrNull(name) {
-    if (name == undefined)
-        return undefined;
-    if (ts.isIdentifier(name)) {
-        return ts.idText(name);
-    }
-    return undefined;
-}
-export function isNamedDeclaration(node) {
-    return ("name" in node);
-}
-export function asString(node) {
-    if (node === undefined)
-        return "undefined node";
-    if (ts.isIdentifier(node))
-        return ts.idText(node);
-    if (ts.isQualifiedName(node))
-        return `${identName(node.left)}.${identName(node.right)}`;
-    if (ts.isStringLiteral(node))
-        return node.text;
-    if (ts.isTypeReferenceNode(node))
-        return `${ts.SyntaxKind[node.kind]}(${asString(node.typeName)})`;
-    if (ts.isImportTypeNode(node))
-        return `${ts.SyntaxKind[node.kind]}(${asString(node.qualifier)})`;
-    if (isNamedDeclaration(node)) {
-        if (node.name === undefined) {
-            return `${ts.SyntaxKind[node.kind]}(undefined name)`;
-        }
-        else {
-            return `${ts.SyntaxKind[node.kind]}(${asString(node.name)})`;
-        }
-    }
-    else {
-        return `${ts.SyntaxKind[node.kind]}`;
-    }
-}
 export function arrayAt(array, index) {
     return array ? array[index >= 0 ? index : array.length + index] : undefined;
 }
-export function getComment(sourceFile, node) {
-    const commentRanges = ts.getLeadingCommentRanges(sourceFile.getFullText(), node.getFullStart());
-    if (!commentRanges)
-        return "";
-    return commentRanges
-        .map(range => sourceFile.getFullText().slice(range.pos, range.end))
-        .join("\n");
-}
-export function getSymbolByNode(typechecker, node) {
-    return typechecker.getSymbolAtLocation(node);
-}
-export function getDeclarationsByNode(typechecker, node) {
-    var _a, _b;
-    return (_b = (_a = getSymbolByNode(typechecker, node)) === null || _a === void 0 ? void 0 : _a.getDeclarations()) !== null && _b !== void 0 ? _b : [];
-}
-export function findRealDeclarations(typechecker, node) {
-    const declarations = getDeclarationsByNode(typechecker, node);
-    const first = declarations[0];
-    if (first && ts.isExportAssignment(first)) {
-        return findRealDeclarations(typechecker, first.expression);
-    }
-    else {
-        return declarations;
-    }
-}
-export function getExportedDeclarationNameByDecl(declaration) {
-    let declName = declaration.name ? ts.idText(declaration.name) : undefined;
-    let current = declaration;
-    while (current != undefined && !ts.isSourceFile(current)) {
-        current = current.parent;
-    }
-    let source = current;
-    let exportedName = declName;
-    source.forEachChild(it => {
-        if (ts.isExportDeclaration(it)) {
-            let clause = it.exportClause;
-            if (clause && ts.isNamedExportBindings(clause) && ts.isNamedExports(clause)) {
-                clause.elements.forEach(it => {
-                    let propName = it.propertyName ? ts.idText(it.propertyName) : undefined;
-                    let property = ts.idText(it.name);
-                    if (propName == declName) {
-                        exportedName = property;
-                    }
-                });
-            }
-        }
-    });
-    return exportedName;
-}
-export function getExportedDeclarationNameByNode(typechecker, node) {
-    let declarations = getDeclarationsByNode(typechecker, node);
-    if (declarations.length == 0)
-        return undefined;
-    return getExportedDeclarationNameByDecl(declarations[0]);
-}
-function hasModifier(modifierLikes, modifier) {
-    return (modifierLikes === null || modifierLikes === void 0 ? void 0 : modifierLikes.find(it => it.kind === modifier)) != undefined;
-}
-export function isReadonly(modifierLikes) {
-    return hasModifier(modifierLikes, ts.SyntaxKind.ReadonlyKeyword);
-}
-export function isExport(modifierLikes) {
-    return hasModifier(modifierLikes, ts.SyntaxKind.ExportKeyword);
-}
-export function isAbstract(modifierLikes) {
-    return hasModifier(modifierLikes, ts.SyntaxKind.AbstractKeyword);
-}
-export function isStatic(modifierLikes) {
-    return hasModifier(modifierLikes, ts.SyntaxKind.StaticKeyword);
-}
-export function isAsync(modifierLikes) {
-    return hasModifier(modifierLikes, ts.SyntaxKind.AsyncKeyword);
-}
-export function isPrivate(modifierLikes) {
-    return hasModifier(modifierLikes, ts.SyntaxKind.PrivateKeyword);
-}
-export function isProtected(modifierLikes) {
-    return hasModifier(modifierLikes, ts.SyntaxKind.ProtectedKeyword);
-}
-export function getLineNumberString(sourceFile, position) {
-    let pos = ts.getLineAndCharacterOfPosition(sourceFile, position);
-    return `${pos.line + 1}:${pos.character}`;
-}
 export function isDefined(value) {
     return !!value;
 }
@@ -191,22 +67,6 @@ export function indentedBy(input, indentedBy) {
         return "";
     }
 }
-export function typeOrUndefined(type) {
-    var _a;
-    let needUndefined = true;
-    if (ts.isUnionTypeNode(type)) {
-        (_a = type.types) === null || _a === void 0 ? void 0 : _a.forEach(it => {
-            if (it.kind == ts.SyntaxKind.UndefinedKeyword)
-                needUndefined = false;
-        });
-    }
-    if (!needUndefined)
-        return type;
-    return ts.factory.createUnionTypeNode([
-        type,
-        ts.factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword)
-    ]);
-}
 export function forEachExpanding(array, action) {
     let i = 0;
     while (true) {
@@ -216,56 +76,6 @@ export function forEachExpanding(array, action) {
         i += 1;
     }
 }
-export function isTypeParamSuitableType(type) {
-    if (ts.isTypeReferenceNode(type)) {
-        return !['boolean', 'number', 'string', 'undefined', 'any'].includes(type.typeName.getText());
-    }
-    return false;
-}
-export function heritageTypes(typechecker, clause) {
-    return clause
-        .types
-        .map(it => {
-        let type = typechecker.getTypeAtLocation(it.expression);
-        let typeNode = typechecker.typeToTypeNode(type, undefined, ts.NodeBuilderFlags.NoTruncation);
-        if (typeNode && ts.isTypeReferenceNode(typeNode))
-            return typeNode;
-        return undefined;
-    })
-        .filter(it => it != undefined);
-}
-export function heritageDeclarations(typechecker, clause) {
-    return clause
-        .types
-        .map(it => {
-        var _a;
-        let decls = getDeclarationsByNode(typechecker, it.expression);
-        return (_a = decls[0]) !== null && _a !== void 0 ? _a : undefined;
-    })
-        .filter(isDefined);
-}
-export function typeName(type) {
-    const entityName = typeEntityName(type);
-    if (!entityName)
-        return undefined;
-    if (ts.isIdentifier(entityName))
-        return ts.idText(entityName);
-    if (ts.isQualifiedName(entityName)) {
-        // a.b.c is QualifiedName((QualifiedName a, b), c) so the right one is always an Identifier?
-        if (!ts.isIdentifier(entityName.right))
-            throw new Error(`Unexpected right of QualifiedName ${asString(entityName.right)}`);
-        return ts.idText(entityName.right);
-    }
-}
-export function typeEntityName(type) {
-    if (ts.isTypeReferenceNode(type))
-        return type.typeName;
-    if (ts.isTypeQueryNode(type))
-        return type.exprName;
-    if (ts.isImportTypeNode(type))
-        return type.qualifier;
-    throw new Error("unsupported");
-}
 export function zip(left, right) {
     if (left.length != right.length)
         throw new Error("Arrays of different length");
@@ -278,178 +88,6 @@ export function zipStrip(left, right) {
     }
     return result;
 }
-export function identNameWithNamespace(node, language) {
-    let parent = node.parent;
-    while (parent && !ts.isModuleDeclaration(parent))
-        parent = parent.parent;
-    if (parent) {
-        const separator = language === Language.CPP ? '_' : '.';
-        return `${identName(parent.name)}${separator}${identName(node)}`;
-    }
-    else {
-        return identName(node);
-    }
-}
-export function identName(node) {
-    if (!node)
-        return undefined;
-    if (node.kind == ts.SyntaxKind.AnyKeyword)
-        return `any`;
-    if (node.kind == ts.SyntaxKind.ObjectKeyword)
-        return `object`;
-    if (node.kind == ts.SyntaxKind.StringKeyword)
-        return `string`;
-    if (node.kind == ts.SyntaxKind.BooleanKeyword)
-        return `boolean`;
-    if (node.kind == ts.SyntaxKind.BigIntKeyword)
-        return `bigint`;
-    if (node.kind == ts.SyntaxKind.NumberKeyword)
-        return `number`;
-    if (node.kind == ts.SyntaxKind.VoidKeyword)
-        return `void`;
-    if (node.kind == ts.SyntaxKind.UndefinedKeyword)
-        return `undefined`;
-    if (ts.isThisTypeNode(node)) {
-        return 'this';
-    }
-    if (ts.isVariableDeclaration(node)) {
-        return identString(node.name);
-    }
-    if (ts.isTypeReferenceNode(node)) {
-        return identString(node.typeName);
-    }
-    if (ts.isArrayTypeNode(node)) {
-        return `Array`;
-    }
-    if (ts.isQualifiedName(node)) {
-        return identName(node.right);
-    }
-    if (ts.isModuleDeclaration(node)) {
-        return identString(node.name);
-    }
-    if (ts.isFunctionDeclaration(node)) {
-        return identString(node.name);
-    }
-    if (ts.isPropertyDeclaration(node)) {
-        // TODO: mention parent's name
-        return identString(node.name);
-    }
-    if (ts.isInterfaceDeclaration(node)) {
-        return identString(node.name);
-    }
-    if (ts.isClassDeclaration(node)) {
-        return identString(node.name);
-    }
-    if (ts.isMethodDeclaration(node)) {
-        return identString(node.name);
-    }
-    if (ts.isEnumDeclaration(node)) {
-        return identString(node.name);
-    }
-    if (ts.isEnumMember(node)) {
-        return identString(node.name);
-    }
-    if (ts.isComputedPropertyName(node)) {
-        return identString(node);
-    }
-    if (ts.isExportAssignment(node)) {
-        return node.expression.getText();
-    }
-    if (ts.isUnionTypeNode(node)) {
-        return `UnionType`;
-    }
-    if (ts.isFunctionTypeNode(node)) {
-        return `FunctionType`;
-    }
-    if (ts.isIdentifier(node))
-        return identString(node);
-    if (ts.isImportTypeNode(node))
-        return `imported ${identString(node.qualifier)}`;
-    if (ts.isTypeLiteralNode(node))
-        return `TypeLiteral`;
-    if (ts.isTupleTypeNode(node))
-        return `TupleType`;
-    if (ts.isIndexSignatureDeclaration(node))
-        return `IndexSignature`;
-    if (ts.isIndexedAccessTypeNode(node))
-        return `IndexedAccess`;
-    if (ts.isTemplateLiteralTypeNode(node))
-        return `TemplateLiteral`;
-    if (ts.isParameter(node))
-        return `Parameter`;
-    if (ts.isParenthesizedTypeNode(node))
-        return identName(node.type);
-    if (ts.isIntersectionTypeNode(node))
-        return node.types.map(it => identName(it)).join("&");
-    if (node.kind === ts.SyntaxKind.UnknownKeyword)
-        return `UnknownKeyword`;
-    throw new Error(`Unknown: ${ts.SyntaxKind[node.kind]}`);
-}
-export function identString(node) {
-    if (!node)
-        return undefined;
-    if (ts.isStringLiteral(node))
-        return node.text;
-    if (ts.isNumericLiteral(node))
-        return node.text;
-    if (ts.isIdentifier(node))
-        return ts.idText(node);
-    if (ts.isQualifiedName(node))
-        return `${identString(node.left)}.${identName(node.right)}`;
-    if (ts.isComputedPropertyName(node))
-        return "<computed property>";
-    throw new Error("Unknown");
-}
-export const defaultCompilerOptions = {
-    target: ts.ScriptTarget.ES5,
-    module: ts.ModuleKind.CommonJS,
-    noLib: true,
-    types: []
-};
-export function serializerBaseMethods() {
-    const program = ts.createProgram([
-        "./utils/ts/SerializerBase.ts",
-        "./utils/ts/types.ts",
-    ], defaultCompilerOptions);
-    const serializerDecl = program.getSourceFiles()
-        .find(it => it.fileName.includes("SerializerBase"));
-    // TODO: pack classes with npm package
-    if (serializerDecl === undefined)
-        return [];
-    const methods = [];
-    visit(serializerDecl);
-    return methods;
-    function visit(node) {
-        if (ts.isSourceFile(node))
-            node.statements.forEach(visit);
-        if (ts.isClassDeclaration(node))
-            node.members.filter(ts.isMethodDeclaration).forEach(visit);
-        if (ts.isMethodDeclaration(node))
-            methods.push(node.name.getText(serializerDecl));
-    }
-}
-export function getNameWithoutQualifiersRight(node) {
-    if (!node)
-        return undefined;
-    if (ts.isQualifiedName(node)) {
-        return identName(node.right);
-    }
-    if (ts.isIdentifier(node)) {
-        return identName(node);
-    }
-    throw new Error("Impossible");
-}
-export function getNameWithoutQualifiersLeft(node) {
-    if (!node)
-        return undefined;
-    if (ts.isQualifiedName(node)) {
-        return identName(node.left);
-    }
-    if (ts.isIdentifier(node)) {
-        return identName(node);
-    }
-    throw new Error("Impossible");
-}
 export function snakeCaseToCamelCase(input, tailToLowerCase = false) {
     return input
         .split("_")
@@ -550,16 +188,9 @@ export function renameClassToMaterialized(className, language, withFileExtension
     }
     return renamed;
 }
-export function importTypeName(type, asType = false) {
-    return asType ? "object" : identName(type.qualifier);
-}
 export function throwException(message) {
     throw new Error(message);
 }
-export function className(node) {
-    var _a;
-    return (_a = nameOrNull(node.name)) !== null && _a !== void 0 ? _a : throwException(`Nameless component ${asString(node)}`);
-}
 /**
  * Add a prefix to an enum value which camel case name coincidence
  * with the the same upper case name for an another enum value
@@ -720,6 +351,21 @@ export function getExtractor(target, lang, toPtr = true) {
     const method = toPtr ? `to${extractorClass}Ptr` : `from${extractorClass}Ptr`;
     return { receiver, method };
 }
+export function getInitializerFeature(lang) {
+    // TBD: update code for KT and CJ
+    return "initializers";
+}
+export function getInitializerDefaultValue(decl, lang) {
+    const parent = decl.parent;
+    const fqn = parent && idl.isProperty(decl)
+        ? `${idl.getFQName(parent)}NS.${decl.name}`
+        : idl.getFQName(decl);
+    // TBD: update code for KT and CJ
+    return `${getInitializerFeature(lang)}.${fqn}`;
+}
+export function getSyntheticTypesFileName() {
+    return "synthetic_types";
+}
 export function getTransformer(library, from, to) {
     const convertor = library.createTypeNameConvertor(Language.CPP);
     return {
@@ -727,4 +373,54 @@ export function getTransformer(library, from, to) {
         method: `transform_${convertor.convert(from)}_to_${convertor.convert(to)}`
     };
 }
+export function removePoints(s) {
+    return s.split(/[\.\-]/g).join('_');
+}
+export function scanDirectory(dir, fileFilter, recursive = false) {
+    const dirsToVisit = [path.resolve(dir)];
+    const result = [];
+    while (dirsToVisit.length > 0) {
+        let dir = dirsToVisit.pop();
+        let dirents = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of dirents) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isFile()) {
+                if (fileFilter(fullPath)) {
+                    result.push(fullPath);
+                }
+            }
+            else if (recursive && entry.isDirectory()) {
+                dirsToVisit.push(fullPath);
+            }
+        }
+    }
+    return result;
+}
+export function scanInputDirs(inputDirs, fileFilter = undefined, recursive = false) {
+    if (typeof fileFilter === 'undefined')
+        return scanInputDirs(inputDirs, (_) => true, recursive);
+    if (typeof fileFilter === 'string')
+        return scanInputDirs(inputDirs, (file) => file.endsWith(fileFilter), recursive);
+    const resolvedInputDirs = inputDirs.map(dir => path.resolve(dir));
+    console.log("Resolved input directories:", resolvedInputDirs);
+    return resolvedInputDirs.flatMap(dir => {
+        if (fs.existsSync(dir) && fs.statSync(dir).isDirectory()) {
+            console.log(`Processing all definitions from directory: ${dir}`);
+            return scanDirectory(dir, fileFilter, recursive);
+        }
+        else {
+            console.warn(`Warning: Directory does not exist or is not a directory: ${dir}`);
+            return [];
+        }
+    }).sort((a, b) => {
+        return path.basename(a).localeCompare(path.basename(b));
+    });
+}
+const printedWarnMessages = new Set();
+export function consoleWarn(message) {
+    if (printedWarnMessages.has(message))
+        return;
+    printedWarnMessages.add(message);
+    console.warn(message);
+}
 //# sourceMappingURL=util.js.map

package/package.json

@@ -1,53 +1,48 @@
 {
-  "name": "@idlizer/core",
-  "version": "2.1.10-arktscgen-4",
-  "description": "",
-  "types": "build/lib/src/index.d.ts",
-  "exports": {
-    ".": [
-      "./build/lib/src/index.js"
+    "name": "@idlizer/core",
+    "version": "2.1.10-arktscgen-6",
+    "description": "",
+    "types": "build/lib/src/index.d.ts",
+    "exports": {
+        ".": [
+            "./build/lib/src/index.js"
+        ],
+        "./idl": [
+            "./build/lib/src/idl/index.js"
+        ]
+    },
+    "typesVersions": {
+        "*": {
+            "idl": [
+                "build/lib/src/idl/index.d.ts"
+            ],
+            "*": [
+                "build/lib/src/index.d.ts"
+            ]
+        }
+    },
+    "files": [
+        "build/lib/**/*.js",
+        "build/lib/**/*.d.ts"
     ],
-    "./idl": [
-      "./build/lib/src/idl.js"
-    ]
-  },
-  "typesVersions": {
-    "*": {
-      "idl": [
-        "build/lib/src/idl.d.ts"
-      ],
-      "*": [
-        "build/lib/src/index.d.ts"
-      ]
+    "engines": {
+        "npm": ">= 8",
+        "node": ">= 18"
+    },
+    "keywords": [],
+    "devDependencies": {
+        "@koalaui/harness": "1.7.6+devel",
+        "@koalaui/ets-tsc": "4.9.5-r5",
+        "mocha": "^9.2.2",
+        "ts-node": "^10.9.2",
+        "typescript": "4.9.5",
+        "@types/node": "^18.0.0",
+        "rimraf": "^6.0.1"
+    },
+    "scripts": {
+        "test": "mocha",
+        "clean": "rimraf -g build",
+        "compile:self": "tsc -b .",
+        "compile": "npm run compile:self"
     }
-  },
-  "files": [
-    "build/lib/**/*.js",
-    "build/lib/**/*.d.ts",
-    "webidl2.js/dist/**/*.js",
-    "webidl2.js/package.json"
-  ],
-  "engines": {
-    "npm": ">= 8",
-    "node": ">= 18"
-  },
-  "keywords": [],
-  "dependencies": {
-    "typescript": "4.9.5"
-  },
-  "devDependencies": {
-    "@koalaui/harness": "1.7.6+devel",
-    "@koalaui/ets-tsc": "4.9.5-r5",
-    "@types/mocha": "^9.1.0",
-    "mocha": "^9.2.2",
-    "ts-node": "^10.9.2",
-    "@koalaui/interop": "1.7.9",
-    "@types/node": "^18.0.0"
-  },
-  "scripts": {
-    "test": "mocha",
-    "clean": "rimraf -g build",
-    "compile:self": "tsc -b .",
-    "compile": "npm run compile:self"
-  }
 }