@idlizer/core 2.1.2 → 2.1.7

package/build/lib/src/idl.js

@@ -64,7 +64,9 @@ export var IDLExtendedAttributes;
     IDLExtendedAttributes["DtsName"] = "DtsName";
     IDLExtendedAttributes["DtsTag"] = "DtsTag";
     IDLExtendedAttributes["Entity"] = "Entity";
+    IDLExtendedAttributes["Extends"] = "Extends";
     IDLExtendedAttributes["Import"] = "Import";
+    IDLExtendedAttributes["DefaultExport"] = "DefaultExport";
     IDLExtendedAttributes["IndexSignature"] = "IndexSignature";
     IDLExtendedAttributes["Interfaces"] = "Interfaces";
     IDLExtendedAttributes["NativeModule"] = "NativeModule";
@@ -94,7 +96,7 @@ export var IDLInterfaceSubkind;
 })(IDLInterfaceSubkind || (IDLInterfaceSubkind = {}));
 export function forEachChild(node, cbEnter, cbLeave) {
     var _a, _b;
-    cbEnter(node);
+    const cleanup = cbEnter(node);
     switch (node.kind) {
         case IDLKind.File:
             node.entries.forEach((value) => forEachChild(value, cbEnter, cbLeave));
@@ -172,8 +174,108 @@ export function forEachChild(node, cbEnter, cbLeave) {
             throw new Error(`Unhandled ${node.kind}`);
         }
     }
-    if (cbLeave)
-        cbLeave(node);
+    cbLeave === null || cbLeave === void 0 ? void 0 : cbLeave(node);
+    cleanup === null || cleanup === void 0 ? void 0 : cleanup();
+}
+/** Updates tree in place! */
+function updateEachChild(node, op, cbLeave) {
+    const old = node;
+    node = op(old);
+    if (node.kind !== old.kind) {
+        throw new Error("Kinds must be the same!");
+    }
+    switch (node.kind) {
+        case IDLKind.File: {
+            const concrete = node;
+            concrete.entries = concrete.entries.map(it => updateEachChild(it, op, cbLeave));
+            break;
+        }
+        case IDLKind.Namespace: {
+            const concrete = node;
+            concrete.members = concrete.members.map((it) => updateEachChild(it, op, cbLeave));
+            break;
+        }
+        case IDLKind.Interface: {
+            const concrete = node;
+            concrete.inheritance = concrete.inheritance.map((it) => updateEachChild(it, op, cbLeave));
+            concrete.constructors = concrete.constructors.map((it) => updateEachChild(it, op, cbLeave));
+            concrete.properties = concrete.properties.map((it) => updateEachChild(it, op, cbLeave));
+            concrete.methods = concrete.methods.map((it) => updateEachChild(it, op, cbLeave));
+            concrete.callables = concrete.callables.map((it) => updateEachChild(it, op, cbLeave));
+            break;
+        }
+        case IDLKind.Method:
+        case IDLKind.Callable:
+        case IDLKind.Callback:
+        case IDLKind.Constructor: {
+            const concrete = node;
+            concrete.parameters = concrete.parameters.map((it) => updateEachChild(it, op, cbLeave));
+            if (concrete.returnType) {
+                concrete.returnType = updateEachChild(concrete.returnType, op, cbLeave);
+            }
+            break;
+        }
+        case IDLKind.UnionType: {
+            const concrete = node;
+            concrete.types = concrete.types.map((it) => updateEachChild(it, op, cbLeave));
+            break;
+        }
+        case IDLKind.OptionalType: {
+            const concrete = node;
+            concrete.type = updateEachChild(concrete.type, op, cbLeave);
+            break;
+        }
+        case IDLKind.Const: {
+            const concrete = node;
+            concrete.type = updateEachChild(concrete.type, op, cbLeave);
+            break;
+        }
+        case IDLKind.Enum: {
+            const concrete = node;
+            concrete.elements = concrete.elements.map((it) => updateEachChild(it, op, cbLeave));
+            break;
+        }
+        case IDLKind.Property: {
+            const concrete = node;
+            concrete.type = updateEachChild(concrete.type, op, cbLeave);
+            break;
+        }
+        case IDLKind.Parameter: {
+            const concrete = node;
+            if (concrete.type)
+                concrete.type = updateEachChild(concrete.type, op, cbLeave);
+            break;
+        }
+        case IDLKind.Typedef: {
+            const concrete = node;
+            concrete.type = updateEachChild(concrete.type, op, cbLeave);
+            break;
+        }
+        case IDLKind.ContainerType: {
+            const concrete = node;
+            concrete.elementType = concrete.elementType.map(it => updateEachChild(it, op, cbLeave));
+            break;
+        }
+        case IDLKind.UnspecifiedGenericType: {
+            const concrete = node;
+            concrete.typeArguments = concrete.typeArguments.map(it => updateEachChild(it, op, cbLeave));
+            break;
+        }
+        case IDLKind.ReferenceType:
+        case IDLKind.TypeParameterType:
+        case IDLKind.EnumMember:
+        case IDLKind.Import:
+        case IDLKind.PrimitiveType:
+        case IDLKind.Version:
+            break;
+        default: {
+            throw new Error(`Unhandled ${node.kind}`);
+        }
+    }
+    if (cbLeave) {
+        cbLeave === null || cbLeave === void 0 ? void 0 : cbLeave(node);
+    }
+    return node;
 }
 export function isNamedNode(type) {
     return "_idlNamedNodeBrand" in type;
@@ -281,16 +383,14 @@ function createPrimitiveType(name) {
         _idlNamedNodeBrand: innerIdlSymbol,
     };
 }
