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

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

@@ -0,0 +1,233 @@
+import { Location } from "../diagnostictypes";
+export declare enum IDLKind {
+    Interface = "Interface",
+    Import = "Import",
+    Callback = "Callback",
+    Const = "Const",
+    Property = "Property",
+    Parameter = "Parameter",
+    Method = "Method",
+    Callable = "Callable",
+    Constructor = "Constructor",
+    Enum = "Enum",
+    EnumMember = "EnumMember",
+    Typedef = "Typedef",
+    PrimitiveType = "PrimitiveType",
+    ContainerType = "ContainerType",
+    ReferenceType = "ReferenceType",
+    UnionType = "UnionType",
+    TypeParameterType = "TypeParameterType",
+    OptionalType = "OptionalType",
+    Version = "Version",
+    Namespace = "Namespace",
+    File = "File"
+}
+export declare enum IDLEntity {
+    Class = "Class",
+    Interface = "Interface",
+    Import = "Import",
+    Intersection = "Intersection",
+    Literal = "Literal",
+    NamedTuple = "NamedTuple",
+    Tuple = "Tuple"
+}
+export declare enum IDLExtendedAttributes {
+    Accessor = "Accessor",
+    Annotations = "Annotations",
+    Async = "Async",
+    CallSignature = "CallSignature",
+    CommonMethod = "CommonMethod",
+    Component = "Component",
+    ComponentInterface = "ComponentInterface",
+    ComponentModifier = "ComponentModifier",
+    Deprecated = "Deprecated",
+    Documentation = "Documentation",
+    DtsName = "DtsName",
+    DtsTag = "DtsTag",
+    Entity = "Entity",
+    Extends = "Extends",
+    ExtensionMethod = "ExtensionMethod",
+    Import = "Import",
+    DefaultExport = "DefaultExport",
+    IndexSignature = "IndexSignature",
+    Interfaces = "Interfaces",
+    NativeModule = "NativeModule",
+    Optional = "Optional",
+    UnionOnlyNull = "OptionalOnlyNull",
+    UnionWithNull = "OptionalWithNull",
+    OriginalEnumMemberName = "OriginalEnumMemberName",
+    OriginalGenericName = "OriginalGenericName",
+    Predefined = "Predefined",
+    Protected = "Protected",
+    Abstract = "Abstract",
+    Synthetic = "Synthetic",
+    Throws = "Throws",
+    TraceKey = "TraceKey",
+    TypeAnnotations = "TypeAnnotations",
+    TypeParametersDefaults = "TypeParametersDefaults",
+    VerbatimDts = "VerbatimDts",
+    HandWrittenImplementation = "HandWrittenImplementation",
+    ExtraMethod = "ExtraMethod",
+    OverloadAlias = "OverloadAlias",
+    OverloadPriority = "OverloadPriority",
+    TransformOnSerialize = "TransformOnSerialize"
+}
+export declare enum IDLAccessorAttribute {
+    Getter = "Getter",
+    Setter = "Setter"
+}
+export interface IDLExtendedAttribute {
+    name: string;
+    value?: string;
+    typesValue?: IDLType[];
+    nameLocation?: Location;
+    valueLocation?: Location;
+}
+export interface IDLNode {
+    _idlNodeBrand: any;
+    kind: IDLKind;
+    parent?: IDLNode;
+    fileName?: string;
+    extendedAttributes?: IDLExtendedAttribute[];
+    documentation?: string;
+    nodeLocation?: Location;
+    nameLocation?: Location;
+    valueLocation?: Location;
+}
+export interface IDLFile extends IDLNode {
+    packageClause: string[];
+    entries: IDLEntry[];
+    text?: string;
+    fileName?: string;
+}
+export interface IDLNamedNode extends IDLNode {
+    _idlNamedNodeBrand: any;
+    name: string;
+}
+export interface IDLEntry extends IDLNode, IDLNamedNode {
+    _idlEntryBrand: any;
+    comment?: string;
+}
+export interface IDLType extends IDLNode {
+    _idlTypeBrand: any;
+}
+export interface IDLTypedef extends IDLEntry {
+    kind: IDLKind.Typedef;
+    type: IDLType;
+    typeParameters?: string[];
+}
+export interface IDLPrimitiveType extends IDLType, IDLNamedNode {
+    kind: IDLKind.PrimitiveType;
+}
+export interface IDLOptionalType extends IDLType {
+    kind: IDLKind.OptionalType;
+    type: IDLType;
+}
+export type IDLContainerKind = 'sequence' | 'record' | 'Promise';
+export interface IDLContainerType extends IDLType {
+    kind: IDLKind.ContainerType;
+    elementType: IDLType[];
+    containerKind: IDLContainerKind;
+}
+export interface IDLReferenceType extends IDLType, IDLNamedNode {
+    kind: IDLKind.ReferenceType;
+    typeArguments?: IDLType[];
+}
+export interface IDLUnionType extends IDLType, IDLNamedNode {
+    kind: IDLKind.UnionType;
+    types: IDLType[];
+}
+export interface IDLTypeParameterType extends IDLType, IDLNamedNode {
+    kind: IDLKind.TypeParameterType;
+}
+export interface IDLVersion extends IDLEntry {
+    kind: IDLKind.Version;
+    value: string[];
+}
+export interface IDLVariable extends IDLEntry {
+    type?: IDLType;
+}
+export interface IDLTypedEntry extends IDLEntry {
+    type: IDLType;
+}
+export interface IDLEnum extends IDLEntry {
+    kind: IDLKind.Enum;
+    elements: IDLEnumMember[];
+}
+export interface IDLEnumMember extends IDLEntry {
+    kind: IDLKind.EnumMember;
+    parent: IDLEnum;
+    type: IDLPrimitiveType;
+    initializer: number | string | undefined;
+}
+export interface IDLConstant extends IDLTypedEntry {
+    kind: IDLKind.Const;
+    type: IDLType;
+    value?: string;
+}
+export interface IDLProperty extends IDLTypedEntry, IDLNamedNode {
+    kind: IDLKind.Property;
+    type: IDLType;
+    isReadonly: boolean;
+    isStatic: boolean;
+    isOptional: boolean;
+}
+export interface IDLParameter extends IDLTypedEntry, IDLNamedNode {
+    kind: IDLKind.Parameter;
+    isVariadic: boolean;
+    isOptional: boolean;
+    type: IDLType;
+}
+export interface IDLSignature extends IDLEntry {
+    typeParameters?: string[];
+    parameters: IDLParameter[];
+    returnType?: IDLType;
+}
+export interface IDLFunction extends IDLSignature {
+    isAsync: boolean;
+}
+export interface IDLMethod extends IDLFunction, IDLNamedNode {
+    kind: IDLKind.Method;
+    returnType: IDLType;
+    isStatic: boolean;
+    isOptional: boolean;
+    isFree: boolean;
+}
+export interface IDLCallable extends IDLFunction {
+    kind: IDLKind.Callable;
+    returnType: IDLType;
+    isStatic: boolean;
+}
+export interface IDLConstructor extends IDLSignature {
+    kind: IDLKind.Constructor;
+}
+export declare enum IDLInterfaceSubkind {
+    Interface = 0,
+    Class = 1,
+    AnonymousInterface = 2,
+    Tuple = 3
+}
+export interface IDLInterface extends IDLEntry {
+    kind: IDLKind.Interface;
+    subkind: IDLInterfaceSubkind;
+    typeParameters?: string[];
+    inheritance: IDLReferenceType[];
+    constructors: IDLConstructor[];
+    constants: IDLConstant[];
+    properties: IDLProperty[];
+    methods: IDLMethod[];
+    callables: IDLCallable[];
+}
+export interface IDLImport extends IDLEntry {
+    kind: IDLKind.Import;
+    clause: string[];
+}
+export interface IDLNamespace extends IDLEntry {
+    kind: IDLKind.Namespace;
+    members: IDLEntry[];
+}
+export interface IDLCallback extends IDLEntry, IDLSignature {
+    kind: IDLKind.Callback;
+    returnType: IDLType;
+}
+//# sourceMappingURL=node.d.ts.map

