@pulumi/pulumi 3.163.0-alpha.x5bf1e8a → 3.163.0-alpha.xa463c1e

package/provider/experimental/analyzer.js

@@ -89,7 +89,7 @@ class Analyzer {
                 else if ((ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node)) && node.name) {
                     // Collect documentation for types
                     const dNode = node;
-                    if ((dNode === null || dNode === void 0 ? void 0 : dNode.jsDoc) && dNode.jsDoc.length > 0) {
+                    if (dNode?.jsDoc && dNode.jsDoc.length > 0) {
                         const typeDocString = dNode.jsDoc.map((doc) => doc.comment).join("\n");
                         if (typeDocString) {
                             this.docStrings[node.name.text] = typeDocString;
@@ -211,15 +211,14 @@ Please ensure these components are properly imported to your package's entry poi
         return importedFiles;
     }
     analyzeComponent(node) {
-        var _a;
-        const componentName = (_a = node.name) === null || _a === void 0 ? void 0 : _a.text;
+        const componentName = node.name?.text;
         // We expect exactly 1 constructor, and it must have and 'args'
         // parameter that has an interface type.
         const constructors = node.members.filter((member) => ts.isConstructorDeclaration(member));
         if (constructors.length !== 1) {
             throw new Error(`Component '${componentName}' must have exactly one constructor`);
         }
-        const argsParam = constructors === null || constructors === void 0 ? void 0 : constructors[0].parameters.find((param) => {
+        const argsParam = constructors?.[0].parameters.find((param) => {
             return ts.isIdentifier(param.name) && param.name.escapedText === "args";
         });
         if (!argsParam) {
@@ -240,7 +239,7 @@ Please ensure these components are properly imported to your package's entry poi
         let outputs = {};
         const classType = this.checker.getTypeAtLocation(node);
         const classSymbol = classType.getSymbol();
-        if (classSymbol === null || classSymbol === void 0 ? void 0 : classSymbol.members) {
+        if (classSymbol?.members) {
             outputs = this.analyzeSymbols({ component: componentName, inputOutput: InputOutput.Output }, symbolTableToSymbols(classSymbol.members), node);
         }
         const definition = {
@@ -260,12 +259,11 @@ Please ensure these components are properly imported to your package's entry poi
         }
         return node.heritageClauses.some((clause) => {
             return clause.types.some((clauseNode) => {
-                var _a;
                 const type = this.checker.getTypeAtLocation(clauseNode);
                 const symbol = type.getSymbol();
-                const matchesName = (symbol === null || symbol === void 0 ? void 0 : symbol.escapedName) === "ComponentResource";
-                const sourceFile = (_a = symbol === null || symbol === void 0 ? void 0 : symbol.declarations) === null || _a === void 0 ? void 0 : _a[0].getSourceFile();
-                const matchesSourceFile = (sourceFile === null || sourceFile === void 0 ? void 0 : sourceFile.fileName.endsWith("resource.ts")) || (sourceFile === null || sourceFile === void 0 ? void 0 : sourceFile.fileName.endsWith("resource.d.ts"));
+                const matchesName = symbol?.escapedName === "ComponentResource";
+                const sourceFile = symbol?.declarations?.[0].getSourceFile();
+                const matchesSourceFile = sourceFile?.fileName.endsWith("resource.ts") || sourceFile?.fileName.endsWith("resource.d.ts");
                 return matchesName && matchesSourceFile;
             });
         });
@@ -277,7 +275,7 @@ Please ensure these components are properly imported to your package's entry poi
                 return;
             }
             const name = member.escapedName;
-            properties[name] = this.analyzeSymbol(Object.assign(Object.assign({}, context), { property: name }), member, location);
+            properties[name] = this.analyzeSymbol({ ...context, property: name }, member, location);
         });
         return properties;
     }
@@ -288,15 +286,13 @@ Please ensure these components are properly imported to your package's entry poi
         const optional = isOptional(symbol);
         const dNode = symbol.valueDeclaration;
         let docString = undefined;
-        if ((dNode === null || dNode === void 0 ? void 0 : dNode.jsDoc) && dNode.jsDoc.length > 0) {
+        if (dNode?.jsDoc && dNode.jsDoc.length > 0) {
             docString = dNode.jsDoc.map((doc) => doc.comment).join("\n");
         }
-        return this.analyzeType(Object.assign(Object.assign({}, context), { inputOutput: InputOutput.Neither }), propType, location, optional, docString);
+        return this.analyzeType({ ...context, inputOutput: InputOutput.Neither }, propType, location, optional, docString);
     }
     analyzeType(context, type, location, optional = false, docString = undefined) {
-        var _a, _b, _c;
-        if (isSimpleType(type)) {
-            const prop = { type: tsTypeToPropertyType(type) };
+        const makeProp = (prop) => {
             if (optional) {
                 prop.optional = true;
             }
@@ -307,101 +303,55 @@ Please ensure these components are properly imported to your package's entry poi
                 prop.description = docString;
             }
             return prop;
+        };
+        const propType = getSimplePropertyType(type);
+        if (propType) {
+            return makeProp({ type: propType });
         }
-        else if (isInput(type)) {
-            // Grab the promise type from the `T | Promise<T> | OutputInstance<T>`
-            // union, and get the type reference `T` from there. With that we
-            // can recursively analyze the type, passing through the optional
-            // flag. The type can now not be plain anymore, since it's in an
-            // input.
-            const base = (_b = (_a = type) === null || _a === void 0 ? void 0 : _a.types) === null || _b === void 0 ? void 0 : _b.find(isPromise);
-            if (!base) {
-                // unreachable due to the isInput check
-                throw new Error(`Input type union must include a Promise: ${this.formatErrorContext(context)} has type '${this.checker.typeToString(type)}'`);
-            }
-            const innerType = this.unwrapTypeReference(context, base);
-            return this.analyzeType(Object.assign(Object.assign({}, context), { inputOutput: InputOutput.Input }), innerType, location, optional, docString);
+        const innerInputType = getInputInnerType(type);
+        if (innerInputType) {
+            const innerType = this.unwrapTypeReference(context, innerInputType);
+            return this.analyzeType({ ...context, inputOutput: InputOutput.Input }, innerType, location, optional, docString);
         }
-        else if (isOutput(type)) {
+        if (isOutput(type)) {
             type = unwrapOutputIntersection(type);
             // Grab the inner type of the OutputInstance<T> type, and then
             // recurse, passing through the optional flag. The type can now not
             // be plain anymore, since it's wrapped in an output.
             const innerType = this.unwrapTypeReference(context, type);
-            return this.analyzeType(Object.assign(Object.assign({}, context), { inputOutput: InputOutput.Output }), innerType, location, optional, docString);
+            return this.analyzeType({ ...context, inputOutput: InputOutput.Output }, innerType, location, optional, docString);
         }
-        else if (isAny(type)) {
-            const $ref = "pulumi.json#/Any";
-            const prop = { $ref };
-            if (optional) {
-                prop.optional = true;
-            }
-            if (docString) {
-                prop.description = docString;
-            }
+        if (isAny(type)) {
+            const prop = makeProp({ $ref: "pulumi.json#/Any" });
+            // Any is never plain, since it can be anything, including an Input<T>.
+            // biome-ignore lint/performance/noDelete: Completely remove the property to not include it in the schema.
+            delete prop.plain;
             return prop;
         }
-        else if (isAsset(type)) {
-            const $ref = "pulumi.json#/Asset";
-            const prop = { $ref };
-            if (optional) {
-                prop.optional = true;
-            }
-            if (context.inputOutput === InputOutput.Neither) {
-                prop.plain = true;
-            }
-            if (docString) {
-                prop.description = docString;
-            }
-            return prop;
+        if (isAsset(type)) {
+            return makeProp({ $ref: "pulumi.json#/Asset" });
         }
-        else if (isArchive(type)) {
-            const $ref = "pulumi.json#/Archive";
-            const prop = { $ref };
-            if (optional) {
-                prop.optional = true;
-            }
-            if (context.inputOutput === InputOutput.Neither) {
-                prop.plain = true;
-            }
-            if (docString) {
-                prop.description = docString;
-            }
-            return prop;
+        if (isArchive(type)) {
+            return makeProp({ $ref: "pulumi.json#/Archive" });
         }
-        else if (isResourceReference(type, this.checker)) {
+        if (isResourceReference(type, this.checker)) {
             const { packageName, packageVersion, pulumiType } = this.getResourceType(context, type);
-            const $ref = `/${packageName}/v${packageVersion}/schema.json#/resources/${pulumiType.replace("/", "%2F")}`;
             this.packageReferences[packageName] = packageVersion;
-            const prop = { $ref };
-            if (optional) {
-                prop.optional = true;
-            }
-            if (context.inputOutput === InputOutput.Neither) {
-                prop.plain = true;
-            }
-            if (docString) {
-                prop.description = docString;
-            }
-            return prop;
+            return makeProp({
+                $ref: `/${packageName}/v${packageVersion}/schema.json#/resources/${pulumiType.replace("/", "%2F")}`,
+            });
         }
-        else if (type.isClassOrInterface()) {
+        if (type.isClassOrInterface()) {
             // This is a complex type, create a typedef and then reference it in
             // the PropertyDefinition.
-            const name = (_c = type.getSymbol()) === null || _c === void 0 ? void 0 : _c.escapedName;
+            const name = type.getSymbol()?.escapedName;
             if (!name) {
                 throw new Error(`Class or interface has no name: ${this.formatErrorContext(context)} has type '${this.checker.typeToString(type)}'`);
             }
             if (this.typeDefinitions[name]) {
                 // Type already exists, just reference it and we're done.
                 const refProp = { $ref: `#/types/${this.providerName}:index:${name}` };
-                if (optional) {
-                    refProp.optional = true;
-                }
-                if (context.inputOutput === InputOutput.Neither) {
-                    refProp.plain = true;
-                }
-                return refProp;
+                return makeProp(refProp);
             }
             // Immediately add an empty type definition, so that it can be
             // referenced recursively, then analyze the properties.
@@ -409,85 +359,44 @@ Please ensure these components are properly imported to your package's entry poi
             if (this.docStrings[name]) {
                 this.typeDefinitions[name].description = this.docStrings[name];
             }
-            const typeContext = Object.assign(Object.assign({}, context), { typeName: name });
+            const typeContext = { ...context, typeName: name };
             const properties = this.analyzeSymbols(typeContext, type.getProperties(), location);
             this.typeDefinitions[name].properties = properties;
-            const $ref = `#/types/${this.providerName}:index:${name}`;
-            const prop = { $ref };
-            if (optional) {
-                prop.optional = true;
-            }
-            if (context.inputOutput === InputOutput.Neither) {
-                prop.plain = true;
-            }
-            if (docString) {
-                prop.description = docString;
-            }
-            return prop;
-        }
-        else if (isArrayType(type)) {
-            const prop = { type: "array" };
-            if (optional) {
-                prop.optional = true;
-            }
-            if (context.inputOutput === InputOutput.Neither) {
-                prop.plain = true;
-            }
-            const typeArguments = type.typeArguments;
-            if (!typeArguments || typeArguments.length !== 1) {
-                throw new Error(`Expected exactly one type argument in '${this.checker.typeToString(type)}': ${this.formatErrorContext(context)} has ${(typeArguments === null || typeArguments === void 0 ? void 0 : typeArguments.length) || 0} type arguments`);
-            }
-            const innerType = typeArguments[0];
-            prop.items = this.analyzeType(Object.assign(Object.assign({}, context), { property: `${context.property}[]`, inputOutput: context.inputOutput === InputOutput.Output ? InputOutput.Output : InputOutput.Neither }), innerType, location, false /* optional */);
-            if (docString) {
-                prop.description = docString;
-            }
-            return prop;
+            return makeProp({ $ref: `#/types/${this.providerName}:index:${name}` });
+        }
+        const arrayItemType = getArrayType(type);
+        if (arrayItemType) {
+            return makeProp({
+                type: "array",
+                items: this.analyzeType({
+                    ...context,
+                    property: `${context.property}[]`,
+                    inputOutput: context.inputOutput === InputOutput.Output ? InputOutput.Output : InputOutput.Neither,
+                }, arrayItemType, location, false /* optional */),
+            });
         }
-        else if (isMapType(type, this.checker)) {
-            const prop = { type: "object" };
-            if (optional) {
-                prop.optional = true;
-            }
-            if (context.inputOutput === InputOutput.Neither) {
-                prop.plain = true;
-            }
-            // We got { [key: string]: <indexInfo.type> }
-            const indexInfo = this.checker.getIndexInfoOfType(type, ts.IndexKind.String);
-            if (!indexInfo) {
-                // We can't actually get here because isMapType checks for indexInfo
-                throw new Error(`Map type has no index info`);
-            }
-            if (docString) {
-                prop.description = docString;
-            }
-            prop.additionalProperties = this.analyzeType(Object.assign(Object.assign({}, context), { property: `${context.property} values` }), indexInfo.type, location, false);
-            return prop;
+        const mapType = getMapType(type, this.checker);
+        if (mapType) {
+            return makeProp({
+                type: "object",
+                additionalProperties: this.analyzeType({
+                    ...context,
+                    property: `${context.property} values`,
+                }, mapType, location, false),
+            });
         }
-        else if (isBooleanOptionalType(type, this.checker)) {
+        if (isBooleanOptionalType(type, this.checker)) {
             // This is the special case for true | false | undefined
-            const prop = { type: "boolean" };
-            prop.optional = true;
-            if (context.inputOutput === InputOutput.Neither) {
-                prop.plain = true;
-            }
-            if (docString) {
-                prop.description = docString;
-            }
-            return prop;
+            return makeProp({ type: "boolean", optional: true });
         }
-        else if (isOptionalType(type, this.checker)) {
-            const unionType = type;
-            const nonUndefinedType = unionType.types.find((t) => !(t.flags & ts.TypeFlags.Undefined));
-            if (!nonUndefinedType) {
-                throw new Error(`Expected exactly one type to not be undefined: ${this.formatErrorContext(context)} has type '${this.checker.typeToString(type)}'`);
-            }
-            return this.analyzeType(context, nonUndefinedType, location, true, docString);
+        const optionalType = getOptionalType(type);
+        if (optionalType) {
+            return this.analyzeType(context, optionalType, location, true, docString);
         }
-        else if (type.isUnion()) {
+        if (type.isUnion()) {
             throw new Error(`Union types are not supported for ${this.formatErrorContext(context)}: type '${this.checker.typeToString(type)}'`);
         }
-        else if (type.isIntersection()) {
+        if (type.isIntersection()) {
             throw new Error(`Intersection types are not supported for ${this.formatErrorContext(context)}: type '${this.checker.typeToString(type)}'`);
         }
         throw new Error(`Unsupported type for ${this.formatErrorContext(context)}: type '${this.checker.typeToString(type)}'`);
@@ -498,7 +407,7 @@ Please ensure these components are properly imported to your package's entry poi
             typeArguments = type.aliasTypeArguments;
         }
         if (!typeArguments || typeArguments.length !== 1) {
-            throw new Error(`Expected exactly one type argument in '${this.checker.typeToString(type)}': ${this.formatErrorContext(context)} has ${(typeArguments === null || typeArguments === void 0 ? void 0 : typeArguments.length) || 0} type arguments`);
+            throw new Error(`Expected exactly one type argument in '${this.checker.typeToString(type)}': ${this.formatErrorContext(context)} has ${typeArguments?.length || 0} type arguments`);
         }
         const innerType = typeArguments[0];
         return innerType;
@@ -536,13 +445,12 @@ Please ensure these components are properly imported to your package's entry poi
      * @throws Error if the resource type cannot be determined with detailed context information
      */
     getResourceType(context, type) {
-        var _a;
         const symbol = type.getSymbol();
         if (!symbol) {
             throw new Error(`Cannot determine resource type: source (symbol) not found for type '${this.checker.typeToString(type)}' for ${this.formatErrorContext(context)}`);
         }
         // Try to find the declaration of the class
-        const declaration = (_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a[0];
+        const declaration = symbol.declarations?.[0];
         if (!declaration) {
             throw new Error(`Cannot determine resource type: source (declaration) not found for symbol '${symbol.name}' for ${this.formatErrorContext(context)}`);
         }
@@ -610,17 +518,22 @@ exports.Analyzer = Analyzer;
 function isOptional(symbol) {
     return (symbol.flags & ts.SymbolFlags.Optional) === ts.SymbolFlags.Optional;
 }
-function isOptionalType(type, checker) {
+function getOptionalType(type) {
     if (!(type.flags & ts.TypeFlags.Union)) {
-        return false;
+        return undefined;
     }
     const unionType = type;
     // We only support union types with two types, one of which must be undefined
     if (!unionType.types || unionType.types.length !== 2) {
-        return false;
+        return undefined;
     }
     // Check if one of the types in the union is undefined
-    return unionType.types.some((t) => t.flags & ts.TypeFlags.Undefined || t.flags & ts.TypeFlags.Void);
+    const undefinedType = unionType.types.find((t) => t.flags & ts.TypeFlags.Undefined || t.flags & ts.TypeFlags.Void); // Also check for void in some cases
+    if (!undefinedType) {
+        return undefined;
+    }
+    const nonUndefinedType = unionType.types.find((t) => !(t.flags & ts.TypeFlags.Undefined || t.flags & ts.TypeFlags.Void));
+    return nonUndefinedType;
 }
 // Checks if a type is a union of true | false | undefined, which represents an optional boolean.
 function isBooleanOptionalType(type, checker) {
@@ -670,16 +583,35 @@ function isBoolean(type) {
 function isAny(type) {
     return (type.flags & ts.TypeFlags.Any) === ts.TypeFlags.Any;
 }
-function isSimpleType(type) {
-    return isNumber(type) || isString(type) || isBoolean(type);
+function getSimplePropertyType(type) {
+    if (isNumber(type)) {
+        return "number";
+    }
+    else if (isString(type)) {
+        return "string";
+    }
+    else if (isBoolean(type)) {
+        return "boolean";
+    }
+    return undefined;
 }
-function isMapType(type, checker) {
+function getMapType(type, checker) {
     const indexInfo = checker.getIndexInfoOfType(type, ts.IndexKind.String);
-    return indexInfo !== undefined;
+    if (!indexInfo) {
+        return undefined;
+    }
+    return indexInfo.type;
 }
-function isArrayType(type) {
-    var _a;
-    return (type.flags & ts.TypeFlags.Object) === ts.TypeFlags.Object && ((_a = type.getSymbol()) === null || _a === void 0 ? void 0 : _a.escapedName) === "Array";
+function getArrayType(type) {
+    const isArray = (type.flags & ts.TypeFlags.Object) === ts.TypeFlags.Object && type.getSymbol()?.escapedName === "Array";
+    if (!isArray) {
+        return undefined;
+    }
+    const typeArguments = type.typeArguments;
+    if (!typeArguments || typeArguments.length !== 1) {
+        return undefined;
+    }
+    return typeArguments[0];
 }
 function isPromise(type) {
     if (!(type.flags & ts.TypeFlags.Object)) {
@@ -692,7 +624,6 @@ function isPromise(type) {
     return symbol.name === "Promise";
 }
 function isOutput(type) {
-    var _a;
     // In sdk/nodejs/output.ts we define Output as:
     //
     //   export type Output<T> = OutputInstance<T> & Lifted<T>;
@@ -712,25 +643,23 @@ function isOutput(type) {
     if (!symbol) {
         symbol = type.aliasSymbol;
     }
-    const matchesName = (symbol === null || symbol === void 0 ? void 0 : symbol.escapedName) === "OutputInstance" || (symbol === null || symbol === void 0 ? void 0 : symbol.escapedName) === "Output";
-    const sourceFile = (_a = symbol === null || symbol === void 0 ? void 0 : symbol.declarations) === null || _a === void 0 ? void 0 : _a[0].getSourceFile();
-    const matchesSourceFile = (sourceFile === null || sourceFile === void 0 ? void 0 : sourceFile.fileName.endsWith("output.ts")) || (sourceFile === null || sourceFile === void 0 ? void 0 : sourceFile.fileName.endsWith("output.d.ts"));
+    const matchesName = symbol?.escapedName === "OutputInstance" || symbol?.escapedName === "Output";
+    const sourceFile = symbol?.declarations?.[0].getSourceFile();
+    const matchesSourceFile = sourceFile?.fileName.endsWith("output.ts") || sourceFile?.fileName.endsWith("output.d.ts");
     return !!matchesName && !!matchesSourceFile;
 }
 function isAsset(type) {
-    var _a;
     const symbol = type.getSymbol();
-    const matchesName = (symbol === null || symbol === void 0 ? void 0 : symbol.escapedName) === "Asset";
-    const sourceFile = (_a = symbol === null || symbol === void 0 ? void 0 : symbol.declarations) === null || _a === void 0 ? void 0 : _a[0].getSourceFile();
-    const matchesSourceFile = (sourceFile === null || sourceFile === void 0 ? void 0 : sourceFile.fileName.endsWith("asset.ts")) || (sourceFile === null || sourceFile === void 0 ? void 0 : sourceFile.fileName.endsWith("asset.d.ts"));
+    const matchesName = symbol?.escapedName === "Asset";
+    const sourceFile = symbol?.declarations?.[0].getSourceFile();
+    const matchesSourceFile = sourceFile?.fileName.endsWith("asset.ts") || sourceFile?.fileName.endsWith("asset.d.ts");
     return !!matchesName && !!matchesSourceFile;
 }
 function isArchive(type) {
-    var _a;
     const symbol = type.getSymbol();
-    const matchesName = (symbol === null || symbol === void 0 ? void 0 : symbol.escapedName) === "Archive";
-    const sourceFile = (_a = symbol === null || symbol === void 0 ? void 0 : symbol.declarations) === null || _a === void 0 ? void 0 : _a[0].getSourceFile();
-    const matchesSourceFile = (sourceFile === null || sourceFile === void 0 ? void 0 : sourceFile.fileName.endsWith("archive.ts")) || (sourceFile === null || sourceFile === void 0 ? void 0 : sourceFile.fileName.endsWith("archive.d.ts"));
+    const matchesName = symbol?.escapedName === "Archive";
+    const sourceFile = symbol?.declarations?.[0].getSourceFile();
+    const matchesSourceFile = sourceFile?.fileName.endsWith("archive.ts") || sourceFile?.fileName.endsWith("archive.d.ts");
     return !!matchesName && !!matchesSourceFile;
 }
 function unwrapOutputIntersection(type) {
@@ -751,54 +680,42 @@ function unwrapOutputIntersection(type) {
 /**
  * An input type is a union of Output<T>, Promise<T>, and T.
  */
-function isInput(type) {
+function getInputInnerType(type) {
     if (!type.isUnion()) {
-        return false;
+        return undefined;
     }
     let hasOutput = false;
     let hasPromise = false;
     let hasOther = false;
+    let promiseType;
     for (const t of type.types) {
         if (isOutput(t)) {
             hasOutput = true;
         }
         else if (isPromise(t)) {
             hasPromise = true;
+            promiseType = t;
         }
         else {
             hasOther = true;
         }
     }
-    return hasOutput && hasPromise && hasOther;
+    return hasOutput && hasPromise && hasOther ? promiseType : undefined;
 }
 function isResourceReference(type, checker) {
     if (!type.isClass()) {
         return false;
     }
     return checker.getBaseTypes(type).some((baseType) => {
-        var _a;
         const symbol = baseType.getSymbol();
-        const matchesName = (symbol === null || symbol === void 0 ? void 0 : symbol.escapedName) === "CustomResource" ||
-            (symbol === null || symbol === void 0 ? void 0 : symbol.escapedName) === "ComponentResource" ||
-            (symbol === null || symbol === void 0 ? void 0 : symbol.escapedName) === "Resource";
-        const sourceFile = (_a = symbol === null || symbol === void 0 ? void 0 : symbol.declarations) === null || _a === void 0 ? void 0 : _a[0].getSourceFile();
-        const matchesSourceFile = (sourceFile === null || sourceFile === void 0 ? void 0 : sourceFile.fileName.endsWith("resource.ts")) || (sourceFile === null || sourceFile === void 0 ? void 0 : sourceFile.fileName.endsWith("resource.d.ts"));
+        const matchesName = symbol?.escapedName === "CustomResource" ||
+            symbol?.escapedName === "ComponentResource" ||
+            symbol?.escapedName === "Resource";
+        const sourceFile = symbol?.declarations?.[0].getSourceFile();
+        const matchesSourceFile = sourceFile?.fileName.endsWith("resource.ts") || sourceFile?.fileName.endsWith("resource.d.ts");
         return (matchesName && matchesSourceFile) || isResourceReference(baseType, checker);
     });
 }
-function tsTypeToPropertyType(type) {
-    var _a;
-    if (isNumber(type)) {
-        return "number";
-    }
-    else if (isString(type)) {
-        return "string";
-    }
-    else if (isBoolean(type)) {
-        return "boolean";
-    }
-    throw new Error(`Unsupported type '${(_a = type.symbol) === null || _a === void 0 ? void 0 : _a.name}'`);
-}
 function symbolTableToSymbols(table) {
     const symbols = [];
     table.forEach((symbol) => {