Check internal properties reported in object preview.

Running test: boxedObjects
expression: new Number(239)
{
    name : [[PrimitiveValue]]
    type : number
    value : 239
}

expression: new Boolean(false)
{
    name : [[PrimitiveValue]]
    type : boolean
    value : false
}

expression: new String("abc")
{
    name : [[PrimitiveValue]]
    type : string
    value : abc
}

expression: Object(Symbol(42))
{
    name : [[PrimitiveValue]]
    type : symbol
    value : Symbol(42)
}
{
    name : description
    type : string
    value : 42
}

expression: Object(BigInt(2))
{
    name : [[PrimitiveValue]]
    type : bigint
    value : 2n
}


Running test: promise
expression: Promise.resolve(42)
{
    name : [[PromiseState]]
    type : string
    value : fulfilled
}
{
    name : [[PromiseResult]]
    type : number
    value : 42
}

expression: new Promise(() => undefined)
{
    name : [[PromiseState]]
    type : string
    value : pending
}
{
    name : [[PromiseResult]]
    type : undefined
    value : undefined
}


Running test: generatorObject
expression: (function* foo() { yield 1 })()
{
    name : [[GeneratorState]]
    type : string
    value : suspended
}


Running test: entriesInMapAndSet
expression: new Map([[1,2]])
{
    name : size
    type : number
    value : 1
}
[[Entries]]:
[
    [0] : {
        key : {
            description : 1
            overflow : false
            properties : [
            ]
            type : number
        }
        value : {
            description : 2
            overflow : false
            properties : [
            ]
            type : number
        }
    }
]

expression: new Set([1])
{
    name : size
    type : number
    value : 1
}
[[Entries]]:
[
    [0] : {
        value : {
            description : 1
            overflow : false
            properties : [
            ]
            type : number
        }
    }
]

expression: new WeakMap([[{}, 42]])
[[Entries]]:
[
    [0] : {
        key : {
            description : Object
            overflow : false
            properties : [
            ]
            type : object
        }
        value : {
            description : 42
            overflow : false
            properties : [
            ]
            type : number
        }
    }
]

expression: new WeakSet([{}])
[[Entries]]:
[
    [0] : {
        value : {
            description : Object
            overflow : false
            properties : [
            ]
            type : object
        }
    }
]


Running test: symbolsAsKeysInEntries
expression: new Map([[Symbol('key1'), 1]])
{
    name : size
    type : number
    value : 1
}
[[Entries]]:
[
    [0] : {
        key : {
            description : Symbol(key1)
            overflow : false
            properties : [
            ]
            type : symbol
        }
        value : {
            description : 1
            overflow : false
            properties : [
            ]
            type : number
        }
    }
]

expression: new Set([Symbol('key2')])
{
    name : size
    type : number
    value : 1
}
[[Entries]]:
[
    [0] : {
        value : {
            description : Symbol(key2)
            overflow : false
            properties : [
            ]
            type : symbol
        }
    }
]

expression: new WeakMap([[Symbol('key3'), 2]])
[[Entries]]:
[
    [0] : {
        key : {
            description : Symbol(key3)
            overflow : false
            properties : [
            ]
            type : symbol
        }
        value : {
            description : 2
            overflow : false
            properties : [
            ]
            type : number
        }
    }
]

expression: new WeakSet([Symbol('key4')])
[[Entries]]:
[
    [0] : {
        value : {
            description : Symbol(key4)
            overflow : false
            properties : [
            ]
            type : symbol
        }
    }
]


Running test: iteratorObject
expression: (new Map([[1,2]])).entries()
[[Entries]]:
[
    [0] : {
        key : {
            description : 1
            overflow : false
            properties : [
            ]
            type : number
        }
        value : {
            description : 2
            overflow : false
            properties : [
            ]
            type : number
        }
    }
]

expression: (new Set([1,2])).entries()
[[Entries]]:
[
    [0] : {
        key : {
            description : 1
            overflow : false
            properties : [
            ]
            type : number
        }
        value : {
            description : 1
            overflow : false
            properties : [
            ]
            type : number
        }
    }
    [1] : {
        key : {
            description : 2
            overflow : false
            properties : [
            ]
            type : number
        }
        value : {
            description : 2
            overflow : false
            properties : [
            ]
            type : number
        }
    }
]


Running test: noPreviewForFunctionObject
(function foo(){})
{
    id : <messageId>
    result : {
        result : {
            className : Function
            description : function foo(){}
            objectId : <objectId>
            type : function
        }
    }
}

Running test: otherObjects
expression: [1,2,3]
{
    name : 0
    type : number
    value : 1
}
{
    name : 1
    type : number
    value : 2
}
{
    name : 2
    type : number
    value : 3
}

expression: /123/
{
    name : lastIndex
    type : number
    value : 0
}
{
    name : dotAll
    type : boolean
    value : false
}
{
    name : flags
    type : string
    value :
}
{
    name : global
    type : boolean
    value : false
}
{
    name : hasIndices
    type : boolean
    value : false
}
{
    name : ignoreCase
    type : boolean
    value : false
}
{
    name : multiline
    type : boolean
    value : false
}
{
    name : source
    type : string
    value : 123
}
{
    name : sticky
    type : boolean
    value : false
}
{
    name : unicode
    type : boolean
    value : false
}
{
    name : unicodeSets
    type : boolean
    value : false
}

expression: ({})

expression: Boolean.prototype
{
    name : [[PrimitiveValue]]
    type : boolean
    value : false
}
{
    name : toString
    type : function
    value :
}
{
    name : valueOf
    type : function
    value :
}


Running test: overridenArrayGetter
expression: Promise.resolve(42)
{
    name : [[PromiseState]]
    type : string
    value : fulfilled
}
{
    name : [[PromiseResult]]
    type : number
    value : 42
}


Running test: privateNames
expression: new class { #foo = 1; #bar = 2; baz = 3;}
{
    name : #foo
    type : number
    value : 1
}
{
    name : #bar
    type : number
    value : 2
}
{
    name : baz
    type : number
    value : 3
}

expression: new class extends class { #baz = 3; } { #foo = 1; #bar = 2; }
{
    name : #baz
    type : number
    value : 3
}
{
    name : #foo
    type : number
    value : 1
}
{
    name : #bar
    type : number
    value : 2
}

expression: new class extends class { constructor() { return new Proxy({}, {}); } } { #foo = 1; #bar = 2; }


Running test: functionProxy
expression: new Proxy(() => {}, { get: () => x++ })
{
    name : length
    type : number
    value : 0
}
{
    name : name
    type : string
    value :
}

