func (o *Object) OrdinaryDefineOwnProperty(p StringOrSymbol, desc *Property) Boolean {
	current := o.GetOwnProperty(p)
	extensible := o.Extensible
	return o.ValidateAndApplyPropertyDescriptor(p, extensible, desc, current)
}
OrdinaryDefineOwnProperty is used to define an own property of the object.
OrdinaryDefineOwnProperty is specified in 9.1.6.1.
package lang
import (
	"reflect"
	"strconv"
	"github.com/gojisvm/gojis/internal/runtime/errors"
)
var _ Value = (*Object)(nil)  
type FunctionMode uint8
const (
	FunctionModeUnknown FunctionMode = iota
	FunctionModeLexical
	FunctionModeStrict
	FunctionModeGlobal
)
type FunctionKind uint8
const (
	FunctionKindUnknown FunctionKind = iota
	FunctionKindNormal
	FunctionKindClassGenerator
	FunctionKindGenerator
	FunctionKindAsync
)
type ConstructorKind uint8
const (
	ConstructorKindUnknown ConstructorKind = iota
	ConstructorKindBase
	ConstructorKindDerived
)
type Object struct {
	fields map[StringOrSymbol]*Property
	slots  map[StringOrSymbol]Value
	Prototype  Value  
	Extensible bool
	Environment      InternalValue
	FormalParameters interface{}
	FunctionKind     FunctionKind
	ConstructorKind  ConstructorKind
	Realm            InternalValue
	ScriptOrModule   interface{}
	ThisMode         FunctionMode
	Strict           bool
	HomeObject       *Object
	Call NativeFunction
	Construct func(*Object, ...Value) (*Object, errors.Error)
}
func ObjectCreate(proto Value, internalSlotsList ...StringOrSymbol) *Object {
	if internalSlotsList == nil {
		internalSlotsList = []StringOrSymbol{}
	}
	obj := new(Object)
	obj.fields = make(map[StringOrSymbol]*Property)
	obj.slots = make(map[StringOrSymbol]Value)
	for _, slot := range internalSlotsList {
		obj.slots[slot] = Undefined
	}
	EnsureTypeOneOf(proto, TypeObject, TypeNull)  
	obj.Prototype = proto
	obj.Extensible = true
	return obj
}
func (o *Object) Value() interface{} { return o }
func (o *Object) Type() Type { return TypeObject }
func (o *Object) GetPrototypeOf() Value {
	return o.OrdinaryGetPrototypeOf()
}
func (o *Object) OrdinaryGetPrototypeOf() Value {
	return o.Prototype
}
func (o *Object) SetPrototypeOf(v Value) Boolean {
	return o.OrdinarySetPrototypeOf(v)
}
func (o *Object) OrdinarySetPrototypeOf(v Value) Boolean {
	EnsureTypeOneOf(v, TypeObject, TypeNull)
	extensible := o.Extensible
	current := o.Prototype
	if InternalSameValue(v, current) {
		return True
	}
	if !extensible {
		return False
	}
	p := v
	done := false
	for !done {
		if p == Null {
			done = true
		} else if InternalSameValue(p, o) {
			return False
		} else {
			p = p.(*Object).Prototype  
		}
	}
	o.Prototype = v
	return True
}
func (o *Object) IsExtensible() Boolean {
	return o.OrdinaryIsExtensible()
}
func (o *Object) OrdinaryIsExtensible() Boolean {
	return Boolean(o.Extensible)
}
func (o *Object) PreventExtensions() Boolean {
	return o.OrdinaryPreventExtensions()
}
func (o *Object) OrdinaryPreventExtensions() Boolean {
	o.Extensible = false
	return True
}
func (o *Object) GetOwnProperty(p StringOrSymbol) *Property {
	return o.OrdinaryGetOwnProperty(p)
}
func (o *Object) OrdinaryGetOwnProperty(p StringOrSymbol) *Property {
	x, ok := o.fields[p]
	if !ok {
		return nil  
	}
	d := NewProperty()
	if x.IsDataDescriptor() {
		d.SetField(FieldNameValue, x.Value())
		d.SetField(FieldNameWritable, x.Writable())
	} else if x.IsAccessorDescriptor() {
		d.SetField(FieldNameGet, x.Get())
		d.SetField(FieldNameSet, x.Set())
	}
	d.SetField(FieldNameEnumerable, x.Enumerable())
	d.SetField(FieldNameConfigurable, x.Configurable())
	return d
}
func (o *Object) DefineOwnProperty(p StringOrSymbol, desc *Property) Boolean {
	return o.OrdinaryDefineOwnProperty(p, desc)
}