//// [awaitUsingDeclarations.1.ts]
import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
import { _ as _await_async_generator } from "@swc/helpers/_/_await_async_generator";
import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
import { _ as _define_property } from "@swc/helpers/_/_define_property";
import { _ as _wrap_async_generator } from "@swc/helpers/_/_wrap_async_generator";
import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
import { _ as _ts_add_disposable_resource } from "@swc/helpers/_/_ts_add_disposable_resource";
import { _ as _ts_dispose_resources } from "@swc/helpers/_/_ts_dispose_resources";
var env = {
    stack: [],
    error: void 0,
    hasError: !1
};
try {
    _ts_add_disposable_resource(env, _define_property({}, Symbol.asyncDispose, function() {
        return _async_to_generator(function() {
            return _ts_generator(this, function(_state) {
                return [
                    2
                ];
            });
        })();
    }), !0);
    var env1 = {
        stack: [],
        error: void 0,
        hasError: !1
    };
    try {
        _ts_add_disposable_resource(env1, _define_property({}, Symbol.asyncDispose, function() {
            return _async_to_generator(function() {
                return _ts_generator(this, function(_state) {
                    return [
                        2
                    ];
                });
            })();
        }), !0);
    } catch (e) {
        env1.error = e, env1.hasError = !0;
    } finally{
        var result = _ts_dispose_resources(env1);
        result && await result;
    }
    switch(Math.random()){
        case 0:
            var env2 = {
                stack: [],
                error: void 0,
                hasError: !1
            };
            try {
                _ts_add_disposable_resource(env2, _define_property({}, Symbol.asyncDispose, function() {
                    return _async_to_generator(function() {
                        return _ts_generator(this, function(_state) {
                            return [
                                2
                            ];
                        });
                    })();
                }), !0);
                break;
            } catch (e) {
                env2.error = e, env2.hasError = !0;
            } finally{
                var result1 = _ts_dispose_resources(env2);
                result1 && await result1;
            }
        case 1:
            var env3 = {
                stack: [],
                error: void 0,
                hasError: !1
            };
            try {
                _ts_add_disposable_resource(env3, _define_property({}, Symbol.asyncDispose, function() {
                    return _async_to_generator(function() {
                        return _ts_generator(this, function(_state) {
                            return [
                                2
                            ];
                        });
                    })();
                }), !0);
            } catch (e) {
                env3.error = e, env3.hasError = !0;
            } finally{
                var result2 = _ts_dispose_resources(env3);
                result2 && await result2;
            }
    }
    var env4 = {
        stack: [],
        error: void 0,
        hasError: !1
    };
    try {
        _ts_add_disposable_resource(env4, _define_property({}, Symbol.asyncDispose, function() {
            return _async_to_generator(function() {
                return _ts_generator(this, function(_state) {
                    return [
                        2
                    ];
                });
            })();
        }), !0);
    } catch (e) {
        env4.error = e, env4.hasError = !0;
    } finally{
        var result3 = _ts_dispose_resources(env4);
        result3 && await result3;
    }
    try {
        var env5 = {
            stack: [],
            error: void 0,
            hasError: !1
        };
        try {
            _ts_add_disposable_resource(env5, _define_property({}, Symbol.asyncDispose, function() {
                return _async_to_generator(function() {
                    return _ts_generator(this, function(_state) {
                        return [
                            2
                        ];
                    });
                })();
            }), !0);
        } catch (e) {
            env5.error = e, env5.hasError = !0;
        } finally{
            var result4 = _ts_dispose_resources(env5);
            result4 && await result4;
        }
    } catch (e) {
        var env6 = {
            stack: [],
            error: void 0,
            hasError: !1
        };
        try {
            _ts_add_disposable_resource(env6, _define_property({}, Symbol.asyncDispose, function() {
                return _async_to_generator(function() {
                    return _ts_generator(this, function(_state) {
                        return [
                            2
                        ];
                    });
                })();
            }), !0);
        } catch (e) {
            env6.error = e, env6.hasError = !0;
        } finally{
            var result5 = _ts_dispose_resources(env6);
            result5 && await result5;
        }
    } finally{
        var env7 = {
            stack: [],
            error: void 0,
            hasError: !1
        };
        try {
            _ts_add_disposable_resource(env7, _define_property({}, Symbol.asyncDispose, function() {
                return _async_to_generator(function() {
                    return _ts_generator(this, function(_state) {
                        return [
                            2
                        ];
                    });
                })();
            }), !0);
        } catch (e) {
            env7.error = e, env7.hasError = !0;
        } finally{
            var result6 = _ts_dispose_resources(env7);
            result6 && await result6;
        }
    }
    var env8 = {
        stack: [],
        error: void 0,
        hasError: !1
    };
    try {
        _ts_add_disposable_resource(env8, _define_property({}, Symbol.asyncDispose, function() {
            return _async_to_generator(function() {
                return _ts_generator(this, function(_state) {
                    return [
                        2
                    ];
                });
            })();
        }), !0);
    } catch (e) {
        env8.error = e, env8.hasError = !0;
    } finally{
        var result7 = _ts_dispose_resources(env8);
        result7 && await result7;
    }
    for(;;){
        var env10 = {
            stack: [],
            error: void 0,
            hasError: !1
        };
        try {
            _ts_add_disposable_resource(env10, _define_property({}, Symbol.asyncDispose, function() {
                return _async_to_generator(function() {
                    return _ts_generator(this, function(_state) {
                        return [
                            2
                        ];
                    });
                })();
            }), !0);
            break;
        } catch (e) {
            env10.error = e, env10.hasError = !0;
        } finally{
            var result9 = _ts_dispose_resources(env10);
            result9 && await result9;
        }
    }
    for(;;){
        var env11 = {
            stack: [],
            error: void 0,
            hasError: !1
        };
        try {
            _ts_add_disposable_resource(env11, _define_property({}, Symbol.asyncDispose, function() {
                return _async_to_generator(function() {
                    return _ts_generator(this, function(_state) {
                        return [
                            2
                        ];
                    });
                })();
            }), !0);
            break;
        } catch (e) {
            env11.error = e, env11.hasError = !0;
        } finally{
            var result10 = _ts_dispose_resources(env11);
            result10 && await result10;
        }
    }
    for(;;){
        var env12 = {
            stack: [],
            error: void 0,
            hasError: !1
        };
        try {
            _ts_add_disposable_resource(env12, _define_property({}, Symbol.asyncDispose, function() {
                return _async_to_generator(function() {
                    return _ts_generator(this, function(_state) {
                        return [
                            2
                        ];
                    });
                })();
            }), !0);
            break;
        } catch (e) {
            env12.error = e, env12.hasError = !0;
        } finally{
            var result11 = _ts_dispose_resources(env12);
            result11 && await result11;
        }
    }
    for(var x in {}){
        var env13 = {
            stack: [],
            error: void 0,
            hasError: !1
        };
        try {
            _ts_add_disposable_resource(env13, _define_property({}, Symbol.asyncDispose, function() {
                return _async_to_generator(function() {
                    return _ts_generator(this, function(_state) {
                        return [
                            2
                        ];
                    });
                })();
            }), !0);
        } catch (e) {
            env13.error = e, env13.hasError = !0;
        } finally{
            var result12 = _ts_dispose_resources(env13);
            result12 && await result12;
        }
    }
    for(var _i = 0, _iter = []; _i < _iter.length; _i++){
        _iter[_i];
        var env14 = {
            stack: [],
            error: void 0,
            hasError: !1
        };
        try {
            _ts_add_disposable_resource(env14, _define_property({}, Symbol.asyncDispose, function() {
                return _async_to_generator(function() {
                    return _ts_generator(this, function(_state) {
                        return [
                            2
                        ];
                    });
                })();
            }), !0);
        } catch (e) {
            env14.error = e, env14.hasError = !0;
        } finally{
            var result13 = _ts_dispose_resources(env14);
            result13 && await result13;
        }
    }
} catch (e) {
    env.error = e, env.hasError = !0;
} finally{
    var result14 = _ts_dispose_resources(env);
    result14 && await result14;
}
