//// [convertClassExpressionToFunctionFromObjectProperty2.ts]
({
    x: class {
        constructor() { }
    },
    y: class {
        constructor() { }
    },

    // keywords
    break: class {
        constructor() { }
    },
    case: class {
        constructor() { }
    },
    catch: class {
        constructor() { }
    },
    class: class {
        constructor() { }
    },
    const: class {
        constructor() { }
    },
    continue: class {
        constructor() { }
    },
    debugger: class {
        constructor() { }
    },
    default: class {
        constructor() { }
    },
    delete: class {
        constructor() { }
    },
    do: class {
        constructor() { }
    },
    else: class {
        constructor() { }
    },
    enum: class {
        constructor() { }
    },
    export: class {
        constructor() { }
    },
    extends: class {
        constructor() { }
    },
    false: class {
        constructor() { }
    },
    finally: class {
        constructor() { }
    },
    for: class {
        constructor() { }
    },
    function: class {
        constructor() { }
    },
    if: class {
        constructor() { }
    },
    import: class {
        constructor() { }
    },
    in: class {
        constructor() { }
    },
    instanceof: class {
        constructor() { }
    },
    new: class {
        constructor() { }
    },
    null: class {
        constructor() { }
    },
    return: class {
        constructor() { }
    },
    super: class {
        constructor() { }
    },
    switch: class {
        constructor() { }
    },
    this: class {
        constructor() { }
    },
    throw: class {
        constructor() { }
    },
    true: class {
        constructor() { }
    },
    try: class {
        constructor() { }
    },
    typeof: class {
        constructor() { }
    },
    var: class {
        constructor() { }
    },
    void: class {
        constructor() { }
    },
    while: class {
        constructor() { }
    },
    with: class {
        constructor() { }
    },
    implements: class {
        constructor() { }
    },
    interface: class {
        constructor() { }
    },
    let: class {
        constructor() { }
    },
    package: class {
        constructor() { }
    },
    private: class {
        constructor() { }
    },
    protected: class {
        constructor() { }
    },
    public: class {
        constructor() { }
    },
    static: class {
        constructor() { }
    },
    yield: class {
        constructor() { }
    },
    abstract: class {
        constructor() { }
    },
    as: class {
        constructor() { }
    },
    asserts: class {
        constructor() { }
    },
    any: class {
        constructor() { }
    },
    async: class {
        constructor() { }
    },
    await: class {
        constructor() { }
    },
    boolean: class {
        constructor() { }
    },
    constructor: class {
        constructor() { }
    },
    declare: class {
        constructor() { }
    },
    get: class {
        constructor() { }
    },
    infer: class {
        constructor() { }
    },
    is: class {
        constructor() { }
    },
    keyof: class {
        constructor() { }
    },
    module: class {
        constructor() { }
    },
    namespace: class {
        constructor() { }
    },
    never: class {
        constructor() { }
    },
    readonly: class {
        constructor() { }
    },
    require: class {
        constructor() { }
    },
    number: class {
        constructor() { }
    },
    object: class {
        constructor() { }
    },
    set: class {
        constructor() { }
    },
    string: class {
        constructor() { }
    },
    symbol: class {
        constructor() { }
    },
    type: class {
        constructor() { }
    },
    undefined: class {
        constructor() { }
    },
    unique: class {
        constructor() { }
    },
    unknown: class {
        constructor() { }
    },
    from: class {
        constructor() { }
    },
    global: class {
        constructor() { }
    },
    bigint: class {
        constructor() { }
    },
    of: class {
        constructor() { }
    }
})