package/build/lib/src/idl/node.js

@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2025 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.
+ */
+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["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["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 = {}));
+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 = {}));
+//# sourceMappingURL=node.js.map

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

@@ -0,0 +1,34 @@
+import { IDLNode, IDLPrimitiveType } from "./node";
+export declare const IDLPointerType: IDLPrimitiveType;
+export declare const IDLVoidType: IDLPrimitiveType;
+export declare const IDLBooleanType: IDLPrimitiveType;
+export declare const IDLI8Type: IDLPrimitiveType;
+export declare const IDLU8Type: IDLPrimitiveType;
+export declare const IDLI16Type: IDLPrimitiveType;
+export declare const IDLU16Type: IDLPrimitiveType;
+export declare const IDLI32Type: IDLPrimitiveType;
+export declare const IDLU32Type: IDLPrimitiveType;
+export declare const IDLI64Type: IDLPrimitiveType;
+export declare const IDLU64Type: IDLPrimitiveType;
+export declare const IDLF16Type: IDLPrimitiveType;
+export declare const IDLF32Type: IDLPrimitiveType;
+export declare const IDLF64Type: IDLPrimitiveType;
+export declare const IDLBigintType: IDLPrimitiveType;
+export declare const IDLNumberType: IDLPrimitiveType;
+export declare const IDLStringType: IDLPrimitiveType;
+export declare const IDLAnyType: IDLPrimitiveType;
+export declare const IDLUndefinedType: IDLPrimitiveType;
+export declare const IDLUnknownType: IDLPrimitiveType;
+export declare const IDLObjectType: IDLPrimitiveType;
+export declare const IDLThisType: IDLPrimitiveType;
+export declare const IDLDate: IDLPrimitiveType;
+export declare const IDLBufferType: IDLPrimitiveType;
+export declare const IDLUint8ArrayType: import("./node").IDLContainerType;
+export declare const IDLSerializerBuffer: IDLPrimitiveType;
+export declare const IDLFunctionType: IDLPrimitiveType;
+export declare const IDLCustomObjectType: IDLPrimitiveType;
+export declare const IDLInteropReturnBufferType: IDLPrimitiveType;
+export declare const IDLNullTypeName = "idlize.stdlib.Null";
+export declare function isUndefinedType(type: IDLNode): type is IDLPrimitiveType;
+export declare function isVoidType(type: IDLNode): type is IDLPrimitiveType;
+//# sourceMappingURL=stdlib.d.ts.map

