class Base {
    constructor(o: object) {
        return o;
    }
}

class Sub extends Base {
    #field = 1;

    constructor(o: object) {
        super(o);
    }

    method() {}

    static run(o: object) {
        if (#field in o) {
            // 'o' is now of type 'Sub' but...
            o.method(); // Throws 'o.method is not a function'
        }
    }
}

const o = {};
new Sub(o);
Sub.run(o);

class Foo {
    #field = 1;
    #method() {}
    static #staticField = 2;
    static #staticMethod() {}

    check(v: any) {
        #field in v;
        #method in v;
        #staticField in v;
        #staticMethod in v;
    }
}

function syntaxError(v: Foo) {
    return #field in v;
}

var __classPrivateFieldIn = (this && this.__classPrivateFieldIn) || function(receiver, state) {
    if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object");
    return typeof state === "function" ? receiver === state : state.has(receiver);
};
var _Foo_instances, _a, _Foo_field, _Foo_method, _Foo_staticField, _Foo_staticMethod, _Bar_field;
class Foo {
    constructor() {
        _Foo_instances.add(this);
        _Foo_field.set(this, 1);
    }
    check(v) {
        __classPrivateFieldIn(v, _Foo_field);
        __classPrivateFieldIn(v, _Foo_instances);
        __classPrivateFieldIn(v, _a);
        __classPrivateFieldIn(v, _a);
    }
}
_a = Foo, _Foo_field = new WeakMap(), _Foo_instances = new WeakSet(), _Foo_method = function _Foo_method() { }, _Foo_staticMethod = function _Foo_staticMethod() { };
_Foo_staticField = { value: 2 };

function syntaxError(v) {
    return  in v;
}