@idlizer/core 2.0.15

package/build/lib/src/idl.js

@@ -0,0 +1,1015 @@
+/*
+ * 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[IDLKind["Interface"] = 0] = "Interface";
+    IDLKind[IDLKind["Package"] = 1] = "Package";
+    IDLKind[IDLKind["Import"] = 2] = "Import";
+    IDLKind[IDLKind["Callback"] = 3] = "Callback";
+    IDLKind[IDLKind["Const"] = 4] = "Const";
+    IDLKind[IDLKind["Property"] = 5] = "Property";
+    IDLKind[IDLKind["Parameter"] = 6] = "Parameter";
+    IDLKind[IDLKind["Method"] = 7] = "Method";
+    IDLKind[IDLKind["Callable"] = 8] = "Callable";
+    IDLKind[IDLKind["Constructor"] = 9] = "Constructor";
+    IDLKind[IDLKind["Enum"] = 10] = "Enum";
+    IDLKind[IDLKind["EnumMember"] = 11] = "EnumMember";
+    IDLKind[IDLKind["Typedef"] = 12] = "Typedef";
+    IDLKind[IDLKind["PrimitiveType"] = 13] = "PrimitiveType";
+    IDLKind[IDLKind["ContainerType"] = 14] = "ContainerType";
+    IDLKind[IDLKind["UnspecifiedGenericType"] = 15] = "UnspecifiedGenericType";
+    IDLKind[IDLKind["ReferenceType"] = 16] = "ReferenceType";
+    IDLKind[IDLKind["UnionType"] = 17] = "UnionType";
+    IDLKind[IDLKind["TypeParameterType"] = 18] = "TypeParameterType";
+    IDLKind[IDLKind["OptionalType"] = 19] = "OptionalType";
+    IDLKind[IDLKind["Version"] = 20] = "Version";
+    IDLKind[IDLKind["Namespace"] = 21] = "Namespace";
+})(IDLKind || (IDLKind = {}));
+export var IDLEntity;
+(function (IDLEntity) {
+    IDLEntity["Class"] = "Class";
+    IDLEntity["Interface"] = "Interface";
+    IDLEntity["Package"] = "Package";
+    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["Async"] = "Async";
+    IDLExtendedAttributes["CallSignature"] = "CallSignature";
+    IDLExtendedAttributes["CJType"] = "CJType";
+    IDLExtendedAttributes["CommonMethod"] = "CommonMethod";
+    IDLExtendedAttributes["Component"] = "Component";
+    IDLExtendedAttributes["ComponentInterface"] = "ComponentInterface";
+    IDLExtendedAttributes["CPPType"] = "CPPType";
+    IDLExtendedAttributes["Deprecated"] = "Deprecated";
+    IDLExtendedAttributes["Documentation"] = "Documentation";
+    IDLExtendedAttributes["DtsName"] = "DtsName";
+    IDLExtendedAttributes["DtsTag"] = "DtsTag";
+    IDLExtendedAttributes["Entity"] = "Entity";
+    IDLExtendedAttributes["GlobalScope"] = "GlobalScope";
+    IDLExtendedAttributes["Import"] = "Import";
+    IDLExtendedAttributes["IndexSignature"] = "IndexSignature";
+    IDLExtendedAttributes["Interfaces"] = "Interfaces";
+    IDLExtendedAttributes["NativeModule"] = "NativeModule";
+    IDLExtendedAttributes["Optional"] = "Optional";
+    IDLExtendedAttributes["OriginalEnumMemberName"] = "OriginalEnumMemberName";
+    IDLExtendedAttributes["Protected"] = "Protected";
+    IDLExtendedAttributes["Synthetic"] = "Synthetic";
+    IDLExtendedAttributes["TSType"] = "TSType";
+    IDLExtendedAttributes["TypeArguments"] = "TypeArguments";
+    IDLExtendedAttributes["TypeParameters"] = "TypeParameters";
+    IDLExtendedAttributes["VerbatimDts"] = "VerbatimDts";
+    IDLExtendedAttributes["HandWrittenImplementation"] = "HandWrittenImplementation";
+    IDLExtendedAttributes["Predefined"] = "Predefined";
+})(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;
+    cbEnter(node);
+    switch (node.kind) {
+        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));
+            (_a = concrete.scope) === null || _a === void 0 ? void 0 : _a.forEach((value) => forEachChild(value, cbEnter, cbLeave));
+            break;
+        }
+        case IDLKind.Method:
+        case IDLKind.Callable:
+        case IDLKind.Callback:
+        case IDLKind.Constructor: {
+            let concrete = node;
+            (_b = concrete.parameters) === null || _b === void 0 ? void 0 : _b.forEach((value) => forEachChild(value, cbEnter, cbLeave));
+            if (concrete.returnType)
+                forEachChild(concrete.returnType, cbEnter, cbLeave);
+            break;
+        }
+        case IDLKind.UnionType: {
+            let concrete = node;
+            (_c = concrete.types) === null || _c === void 0 ? void 0 : _c.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:
+        case IDLKind.TypeParameterType:
+        case IDLKind.EnumMember:
+        case IDLKind.Package:
+        case IDLKind.Import:
+        case IDLKind.PrimitiveType:
+        case IDLKind.Version:
+            break;
+        default: {
+            throw new Error(`Unhandled ${node.kind}`);
+        }
+    }
+    if (cbLeave)
+        cbLeave(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 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 isPackage(type) {
+    return type.kind == IDLKind.Package;
+}
+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) {
+    if (isOptionalType(element)) {
+        return element;
+    }
+    return {
+        kind: IDLKind.OptionalType,
+        type: element,
+        _idlNodeBrand: innerIdlSymbol,
+        _idlTypeBrand: innerIdlSymbol,
+    };
+}
+/**
+ * This placeholder is used when a class has no superclass.
+ * Examples:
+ *  class definition:               inheritance:
+ * `C extends T`                  :  [T]
+ * `C implements T`               :  [Top, T]
+ * `C extends T implements I, J`  :  [T, I, J]
+ */
+export const IDLTopType = createReferenceType("__TOP__");
+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 = createReferenceType('Object');
+export const IDLThisType = createPrimitiveType('this');
+export const IDLDate = createPrimitiveType('date');
+export const IDLBufferType = createPrimitiveType('buffer');
+export const IDLUint8ArrayType = createContainerType('sequence', [IDLU8Type]);
+// Stub for IdlPeerLibrary
+export const IDLFunctionType = createPrimitiveType('Function');
+export const IDLLengthType = createPrimitiveType('Length');
+export const IDLCustomObjectType = createPrimitiveType('CustomObject');
+export function createNamespace(name, extendedAttributes, fileName) {
+    return {
+        kind: IDLKind.Namespace,
+        members: [],
+        name: name,
+        extendedAttributes,
+        fileName,
+        _idlNodeBrand: innerIdlSymbol,
+        _idlEntryBrand: innerIdlSymbol,
+        _idlNamedNodeBrand: innerIdlSymbol,
+    };
+}
+export function linkNamespacesBack(node) {
+    let namespacePath = [];
+    forEachChild(node, child => {
+        if (isEntry(child) || isReferenceType(child)) {
+            if (!child.namespace)
+                child.namespace = namespacePath.length ? namespacePath[namespacePath.length - 1] : undefined;
+        }
+        if (isNamespace(child))
+            namespacePath.push(child);
+    }, child => {
+        if (isNamespace(child))
+            namespacePath.pop();
+    });
+}
+export function getNamespacesPathFor(entry) {
+    let iterator = entry.namespace;
+    const result = [];
+    while (iterator) {
+        result.unshift(iterator);
+        iterator = iterator.namespace;
+    }
+    return result;
+}
+export function isEqualByQualifedName(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b)
+        return false;
+    if (a.kind !== b.kind || a.name !== b.name)
+        return false;
+    return isEqualByQualifedName(a.namespace, b.namespace);
+}
+export function createVersion(value, extendedAttributes, fileName) {
+    return {
+        kind: IDLKind.Version,
+        value,
+        name: "version",
+        extendedAttributes,
+        fileName,
+        _idlNodeBrand: innerIdlSymbol,
+        _idlEntryBrand: innerIdlSymbol,
+        _idlNamedNodeBrand: innerIdlSymbol,
+    };
+}
+export function fetchNamespaceFrom(pointOfView) {
+    if (pointOfView) {
+        if (isNamespace(pointOfView))
+            return pointOfView;
+        if (isEntry(pointOfView) || isReferenceType(pointOfView))
+            return pointOfView.namespace;
+    }
+    return undefined;
+}
+export function createReferenceType(name, typeArguments, pointOfView) {
+    return {
+        kind: IDLKind.ReferenceType,
+        name,
+        typeArguments,
+        namespace: fetchNamespaceFrom(pointOfView),
+        _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 entityToType(entity) {
+    if (isType(entity)) {
+        return entity;
+    }
+    return createReferenceType(forceAsNamedNode(entity).name, undefined, entity);
+}
+export function createContainerType(container, element) {
+    return {
+        kind: IDLKind.ContainerType,
+        containerKind: container,
+        elementType: element,
+        _idlNodeBrand: innerIdlSymbol,
+        _idlTypeBrand: innerIdlSymbol,
+    };
+}
+export function createUnionType(types, name) {
+    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,
+    };
+}
+export function createPackage(name) {
+    return {
+        kind: IDLKind.Package,
+        name,
+        _idlNodeBrand: innerIdlSymbol,
+        _idlEntryBrand: innerIdlSymbol,
+        _idlNamedNodeBrand: innerIdlSymbol,
+    };
+}
+export function createImport(name, importClause) {
+    return {
+        kind: IDLKind.Import,
+        name,
+        importClause: importClause,
+        _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 = []) {
+    if (returnType === IDLThisType)
+        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 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 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) {
+    if (!type)
+        throw new Error("Missing type");
+    if (isInterface(type))
+        return type.name;
+    if (isOptionalType(type))
+        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)) {
+        const extAttrs = type.extendedAttributes ? Array.from(type.extendedAttributes) : [];
+        if (type.typeArguments)
+            extAttrs.push({ name: IDLExtendedAttributes.TypeArguments, value: type.typeArguments.map(it => printType(it)).join(",") });
+        if (!extAttrs.length)
+            return type.name;
+        let res = `[${quoteAttributeValues(extAttrs)}] ${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 [`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.push({ name: IDLExtendedAttributes.TypeParameters, value: typeParameters.join(",") });
+    if (typeArguments === null || typeArguments === void 0 ? void 0 : typeArguments.length)
+        attributes.push({ name: IDLExtendedAttributes.TypeArguments, value: typeArguments.map(it => printType(it)).join(",") });
+    if (idl.documentation) {
+        let docs = {
+            name: IDLExtendedAttributes.Documentation,
+            value: idl.documentation
+        };
+        attributes.push(docs);
+    }
+    const attrSpec = quoteAttributeValues(attributes);
+    return attrSpec ? [`[${attrSpec}]`] : [];
+}
+export const attributesToQuote = new Set([
+    IDLExtendedAttributes.Documentation,
+    IDLExtendedAttributes.DtsName,
+    IDLExtendedAttributes.DtsTag,
+    IDLExtendedAttributes.Import,
+    IDLExtendedAttributes.Interfaces,
+    IDLExtendedAttributes.TypeArguments,
+    IDLExtendedAttributes.TypeParameters,
+]);
+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) {
+    return [
+        `package "${idl.name}";`
+    ];
+}
+export function printImport(idl) {
+    return [
+        `import "${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}`);
+}
+export function printInterface(idl) {
+    idl.methods
+        .map(it => {
+        let result = it.scope;
+        it.scope = undefined;
+        return result;
+    })
+        .filter(isDefined)
+        .forEach(scope => idl.scope ? idl.scope.push(...scope) : idl.scope = scope);
+    return [
+        ...printExtendedAttributes(idl, 0),
+        `interface ${idl.name}${hasSuperType(idl) ? ": " + printType(idl.inheritance[0]) : ""} {`,
+        // 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 getSuperType(idl) {
+    if (!idl.inheritance)
+        return undefined;
+    const parent = idl.inheritance[0];
+    return parent && parent !== IDLTopType ? parent : undefined;
+}
+export function hasSuperType(idl) {
+    return isDefined(getSuperType(idl));
+}
+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};`
+    ];
+}
+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.Package)
+        return printPackage(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(entries, options) {
+    let indent = 0;
+    const generatedIdl = entries
+        .map(it => printIDL(it, options))
+        .concat(printScopes(entries))
+        .flat()
+        .filter(isDefined)
+        .filter(it => it.length > 0)
+        .map(it => {
+        if (it === printedIndentInc)
+            ++indent;
+        else if (it === printedIndentDec)
+            --indent;
+        else
+            return indentedBy(it, indent);
+    })
+        .join("\n");
+    return generatedIdl;
+}
+// throws validation error
+export function verifyIDLString(source) {
+    webidl2.validate(webidl2.parse(source));
+    return true;
+}
+function printScopes(entries) {
+    return entries
+        .map((it) => it.scope)
+        .filter(isDefined)
+        .flatMap((it) => it.map(printScoped));
+}
+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 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 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;
+    if (!isContainerType(type))
+        return;
+    const container = type;
+    if (!IDLContainerUtils.isPromise(container))
+        return;
+    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) {
+        if (isNamespace(entry))
+            linearized.push(...linearizeNamespaceMembers(entry.members));
+        else
+            linearized.push(entry);
+    }
+    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 };
+}
+//# sourceMappingURL=idl.js.map