package/build/lib/src/idl/stdlib.js

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2025 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 { createContainerType, createPrimitiveType } from "./builders";
+import { isPrimitiveType } from "./discriminators";
+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 isUndefinedType(type) {
+    return isPrimitiveType(type) && type.name === IDLUndefinedType.name;
+}
+export function isVoidType(type) {
+    return isPrimitiveType(type) && type.name === IDLVoidType.name;
+}
+//# sourceMappingURL=stdlib.js.map

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

@@ -0,0 +1,44 @@
+import { stringOrNone } from "../util";
+import { QNPattern } from "./discriminators";
+import { IDLNode, IDLNamedNode, IDLType, IDLEntry, IDLReferenceType, IDLContainerType, IDLSignature, IDLParameter, IDLEnum, IDLFile } from "./node";
+export declare function entityToType(entity: IDLNode): IDLType;
+export declare function forceAsNamedNode(type: IDLNode): IDLNamedNode;
+export declare function isEqualByQualifedName(a?: IDLNamedNode, b?: IDLNamedNode, pattern?: QNPattern): boolean;
+export declare function getVerbatimDts(node: IDLEntry): stringOrNone;
+/**
+ * @returns tuple of qualifier name and real type name
+ */
+export declare function decomposeQualifiedName(type: IDLReferenceType): [string | undefined, string];
+export declare function qualifiedNameStartsWith(node: IDLNode | string[], template: string[]): boolean;
+export declare function maybeUnwrapOptionalType(type: IDLType): IDLType;
+export declare function maybeOptional(type: IDLType, optional?: boolean): IDLType;
+export declare const DebugUtils: {
+    debugPrintType: (type: IDLType) => string;
+};
+export declare function asPromise(type?: IDLType): IDLContainerType | undefined;
+export declare function transformMethodsAsync2ReturnPromise(entry: IDLEntry): void;
+export declare function transformMethodsReturnPromise2Async(entry: IDLEntry): void;
+export interface SignatureTag {
+    index: number;
+    name: string;
+    value: string;
+}
+export declare function fetchSignatureTags(node: IDLSignature): SignatureTag[];
+export declare function mixMethodParametersAndTags(node: IDLSignature): (IDLParameter | SignatureTag)[];
+export declare function isHandwritten(decl: IDLEntry): boolean;
+export declare function isStringEnum(decl: IDLEnum): boolean;
+export declare function linearizeNamespaceMembers(entries: IDLEntry[]): IDLEntry[];
+export declare function extremumOfOrdinals(enumEntry: IDLEnum): {
+    low: number;
+    high: number;
+};
+export declare const PACKAGE_IDLIZE_INTERNAL = "idlize.internal";
+export declare function isInIdlize(entry: IDLEntry | IDLFile): boolean;
+export declare function isInIdlizeInterop(entry: IDLEntry | IDLFile): boolean;
+export declare function isInIdlizeInternal(entry: IDLEntry | IDLFile): boolean;
+export declare function isInIdlizeStdlib(entry: IDLEntry | IDLFile): boolean;
+export declare function hasTypeParameters(entry: IDLEntry): boolean;
+export declare function isGeneric(entry: IDLEntry): entry is IDLEntry & {
+    typeParameters?: string[];
+};
+//# sourceMappingURL=utils.d.ts.map