//// [convertClassExpressionToFunctionFromObjectProperty2.js]
({
    x: /** @class */ (function () {
        function x() {
        }
        return x;
    }()),
    y: /** @class */ (function () {
        function y() {
        }
        return y;
    }()),
    // keywords
    break: /** @class */ (function () {
        function break_1() {
        }
        return break_1;
    }()),
    case: /** @class */ (function () {
        function case_1() {
        }
        return case_1;
    }()),
    catch: /** @class */ (function () {
        function catch_1() {
        }
        return catch_1;
    }()),
    class: /** @class */ (function () {
        function class_1() {
        }
        return class_1;
    }()),
    const: /** @class */ (function () {
        function const_1() {
        }
        return const_1;
    }()),
    continue: /** @class */ (function () {
        function continue_1() {
        }
        return continue_1;
    }()),
    debugger: /** @class */ (function () {
        function debugger_1() {
        }
        return debugger_1;
    }()),
    default: /** @class */ (function () {
        function default_1() {
        }
        return default_1;
    }()),
    delete: /** @class */ (function () {
        function delete_1() {
        }
        return delete_1;
    }()),
    do: /** @class */ (function () {
        function do_1() {
        }
        return do_1;
    }()),
    else: /** @class */ (function () {
        function else_1() {
        }
        return else_1;
    }()),
    enum: /** @class */ (function () {
        function enum_1() {
        }
        return enum_1;
    }()),
    export: /** @class */ (function () {
        function export_1() {
        }
        return export_1;
    }()),
    extends: /** @class */ (function () {
        function extends_1() {
        }
        return extends_1;
    }()),
    false: /** @class */ (function () {
        function false_1() {
        }
        return false_1;
    }()),
    finally: /** @class */ (function () {
        function finally_1() {
        }
        return finally_1;
    }()),
    for: /** @class */ (function () {
        function for_1() {
        }
        return for_1;
    }()),
    function: /** @class */ (function () {
        function function_1() {
        }
        return function_1;
    }()),
    if: /** @class */ (function () {
        function if_1() {
        }
        return if_1;
    }()),
    import: /** @class */ (function () {
        function import_1() {
        }
        return import_1;
    }()),
    in: /** @class */ (function () {
        function in_1() {
        }
        return in_1;
    }()),
    instanceof: /** @class */ (function () {
        function instanceof_1() {
        }
        return instanceof_1;
    }()),
    new: /** @class */ (function () {
        function new_1() {
        }
        return new_1;
    }()),
    null: /** @class */ (function () {
        function null_1() {
        }
        return null_1;
    }()),
    return: /** @class */ (function () {
        function return_1() {
        }
        return return_1;
    }()),
    super: /** @class */ (function () {
        function super_1() {
        }
        return super_1;
    }()),
    switch: /** @class */ (function () {
        function switch_1() {
        }
        return switch_1;
    }()),
    this: /** @class */ (function () {
        function this_1() {
        }
        return this_1;
    }()),
    throw: /** @class */ (function () {
        function throw_1() {
        }
        return throw_1;
    }()),
    true: /** @class */ (function () {
        function true_1() {
        }
        return true_1;
    }()),
    try: /** @class */ (function () {
        function try_1() {
        }
        return try_1;
    }()),
    typeof: /** @class */ (function () {
        function typeof_1() {
        }
        return typeof_1;
    }()),
    var: /** @class */ (function () {
        function var_1() {
        }
        return var_1;
    }()),
    void: /** @class */ (function () {
        function void_1() {
        }
        return void_1;
    }()),
    while: /** @class */ (function () {
        function while_1() {
        }
        return while_1;
    }()),
    with: /** @class */ (function () {
        function with_1() {
        }
        return with_1;
    }()),
    implements: /** @class */ (function () {
        function implements_1() {
        }
        return implements_1;
    }()),
    interface: /** @class */ (function () {
        function interface_1() {
        }
        return interface_1;
    }()),
    let: /** @class */ (function () {
        function let_1() {
        }
        return let_1;
    }()),
    package: /** @class */ (function () {
        function package_1() {
        }
        return package_1;
    }()),
    private: /** @class */ (function () {
        function private_1() {
        }
        return private_1;
    }()),
    protected: /** @class */ (function () {
        function protected_1() {
        }
        return protected_1;
    }()),
    public: /** @class */ (function () {
        function public_1() {
        }
        return public_1;
    }()),
    static: /** @class */ (function () {
        function static_1() {
        }
        return static_1;
    }()),
    yield: /** @class */ (function () {
        function yield_1() {
        }
        return yield_1;
    }()),
    abstract: /** @class */ (function () {
        function abstract() {
        }
        return abstract;
    }()),
    as: /** @class */ (function () {
        function as() {
        }
        return as;
    }()),
    asserts: /** @class */ (function () {
        function asserts() {
        }
        return asserts;
    }()),
    any: /** @class */ (function () {
        function any() {
        }
        return any;
    }()),
    async: /** @class */ (function () {
        function async() {
        }
        return async;
    }()),
    await: /** @class */ (function () {
        function await() {
        }
        return await;
    }()),
    boolean: /** @class */ (function () {
        function boolean() {
        }
        return boolean;
    }()),
    constructor: /** @class */ (function () {
        function constructor() {
        }
        return constructor;
    }()),
    declare: /** @class */ (function () {
        function declare() {
        }
        return declare;
    }()),
    get: /** @class */ (function () {
        function get() {
        }
        return get;
    }()),
    infer: /** @class */ (function () {
        function infer() {
        }
        return infer;
    }()),
    is: /** @class */ (function () {
        function is() {
        }
        return is;
    }()),
    keyof: /** @class */ (function () {
        function keyof() {
        }
        return keyof;
    }()),
    module: /** @class */ (function () {
        function module() {
        }
        return module;
    }()),
    namespace: /** @class */ (function () {
        function namespace() {
        }
        return namespace;
    }()),
    never: /** @class */ (function () {
        function never() {
        }
        return never;
    }()),
    readonly: /** @class */ (function () {
        function readonly() {
        }
        return readonly;
    }()),
    require: /** @class */ (function () {
        function require() {
        }
        return require;
    }()),
    number: /** @class */ (function () {
        function number() {
        }
        return number;
    }()),
    object: /** @class */ (function () {
        function object() {
        }
        return object;
    }()),
    set: /** @class */ (function () {
        function set() {
        }
        return set;
    }()),
    string: /** @class */ (function () {
        function string() {
        }
        return string;
    }()),
    symbol: /** @class */ (function () {
        function symbol() {
        }
        return symbol;
    }()),
    type: /** @class */ (function () {
        function type() {
        }
        return type;
    }()),
    undefined: /** @class */ (function () {
        function undefined() {
        }
        return undefined;
    }()),
    unique: /** @class */ (function () {
        function unique() {
        }
        return unique;
    }()),
    unknown: /** @class */ (function () {
        function unknown() {
        }
        return unknown;
    }()),
    from: /** @class */ (function () {
        function from() {
        }
        return from;
    }()),
    global: /** @class */ (function () {
        function global() {
        }
        return global;
    }()),
    bigint: /** @class */ (function () {
        function bigint() {
        }
        return bigint;
    }()),
    of: /** @class */ (function () {
        function of() {
        }
        return of;
    }())
});