-export function createOptionalType(element) {
-    if (isOptionalType(element)) {
+export function createOptionalType(element, nodeInitializer) {
+    if (isOptionalType(element) && !nodeInitializer) {
         return element;
     }
-    return {
-        kind: IDLKind.OptionalType,
-        type: element,
-        _idlNodeBrand: innerIdlSymbol,
-        _idlTypeBrand: innerIdlSymbol,
-    };
+    if (isOptionalType(element)) {
+        return Object.assign(Object.assign({ kind: IDLKind.OptionalType, type: element.type }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlTypeBrand: innerIdlSymbol });
+    }
+    return Object.assign(Object.assign({ kind: IDLKind.OptionalType, type: element }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlTypeBrand: innerIdlSymbol });
 }
 /**
  * This placeholder is used when a class has no superclass.
@@ -301,6 +401,7 @@ export function createOptionalType(element) {
  * `C extends T implements I, J`  :  [T, I, J]
  */
 export const IDLTopType = createReferenceType("__TOP__");
+// must match with toIDLType in deserialize.ts
 export const IDLPointerType = createPrimitiveType('pointer');
 export const IDLVoidType = createPrimitiveType('void');
 export const IDLBooleanType = createPrimitiveType('boolean');
@@ -321,7 +422,7 @@ export const IDLStringType = createPrimitiveType('String');
 export const IDLAnyType = createPrimitiveType('any');
 export const IDLUndefinedType = createPrimitiveType('undefined');
 export const IDLUnknownType = createPrimitiveType('unknown');
-export const IDLObjectType = createReferenceType('Object');
+export const IDLObjectType = createPrimitiveType('Object');
 export const IDLThisType = createPrimitiveType('this');
 export const IDLDate = createPrimitiveType('date');
 export const IDLBufferType = createPrimitiveType('buffer');
@@ -329,38 +430,41 @@ export const IDLUint8ArrayType = createContainerType('sequence', [IDLU8Type]);
 export const IDLSerializerBuffer = createPrimitiveType('SerializerBuffer');
 // Stub for IdlPeerLibrary
 export const IDLFunctionType = createPrimitiveType('Function');
-export const IDLLengthType = createPrimitiveType('Length');
 export const IDLCustomObjectType = createPrimitiveType('CustomObject');
 export const IDLInteropReturnBufferType = createPrimitiveType('InteropReturnBuffer');
-export function createNamespace(name, extendedAttributes, fileName) {
-    return {
-        kind: IDLKind.Namespace,
-        members: [],
-        name: name,
-        extendedAttributes,
-        fileName,
-        _idlNodeBrand: innerIdlSymbol,
-        _idlEntryBrand: innerIdlSymbol,
-        _idlNamedNodeBrand: innerIdlSymbol,
-    };
+export 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 });
+}
+function isSpecialNodes(node) {
+    return node === IDLTopType
+        || node === IDLObjectType
+        || isPrimitiveType(node);
 }
 export function linkParentBack(node) {
     const parentStack = [];
-    forEachChild(node, (node) => {
-        if (isPrimitiveType(node))
-            return;
-        if (parentStack.length)
-            node.parent = parentStack[parentStack.length - 1];
+    updateEachChild(node, (node) => {
+        if (isSpecialNodes(node)) {
+            return node;
+        }
+        if (parentStack.length) {
+            const top = parentStack[parentStack.length - 1];
+            if (node.parent !== undefined && node.parent !== top) {
+                node = clone(node);
+            }
+            node.parent = top;
+        }
         parentStack.push(node);
+        return node;
     }, (node) => {
-        if (isPrimitiveType(node))
+        if (isSpecialNodes(node)) {
             return;
+        }
         parentStack.pop();
     });
     return node;
 }
-export function getNamespacesPathFor(entry) {
-    let iterator = entry.parent;
+export function getNamespacesPathFor(node) {
+    let iterator = node.parent;
     const result = [];
     while (iterator) {
         if (isNamespace(iterator))
@@ -369,28 +473,29 @@ export function getNamespacesPathFor(entry) {
     }
     return result;
 }
-export function getFileFor(entry) {
-    let iterator = entry;
+export function getFileFor(node) {
+    let iterator = node;
     while (iterator) {
         if (isFile(iterator))
             return iterator;
         iterator = iterator.parent;
     }
-    console.warn(`Entry ${JSON.stringify(entry)} does not have IDLFile in parents`);
+    console.warn(`Node ${getQualifiedName(node, "namespace.name")} does not have IDLFile in parents`);
     return undefined;
 }
-export function isEqualByQualifedName(a, b) {
+export function isEqualByQualifedName(a, b, pattern = "package.namespace.name") {
     if (a === b)
         return true;
     if (!a || !b)
         return false;
     if (a.kind !== b.kind || a.name !== b.name)
         return false;
-    return getFQName(a) === getFQName(b);
+    return getQualifiedName(a, pattern) === getQualifiedName(b, pattern);
 }
-export function getPackageClause(entry) {
-    let file = getFileFor(entry);
-    return (file === null || file === void 0 ? void 0 : file.packageClause) || [];
+export function getPackageClause(node) {
+    var _a;
+    const file = getFileFor(node);
+    return (_a = file === null || file === void 0 ? void 0 : file.packageClause) !== null && _a !== void 0 ? _a : [];
 }
 export function getPackageName(node) {
     return getPackageClause(node).join(".");
@@ -404,22 +509,21 @@ export function isInPackage(entry, packageName, exactMatch = false) {
 export function getNamespaceName(a) {
     return getNamespacesPathFor(a).map(it => it.name).join('.');
 }
+export function getQualifiedName(a, pattern) {
+    const result = [];
+    if ("package.namespace.name" === pattern)
+        result.push(...getPackageClause(a), ...getNamespacesPathFor(a).map(it => it.name));
+    else if ("namespace.name" === pattern)
+        result.push(...getNamespacesPathFor(a).map(it => it.name));
+    if (isNamedNode(a) && a.name)
+        result.push(a.name);
+    return result.join(".");
+}
 export function getFQName(a) {
-    // TODO package name is very dirty now, waiting for Alexander Rekunkov PR
-    // return [...getPackageClause(a), ...getNamespacesPathFor(a).map(it => it.name), a.name].join('.')
-    return [...getNamespacesPathFor(a).map(it => it.name), a.name].join('.');
+    return getQualifiedName(a, "package.namespace.name");
 }
-export function createVersion(value, extendedAttributes, fileName) {
-    return {
-        kind: IDLKind.Version,
-        value,
-        name: "version",
-        extendedAttributes,
-        fileName,
-        _idlNodeBrand: innerIdlSymbol,
-        _idlEntryBrand: innerIdlSymbol,
-        _idlNamedNodeBrand: innerIdlSymbol,
-    };
+export function createVersion(value, nodeInitializer) {
+    return Object.assign(Object.assign({ kind: IDLKind.Version, value, name: "version" }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
 }
 export function fetchNamespaceFrom(pointOfView) {
     let node = pointOfView;
@@ -430,7 +534,7 @@ export function fetchNamespaceFrom(pointOfView) {
     }
     return undefined;
 }
-export function createReferenceType(nameOrSource, typeArguments) {
+export function createReferenceType(nameOrSource, typeArguments, nodeInitializer) {
     let name;
     if (typeof nameOrSource === 'string') {
         name = nameOrSource;
@@ -438,24 +542,12 @@ export function createReferenceType(nameOrSource, typeArguments) {
     else {
         name = getFQName(nameOrSource);
     }
-    return {
-        kind: IDLKind.ReferenceType,
-        name,
-        typeArguments,
-        _idlNodeBrand: innerIdlSymbol,
-        _idlTypeBrand: innerIdlSymbol,
-        _idlNamedNodeBrand: innerIdlSymbol,
-    };
+    return Object.assign(Object.assign({ kind: IDLKind.ReferenceType, name,
+        typeArguments }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlTypeBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
 }
-export function createUnspecifiedGenericType(name, typeArguments) {
-    return {
-        kind: IDLKind.UnspecifiedGenericType,
-        name,
-        typeArguments,
-        _idlNodeBrand: innerIdlSymbol,
-        _idlTypeBrand: innerIdlSymbol,
-        _idlNamedNodeBrand: innerIdlSymbol,
-    };
+export function createUnspecifiedGenericType(name, typeArguments, nodeInitializer) {
+    return Object.assign(Object.assign({ kind: IDLKind.UnspecifiedGenericType, name,
+        typeArguments }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlTypeBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
 }
 export function entityToType(entity) {
     if (isType(entity)) {
@@ -468,38 +560,19 @@ export function entityToType(entity) {
         throw new Error(`Expected to have IDLType or IDLEntry, got ${entity}`);
     }
 }
-export function createContainerType(container, element) {
-    return {
-        kind: IDLKind.ContainerType,
-        containerKind: container,
-        elementType: element,
-        _idlNodeBrand: innerIdlSymbol,
-        _idlTypeBrand: innerIdlSymbol,
-    };
+export function createContainerType(container, element, nodeInitializer) {
+    return Object.assign(Object.assign({ kind: IDLKind.ContainerType, containerKind: container, elementType: element }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlTypeBrand: innerIdlSymbol });
 }
-export function createUnionType(types, name) {
+export function createUnionType(types, name, nodeInitializer) {
     if (types.length < 2)
         throw new Error("IDLUnionType should contain at least 2 types");
-    return {
-        kind: IDLKind.UnionType,
-        name: name !== null && name !== void 0 ? name : "Union_" + types.map(it => generateSyntheticIdlNodeName(it)).join("_"),
-        types: types,
-        _idlNodeBrand: innerIdlSymbol,
-        _idlTypeBrand: innerIdlSymbol,
-        _idlNamedNodeBrand: innerIdlSymbol,
-    };
+    return Object.assign(Object.assign({ kind: IDLKind.UnionType, name: name !== null && name !== void 0 ? name : "Union_" + types.map(it => generateSyntheticIdlNodeName(it)).join("_"), types: types }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlTypeBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
 }
-export function createFile(entries, fileName, packageClause = []) {
-    return {
-        kind: IDLKind.File,
-        packageClause,
-        entries: entries,
-        fileName,
-        _idlNodeBrand: innerIdlSymbol,
-    };
+export function createFile(entries, fileName, packageClause = [], nodeInitializer) {
+    return Object.assign(Object.assign({ kind: IDLKind.File, packageClause, entries: entries, fileName }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol });
 }
 export function createImport(clause, name, nodeInitializer) {
-    return Object.assign(Object.assign({ kind: IDLKind.Import, name: name || "", clause }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
+    return Object.assign(Object.assign({ kind: IDLKind.Import, name: name !== null && name !== void 0 ? name : "", clause }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
 }
 export function createEnum(name, elements, nodeInitializer) {
     return Object.assign(Object.assign({ kind: IDLKind.Enum, name: name, elements: elements }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
@@ -553,23 +626,10 @@ export function createConstructor(parameters, returnType, nodeInitializer = {})
         returnType }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
 }
 export function createCallback(name, parameters, returnType, nodeInitializer = {}, typeParameters = []) {
-    if (returnType === IDLThisType || isReferenceType(returnType) && returnType.name === "this")
-        returnType = IDLAnyType;
-    parameters = parameters.map(it => {
-        if (it.type && isNamedNode(it.type) && (it.type.name === "T" || it.type.name === "this"))
-            return createParameter(it.name, IDLAnyType, it.isOptional, it.isVariadic, { fileName: it.fileName });
-        return it;
-    });
     return Object.assign(Object.assign({ kind: IDLKind.Callback, name, parameters, returnType, typeParameters }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
 }
-export function createTypeParameterReference(name) {
-    return {
-        kind: IDLKind.TypeParameterType,
-        name: name,
-        _idlNodeBrand: innerIdlSymbol,
-        _idlTypeBrand: innerIdlSymbol,
-        _idlNamedNodeBrand: innerIdlSymbol,
-    };
+export function createTypeParameterReference(name, nodeInitializer) {
+    return Object.assign(Object.assign({ kind: IDLKind.TypeParameterType, name: name }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlTypeBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
 }
 export function createTypedef(name, type, typeParameters = [], nodeInitializer = {}) {
     return Object.assign(Object.assign({ name, type, typeParameters, kind: IDLKind.Typedef }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
@@ -579,6 +639,205 @@ export function createConstant(name, type, value, nodeInitializer = {}) {
         type,
         value }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
 }
+export function clone(node) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0;
+    const make = (node) => node;
+    const get = (node) => node;
+    switch (node.kind) {
+        case IDLKind.Interface: {
+            const entry = get(node);
+            return make(createInterface(entry.name, entry.subkind, (_a = entry.inheritance) === null || _a === void 0 ? void 0 : _a.map(clone), (_b = entry.constructors) === null || _b === void 0 ? void 0 : _b.map(clone), entry.constants.map(clone), entry.properties.map(clone), entry.methods.map(clone), entry.callables.map(clone), (_c = entry.typeParameters) === null || _c === void 0 ? void 0 : _c.map(it => it), {
+                documentation: node.documentation,
+                extendedAttributes: (_d = node.extendedAttributes) === null || _d === void 0 ? void 0 : _d.slice(),
+                fileName: node.fileName
+            }));
+        }
+        case IDLKind.Import: {
+            const entry = get(node);
+            return make(createImport(entry.clause, entry.name, {
+                documentation: entry.documentation,
+                extendedAttributes: (_e = entry.extendedAttributes) === null || _e === void 0 ? void 0 : _e.slice(),
+                fileName: entry.fileName
+            }));
+        }
+        case IDLKind.Callback: {
+            const entry = get(node);
+            return make(createCallback(entry.name, entry.parameters.map(clone), clone(entry.returnType), {
+                documentation: entry.documentation,
+                extendedAttributes: (_f = entry.extendedAttributes) === null || _f === void 0 ? void 0 : _f.slice(),
+                fileName: entry.fileName
+            }, entry.typeParameters));
+        }
+        case IDLKind.Const: {
+            const entry = get(node);
+            return make(createConstant(entry.name, clone(entry.type), entry.value, {
+                documentation: entry.documentation,
+                extendedAttributes: (_g = entry.extendedAttributes) === null || _g === void 0 ? void 0 : _g.slice(),
+                fileName: entry.fileName
+            }));
+        }
+        case IDLKind.Property: {
+            const entry = get(node);
+            return make(createProperty(entry.name, clone(entry.type), entry.isReadonly, entry.isStatic, entry.isOptional, {
+                documentation: entry.documentation,
+                extendedAttributes: (_h = entry.extendedAttributes) === null || _h === void 0 ? void 0 : _h.slice(),
+                fileName: entry.fileName
+            }));
+        }
+        case IDLKind.Parameter: {
+            const entry = get(node);
+            return make(createParameter(entry.name, clone(entry.type), entry.isOptional, entry.isVariadic, {
+                documentation: entry.documentation,
+                extendedAttributes: (_j = entry.extendedAttributes) === null || _j === void 0 ? void 0 : _j.slice(),
+                fileName: entry.fileName
+            }));
+        }
+        case IDLKind.Method: {
+            const entry = get(node);
+            return make(createMethod(entry.name, entry.parameters.map(clone), clone(entry.returnType), {
+                isAsync: entry.isAsync,
+                isFree: entry.isFree,
+                isOptional: entry.isOptional,
+                isStatic: entry.isStatic
+            }, {
+                documentation: entry.documentation,
+                extendedAttributes: (_k = entry.extendedAttributes) === null || _k === void 0 ? void 0 : _k.slice(),
+                fileName: entry.fileName
+            }, entry.typeParameters));
+        }
+        case IDLKind.Callable: {
+            const entry = get(node);
+            return make(createCallable(entry.name, entry.parameters.map(clone), clone(entry.returnType), {
+                isAsync: entry.isAsync,
+                isStatic: entry.isStatic
+            }, {
+                documentation: entry.documentation,
+                extendedAttributes: (_l = entry.extendedAttributes) === null || _l === void 0 ? void 0 : _l.slice(),
+                fileName: entry.documentation
+            }, entry.typeParameters));
+        }
+        case IDLKind.Constructor: {
+            const entry = get(node);
+            return make(createConstructor(entry.parameters.map(clone), entry.returnType ? clone(entry.returnType) : undefined, {
+                documentation: entry.documentation,
+                extendedAttributes: (_m = entry.extendedAttributes) === null || _m === void 0 ? void 0 : _m.slice(),
+                fileName: entry.fileName
+            }));
+        }
+        case IDLKind.Enum: {
+            const entry = get(node);
+            const cloned = createEnum(entry.name, entry.elements.map(clone), {
+                documentation: entry.documentation,
+                extendedAttributes: (_o = entry.extendedAttributes) === null || _o === void 0 ? void 0 : _o.slice(),
+                fileName: entry.fileName
+            });
+            cloned.elements.forEach(it => {
+                it.parent = cloned;
+            });
+            return make(cloned);
+        }
+        case IDLKind.EnumMember: {
+            const entry = get(node);
+            return make(createEnumMember(entry.name, entry.parent, clone(entry.type), entry.initializer, {
+                documentation: entry.documentation,
+                extendedAttributes: (_p = entry.extendedAttributes) === null || _p === void 0 ? void 0 : _p.slice(),
+                fileName: entry.fileName
+            }));
+        }
+        case IDLKind.Typedef: {
+            const entry = get(node);
+            return make(createTypedef(entry.name, clone(entry.type), entry.typeParameters, {
+                documentation: entry.documentation,
+                extendedAttributes: (_q = entry.extendedAttributes) === null || _q === void 0 ? void 0 : _q.slice(),
+                fileName: entry.fileName
+            }));
+        }
+        case IDLKind.PrimitiveType: {
+            return node;
+        }
+        case IDLKind.ContainerType: {
+            const type = get(node);
+            return make(createContainerType(type.containerKind, type.elementType.map(clone), {
+                documentation: type.documentation,
+                extendedAttributes: (_r = type.extendedAttributes) === null || _r === void 0 ? void 0 : _r.slice(),
+                fileName: type.fileName
+            }));
+        }
+        case IDLKind.UnspecifiedGenericType: {
+            const type = get(node);
+            return make(createUnspecifiedGenericType(type.name, type.typeArguments.map(clone), {
+                documentation: type.documentation,
+                extendedAttributes: (_s = type.extendedAttributes) === null || _s === void 0 ? void 0 : _s.slice(),
+                fileName: type.fileName
+            }));
+        }
+        case IDLKind.ReferenceType: {
+            const type = get(node);
+            return make(createReferenceType(type.name, (_t = type.typeArguments) === null || _t === void 0 ? void 0 : _t.map(clone), {
+                documentation: type.documentation,
+                extendedAttributes: (_u = type.extendedAttributes) === null || _u === void 0 ? void 0 : _u.slice(),
+                fileName: type.fileName
+            }));
+        }
+        case IDLKind.UnionType: {
+            const type = get(node);
+            return make(createUnionType(type.types.map(clone), type.name, {
+                documentation: type.documentation,
+                extendedAttributes: (_v = type.extendedAttributes) === null || _v === void 0 ? void 0 : _v.slice(),
+                fileName: type.fileName
+            }));
+        }
+        case IDLKind.TypeParameterType: {
+            const type = get(node);
+            return make(createTypeParameterReference(type.name, {
+                documentation: type.documentation,
+                extendedAttributes: (_w = type.extendedAttributes) === null || _w === void 0 ? void 0 : _w.slice(),
+                fileName: type.fileName
+            }));
+        }
+        case IDLKind.OptionalType: {
+            const type = get(node);
+            return make(createOptionalType(clone(type.type), {
+                documentation: type.documentation,
+                extendedAttributes: (_x = type.extendedAttributes) === null || _x === void 0 ? void 0 : _x.slice(),
+                fileName: type.fileName
+            }));
+        }
+        case IDLKind.Version: {
+            const entry = get(node);
+            return make(createVersion(entry.value, {
+                documentation: entry.documentation,
+                extendedAttributes: (_y = entry.extendedAttributes) === null || _y === void 0 ? void 0 : _y.slice(),
+                fileName: entry.fileName
+            }));
+        }
+        case IDLKind.Namespace: {
+            const ns = get(node);
+            return make(createNamespace(ns.name, ns.members.map(clone), {
+                documentation: ns.documentation,
+                extendedAttributes: (_z = ns.extendedAttributes) === null || _z === void 0 ? void 0 : _z.slice(),
+                fileName: ns.fileName
+            }));
+        }
+        case IDLKind.File: {
+            const file = get(node);
+            return make(createFile(file.entries.map(clone), file.fileName, file.packageClause, {
+                documentation: file.documentation,
+                extendedAttributes: (_0 = file.extendedAttributes) === null || _0 === void 0 ? void 0 : _0.slice(),
+                fileName: file.fileName
+            }));
+        }
+    }
+}
+export function hasTypeParameters(entry) {
+    let foundTypeParameter = false;
+    forEachChild(entry, n => {
+        if (isTypeParameterType(n)) {
+            foundTypeParameter = true;
+        }
+    });
+    return foundTypeParameter;
+}
 export function escapeIDLKeyword(name) {
     return name + (IDLKeywords.has(name) ? "_" : "");
 }
@@ -735,15 +994,17 @@ export function printMethod(idl) {
     ];
 }
 export function printPackage(idl) {
-    if (!idl.packageClause.length)
+    const effectiveClause = idl.packageClause.filter(it => !!it);
+    if (!effectiveClause.length)
         return [];
     return [
-        `package ${idl.packageClause.join(".")};`
+        `package ${effectiveClause.join(".")};`
     ];
 }
 export function printImport(idl) {
+    const effectiveClause = idl.clause.filter(it => !!it);
     return [
-        `import ${idl.clause.join(".")}${idl.name ? " as " : ""}${idl.name};`
+        `import ${effectiveClause.join(".") || "NULL_IMPORT"}${idl.name ? " as " : ""}${idl.name};`
     ];
 }
 export function printNamespace(idl) {
@@ -769,10 +1030,35 @@ export function printScoped(idl) {
         return printInterface(idl);
     throw new Error(`Unexpected scoped: ${idl.kind} ${idl.name}`);
 }
+function printInterfaceInherit(idl) {
+    var _a;
+    if (idl.inheritance.length === 0) {
+        return "";
+    }
+    const inheritance = [...idl.inheritance];
+    const types = [];
+    if (idl.subkind === IDLInterfaceSubkind.Class) {
+        if (inheritance[0] !== IDLTopType) {
+            const ref = clone(inheritance[0]);
+            (_a = ref.extendedAttributes) !== null && _a !== void 0 ? _a : (ref.extendedAttributes = []);
+            if (!hasExtAttribute(ref, IDLExtendedAttributes.Extends)) {
+                ref.extendedAttributes = ref.extendedAttributes.concat([
+                    { name: IDLExtendedAttributes.Extends }
+                ]);
+            }
+            types.push(`${printType(ref)}`);
+            inheritance.shift();
+        }
+    }
+    inheritance.forEach(type => {
+        types.push(printType(type));
+    });
+    return ": " + types.join(', ');
+}
 export function printInterface(idl) {
     return [
         ...printExtendedAttributes(idl, 0),
-        `interface ${idl.name}${hasSuperType(idl) ? ": " + printType(idl.inheritance[0]) : ""} {`,
+        `interface ${idl.name}${printInterfaceInherit(idl)} {`,
         // TODO: type system hack!
     ]
         .concat(printedIndentInc)
@@ -1026,10 +1312,9 @@ export function isStringEnum(decl) {
 export function linearizeNamespaceMembers(entries) {
     const linearized = [];
     for (const entry of entries) {
+        linearized.push(entry);
         if (isNamespace(entry))
             linearized.push(...linearizeNamespaceMembers(entry.members));
-        else
-            linearized.push(entry);
     }
     return linearized;
 }