@idlizer/core 2.1.5 → 2.1.9-arktscgen-4

package/build/lib/src/config.js

@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 import { D } from "./configDescriber";
+import { capitalize } from "./util";
 const T = {
     stringArray: () => D.array(D.string())
 };
@@ -21,6 +22,9 @@ export const ModuleConfigurationSchema = D.object({
     packages: T.stringArray(),
     useFoldersLayout: D.maybe(D.boolean()),
 });
+export const HookMethodSchema = D.object({
+    hookName: D.string(),
+});
 export const CoreConfigurationSchema = D.object({
     TypePrefix: D.string(),
     LibraryPrefix: D.string(),
@@ -34,6 +38,9 @@ export const CoreConfigurationSchema = D.object({
     forceCallback: D.map(D.string(), T.stringArray()).onMerge('replace'),
     forceResource: T.stringArray(),
     forceContext: T.stringArray(),
+    hooks: D.map(D.string(), D.map(D.string(), HookMethodSchema)).onMerge('replace'),
+    externalTypes: D.map(D.string(), D.string()).onMerge('replace'),
+    externalPackages: T.stringArray(),
     moduleName: D.string(),
     modules: D.map(D.string(), ModuleConfigurationSchema).onMerge('replace'),
     globalPackages: T.stringArray()
@@ -51,6 +58,9 @@ export const defaultCoreConfiguration = {
     forceCallback: new Map(),
     forceResource: [],
     forceContext: [],
+    hooks: new Map(),
+    externalTypes: new Map(),
+    externalPackages: [],
     moduleName: "",
     modules: new Map(),
     globalPackages: []
@@ -69,4 +79,14 @@ export function generatorTypePrefix() {
     const conf = generatorConfiguration();
     return `${conf.TypePrefix}${conf.LibraryPrefix}`;
 }
+export function generatorHookName(className, methodName) {
+    var _a;
+    const hookMethods = generatorConfiguration().hooks.get(className);
+    if (!hookMethods)
+        return undefined;
+    const hook = hookMethods.get(methodName);
+    if (!hook)
+        return undefined;
+    return (_a = hook.hookName) !== null && _a !== void 0 ? _a : `hook${className}${capitalize(methodName)}`;
+}
 //# sourceMappingURL=config.js.map

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

@@ -49,7 +49,7 @@ declare class ValidationBox<T> {
     static fail<T>(errorMessage: string): ValidationBox<T>;
     static ok<T>(value: T): ValidationBox<T>;
     success(): boolean;
-    unwrap(): T;
+    unwrap(message?: string): T;
     error(): string;
     get(): ValidationResult<T>;
     or<U>(x: U): ValidationBox<U | T>;
@@ -102,7 +102,7 @@ export declare const D: {
         string<T_3 extends string>(x: T_3): ConfigDescriberLeaf<T_3>;
         number<T_4 extends number>(x: T_4): ConfigDescriberLeaf<T_4>;
         boolean<T_5 extends boolean>(x: T_5): ConfigDescriberLeaf<T_5>;
-        null(x: null): ConfigDescriberLeaf<null>;
+        null(): ConfigDescriberLeaf<null>;
     };
     combine<A, B>(a: ConfigDescriberObjectLeaf<A>, b: ConfigDescriberObjectLeaf<B>): ConfigDescriberObjectLeaf<A & B>;
     printJSONSchema<T_6>(schema: ConfigDescriberLeaf<T_6>): string;

package/build/lib/src/configDescriber.js

@@ -26,11 +26,11 @@ class ValidationBox {
     success() {
         return this.box.success;
     }
-    unwrap() {
+    unwrap(message) {
         if (this.box.success) {
             return this.box.value;
         }
-        throw new Error("");
+        throw new Error(message !== null && message !== void 0 ? message : 'panic');
     }
     error() {
         if (!this.box.success) {
@@ -347,7 +347,7 @@ export const D = {
                 };
             });
         },
-        null(x) {
+        null() {
             return new ConfigDescriberLeaf(xs => {
                 if (typeof xs === 'object' && xs === null) {
                     return ValidationBox.ok(null);

package/build/lib/src/from-idl/DtsPrinter.js

@@ -13,7 +13,7 @@
  * limitations under the License.
  */
 import { indentedBy, isInNamespace } from "../util";
-import { IDLEntity, IDLKind, getExtAttribute, getVerbatimDts, hasExtAttribute, isCallback, isConstructor, isContainerType, isEnum, isInterface, isMethod, isPrimitiveType, isProperty, isReferenceType, isSyntheticEntry, isTypeParameterType, isTypedef, isUnionType, isImport, isVersion, isNamespace, IDLExtendedAttributes, IDLAccessorAttribute, IDLVoidType, IDLStringType, IDLUndefinedType, isCallable, getSuperType, IDLAnyType, IDLContainerUtils, DebugUtils, mixMethodParametersAndTags, createReferenceType, transformMethodsAsync2ReturnPromise, linearizeNamespaceMembers, isNamedNode, IDLThisType, isOptionalType, IDLI8Type, IDLU8Type, IDLI16Type, IDLU16Type, IDLI32Type, IDLU32Type, IDLI64Type, IDLU64Type, IDLF16Type, IDLF32Type, IDLF64Type, IDLBufferType, isUnspecifiedGenericType, IDLUnknownType, IDLBooleanType, IDLNumberType, IDLPointerType, IDLInterfaceSubkind, escapeIDLKeyword, getNamespacesPathFor, IDLBigintType, IDLDate, IDLFunctionType, getQualifiedName } from "../idl";
+import { IDLEntity, IDLKind, getExtAttribute, getVerbatimDts, hasExtAttribute, isCallback, isConstructor, isContainerType, isEnum, isInterface, isMethod, isPrimitiveType, isProperty, isReferenceType, isSyntheticEntry, isTypeParameterType, isTypedef, isUnionType, isImport, isVersion, isNamespace, IDLExtendedAttributes, IDLAccessorAttribute, IDLVoidType, IDLStringType, IDLUndefinedType, isCallable, IDLAnyType, IDLContainerUtils, DebugUtils, mixMethodParametersAndTags, createReferenceType, transformMethodsAsync2ReturnPromise, linearizeNamespaceMembers, isNamedNode, IDLThisType, isOptionalType, IDLI8Type, IDLU8Type, IDLI16Type, IDLU16Type, IDLI32Type, IDLU32Type, IDLI64Type, IDLU64Type, IDLF16Type, IDLF32Type, IDLF64Type, IDLBufferType, isUnspecifiedGenericType, IDLUnknownType, IDLBooleanType, IDLNumberType, IDLPointerType, IDLInterfaceSubkind, escapeIDLKeyword, getNamespacesPathFor, IDLBigintType, IDLDate, IDLFunctionType, getQualifiedName, IDLObjectType } from "../idl";
 import { resolveSyntheticType, toIDLFile } from "./deserialize";
 import { Language } from "../Language";
 import { warn } from "../util";
@@ -103,7 +103,7 @@ export class CustomPrintVisitor {
             let interfaces = node.inheritance;
             let keyword = "extends";
             if (node.subkind === IDLInterfaceSubkind.Class) {
-                const superType = getSuperType(node);
+                const superType = node.inheritance.find(it => hasExtAttribute(it, IDLExtendedAttributes.Extends));
                 if (superType)
                     typeSpec += ` extends ${this.printTypeForTS(superType)}`;
                 interfaces = interfaces.slice(1);
@@ -129,8 +129,11 @@ export class CustomPrintVisitor {
         }
     }
     printMethod(node, forceAsFree = false) {
-        const returnType = node.returnType && !(isConstructor(node) && this.currentInterface.subkind === IDLInterfaceSubkind.Class)
+        let returnType = node.returnType && !(isConstructor(node) && this.currentInterface.subkind === IDLInterfaceSubkind.Class)
             ? `: ${this.printTypeForTS(node.returnType, true)}` : "";
+        if (hasExtAttribute(node, IDLExtendedAttributes.CommonMethod)) {
+            returnType = `: ${this.currentInterface.name}`;
+        }
         const name = isConstructor(node)
             ? this.currentInterface.subkind === IDLInterfaceSubkind.Class ? "constructor" : "new"
             : getName(node);
@@ -188,11 +191,11 @@ export class CustomPrintVisitor {
         this.print(`${isInNamespace(node) ? "" : "declare "}enum ${node.name} {`);
         this.pushIndent();
         node.elements.forEach(it => {
-            const initializer = (it.type === IDLStringType ? `"${it.initializer}"` : `${it.initializer}`);
-            this.print(`${getName(it)} = ${initializer},`);
+            const initializer = it.initializer ? (it.type === IDLStringType ? ` = "${it.initializer}"` : ` = ${it.initializer}`) : "";
+            this.print(`${getName(it)}${initializer},`);
             let originalName = getExtAttribute(it, IDLExtendedAttributes.OriginalEnumMemberName);
             if (originalName && originalName != getName(it)) {
-                this.print(`${originalName} = ${initializer},`);
+                this.print(`${originalName}${initializer},`);
             }
         });
         this.popIndent();
@@ -283,13 +286,14 @@ export class CustomPrintVisitor {
                 case IDLNumberType:
                     return "number";
                 case IDLAnyType: return "any";
+                case IDLObjectType: return "Object";
                 case IDLUnknownType: return "unknown";
                 case IDLBufferType: return "ArrayBuffer";
                 case IDLBooleanType: return "boolean";
                 case IDLUndefinedType: return undefinedToVoid ? "void" : "undefined";
                 case IDLStringType: return "string";
                 case IDLVoidType: return "void";
-                case IDLThisType: return "T";
+                case IDLThisType: return this.currentInterface.name;
                 case IDLBigintType:
                 case IDLPointerType: return "number|bigint";
                 case IDLDate: return "Date";
@@ -355,7 +359,7 @@ export class CustomPrintVisitor {
 }
 export function idlToDtsString(name, content) {
     let printer = new CustomPrintVisitor(resolveSyntheticType, Language.TS);
-    const [idlFile] = toIDLFile(name, content);
+    const [idlFile] = toIDLFile(name, { content });
     printer.printPackage(idlFile);
     linearizeNamespaceMembers(idlFile.entries).forEach(it => {
         transformMethodsAsync2ReturnPromise(it);

package/build/lib/src/from-idl/IDLLinter.d.ts

@@ -39,7 +39,6 @@ export declare class IDLLinter {
     protected check(node: idl.IDLNode): void;
     protected checkValidAttributes(entry: idl.IDLEntry, validAttributes: string[]): void;
     protected checkEnumConsistency(entry: idl.IDLEnum): void;
-    private static builtinReferences;
     protected checkReferenceResolved(reference: idl.IDLReferenceType): void;
 }
 interface IDLLinterDiagnosticsSummary {

package/build/lib/src/from-idl/IDLLinter.js

@@ -67,7 +67,7 @@ export class IDLLinter {
     }
     enter(node) {
         var _a, _b;
-        if (idl.isInterface(node) || idl.isTypedef(node) || idl.isMethod(node) || idl.isCallable(node)) {
+        if (idl.isInterface(node) || idl.isTypedef(node) || idl.isMethod(node) || idl.isCallable(node) || idl.isCallback(node)) {
             this.context.enter({ typeParameters: new Set((_b = (_a = node.typeParameters) === null || _a === void 0 ? void 0 : _a.map(parseTypeParameter)) !== null && _b !== void 0 ? _b : []) });
             return () => this.context.leave();
         }
@@ -129,8 +129,6 @@ export class IDLLinter {
     }
     checkReferenceResolved(reference) {
         var _a, _b, _c, _d, _e, _f;
-        if (IDLLinter.builtinReferences.includes(reference.name))
-            return;
         if (this.context.hasTypeParameter(reference.name)) {
             return;
         }
@@ -156,10 +154,6 @@ export class IDLLinter {
         }
     }
 }
-IDLLinter.builtinReferences = [
-    idl.IDLTopType.name,
-    idl.IDLObjectType.name,
-];
 export class IDLLinterError extends Error {
     constructor(message, size) {
         super(message);

package/build/lib/src/from-idl/deserialize.d.ts

@@ -4,5 +4,11 @@ export type WebIDLTokenCollection = Record<string, webidl2.Token | null | undefi
 export type IDLTokenInfoMap = Map<unknown, WebIDLTokenCollection>;
 export declare function addSyntheticType(name: string, type: idl.IDLEntry): void;
 export declare function resolveSyntheticType(type: idl.IDLReferenceType): idl.IDLEntry | undefined;
-export declare function toIDLFile(fileName: string, content?: string): [idl.IDLFile, IDLTokenInfoMap];
+type IDLInheritanceMode = 'single' | 'multiple';
+interface ToIDLFileProps {
+    inheritanceMode?: IDLInheritanceMode;
+    content?: string;
+}
+export declare function toIDLFile(fileName: string, { content, inheritanceMode }?: ToIDLFileProps): [idl.IDLFile, IDLTokenInfoMap];
+export {};
 //# sourceMappingURL=deserialize.d.ts.map

package/build/lib/src/from-idl/deserialize.js

@@ -33,8 +33,12 @@ export function resolveSyntheticType(type) {
     return syntheticTypes.get(type.name);
 }
 class IDLDeserializer {
-    constructor(info) {
+    enterGenericScope(generics) {
+        this.genericsScopes.push(new Set(generics !== null && generics !== void 0 ? generics : []));
+    }
+    constructor(info, inheritanceMode = 'multiple') {
         this.info = info;
+        this.inheritanceMode = inheritanceMode;
         this.namespacePathNames = [];
         this.currentPackage = [];
         this.genericsScopes = [];
@@ -61,7 +65,7 @@ class IDLDeserializer {
     }
     extractGenerics(extAttrs) {
         var _a, _b;
-        return new Set((_b = (_a = this.findExtendedAttribute(extAttrs, idl.IDLExtendedAttributes.TypeParameters)) === null || _a === void 0 ? void 0 : _a.split(",")) === null || _b === void 0 ? void 0 : _b.map(it => this.sanitizeTypeParameter(it)));
+        return (_b = (_a = this.findExtendedAttribute(extAttrs, idl.IDLExtendedAttributes.TypeParameters)) === null || _a === void 0 ? void 0 : _a.split(",")) === null || _b === void 0 ? void 0 : _b.map(it => this.sanitizeTypeParameter(it));
     }
     ///
     toIDLNode(file, node) {
@@ -107,34 +111,38 @@ class IDLDeserializer {
         throw new Error(`unexpected node type: ${toString(node)}`);
     }
     toIDLImport(node) {
-        // console.log(node)
         return this.withInfo(node, idl.createImport(node.clause.split("."), node.alias || undefined));
     }
     interfaceSubkind(node) {
         var _a, _b;
         const nodeIDLEntity = (_b = (_a = node.extAttrs.find(it => it.name === "Entity")) === null || _a === void 0 ? void 0 : _a.rhs) === null || _b === void 0 ? void 0 : _b.value;
-        if (nodeIDLEntity == idl.IDLEntity.Class)
-            return idl.IDLInterfaceSubkind.Class;
-        if (nodeIDLEntity == idl.IDLEntity.Interface)
-            return idl.IDLInterfaceSubkind.Interface;
-        if (nodeIDLEntity == idl.IDLEntity.Tuple)
-            return idl.IDLInterfaceSubkind.Tuple;
-        return idl.IDLInterfaceSubkind.Interface;
+        switch (nodeIDLEntity) {
+            case idl.IDLEntity.Class: return idl.IDLInterfaceSubkind.Class;
+            case idl.IDLEntity.Literal: return idl.IDLInterfaceSubkind.AnonymousInterface;
+            case idl.IDLEntity.Tuple: return idl.IDLInterfaceSubkind.Tuple;
+            default: return idl.IDLInterfaceSubkind.Interface;
+        }
     }
     toIDLInterface(file, node) {
-        var _a;
         const generics = this.extractGenerics(node.extAttrs);
-        this.genericsScopes.push(generics);
-        const result = idl.createInterface(node.name, this.interfaceSubkind(node), (() => {
-            var _a, _b;
-            if (!node.inheritance)
+        this.enterGenericScope(generics);
+        const subkind = this.interfaceSubkind(node);
+        const result = idl.createInterface(node.name, subkind, (() => {
+            if (!node.inheritance) {
                 return [];
-            const parentTypeArgs = this.extractTypeArguments(file, (_a = node.inheritanceExtAttrs) !== null && _a !== void 0 ? _a : [], idl.IDLExtendedAttributes.TypeArguments);
-            const parentType = idl.createReferenceType(node.inheritance, parentTypeArgs);
-            parentType.fileName = file;
-            if (node.inheritanceExtAttrs)
-                parentType.extendedAttributes = (_b = this.toExtendedAttributes(node.inheritanceExtAttrs)) === null || _b === void 0 ? void 0 : _b.filter(it => it.name !== idl.IDLExtendedAttributes.TypeArguments);
-            return [parentType];
+            }
+            const implementations = [];
+            node.inheritance.forEach(it => {
+                var _a;
+                const attributes = it.extAttrs;
+                const parentTypeArgs = this.extractTypeArguments(file, attributes !== null && attributes !== void 0 ? attributes : [], idl.IDLExtendedAttributes.TypeArguments);
+                const attrs = (_a = this.toExtendedAttributes(attributes !== null && attributes !== void 0 ? attributes : [])) === null || _a === void 0 ? void 0 : _a.filter(it => it.name !== idl.IDLExtendedAttributes.TypeArguments);
+                const ref = idl.createReferenceType(it.inheritance, parentTypeArgs, {
+                    extendedAttributes: attrs
+                });
+                implementations.push(ref);
+            });
+            return implementations;
         })(), node.members
             .filter(isConstructor)
             .map(it => this.toIDLConstructor(file, it)), [], node.members
@@ -145,7 +153,7 @@ class IDLDeserializer {
             .map(it => this.toIDLMethod(file, it, false)), node.members
             .filter(isOperation)
             .filter(it => this.isCallable(it))
-            .map(it => this.toIDLCallable(file, it)), (_a = this.findExtendedAttribute(node.extAttrs, idl.IDLExtendedAttributes.TypeParameters)) === null || _a === void 0 ? void 0 : _a.split(","), {
+            .map(it => this.toIDLCallable(file, it)), generics, {
             fileName: file,
             documentation: this.makeDocs(node),
             extendedAttributes: this.toExtendedAttributes(node.extAttrs),
@@ -158,7 +166,7 @@ class IDLDeserializer {
         }
         return result;
     }
-    toIDLType(file, type, extAttrs) {
+    toIDLType(file, type, extAttrs, suggestedName) {
         var _a;
         if (typeof type === "string") {
             // is it IDLStringType?
@@ -178,7 +186,7 @@ class IDLDeserializer {
                 types = types.filter(it => it !== idl.IDLUndefinedType);
                 return this.withInfo(type, idl.createOptionalType(collapseTypes(types)));
             }
-            const name = generateSyntheticUnionName(types);
+            const name = suggestedName !== null && suggestedName !== void 0 ? suggestedName : generateSyntheticUnionName(types);
             return this.withInfo(type, idl.createUnionType(types, name));
         }
         if (isSingleTypeDescription(type)) {
@@ -233,12 +241,12 @@ class IDLDeserializer {
         throw new Error(`unexpected type: ${toString(type)}`);
     }
     toIDLCallable(file, node) {
-        var _a, _b;
+        var _a;
         if (!node.idlType) {
             throw new Error(`method with no type ${toString(node)}`);
         }
         const generics = this.extractGenerics(node.extAttrs);
-        this.genericsScopes.push(generics);
+        this.enterGenericScope(generics);
         const returnType = this.toIDLType(file, node.idlType, node.extAttrs);
         if (idl.isReferenceType(returnType)) {
             const returnTypeArgs = this.extractTypeArguments(file, node.extAttrs, idl.IDLExtendedAttributes.TypeArguments);
@@ -250,17 +258,17 @@ class IDLDeserializer {
         }, {
             documentation: this.makeDocs(node),
             extendedAttributes: this.toExtendedAttributes(node.extAttrs),
-        }, (_b = this.findExtendedAttribute(node.extAttrs, idl.IDLExtendedAttributes.TypeParameters)) === null || _b === void 0 ? void 0 : _b.split(",")));
+        }, generics));
         this.genericsScopes.pop();
         return result;
     }
     toIDLMethod(file, node, isFree = false) {
-        var _a, _b;
+        var _a;
         if (!node.idlType) {
             throw new Error(`method with no type ${toString(node)}`);
         }
         const generics = this.extractGenerics(node.extAttrs);
-        this.genericsScopes.push(generics);
+        this.enterGenericScope(generics);
         const returnType = this.toIDLType(file, node.idlType, node.extAttrs);
         if (idl.isReferenceType(returnType))
             returnType.typeArguments = this.extractTypeArguments(file, node.extAttrs, idl.IDLExtendedAttributes.TypeArguments);
@@ -272,7 +280,7 @@ class IDLDeserializer {
         }, {
             documentation: this.makeDocs(node),
             extendedAttributes: this.toExtendedAttributes(node.extAttrs),
-        }, (_b = this.findExtendedAttribute(node.extAttrs, idl.IDLExtendedAttributes.TypeParameters)) === null || _b === void 0 ? void 0 : _b.split(",")));
+        }, generics));
         this.genericsScopes.pop();
         return result;
     }
@@ -287,22 +295,24 @@ class IDLDeserializer {
         }));
     }
     toIDLCallback(file, node) {
+        const generics = this.extractGenerics(node.extAttrs);
+        this.enterGenericScope(generics);
         const result = idl.createCallback(node.name, node.arguments.map(it => this.toIDLParameter(file, it)), this.toIDLType(file, node.idlType, undefined), {
             fileName: file,
             extendedAttributes: this.toExtendedAttributes(node.extAttrs),
             documentation: this.makeDocs(node),
-        });
+        }, generics);
         if (node.extAttrs.find(it => it.name === "Synthetic")) {
             const fqName = this.currentPackage.concat(this.namespacePathNames).concat([node.name]).join('.');
             addSyntheticType(fqName, result);
         }
+        this.genericsScopes.pop();
         return this.withInfo(node, result);
     }
     toIDLTypedef(file, node) {
-        var _a;
         const generics = this.extractGenerics(node.extAttrs);
-        this.genericsScopes.push(generics);
-        const result = this.withInfo(node, idl.createTypedef(node.name, this.toIDLType(file, node.idlType, undefined), (_a = this.findExtendedAttribute(node.extAttrs, idl.IDLExtendedAttributes.TypeParameters)) === null || _a === void 0 ? void 0 : _a.split(","), {
+        this.enterGenericScope(generics);
+        const result = this.withInfo(node, idl.createTypedef(node.name, this.toIDLType(file, node.idlType, undefined, node.name), generics, {
             extendedAttributes: this.toExtendedAttributes(node.extAttrs),
             documentation: this.makeDocs(node),
             fileName: file,
@@ -358,7 +368,7 @@ class IDLDeserializer {
             initializer = undefined;
         }
         else {
-            throw new Error(`Not representable enum initializer: ${node.default}`);
+            throw new Error(`Not representable enum initializer: ${JSON.stringify(node.default)}. Found in ${file}`);
         }
         return this.withInfo(node, idl.createEnumMember(node.name, parent, this.toIDLType(file, node.idlType, undefined), initializer, {
             extendedAttributes: this.toExtendedAttributes(node.extAttrs),
@@ -401,17 +411,39 @@ class IDLDeserializer {
         return node.type === 'import';
     }
     isCallable(node) {
-        return node.extAttrs.some(it => it.name == "Invoke");
+        return node.extAttrs.some(it => it.name == idl.IDLExtendedAttributes.CallSignature);
     }
     ///
+    splitTypeArguments(line) {
+        let buffer = "";
+        let brackets = 0;
+        const result = [];
+        for (const letter of line) {
+            if (letter === ',' && brackets === 0) {
+                result.push(buffer);
+                buffer = '';
+                continue;
+            }
+            if (letter === '<') {
+                brackets += 1;
+            }
+            if (letter === '>') {
+                brackets -= 1;
+            }
+            buffer += letter;
+        }
+        if (buffer.length) {
+            result.push(buffer);
+        }
+        return result;
+    }
     extractTypeArguments(file, extAttrs, attribute) {
         var _a;
         const attr = extAttrs === null || extAttrs === void 0 ? void 0 : extAttrs.find(it => it.name === attribute);
         if (!attr)
             return undefined;
         let value = this.toExtendedAttributeValue(attr);
-        return (_a = value === null || value === void 0 ? void 0 : value.split(",") // TODO need real parsing here. What about "<T, Map<K, Callback<K,R>>, U>"
-        ) === null || _a === void 0 ? void 0 : _a.map(it => { var _a; return this.toIDLType(file, (_a = webidl2.parseType(it, file)) !== null && _a !== void 0 ? _a : it); });
+        return (_a = this.splitTypeArguments(value)) === null || _a === void 0 ? void 0 : _a.map(it => { var _a; return this.toIDLType(file, (_a = webidl2.parseType(it.replaceAll('\'', '"'), file)) !== null && _a !== void 0 ? _a : it); });
     }
     constantValue(node) {
         switch (node.value.type) {
@@ -480,9 +512,9 @@ class IDLDeserializer {
         return attr ? this.toExtendedAttributeValue(attr) : undefined;
     }
 }
-export function toIDLFile(fileName, content) {
+export function toIDLFile(fileName, { content, inheritanceMode = 'multiple' } = {}) {
     const lexicalInfo = new Map();
-    const deserializer = new IDLDeserializer(lexicalInfo);
+    const deserializer = new IDLDeserializer(lexicalInfo, inheritanceMode);
     if (undefined === content)
         content = fs.readFileSync(fileName).toString();
     let packageClause = [];

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

@@ -44,6 +44,7 @@ export declare enum IDLExtendedAttributes {
     DtsName = "DtsName",
     DtsTag = "DtsTag",
     Entity = "Entity",
+    Extends = "Extends",
     Import = "Import",
     DefaultExport = "DefaultExport",
     IndexSignature = "IndexSignature",
@@ -55,10 +56,12 @@ export declare enum IDLExtendedAttributes {
     Protected = "Protected",
     Synthetic = "Synthetic",
     Throws = "Throws",
+    TraceKey = "TraceKey",
     TypeArguments = "TypeArguments",
     TypeParameters = "TypeParameters",
     VerbatimDts = "VerbatimDts",
-    HandWrittenImplementation = "HandWrittenImplementation"
+    HandWrittenImplementation = "HandWrittenImplementation",
+    ExtraMethod = "ExtraMethod"
 }
 export declare enum IDLAccessorAttribute {
     Getter = "Getter",
@@ -252,15 +255,6 @@ export declare function isSyntheticEntry(node: IDLNode): boolean;
 export declare function isOptionalType(type: IDLNode): type is IDLOptionalType;
 export declare function isVersion(node: IDLNode): node is IDLVersion;
 export declare function createOptionalType(element: IDLType, nodeInitializer?: IDLNodeInitializer): IDLOptionalType;
-/**
- * This placeholder is used when a class has no superclass.
- * Examples:
- *  class definition:               inheritance:
- * `C extends T`                  :  [T]
- * `C implements T`               :  [Top, T]
- * `C extends T implements I, J`  :  [T, I, J]
- */
-export declare const IDLTopType: IDLReferenceType;
 export declare const IDLPointerType: IDLPrimitiveType;
 export declare const IDLVoidType: IDLPrimitiveType;
 export declare const IDLBooleanType: IDLPrimitiveType;
@@ -281,7 +275,7 @@ export declare const IDLStringType: IDLPrimitiveType;
 export declare const IDLAnyType: IDLPrimitiveType;
 export declare const IDLUndefinedType: IDLPrimitiveType;
 export declare const IDLUnknownType: IDLPrimitiveType;
-export declare const IDLObjectType: IDLReferenceType;
+export declare const IDLObjectType: IDLPrimitiveType;
 export declare const IDLThisType: IDLPrimitiveType;
 export declare const IDLDate: IDLPrimitiveType;
 export declare const IDLBufferType: IDLPrimitiveType;
@@ -305,6 +299,7 @@ export declare function getPackageName(node: IDLNode): string;
 export declare function isInPackage(entry: IDLEntry | IDLFile, packageName: string, exactMatch?: boolean): boolean;
 export declare function getNamespaceName(a: IDLEntry): string;
 export type QNPattern = "package.namespace.name" | "namespace.name" | "name";
+export declare function deriveQualifiedNameFrom(name: string, from: IDLNode): string;
 export declare function getQualifiedName(a: IDLNode, pattern: QNPattern): string;
 export declare function getFQName(a: IDLNode): string;
 export declare function createVersion(value: string[], nodeInitializer?: IDLNodeInitializer): IDLVersion;
@@ -333,13 +328,14 @@ export type IDLCallableInitializer = {
     isAsync: boolean;
     isStatic: boolean;
 };
-export declare function createCallable(name: string, parameters: IDLParameter[], returnType: IDLType, callableInitializer: IDLCallableInitializer, nodeInitializer: IDLNodeInitializer, typeParameters?: string[]): IDLCallable;
+export declare function createCallable(name: string, parameters: IDLParameter[], returnType: IDLType, callableInitializer: IDLCallableInitializer, nodeInitializer?: IDLNodeInitializer, typeParameters?: string[]): IDLCallable;
 export declare function createConstructor(parameters: IDLParameter[], returnType: IDLType | undefined, nodeInitializer?: IDLNodeInitializer): IDLConstructor;
 export declare function createCallback(name: string, parameters: IDLParameter[], returnType: IDLType, nodeInitializer?: IDLNodeInitializer, typeParameters?: string[]): IDLCallback;
 export declare function createTypeParameterReference(name: string, nodeInitializer?: IDLNodeInitializer): IDLTypeParameterType;
 export declare function createTypedef(name: string, type: IDLType, typeParameters?: string[], nodeInitializer?: IDLNodeInitializer): IDLTypedef;
 export declare function createConstant(name: string, type: IDLType, value: string, nodeInitializer?: IDLNodeInitializer): IDLConstant;
 export declare function clone<T extends IDLNode>(node: T): T;
+export declare function hasTypeParameters(entry: IDLEntry): boolean;
 export declare function escapeIDLKeyword(name: string): string;
 export declare function unescapeKeyword(name: string): string;
 type PrintedIndentInc = "[[indent-inc]]";
@@ -365,9 +361,6 @@ export declare function printNamespace(idl: IDLNamespace): PrintedLine[];
 export declare function printCallback(idl: IDLCallback): PrintedLine[];
 export declare function printScoped(idl: IDLEntry): PrintedLine[];
 export declare function printInterface(idl: IDLInterface): PrintedLine[];
-export declare function getSuperType(idl: IDLInterface): IDLReferenceType | undefined;
-export declare function getSuperTypes(idl: IDLInterface): IDLReferenceType[] | undefined;
-export declare function hasSuperType(idl: IDLInterface): boolean;
 export declare function printEnumMember(idl: IDLEnumMember): PrintedLine[];
 export declare function printEnum(idl: IDLEnum, skipInitializers: boolean): PrintedLine[];
 export declare function printTypedef(idl: IDLTypedef): PrintedLine[];