package/build/lib/src/idl/utils.js

@@ -0,0 +1,215 @@
+/*
+ * Copyright (c) 2025 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 { createOptionalType, createContainerType, createReferenceType } from "./builders";
+import { isNamedNode, getQualifiedName, getFQName, isOptionalType, isContainerType, IDLContainerUtils, isNamespace, isInPackage, isType, isEntry, isTypeParameterType, isInterface, isTypedef, isCallback, isMethod, isCallable, getExtAttribute, hasExtAttribute } from "./discriminators";
+import { printType } from "./dump";
+import { IDLKind, IDLExtendedAttributes } from "./node";
+import { IDLVoidType, IDLStringType } from "./stdlib";
+import { forEachChild, forEachFunction } from "./visitors";
+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 forceAsNamedNode(type) {
+    if (!isNamedNode(type)) {
+        throw new Error(`Expected to be an IDLNamedNode, but got '${IDLKind[type.kind]}'`);
+    }
+    return type;
+}
+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 getVerbatimDts(node) {
+    let value = getExtAttribute(node, IDLExtendedAttributes.VerbatimDts);
+    return value ? value.substring(1, value.length - 1) : undefined;
+}
+/**
+ * @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) => {
+        const filename = type.fileName ? `, fileName: '${type.fileName}'` : "";
+        if (isContainerType(type)) {
+            return `[IDLType, name: '${printType(type)}', kind: '${IDLKind[type.kind]}', elements: [${type.elementType.map(DebugUtils.debugPrintType).join(', ')}]${filename}]`;
+        }
+        return `[IDLType, name: '${printType(type)}', kind: '${IDLKind[type.kind]}'${filename}]`;
+    },
+};
+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");
+}
+export function hasTypeParameters(entry) {
+    let foundTypeParameter = false;
+    forEachChild(entry, n => {
+        if (isTypeParameterType(n)) {
+            foundTypeParameter = true;
+        }
+    });
+    return foundTypeParameter;
+}
+export function isGeneric(entry) {
+    return isInterface(entry)
+        || isTypedef(entry)
+        || isCallback(entry)
+        || isMethod(entry)
+        || isCallable(entry);
+}
+//# sourceMappingURL=utils.js.map