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

package/build/lib/src/idl.js

@@ -1,1385 +0,0 @@
-/*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import * as webidl2 from "webidl2";
-import { indentedBy, isDefined } from "./util";
-import { generateSyntheticIdlNodeName } from "./peer-generation/idl/common";
-import { IDLKeywords } from "./languageSpecificKeywords";
-export var IDLKind;
-(function (IDLKind) {
-    IDLKind["Interface"] = "Interface";
-    IDLKind["Import"] = "Import";
-    IDLKind["Callback"] = "Callback";
-    IDLKind["Const"] = "Const";
-    IDLKind["Property"] = "Property";
-    IDLKind["Parameter"] = "Parameter";
-    IDLKind["Method"] = "Method";
-    IDLKind["Callable"] = "Callable";
-    IDLKind["Constructor"] = "Constructor";
-    IDLKind["Enum"] = "Enum";
-    IDLKind["EnumMember"] = "EnumMember";
-    IDLKind["Typedef"] = "Typedef";
-    IDLKind["PrimitiveType"] = "PrimitiveType";
-    IDLKind["ContainerType"] = "ContainerType";
-    IDLKind["UnspecifiedGenericType"] = "UnspecifiedGenericType";
-    IDLKind["ReferenceType"] = "ReferenceType";
-    IDLKind["UnionType"] = "UnionType";
-    IDLKind["TypeParameterType"] = "TypeParameterType";
-    IDLKind["OptionalType"] = "OptionalType";
-    IDLKind["Version"] = "Version";
-    IDLKind["Namespace"] = "Namespace";
-    IDLKind["File"] = "File";
-})(IDLKind || (IDLKind = {}));
-export var IDLEntity;
-(function (IDLEntity) {
-    IDLEntity["Class"] = "Class";
-    IDLEntity["Interface"] = "Interface";
-    IDLEntity["Import"] = "Import";
-    IDLEntity["Intersection"] = "Intersection";
-    IDLEntity["Literal"] = "Literal";
-    IDLEntity["NamedTuple"] = "NamedTuple";
-    IDLEntity["Tuple"] = "Tuple";
-})(IDLEntity || (IDLEntity = {}));
-export var IDLExtendedAttributes;
-(function (IDLExtendedAttributes) {
-    IDLExtendedAttributes["Accessor"] = "Accessor";
-    IDLExtendedAttributes["Annotations"] = "Annotations";
-    IDLExtendedAttributes["Async"] = "Async";
-    IDLExtendedAttributes["CallSignature"] = "CallSignature";
-    IDLExtendedAttributes["CommonMethod"] = "CommonMethod";
-    IDLExtendedAttributes["Component"] = "Component";
-    IDLExtendedAttributes["ComponentInterface"] = "ComponentInterface";
-    IDLExtendedAttributes["ComponentModifier"] = "ComponentModifier";
-    IDLExtendedAttributes["Deprecated"] = "Deprecated";
-    IDLExtendedAttributes["Documentation"] = "Documentation";
-    IDLExtendedAttributes["DtsName"] = "DtsName";
-    IDLExtendedAttributes["DtsTag"] = "DtsTag";
-    IDLExtendedAttributes["Entity"] = "Entity";
-    IDLExtendedAttributes["Extends"] = "Extends";
-    IDLExtendedAttributes["ExtensionMethod"] = "ExtensionMethod";
-    IDLExtendedAttributes["Import"] = "Import";
-    IDLExtendedAttributes["DefaultExport"] = "DefaultExport";
-    IDLExtendedAttributes["IndexSignature"] = "IndexSignature";
-    IDLExtendedAttributes["Interfaces"] = "Interfaces";
-    IDLExtendedAttributes["NativeModule"] = "NativeModule";
-    IDLExtendedAttributes["Optional"] = "Optional";
-    IDLExtendedAttributes["UnionOnlyNull"] = "OptionalOnlyNull";
-    IDLExtendedAttributes["UnionWithNull"] = "OptionalWithNull";
-    IDLExtendedAttributes["OriginalEnumMemberName"] = "OriginalEnumMemberName";
-    IDLExtendedAttributes["OriginalGenericName"] = "OriginalGenericName";
-    IDLExtendedAttributes["Predefined"] = "Predefined";
-    IDLExtendedAttributes["Protected"] = "Protected";
-    IDLExtendedAttributes["Abstract"] = "Abstract";
-    IDLExtendedAttributes["Synthetic"] = "Synthetic";
-    IDLExtendedAttributes["Throws"] = "Throws";
-    IDLExtendedAttributes["TraceKey"] = "TraceKey";
-    IDLExtendedAttributes["TypeAnnotations"] = "TypeAnnotations";
-    IDLExtendedAttributes["TypeArguments"] = "TypeArguments";
-    IDLExtendedAttributes["TypeParameters"] = "TypeParameters";
-    IDLExtendedAttributes["TypeParametersDefaults"] = "TypeParametersDefaults";
-    IDLExtendedAttributes["VerbatimDts"] = "VerbatimDts";
-    IDLExtendedAttributes["HandWrittenImplementation"] = "HandWrittenImplementation";
-    IDLExtendedAttributes["ExtraMethod"] = "ExtraMethod";
-    IDLExtendedAttributes["OverloadAlias"] = "OverloadAlias";
-    IDLExtendedAttributes["OverloadPriority"] = "OverloadPriority";
-    IDLExtendedAttributes["TransformOnSerialize"] = "TransformOnSerialize";
-})(IDLExtendedAttributes || (IDLExtendedAttributes = {}));
-export var IDLAccessorAttribute;
-(function (IDLAccessorAttribute) {
-    IDLAccessorAttribute["Getter"] = "Getter";
-    IDLAccessorAttribute["Setter"] = "Setter";
-})(IDLAccessorAttribute || (IDLAccessorAttribute = {}));
-const innerIdlSymbol = Symbol("innerIdlSymbol");
-export var IDLInterfaceSubkind;
-(function (IDLInterfaceSubkind) {
-    IDLInterfaceSubkind[IDLInterfaceSubkind["Interface"] = 0] = "Interface";
-    IDLInterfaceSubkind[IDLInterfaceSubkind["Class"] = 1] = "Class";
-    IDLInterfaceSubkind[IDLInterfaceSubkind["AnonymousInterface"] = 2] = "AnonymousInterface";
-    IDLInterfaceSubkind[IDLInterfaceSubkind["Tuple"] = 3] = "Tuple";
-})(IDLInterfaceSubkind || (IDLInterfaceSubkind = {}));
-export function forEachChild(node, cbEnter, cbLeave) {
-    var _a, _b, _c;
-    const cleanup = cbEnter(node);
-    switch (node.kind) {
-        case IDLKind.File:
-            node.entries.forEach((value) => forEachChild(value, cbEnter, cbLeave));
-            break;
-        case IDLKind.Namespace:
-            node.members.forEach((value) => forEachChild(value, cbEnter, cbLeave));
-            break;
-        case IDLKind.Interface: {
-            let concrete = node;
-            concrete.inheritance.forEach((value) => forEachChild(value, cbEnter, cbLeave));
-            concrete.constructors.forEach((value) => forEachChild(value, cbEnter, cbLeave));
-            concrete.properties.forEach((value) => forEachChild(value, cbEnter, cbLeave));
-            concrete.methods.forEach((value) => forEachChild(value, cbEnter, cbLeave));
-            concrete.callables.forEach((value) => forEachChild(value, cbEnter, cbLeave));
-            break;
-        }
-        case IDLKind.Method:
-        case IDLKind.Callable:
-        case IDLKind.Callback:
-        case IDLKind.Constructor: {
-            let concrete = node;
-            (_a = concrete.parameters) === null || _a === void 0 ? void 0 : _a.forEach((value) => forEachChild(value, cbEnter, cbLeave));
-            if (concrete.returnType)
-                forEachChild(concrete.returnType, cbEnter, cbLeave);
-            break;
-        }
-        case IDLKind.UnionType: {
-            let concrete = node;
-            (_b = concrete.types) === null || _b === void 0 ? void 0 : _b.forEach((value) => forEachChild(value, cbEnter, cbLeave));
-            break;
-        }
-        case IDLKind.OptionalType: {
-            let concrete = node;
-            forEachChild(concrete.type, cbEnter, cbLeave);
-            break;
-        }
-        case IDLKind.Const: {
-            forEachChild(node.type, cbEnter, cbLeave);
-            break;
-        }
-        case IDLKind.Enum: {
-            node.elements.forEach((value) => forEachChild(value, cbEnter, cbLeave));
-            break;
-        }
-        case IDLKind.Property: {
-            forEachChild(node.type, cbEnter, cbLeave);
-            break;
-        }
-        case IDLKind.Parameter: {
-            const concrete = node;
-            if (concrete.type)
-                forEachChild(concrete.type, cbEnter, cbLeave);
-            break;
-        }
-        case IDLKind.Typedef: {
-            forEachChild(node.type, cbEnter, cbLeave);
-            break;
-        }
-        case IDLKind.ContainerType: {
-            node.elementType.forEach((value) => forEachChild(value, cbEnter, cbLeave));
-            break;
-        }
-        case IDLKind.UnspecifiedGenericType: {
-            node.typeArguments.forEach((value) => forEachChild(value, cbEnter, cbLeave));
-            break;
-        }
-        case IDLKind.ReferenceType: {
-            (_c = node.typeArguments) === null || _c === void 0 ? void 0 : _c.forEach((value) => forEachChild(value, cbEnter, cbLeave));
-            break;
-        }
-        case IDLKind.TypeParameterType:
-        case IDLKind.EnumMember:
-        case IDLKind.Import:
-        case IDLKind.PrimitiveType:
-        case IDLKind.Version:
-            break;
-        default: {
-            throw new Error(`Unhandled ${node.kind}`);
-        }
-    }
-    cbLeave === null || cbLeave === void 0 ? void 0 : cbLeave(node);
-    cleanup === null || cleanup === void 0 ? void 0 : cleanup();
-}
-/** Updates tree in place! */
-export function updateEachChild(node, op, cbLeave) {
-    var _a;
-    const old = node;
-    node = op(old);
-    if (node.kind !== old.kind && !(isType(old) && isType(node))) {
-        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: {
-            const concrete = node;
-            concrete.typeArguments = (_a = concrete.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => updateEachChild(it, op, cbLeave));
-            break;
-        }
-        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;
-}
-export function forceAsNamedNode(type) {
-    if (!isNamedNode(type)) {
-        throw new Error(`Expected to be an IDLNamedNode, but got '${IDLKind[type.kind]}'`);
-    }
-    return type;
-}
-export function isFile(node) {
-    return node.kind === IDLKind.File;
-}
-export function isUndefinedType(type) {
-    return isPrimitiveType(type) && type.name === IDLUndefinedType.name;
-}
-export function isVoidType(type) {
-    return isPrimitiveType(type) && type.name === IDLVoidType.name;
-}
-export function isPrimitiveType(type) {
-    return type.kind == IDLKind.PrimitiveType;
-}
-export function isContainerType(type) {
-    return type.kind == IDLKind.ContainerType;
-}
-export function isReferenceType(type) {
-    return type.kind == IDLKind.ReferenceType;
-}
-export function isUnspecifiedGenericType(type) {
-    return type.kind == IDLKind.UnspecifiedGenericType;
-}
-export function isEnum(type) {
-    return type.kind == IDLKind.Enum;
-}
-export function isEnumMember(type) {
-    return type.kind == IDLKind.EnumMember;
-}
-export function isUnionType(type) {
-    return type.kind == IDLKind.UnionType;
-}
-export function isTypeParameterType(type) {
-    return type.kind == IDLKind.TypeParameterType;
-}
-export function isInterface(node) {
-    return node.kind === IDLKind.Interface;
-}
-export function isImport(type) {
-    return type.kind == IDLKind.Import;
-}
-export function isCallable(node) {
-    return node.kind === IDLKind.Callable;
-}
-export function isMethod(node) {
-    return node.kind === IDLKind.Method;
-}
-export function isParameter(node) {
-    return node.kind === IDLKind.Parameter;
-}
-export function isConstructor(node) {
-    return node.kind === IDLKind.Constructor;
-}
-export function isProperty(node) {
-    return node.kind === IDLKind.Property;
-}
-export function isCallback(node) {
-    return node.kind === IDLKind.Callback;
-}
-export function isInterfaceSubkind(idl) {
-    return idl.subkind === IDLInterfaceSubkind.Interface;
-}
-export function isClassSubkind(idl) {
-    return idl.subkind === IDLInterfaceSubkind.Class;
-}
-export function isConstant(node) {
-    return node.kind === IDLKind.Const;
-}
-export function isTypedef(node) {
-    return node.kind === IDLKind.Typedef;
-}
-export function isType(node) {
-    return "_idlTypeBrand" in node;
-}
-export function isEntry(node) {
-    return "_idlEntryBrand" in node;
-}
-export function isNamespace(node) {
-    return node.kind === IDLKind.Namespace;
-}
-export function isSyntheticEntry(node) {
-    var _a;
-    return isDefined((_a = node.extendedAttributes) === null || _a === void 0 ? void 0 : _a.find(it => it.name === IDLExtendedAttributes.Synthetic));
-}
-export function isOptionalType(type) {
-    return type.kind === IDLKind.OptionalType;
-}
-export function isVersion(node) {
-    return node.kind === IDLKind.Version;
-}
-function createPrimitiveType(name) {
-    return {
-        kind: IDLKind.PrimitiveType,
-        name: name,
-        _idlNodeBrand: innerIdlSymbol,
-        _idlTypeBrand: innerIdlSymbol,
-        _idlNamedNodeBrand: innerIdlSymbol,
-    };
-}
-export function createOptionalType(element, nodeInitializer) {
-    if (isOptionalType(element) && !nodeInitializer) {
-        return element;
-    }
-    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 });
-}
-// must match with toIDLType in deserialize.ts
-export const IDLPointerType = createPrimitiveType('pointer');
-export const IDLVoidType = createPrimitiveType('void');
-export const IDLBooleanType = createPrimitiveType('boolean');
-export const IDLI8Type = createPrimitiveType('i8');
-export const IDLU8Type = createPrimitiveType('u8');
-export const IDLI16Type = createPrimitiveType('i16');
-export const IDLU16Type = createPrimitiveType('u16');
-export const IDLI32Type = createPrimitiveType('i32');
-export const IDLU32Type = createPrimitiveType('u32');
-export const IDLI64Type = createPrimitiveType('i64');
-export const IDLU64Type = createPrimitiveType('u64');
-export const IDLF16Type = createPrimitiveType('f16');
-export const IDLF32Type = createPrimitiveType('f32');
-export const IDLF64Type = createPrimitiveType('f64');
-export const IDLBigintType = createPrimitiveType("bigint");
-export const IDLNumberType = createPrimitiveType('number');
-export const IDLStringType = createPrimitiveType('String');
-export const IDLAnyType = createPrimitiveType('any');
-export const IDLUndefinedType = createPrimitiveType('undefined');
-export const IDLUnknownType = createPrimitiveType('unknown');
-export const IDLObjectType = createPrimitiveType('Object');
-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 IDLCustomObjectType = createPrimitiveType('CustomObject');
-export const IDLInteropReturnBufferType = createPrimitiveType('InteropReturnBuffer');
-export const IDLNullTypeName = "idlize.stdlib.Null";
-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 });
-}
-export function linkParentBack(node) {
-    const parentStack = [];
-    updateEachChild(node, (node) => {
-        if (isPrimitiveType(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)) {
-            return;
-        }
-        parentStack.pop();
-    });
-    return node;
-}
-export function getNamespacesPathFor(node) {
-    let iterator = node.parent;
-    const result = [];
-    while (iterator) {
-        if (isNamespace(iterator))
-            result.unshift(iterator);
-        iterator = iterator.parent;
-    }
-    return result;
-}
-const nodesWithoutIDLFiles = new Set();
-export function getFileFor(node) {
-    let iterator = node;
-    while (iterator) {
-        if (isFile(iterator))
-            return iterator;
-        iterator = iterator.parent;
-    }
-    const name = getQualifiedName(node, "namespace.name");
-    if (!nodesWithoutIDLFiles.has(name)) {
-        console.warn(`Node ${name} does not have IDLFile in parents`);
-        nodesWithoutIDLFiles.add(name);
-    }
-    return undefined;
-}
-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 getQualifiedName(a, pattern) === getQualifiedName(b, pattern);
-}
-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(".");
-}
-export function isInPackage(entry, packageName, exactMatch = false) {
-    const entryPackageName = getPackageName(entry);
-    return exactMatch
-        ? entryPackageName === packageName
-        : entryPackageName.startsWith(packageName);
-}
-export function getNamespaceName(a) {
-    return getNamespacesPathFor(a).map(it => it.name).join('.');
-}
-export function deriveQualifiedNameFrom(name, from) {
-    return [...getPackageClause(from), ...getNamespacesPathFor(from).map(it => it.name), 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) {
-    return getQualifiedName(a, "package.namespace.name");
-}
-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;
-    while (node) {
-        if (isNamespace(node))
-            return node;
-        node = node.parent;
-    }
-    return undefined;
-}
-export function createReferenceType(nameOrSource, typeArguments, nodeInitializer) {
-    let name;
-    if (typeof nameOrSource === 'string') {
-        name = nameOrSource;
-    }
-    else {
-        name = getFQName(nameOrSource);
-    }
-    return Object.assign(Object.assign({ kind: IDLKind.ReferenceType, name,
-        typeArguments }, nodeInitializer), { _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)) {
-        return entity;
-    }
-    else if (isEntry(entity)) {
-        return createReferenceType(entity);
-    }
-    else {
-        throw new Error(`Expected to have IDLType or IDLEntry, got ${entity}`);
-    }
-}
-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, nodeInitializer) {
-    if (types.length < 2)
-        throw new Error("IDLUnionType should contain at least 2 types");
-    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 = [], 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 !== 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 });
-}
-export function createEnumMember(name, parent, type, initializer, nodeInitializer = {}) {
-    return Object.assign(Object.assign({ kind: IDLKind.EnumMember, name: name, parent,
-        type,
-        initializer }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
-}
-export function createInterface(name, subkind, inheritance = [], constructors = [], constants = [], properties = [], methods = [], callables = [], typeParameters = [], nodeInitializer = {}) {
-    return Object.assign(Object.assign({ kind: IDLKind.Interface, name,
-        subkind,
-        typeParameters,
-        inheritance,
-        constructors,
-        constants,
-        properties,
-        methods,
-        callables }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
-}
-export function createProperty(name, type, isReadonly = false, isStatic = false, isOptional = false, nodeInitializer = {}) {
-    return Object.assign(Object.assign({ name, kind: IDLKind.Property, type,
-        isReadonly,
-        isStatic,
-        isOptional }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
-}
-export function createParameter(name, type, isOptional = false, isVariadic = false, nodeInitializer = {}) {
-    return Object.assign(Object.assign({ kind: IDLKind.Parameter, name: name, type: type, isOptional,
-        isVariadic }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
-}
-export function createMethod(name, parameters, returnType, methodInitializer = {
-    isAsync: false,
-    isStatic: false,
-    isOptional: false,
-    isFree: false,
-}, nodeInitializer = {}, typeParameters = []) {
-    return Object.assign(Object.assign(Object.assign({ kind: IDLKind.Method, name,
-        parameters,
-        returnType,
-        typeParameters }, methodInitializer), nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
-}
-export function createCallable(
-// TODO name here seems useless
-name, parameters, returnType, callableInitializer, nodeInitializer, typeParameters = []) {
-    return Object.assign(Object.assign(Object.assign({ kind: IDLKind.Callable, name,
-        parameters,
-        returnType }, callableInitializer), nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
-}
-export function createConstructor(parameters, returnType, nodeInitializer = {}) {
-    return Object.assign(Object.assign({ kind: IDLKind.Constructor, name: "$CONSTRUCTOR%", parameters,
-        returnType }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
-}
-export function createCallback(name, parameters, returnType, nodeInitializer = {}, typeParameters = []) {
-    return Object.assign(Object.assign({ kind: IDLKind.Callback, name, parameters, returnType, typeParameters }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: 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 });
-}
-export function createConstant(name, type, value, nodeInitializer = {}) {
-    return Object.assign(Object.assign({ kind: IDLKind.Const, name,
-        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 = (newnode) => {
-        if (node.nodeLocation) {
-            newnode.nodeLocation = node.nodeLocation;
-        }
-        if (node.nameLocation) {
-            newnode.nameLocation = node.nameLocation;
-        }
-        if (node.valueLocation) {
-            newnode.valueLocation = node.valueLocation;
-        }
-        return newnode;
-    };
-    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) ? "_" : "");
-}
-export function unescapeKeyword(name) {
-    if (name.endsWith("_")) {
-        const unwrapped = name.slice(0, -1);
-        if (IDLKeywords.has(unwrapped))
-            return unwrapped;
-    }
-    return name;
-}
-const printedIndentInc = "[[indent-inc]]";
-const printedIndentDec = "[[indent-dec]]";
-export function printType(type, options) {
-    var _a;
-    if (!type)
-        throw new Error("Missing type");
-    if (isInterface(type))
-        return type.name;
-    if (isOptionalType(type)) {
-        if (hasExtAttribute(type, IDLExtendedAttributes.UnionOnlyNull))
-            return `(${printType(type.type)} or ${IDLNullTypeName})`;
-        else if (hasExtAttribute(type, IDLExtendedAttributes.UnionWithNull))
-            return `(${printType(type.type)} or ${IDLUndefinedType.name} or${IDLNullTypeName})`;
-        else
-            return `(${printType(type.type)} or ${IDLUndefinedType.name})`;
-    }
-    if (isPrimitiveType(type))
-        return type.name;
-    if (isContainerType(type))
-        return `${type.containerKind}<${type.elementType.map(it => printType(it)).join(", ")}>`;
-    if (isReferenceType(type)) {
-        if (type.typeArguments)
-            updateExtAttribute(type, IDLExtendedAttributes.TypeArguments, type.typeArguments.map(it => printType(it)).join(","));
-        if (!((_a = type.extendedAttributes) === null || _a === void 0 ? void 0 : _a.length))
-            return type.name;
-        let res = `[${quoteAttributeValues(type.extendedAttributes)}] ${type.name}`;
-        if (options === null || options === void 0 ? void 0 : options.bracketsAroundReferenceTypeWithExtAttrs)
-            return `(${res})`;
-        return res;
-    }
-    if (isUnspecifiedGenericType(type))
-        return `${type.name}<${type.typeArguments.map(it => printType(it)).join(", ")}>`;
-    if (isUnionType(type))
-        return `(${type.types.map(it => printType(it)).join(" or ")})`;
-    if (isTypeParameterType(type))
-        return type.name;
-    throw new Error(`Cannot map type: ${IDLKind[type.kind]}`);
-}
-export function printReturnType(type) {
-    return printType(type, { bracketsAroundReferenceTypeWithExtAttrs: true });
-}
-export function printParameters(parameters) {
-    var _a, _b;
-    return (_b = (_a = parameters === null || parameters === void 0 ? void 0 : parameters.map(it => nameWithType(it, it.isVariadic, it.isOptional))) === null || _a === void 0 ? void 0 : _a.join(", ")) !== null && _b !== void 0 ? _b : "";
-}
-export function printConstructor(idl) {
-    return [
-        ...printExtendedAttributes(idl, 1),
-        `constructor(${printParameters(idl.parameters)});`
-    ];
-}
-export function nameWithType(idl, isVariadic = false, isOptional = false) {
-    const type = printType(idl.type);
-    const variadic = isVariadic ? "..." : "";
-    const optional = isOptional ? "optional " : "";
-    return `${optional}${type}${variadic} ${escapeIDLKeyword(idl.name)}`;
-}
-export function printConstant(idl) {
-    return [
-        ...printExtendedAttributes(idl, 1),
-        `const ${nameWithType(idl)} = ${idl.value};`
-    ];
-}
-export function printProperty(idl) {
-    const staticMod = idl.isStatic ? "static " : "";
-    const readonlyMod = idl.isReadonly ? "readonly " : "";
-    return [
-        ...printExtendedAttributes(idl, 1),
-        `${staticMod}${readonlyMod}attribute ${nameWithType(idl)};`
-    ];
-}
-export function printExtendedAttributes(idl, indentLevel) {
-    let typeParameters;
-    let typeArguments;
-    switch (idl.kind) {
-        case IDLKind.Interface:
-            typeParameters = idl.typeParameters;
-            break;
-        case IDLKind.Callback:
-        case IDLKind.Method:
-        case IDLKind.Callable:
-        case IDLKind.Constructor:
-            typeParameters = idl.typeParameters;
-            break;
-        case IDLKind.Typedef:
-            typeParameters = idl.typeParameters;
-            break;
-        case IDLKind.ReferenceType:
-            typeArguments = idl.typeArguments;
-            break;
-        case IDLKind.UnspecifiedGenericType:
-            typeArguments = idl.typeArguments;
-            break;
-    }
-    const attributes = Array.from(idl.extendedAttributes || []);
-    if ((typeParameters === null || typeParameters === void 0 ? void 0 : typeParameters.length) && !attributes.find(x => x.name === IDLExtendedAttributes.TypeParameters))
-        attributes.push({ name: IDLExtendedAttributes.TypeParameters, value: typeParameters.join(",") });
-    if ((typeArguments === null || typeArguments === void 0 ? void 0 : typeArguments.length) && !attributes.find(x => x.name === IDLExtendedAttributes.TypeArguments))
-        attributes.push({ name: IDLExtendedAttributes.TypeArguments, value: typeArguments.map(it => printType(it)).join(",") });
-    if (idl.documentation) {
-        let docs = {
-            name: IDLExtendedAttributes.Documentation,
-            value: idl.documentation
-        };
-        attributes.unshift(docs);
-    }
-    // Deduplicate
-    const names = new Set();
-    const actualAttributes = [];
-    for (const attr of attributes) {
-        if (names.has(attr.name)) {
-            continue;
-        }
-        names.add(attr.name);
-        actualAttributes.push(attr);
-    }
-    if (actualAttributes.length == 0) {
-        return [];
-    }
-    const attrSpec = quoteAttributeValues(actualAttributes);
-    return attrSpec ? [`[${attrSpec}]`] : [];
-}
-export const attributesToQuote = new Set([
-    IDLExtendedAttributes.Documentation,
-    IDLExtendedAttributes.DtsName,
-    IDLExtendedAttributes.DtsTag,
-    IDLExtendedAttributes.Import,
-    IDLExtendedAttributes.Interfaces,
-    IDLExtendedAttributes.TraceKey,
-    IDLExtendedAttributes.TypeArguments,
-    IDLExtendedAttributes.TypeParameters,
-    IDLExtendedAttributes.TypeParametersDefaults,
-]);
-function quoteAttributeValues(attributes) {
-    return attributes === null || attributes === void 0 ? void 0 : attributes.map(it => {
-        let attr = it.name;
-        if (it.value) {
-            let value = it.value;
-            if (value.includes('"') && !value.includes("'"))
-                value = value.replaceAll('"', "'");
-            value = value.replaceAll('\\', '\\\\').replaceAll('"', '\\"');
-            attr += `=${attributesToQuote.has(it.name) ? `"${value}"` : it.value}`;
-        }
-        return attr;
-    }).join(", ");
-}
-export function printFunction(idl) {
-    var _a;
-    if ((_a = idl.name) === null || _a === void 0 ? void 0 : _a.startsWith("__")) {
-        console.log(`Ignore ${idl.name}`);
-        return [];
-    }
-    return [
-        ...printExtendedAttributes(idl, 1),
-        `${idl.isAsync ? "async " : ""}${printReturnType(idl.returnType)} ${idl.name}(${printParameters(idl.parameters)});`
-    ];
-}
-export function printMethod(idl) {
-    var _a;
-    if ((_a = idl.name) === null || _a === void 0 ? void 0 : _a.startsWith("__")) {
-        console.log(`Ignore ${idl.name}`);
-        return [];
-    }
-    return [
-        ...printExtendedAttributes(idl, 1),
-        `${idl.isStatic ? "static " : ""}${idl.isAsync ? "async " : ""}${printReturnType(idl.returnType)} ${idl.name}(${printParameters(idl.parameters)});`
-    ];
-}
-export function printPackage(idl) {
-    const effectiveClause = idl.packageClause.filter(it => !!it);
-    if (!effectiveClause.length)
-        return [];
-    return [
-        `package ${effectiveClause.join(".")};`
-    ];
-}
-export function printImport(idl) {
-    const effectiveClause = idl.clause.filter(it => !!it);
-    return [
-        `import ${effectiveClause.join(".") || "NULL_IMPORT"}${idl.name ? " as " : ""}${idl.name};`
-    ];
-}
-export function printNamespace(idl) {
-    return [
-        ...printExtendedAttributes(idl, 0),
-        `namespace ${idl.name} {`,
-        printedIndentInc,
-        ...idl.members.map(member => printIDL(member)).flat(),
-        printedIndentDec,
-        "};"
-    ];
-}
-export function printCallback(idl) {
-    return [
-        ...printExtendedAttributes(idl, 0),
-        `callback ${idl.name} = ${printReturnType(idl.returnType)} (${printParameters(idl.parameters)});`
-    ];
-}
-export function printScoped(idl) {
-    if (idl.kind == IDLKind.Callback)
-        return printCallback(idl);
-    if (idl.kind === IDLKind.Interface)
-        return printInterface(idl);
-    throw new Error(`Unexpected scoped: ${idl.kind} ${idl.name}`);
-}
-function printInterfaceInherit(idl) {
-    if (idl.inheritance.length === 0) {
-        return "";
-    }
-    const types = idl.inheritance.map(type => printType(type));
-    return ": " + types.join(', ');
-}
-export function printInterface(idl) {
-    return [
-        ...printExtendedAttributes(idl, 0),
-        `interface ${idl.name}${printInterfaceInherit(idl)} {`,
-        // TODO: type system hack!
-    ]
-        .concat(printedIndentInc)
-        .concat(idl.constructors.map(printConstructor).flat())
-        .concat(idl.constants.map(printConstant).flat())
-        .concat(idl.properties.map(printProperty).flat())
-        .concat(idl.methods.map(printMethod).flat())
-        .concat(idl.callables.map(printFunction).flat())
-        .concat(printedIndentDec)
-        .concat(["};"]);
-}
-export function printEnumMember(idl) {
-    const type = printType(idl.type);
-    const initializer = idl.initializer === undefined
-        ? ''
-        : ' = ' + (type === IDLStringType.name
-            ? `"${String(idl.initializer).replaceAll('"', "'")}"`
-            : idl.initializer);
-    return [
-        idl.documentation,
-        ...printExtendedAttributes(idl, 0),
-        `${type} ${idl.name}${initializer};`
-    ];
-}
-export function printEnum(idl, skipInitializers) {
-    if (skipInitializers) {
-        return [
-            idl.documentation,
-            ...printExtendedAttributes(idl, 0),
-            `enum ${idl.name} {`,
-            printedIndentInc,
-            ...idl.elements.map(it => `${it.name} ${(it.initializer !== undefined ? " /* " + it.initializer + " */" : "")}`),
-            printedIndentDec,
-            "};"
-        ];
-    }
-    else {
-        return [
-            idl.documentation,
-            ...printExtendedAttributes(idl, 0),
-            `dictionary ${idl.name} {`,
-            printedIndentInc,
-            ...idl.elements.map(printEnumMember),
-            printedIndentDec,
-            "};"
-        ].flat();
-    }
-}
-export function printTypedef(idl) {
-    return [
-        idl.documentation,
-        ...printExtendedAttributes(idl, 0),
-        `typedef ${printType(idl.type)} ${idl.name};`
-    ];
-}
-// TODO: use IndentedPrinter instead!
-export function printIDL(idl, options) {
-    var _a;
-    if (idl.kind == IDLKind.Interface)
-        return printInterface(idl);
-    if (idl.kind == IDLKind.Enum)
-        return printEnum(idl, (_a = options === null || options === void 0 ? void 0 : options.disableEnumInitializers) !== null && _a !== void 0 ? _a : false);
-    if (idl.kind == IDLKind.Typedef)
-        return printTypedef(idl);
-    if (idl.kind == IDLKind.Callback)
-        return printCallback(idl);
-    if (idl.kind == IDLKind.Import)
-        return printImport(idl);
-    if (idl.kind == IDLKind.Namespace)
-        return printNamespace(idl);
-    if (idl.kind == IDLKind.Method)
-        return printMethod(idl);
-    if (idl.kind == IDLKind.Const)
-        return printConstant(idl);
-    if (options === null || options === void 0 ? void 0 : options.allowUnknownKinds) {
-        return [`${IDLKind[idl.kind]} ${"name" in idl ? idl.name : ""}`];
-    }
-    else {
-        throw new Error(`unexpected kind: ${idl.kind}`);
-    }
-}
-export function toIDLString(file, options) {
-    let indent = 0;
-    const generated = printPackage(file);
-    return generated.concat(file.entries
-        .map(it => printIDL(it, options))
-        .flat()
-        .filter(isDefined)
-        .filter(it => it.length > 0)
-        .map(it => {
-        if (it === printedIndentInc) {
-            ++indent;
-            return undefined;
-        }
-        else if (it === printedIndentDec) {
-            --indent;
-            return undefined;
-        }
-        else
-            return indentedBy(it, indent);
-    })
-        .filter(isDefined)).join("\n");
-}
-// throws validation error
-export function verifyIDLString(source) {
-    webidl2.validate(webidl2.parse(source));
-    return true;
-}
-export function hasExtAttribute(node, attribute) {
-    var _a;
-    return ((_a = node.extendedAttributes) === null || _a === void 0 ? void 0 : _a.find((it) => it.name == attribute)) != undefined;
-}
-export function getExtAttribute(node, name) {
-    var _a, _b;
-    return (_b = (_a = node.extendedAttributes) === null || _a === void 0 ? void 0 : _a.find(it => it.name === name)) === null || _b === void 0 ? void 0 : _b.value;
-}
-export function removeExtAttribute(node, name) {
-    if (node.extendedAttributes) {
-        node.extendedAttributes = node.extendedAttributes.filter(it => it.name !== name);
-    }
-}
-export function updateExtAttribute(node, name, value) {
-    var _a;
-    removeExtAttribute(node, name);
-    (_a = node.extendedAttributes) !== null && _a !== void 0 ? _a : (node.extendedAttributes = []);
-    node.extendedAttributes.push({ name, value });
-}
-export function getVerbatimDts(node) {
-    let value = getExtAttribute(node, IDLExtendedAttributes.VerbatimDts);
-    return value ? value.substring(1, value.length - 1) : undefined;
-}
-export const IDLContainerUtils = {
-    isRecord: (x) => isContainerType(x) && x.containerKind === 'record',
-    isSequence: (x) => isContainerType(x) && x.containerKind === 'sequence',
-    isPromise: (x) => isContainerType(x) && x.containerKind === 'Promise'
-};
-/**
- * @returns tuple of qualifier name and real type name
- */
-export function decomposeQualifiedName(type) {
-    const typeName = type.name;
-    const lastDot = typeName.lastIndexOf(".");
-    if (lastDot >= 0) {
-        const qualifier = typeName.slice(0, lastDot);
-        const realTypeName = typeName.slice(lastDot + 1);
-        return [qualifier, realTypeName];
-    }
-    return [undefined, typeName];
-}
-export function qualifiedNameStartsWith(node, template) {
-    const name = Array.isArray(node) ? node : getFQName(node).split(".");
-    if (name.length < template.length)
-        return false;
-    for (let i = 0; i < template.length; i++) {
-        if (name[i] != template[i])
-            return false;
-    }
-    return true;
-}
-export function maybeUnwrapOptionalType(type) {
-    if (isOptionalType(type)) {
-        return type.type;
-    }
-    return type;
-}
-export function maybeOptional(type, optional = false) {
-    if (optional) {
-        return createOptionalType(type);
-    }
-    return type;
-}
-export const DebugUtils = {
-    debugPrintType: (type) => {
-        if (isContainerType(type)) {
-            return `[IDLType, name: '${printType(type)}', kind: '${IDLKind[type.kind]}', elements: [${type.elementType.map(DebugUtils.debugPrintType).join(', ')}]]`;
-        }
-        return `[IDLType, name: '${printType(type)}', kind: '${IDLKind[type.kind]}']`;
-    },
-};
-export function forEachFunction(node, cb) {
-    forEachChild(node, child => {
-        if (child.kind === IDLKind.Method || child.kind === IDLKind.Callable)
-            cb(child);
-    });
-}
-export function asPromise(type) {
-    if (!type)
-        return undefined;
-    if (!isContainerType(type))
-        return undefined;
-    const container = type;
-    if (!IDLContainerUtils.isPromise(container))
-        return undefined;
-    return container;
-}
-export function transformMethodsAsync2ReturnPromise(entry) {
-    forEachFunction(entry, function_ => {
-        var _a;
-        if (function_.isAsync) {
-            function_.isAsync = false;
-            if (!asPromise(function_.returnType))
-                function_.returnType = createContainerType("Promise", [(_a = function_.returnType) !== null && _a !== void 0 ? _a : IDLVoidType]);
-        }
-    });
-}
-export function transformMethodsReturnPromise2Async(entry) {
-    forEachFunction(entry, function_ => {
-        const promise = asPromise(function_.returnType);
-        if (promise) {
-            function_.returnType = promise.elementType[0];
-            function_.isAsync = true;
-        }
-    });
-}
-export function fetchSignatureTags(node) {
-    if (!node.extendedAttributes)
-        return [];
-    return node.extendedAttributes
-        .filter((ea) => ea.name === IDLExtendedAttributes.DtsTag)
-        .map((ea) => {
-        if (!ea.value)
-            throw new Error('Empty DtsTag is not allowed');
-        let indexNameValue = ea.value.split('|');
-        if (indexNameValue.length === 1) {
-            return {
-                index: 0,
-                name: 'type',
-                value: indexNameValue[0],
-            };
-        }
-        if (indexNameValue.length !== 3)
-            throw new Error(`Malformed DtsTag: "${ea.value}"`);
-        return {
-            index: Number(indexNameValue[0]),
-            name: indexNameValue[1],
-            value: indexNameValue[2],
-        };
-    })
-        .sort((a, b) => a.index - b.index);
-}
-export function mixMethodParametersAndTags(node) {
-    let mix = node.parameters.slice(0);
-    for (const tag of fetchSignatureTags(node))
-        mix.splice(tag.index, 0, tag);
-    return mix;
-}
-export function isHandwritten(decl) {
-    return hasExtAttribute(decl, IDLExtendedAttributes.HandWrittenImplementation);
-}
-export function isStringEnum(decl) {
-    return decl.elements.some(e => e.type === IDLStringType);
-}
-export function linearizeNamespaceMembers(entries) {
-    const linearized = [];
-    for (const entry of entries) {
-        linearized.push(entry);
-        if (isNamespace(entry))
-            linearized.push(...linearizeNamespaceMembers(entry.members));
-    }
-    return linearized;
-}
-export function extremumOfOrdinals(enumEntry) {
-    let low = 0;
-    let high = 0;
-    enumEntry.elements.forEach((member, index) => {
-        let value = index;
-        if ((typeof member.initializer === 'number') && !isStringEnum(enumEntry)) {
-            value = member.initializer;
-        }
-        if (low > value)
-            low = value;
-        if (high < value)
-            high = value;
-    });
-    return { low, high };
-}
-export const PACKAGE_IDLIZE_INTERNAL = "idlize.internal";
-export function isInIdlize(entry) {
-    return isInPackage(entry, "idlize");
-}
-export function isInIdlizeInterop(entry) {
-    return isInPackage(entry, `${PACKAGE_IDLIZE_INTERNAL}.interop`);
-}
-export function isInIdlizeInternal(entry) {
-    return isInPackage(entry, PACKAGE_IDLIZE_INTERNAL);
-}
-export function isInIdlizeStdlib(entry) {
-    return isInPackage(entry, "idlize.stdlib");
-}
-//# sourceMappingURL=idl.js.map