@idlizer/core 2.1.0 → 2.1.5

package/build/lib/src/idl.js

@@ -65,6 +65,7 @@ export var IDLExtendedAttributes;
     IDLExtendedAttributes["DtsTag"] = "DtsTag";
     IDLExtendedAttributes["Entity"] = "Entity";
     IDLExtendedAttributes["Import"] = "Import";
+    IDLExtendedAttributes["DefaultExport"] = "DefaultExport";
     IDLExtendedAttributes["IndexSignature"] = "IndexSignature";
     IDLExtendedAttributes["Interfaces"] = "Interfaces";
     IDLExtendedAttributes["NativeModule"] = "NativeModule";
@@ -94,7 +95,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 +173,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 +382,11 @@ 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,
-    };
+    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 +397,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');
@@ -326,40 +423,44 @@ export const IDLThisType = createPrimitiveType('this');
 export const IDLDate = createPrimitiveType('date');
 export const IDLBufferType = createPrimitiveType('buffer');
 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))
@@ -368,31 +469,32 @@ 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(entry) {
-    return getPackageClause(entry).join(".");
+export function getPackageName(node) {
+    return getPackageClause(node).join(".");
 }
 export function isInPackage(entry, packageName, exactMatch = false) {
     const entryPackageName = getPackageName(entry);
@@ -403,22 +505,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;
@@ -429,7 +530,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;
@@ -437,24 +538,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)) {
@@ -467,35 +556,16 @@ 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 });
@@ -561,14 +631,8 @@ export function createCallback(name, parameters, returnType, nodeInitializer = {
     });
     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 });
@@ -578,6 +642,196 @@ 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;
+    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: node.extendedAttributes,
+                fileName: node.fileName
+            }));
+        }
+        case IDLKind.Import: {
+            const entry = get(node);
+            return make(createImport(entry.clause, entry.name, {
+                documentation: entry.documentation,
+                extendedAttributes: entry.extendedAttributes,
+                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: entry.extendedAttributes,
+                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: entry.extendedAttributes,
+                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: entry.extendedAttributes,
+                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: entry.extendedAttributes,
+                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: entry.extendedAttributes,
+                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: entry.extendedAttributes,
+                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: entry.extendedAttributes,
+                fileName: entry.fileName
+            }));
+        }
+        case IDLKind.Enum: {
+            const entry = get(node);
+            const cloned = createEnum(entry.name, entry.elements.map(clone), {
+                documentation: entry.documentation,
+                extendedAttributes: entry.extendedAttributes,
+                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: entry.extendedAttributes,
+                fileName: entry.fileName
+            }));
+        }
+        case IDLKind.Typedef: {
+            const entry = get(node);
+            return make(createTypedef(entry.name, clone(entry.type), entry.typeParameters, {
+                documentation: entry.documentation,
+                extendedAttributes: entry.extendedAttributes,
+                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: type.extendedAttributes,
+                fileName: type.fileName
+            }));
+        }
+        case IDLKind.UnspecifiedGenericType: {
+            const type = get(node);
+            return make(createUnspecifiedGenericType(type.name, type.typeArguments.map(clone), {
+                documentation: type.documentation,
+                extendedAttributes: type.extendedAttributes,
+                fileName: type.fileName
+            }));
+        }
+        case IDLKind.ReferenceType: {
+            const type = get(node);
+            return make(createReferenceType(type.name, (_d = type.typeArguments) === null || _d === void 0 ? void 0 : _d.map(clone), {
+                documentation: type.documentation,
+                extendedAttributes: type.extendedAttributes,
+                fileName: type.fileName
+            }));
+        }
+        case IDLKind.UnionType: {
+            const type = get(node);
+            return make(createUnionType(type.types.map(clone), type.name, {
+                documentation: type.documentation,
+                extendedAttributes: type.extendedAttributes,
+                fileName: type.fileName
+            }));
+        }
+        case IDLKind.TypeParameterType: {
+            const type = get(node);
+            return make(createTypeParameterReference(type.name, {
+                documentation: type.documentation,
+                extendedAttributes: type.extendedAttributes,
+                fileName: type.fileName
+            }));
+        }
+        case IDLKind.OptionalType: {
+            const type = get(node);
+            return make(createOptionalType(clone(type.type), {
+                documentation: type.documentation,
+                extendedAttributes: type.extendedAttributes,
+                fileName: type.fileName
+            }));
+        }
+        case IDLKind.Version: {
+            const entry = get(node);
+            return make(createVersion(entry.value, {
+                documentation: entry.documentation,
+                extendedAttributes: entry.extendedAttributes,
+                fileName: entry.fileName
+            }));
+        }
+        case IDLKind.Namespace: {
+            const ns = get(node);
+            return make(createNamespace(ns.name, ns.members.map(clone), {
+                documentation: ns.documentation,
+                extendedAttributes: ns.extendedAttributes,
+                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: file.extendedAttributes,
+                fileName: file.fileName
+            }));
+        }
+    }
+}
 export function escapeIDLKeyword(name) {
     return name + (IDLKeywords.has(name) ? "_" : "");
 }
@@ -734,15 +988,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) {
@@ -789,6 +1045,16 @@ export function getSuperType(idl) {
     const parent = idl.inheritance[0];
     return parent && parent !== IDLTopType ? parent : undefined;
 }
+export function getSuperTypes(idl) {
+    if (!idl.inheritance)
+        return undefined;
+    if (idl.inheritance[0] == IDLTopType) {
+        return idl.inheritance.length == 1 ? undefined : idl.inheritance.slice(1);
+    }
+    else {
+        return idl.inheritance.length == 0 ? undefined : idl.inheritance;
+    }
+}
 export function hasSuperType(idl) {
     return isDefined(getSuperType(idl));
 }
@@ -1015,10 +1281,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;
 }

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

@@ -12,10 +12,12 @@ export interface GenerateVisitor<T> {
             tsSourceFile: ts.SourceFile;
             visitor: GenerateVisitor<T>;
             result: T;
+            isAux: boolean;
         };
     }): T;
 }
-export declare function generate<T>(inputFiles: string[], outputDir: string, visitorFactory: (sourceFile: ts.SourceFile, program: ts.Program, compilerHost: ts.CompilerHost) => GenerateVisitor<T>, options: GenerateOptions<T>): void;
+export declare function generate<T>(baseDirs: string[], lookupDirs: string[], inputFiles: string[], auxInputFiles: string[], outputDir: string, stdlibFile: string, visitorFactory: (sourceFile: ts.SourceFile, program: ts.Program, compilerHost: ts.CompilerHost) => GenerateVisitor<T>, options: GenerateOptions<T>): void;
+export declare const PACKAGE_IDLIZE_INTERNAL = "idlize.internal";
 export declare function isInIdlize(entry: idl.IDLEntry | idl.IDLFile): boolean;
 export declare function isInIdlizeInterop(entry: idl.IDLEntry | idl.IDLFile): boolean;
 export declare function isInIdlizeInternal(entry: idl.IDLEntry | idl.IDLFile): boolean;