1795 lines
47 KiB
Go
1795 lines
47 KiB
Go
package goja
|
|
|
|
import (
|
|
"math"
|
|
"sort"
|
|
"sync"
|
|
)
|
|
|
|
func (r *Runtime) newArray(prototype *Object) (a *arrayObject) {
|
|
v := &Object{runtime: r}
|
|
|
|
a = &arrayObject{}
|
|
a.class = classArray
|
|
a.val = v
|
|
a.extensible = true
|
|
v.self = a
|
|
a.prototype = prototype
|
|
a.init()
|
|
return
|
|
}
|
|
|
|
func (r *Runtime) newArrayObject() *arrayObject {
|
|
return r.newArray(r.getArrayPrototype())
|
|
}
|
|
|
|
func setArrayValues(a *arrayObject, values []Value) *arrayObject {
|
|
a.values = values
|
|
a.length = uint32(len(values))
|
|
a.objCount = len(values)
|
|
return a
|
|
}
|
|
|
|
func setArrayLength(a *arrayObject, l int64) *arrayObject {
|
|
a.setOwnStr("length", intToValue(l), true)
|
|
return a
|
|
}
|
|
|
|
func arraySpeciesCreate(obj *Object, size int64) *Object {
|
|
if isArray(obj) {
|
|
v := obj.self.getStr("constructor", nil)
|
|
if constructObj, ok := v.(*Object); ok {
|
|
v = constructObj.self.getSym(SymSpecies, nil)
|
|
if v == _null {
|
|
v = nil
|
|
}
|
|
}
|
|
|
|
if v != nil && v != _undefined {
|
|
constructObj, _ := v.(*Object)
|
|
if constructObj != nil {
|
|
if constructor := constructObj.self.assertConstructor(); constructor != nil {
|
|
return constructor([]Value{intToValue(size)}, constructObj)
|
|
}
|
|
}
|
|
panic(obj.runtime.NewTypeError("Species is not a constructor"))
|
|
}
|
|
}
|
|
return obj.runtime.newArrayLength(size)
|
|
}
|
|
|
|
func max(a, b int64) int64 {
|
|
if a > b {
|
|
return a
|
|
}
|
|
return b
|
|
}
|
|
|
|
func min(a, b int64) int64 {
|
|
if a < b {
|
|
return a
|
|
}
|
|
return b
|
|
}
|
|
|
|
func relToIdx(rel, l int64) int64 {
|
|
if rel >= 0 {
|
|
return min(rel, l)
|
|
}
|
|
return max(l+rel, 0)
|
|
}
|
|
|
|
func (r *Runtime) newArrayValues(values []Value) *Object {
|
|
return setArrayValues(r.newArrayObject(), values).val
|
|
}
|
|
|
|
func (r *Runtime) newArrayLength(l int64) *Object {
|
|
return setArrayLength(r.newArrayObject(), l).val
|
|
}
|
|
|
|
func (r *Runtime) builtin_newArray(args []Value, proto *Object) *Object {
|
|
l := len(args)
|
|
if l == 1 {
|
|
if al, ok := args[0].(valueInt); ok {
|
|
return setArrayLength(r.newArray(proto), int64(al)).val
|
|
} else if f, ok := args[0].(valueFloat); ok {
|
|
al := int64(f)
|
|
if float64(al) == float64(f) {
|
|
return r.newArrayLength(al)
|
|
} else {
|
|
panic(r.newError(r.getRangeError(), "Invalid array length"))
|
|
}
|
|
}
|
|
return setArrayValues(r.newArray(proto), []Value{args[0]}).val
|
|
} else {
|
|
argsCopy := make([]Value, l)
|
|
copy(argsCopy, args)
|
|
return setArrayValues(r.newArray(proto), argsCopy).val
|
|
}
|
|
}
|
|
|
|
func (r *Runtime) generic_push(obj *Object, call FunctionCall) Value {
|
|
l := toLength(obj.self.getStr("length", nil))
|
|
nl := l + int64(len(call.Arguments))
|
|
if nl >= maxInt {
|
|
r.typeErrorResult(true, "Invalid array length")
|
|
panic("unreachable")
|
|
}
|
|
for i, arg := range call.Arguments {
|
|
obj.self.setOwnIdx(valueInt(l+int64(i)), arg, true)
|
|
}
|
|
n := valueInt(nl)
|
|
obj.self.setOwnStr("length", n, true)
|
|
return n
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_push(call FunctionCall) Value {
|
|
obj := call.This.ToObject(r)
|
|
return r.generic_push(obj, call)
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_pop_generic(obj *Object) Value {
|
|
l := toLength(obj.self.getStr("length", nil))
|
|
if l == 0 {
|
|
obj.self.setOwnStr("length", intToValue(0), true)
|
|
return _undefined
|
|
}
|
|
idx := valueInt(l - 1)
|
|
val := obj.self.getIdx(idx, nil)
|
|
obj.self.deleteIdx(idx, true)
|
|
obj.self.setOwnStr("length", idx, true)
|
|
return val
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_pop(call FunctionCall) Value {
|
|
obj := call.This.ToObject(r)
|
|
if a, ok := obj.self.(*arrayObject); ok {
|
|
l := a.length
|
|
var val Value
|
|
if l > 0 {
|
|
l--
|
|
if l < uint32(len(a.values)) {
|
|
val = a.values[l]
|
|
}
|
|
if val == nil {
|
|
// optimisation bail-out
|
|
return r.arrayproto_pop_generic(obj)
|
|
}
|
|
if _, ok := val.(*valueProperty); ok {
|
|
// optimisation bail-out
|
|
return r.arrayproto_pop_generic(obj)
|
|
}
|
|
//a._setLengthInt(l, false)
|
|
a.values[l] = nil
|
|
a.values = a.values[:l]
|
|
} else {
|
|
val = _undefined
|
|
}
|
|
if a.lengthProp.writable {
|
|
a.length = l
|
|
} else {
|
|
a.setLength(0, true) // will throw
|
|
}
|
|
return val
|
|
} else {
|
|
return r.arrayproto_pop_generic(obj)
|
|
}
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_join(call FunctionCall) Value {
|
|
o := call.This.ToObject(r)
|
|
l := int(toLength(o.self.getStr("length", nil)))
|
|
var sep String
|
|
if s := call.Argument(0); s != _undefined {
|
|
sep = s.toString()
|
|
} else {
|
|
sep = asciiString(",")
|
|
}
|
|
if l == 0 {
|
|
return stringEmpty
|
|
}
|
|
|
|
var buf StringBuilder
|
|
|
|
element0 := o.self.getIdx(valueInt(0), nil)
|
|
if element0 != nil && element0 != _undefined && element0 != _null {
|
|
buf.WriteString(element0.toString())
|
|
}
|
|
|
|
for i := 1; i < l; i++ {
|
|
buf.WriteString(sep)
|
|
element := o.self.getIdx(valueInt(int64(i)), nil)
|
|
if element != nil && element != _undefined && element != _null {
|
|
buf.WriteString(element.toString())
|
|
}
|
|
}
|
|
|
|
return buf.String()
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_toString(call FunctionCall) Value {
|
|
array := call.This.ToObject(r)
|
|
var toString func() Value
|
|
switch a := array.self.(type) {
|
|
case *objectGoSliceReflect:
|
|
toString = a.toString
|
|
case *objectGoArrayReflect:
|
|
toString = a.toString
|
|
}
|
|
if toString != nil {
|
|
return toString()
|
|
}
|
|
f := array.self.getStr("join", nil)
|
|
if fObj, ok := f.(*Object); ok {
|
|
if fcall, ok := fObj.self.assertCallable(); ok {
|
|
return fcall(FunctionCall{
|
|
This: array,
|
|
})
|
|
}
|
|
}
|
|
return r.objectproto_toString(FunctionCall{
|
|
This: array,
|
|
})
|
|
}
|
|
|
|
func (r *Runtime) writeItemLocaleString(item Value, buf *StringBuilder) {
|
|
if item != nil && item != _undefined && item != _null {
|
|
if f, ok := r.getVStr(item, "toLocaleString").(*Object); ok {
|
|
if c, ok := f.self.assertCallable(); ok {
|
|
strVal := c(FunctionCall{
|
|
This: item,
|
|
})
|
|
buf.WriteString(strVal.toString())
|
|
return
|
|
}
|
|
}
|
|
r.typeErrorResult(true, "Property 'toLocaleString' of object %s is not a function", item)
|
|
}
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_toLocaleString(call FunctionCall) Value {
|
|
array := call.This.ToObject(r)
|
|
var buf StringBuilder
|
|
if a := r.checkStdArrayObj(array); a != nil {
|
|
for i, item := range a.values {
|
|
if i > 0 {
|
|
buf.WriteRune(',')
|
|
}
|
|
r.writeItemLocaleString(item, &buf)
|
|
}
|
|
} else {
|
|
length := toLength(array.self.getStr("length", nil))
|
|
for i := int64(0); i < length; i++ {
|
|
if i > 0 {
|
|
buf.WriteRune(',')
|
|
}
|
|
item := array.self.getIdx(valueInt(i), nil)
|
|
r.writeItemLocaleString(item, &buf)
|
|
}
|
|
}
|
|
|
|
return buf.String()
|
|
}
|
|
|
|
func isConcatSpreadable(obj *Object) bool {
|
|
spreadable := obj.self.getSym(SymIsConcatSpreadable, nil)
|
|
if spreadable != nil && spreadable != _undefined {
|
|
return spreadable.ToBoolean()
|
|
}
|
|
return isArray(obj)
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_concat_append(a *Object, item Value) {
|
|
aLength := toLength(a.self.getStr("length", nil))
|
|
if obj, ok := item.(*Object); ok && isConcatSpreadable(obj) {
|
|
length := toLength(obj.self.getStr("length", nil))
|
|
if aLength+length >= maxInt {
|
|
panic(r.NewTypeError("Invalid array length"))
|
|
}
|
|
for i := int64(0); i < length; i++ {
|
|
v := obj.self.getIdx(valueInt(i), nil)
|
|
if v != nil {
|
|
createDataPropertyOrThrow(a, intToValue(aLength), v)
|
|
}
|
|
aLength++
|
|
}
|
|
} else {
|
|
createDataPropertyOrThrow(a, intToValue(aLength), item)
|
|
aLength++
|
|
}
|
|
a.self.setOwnStr("length", intToValue(aLength), true)
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_concat(call FunctionCall) Value {
|
|
obj := call.This.ToObject(r)
|
|
a := arraySpeciesCreate(obj, 0)
|
|
r.arrayproto_concat_append(a, call.This.ToObject(r))
|
|
for _, item := range call.Arguments {
|
|
r.arrayproto_concat_append(a, item)
|
|
}
|
|
return a
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_slice(call FunctionCall) Value {
|
|
o := call.This.ToObject(r)
|
|
length := toLength(o.self.getStr("length", nil))
|
|
start := relToIdx(call.Argument(0).ToInteger(), length)
|
|
var end int64
|
|
if endArg := call.Argument(1); endArg != _undefined {
|
|
end = endArg.ToInteger()
|
|
} else {
|
|
end = length
|
|
}
|
|
end = relToIdx(end, length)
|
|
|
|
count := end - start
|
|
if count < 0 {
|
|
count = 0
|
|
}
|
|
|
|
a := arraySpeciesCreate(o, count)
|
|
if src := r.checkStdArrayObj(o); src != nil {
|
|
if dst := r.checkStdArrayObjWithProto(a); dst != nil {
|
|
values := make([]Value, count)
|
|
copy(values, src.values[start:])
|
|
setArrayValues(dst, values)
|
|
return a
|
|
}
|
|
}
|
|
|
|
n := int64(0)
|
|
for start < end {
|
|
p := o.self.getIdx(valueInt(start), nil)
|
|
if p != nil {
|
|
createDataPropertyOrThrow(a, valueInt(n), p)
|
|
}
|
|
start++
|
|
n++
|
|
}
|
|
return a
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_sort(call FunctionCall) Value {
|
|
o := call.This.ToObject(r)
|
|
|
|
var compareFn func(FunctionCall) Value
|
|
arg := call.Argument(0)
|
|
if arg != _undefined {
|
|
if arg, ok := call.Argument(0).(*Object); ok {
|
|
compareFn, _ = arg.self.assertCallable()
|
|
}
|
|
if compareFn == nil {
|
|
panic(r.NewTypeError("The comparison function must be either a function or undefined"))
|
|
}
|
|
}
|
|
|
|
var s sortable
|
|
if r.checkStdArrayObj(o) != nil {
|
|
s = o.self
|
|
} else if _, ok := o.self.(reflectValueWrapper); ok {
|
|
s = o.self
|
|
}
|
|
|
|
if s != nil {
|
|
ctx := arraySortCtx{
|
|
obj: s,
|
|
compare: compareFn,
|
|
}
|
|
|
|
sort.Stable(&ctx)
|
|
} else {
|
|
length := toLength(o.self.getStr("length", nil))
|
|
a := make([]Value, 0, length)
|
|
for i := int64(0); i < length; i++ {
|
|
idx := valueInt(i)
|
|
if o.self.hasPropertyIdx(idx) {
|
|
a = append(a, nilSafe(o.self.getIdx(idx, nil)))
|
|
}
|
|
}
|
|
ar := r.newArrayValues(a)
|
|
ctx := arraySortCtx{
|
|
obj: ar.self,
|
|
compare: compareFn,
|
|
}
|
|
|
|
sort.Stable(&ctx)
|
|
for i := 0; i < len(a); i++ {
|
|
o.self.setOwnIdx(valueInt(i), a[i], true)
|
|
}
|
|
for i := int64(len(a)); i < length; i++ {
|
|
o.self.deleteIdx(valueInt(i), true)
|
|
}
|
|
}
|
|
return o
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_splice(call FunctionCall) Value {
|
|
o := call.This.ToObject(r)
|
|
length := toLength(o.self.getStr("length", nil))
|
|
actualStart := relToIdx(call.Argument(0).ToInteger(), length)
|
|
var actualDeleteCount int64
|
|
switch len(call.Arguments) {
|
|
case 0:
|
|
case 1:
|
|
actualDeleteCount = length - actualStart
|
|
default:
|
|
actualDeleteCount = min(max(call.Argument(1).ToInteger(), 0), length-actualStart)
|
|
}
|
|
itemCount := max(int64(len(call.Arguments)-2), 0)
|
|
newLength := length - actualDeleteCount + itemCount
|
|
if newLength >= maxInt {
|
|
panic(r.NewTypeError("Invalid array length"))
|
|
}
|
|
a := arraySpeciesCreate(o, actualDeleteCount)
|
|
if src := r.checkStdArrayObj(o); src != nil {
|
|
if dst := r.checkStdArrayObjWithProto(a); dst != nil {
|
|
values := make([]Value, actualDeleteCount)
|
|
copy(values, src.values[actualStart:])
|
|
setArrayValues(dst, values)
|
|
} else {
|
|
for k := int64(0); k < actualDeleteCount; k++ {
|
|
createDataPropertyOrThrow(a, intToValue(k), src.values[k+actualStart])
|
|
}
|
|
a.self.setOwnStr("length", intToValue(actualDeleteCount), true)
|
|
}
|
|
var values []Value
|
|
if itemCount < actualDeleteCount {
|
|
values = src.values
|
|
copy(values[actualStart+itemCount:], values[actualStart+actualDeleteCount:])
|
|
tail := values[newLength:]
|
|
for k := range tail {
|
|
tail[k] = nil
|
|
}
|
|
values = values[:newLength]
|
|
} else if itemCount > actualDeleteCount {
|
|
if int64(cap(src.values)) >= newLength {
|
|
values = src.values[:newLength]
|
|
copy(values[actualStart+itemCount:], values[actualStart+actualDeleteCount:length])
|
|
} else {
|
|
values = make([]Value, newLength)
|
|
copy(values, src.values[:actualStart])
|
|
copy(values[actualStart+itemCount:], src.values[actualStart+actualDeleteCount:])
|
|
}
|
|
} else {
|
|
values = src.values
|
|
}
|
|
if itemCount > 0 {
|
|
copy(values[actualStart:], call.Arguments[2:])
|
|
}
|
|
src.values = values
|
|
src.objCount = len(values)
|
|
} else {
|
|
for k := int64(0); k < actualDeleteCount; k++ {
|
|
from := valueInt(k + actualStart)
|
|
if o.self.hasPropertyIdx(from) {
|
|
createDataPropertyOrThrow(a, valueInt(k), nilSafe(o.self.getIdx(from, nil)))
|
|
}
|
|
}
|
|
|
|
if itemCount < actualDeleteCount {
|
|
for k := actualStart; k < length-actualDeleteCount; k++ {
|
|
from := valueInt(k + actualDeleteCount)
|
|
to := valueInt(k + itemCount)
|
|
if o.self.hasPropertyIdx(from) {
|
|
o.self.setOwnIdx(to, nilSafe(o.self.getIdx(from, nil)), true)
|
|
} else {
|
|
o.self.deleteIdx(to, true)
|
|
}
|
|
}
|
|
|
|
for k := length; k > length-actualDeleteCount+itemCount; k-- {
|
|
o.self.deleteIdx(valueInt(k-1), true)
|
|
}
|
|
} else if itemCount > actualDeleteCount {
|
|
for k := length - actualDeleteCount; k > actualStart; k-- {
|
|
from := valueInt(k + actualDeleteCount - 1)
|
|
to := valueInt(k + itemCount - 1)
|
|
if o.self.hasPropertyIdx(from) {
|
|
o.self.setOwnIdx(to, nilSafe(o.self.getIdx(from, nil)), true)
|
|
} else {
|
|
o.self.deleteIdx(to, true)
|
|
}
|
|
}
|
|
}
|
|
|
|
if itemCount > 0 {
|
|
for i, item := range call.Arguments[2:] {
|
|
o.self.setOwnIdx(valueInt(actualStart+int64(i)), item, true)
|
|
}
|
|
}
|
|
}
|
|
|
|
o.self.setOwnStr("length", intToValue(newLength), true)
|
|
|
|
return a
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_unshift(call FunctionCall) Value {
|
|
o := call.This.ToObject(r)
|
|
length := toLength(o.self.getStr("length", nil))
|
|
argCount := int64(len(call.Arguments))
|
|
newLen := intToValue(length + argCount)
|
|
if argCount > 0 {
|
|
newSize := length + argCount
|
|
if newSize >= maxInt {
|
|
panic(r.NewTypeError("Invalid array length"))
|
|
}
|
|
if arr := r.checkStdArrayObjWithProto(o); arr != nil && newSize < math.MaxUint32 {
|
|
if int64(cap(arr.values)) >= newSize {
|
|
arr.values = arr.values[:newSize]
|
|
copy(arr.values[argCount:], arr.values[:length])
|
|
} else {
|
|
values := make([]Value, newSize)
|
|
copy(values[argCount:], arr.values)
|
|
arr.values = values
|
|
}
|
|
copy(arr.values, call.Arguments)
|
|
arr.objCount = int(arr.length)
|
|
} else {
|
|
for k := length - 1; k >= 0; k-- {
|
|
from := valueInt(k)
|
|
to := valueInt(k + argCount)
|
|
if o.self.hasPropertyIdx(from) {
|
|
o.self.setOwnIdx(to, nilSafe(o.self.getIdx(from, nil)), true)
|
|
} else {
|
|
o.self.deleteIdx(to, true)
|
|
}
|
|
}
|
|
|
|
for k, arg := range call.Arguments {
|
|
o.self.setOwnIdx(valueInt(int64(k)), arg, true)
|
|
}
|
|
}
|
|
}
|
|
|
|
o.self.setOwnStr("length", newLen, true)
|
|
return newLen
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_at(call FunctionCall) Value {
|
|
o := call.This.ToObject(r)
|
|
idx := call.Argument(0).ToInteger()
|
|
length := toLength(o.self.getStr("length", nil))
|
|
if idx < 0 {
|
|
idx = length + idx
|
|
}
|
|
if idx >= length || idx < 0 {
|
|
return _undefined
|
|
}
|
|
i := valueInt(idx)
|
|
if o.self.hasPropertyIdx(i) {
|
|
return o.self.getIdx(i, nil)
|
|
}
|
|
return _undefined
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_indexOf(call FunctionCall) Value {
|
|
o := call.This.ToObject(r)
|
|
length := toLength(o.self.getStr("length", nil))
|
|
if length == 0 {
|
|
return intToValue(-1)
|
|
}
|
|
|
|
n := call.Argument(1).ToInteger()
|
|
if n >= length {
|
|
return intToValue(-1)
|
|
}
|
|
|
|
if n < 0 {
|
|
n = max(length+n, 0)
|
|
}
|
|
|
|
searchElement := call.Argument(0)
|
|
|
|
if arr := r.checkStdArrayObj(o); arr != nil {
|
|
for i, val := range arr.values[n:] {
|
|
if searchElement.StrictEquals(val) {
|
|
return intToValue(n + int64(i))
|
|
}
|
|
}
|
|
return intToValue(-1)
|
|
}
|
|
|
|
for ; n < length; n++ {
|
|
idx := valueInt(n)
|
|
if o.self.hasPropertyIdx(idx) {
|
|
if val := o.self.getIdx(idx, nil); val != nil {
|
|
if searchElement.StrictEquals(val) {
|
|
return idx
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return intToValue(-1)
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_includes(call FunctionCall) Value {
|
|
o := call.This.ToObject(r)
|
|
length := toLength(o.self.getStr("length", nil))
|
|
if length == 0 {
|
|
return valueFalse
|
|
}
|
|
|
|
n := call.Argument(1).ToInteger()
|
|
if n >= length {
|
|
return valueFalse
|
|
}
|
|
|
|
if n < 0 {
|
|
n = max(length+n, 0)
|
|
}
|
|
|
|
searchElement := call.Argument(0)
|
|
if searchElement == _negativeZero {
|
|
searchElement = _positiveZero
|
|
}
|
|
|
|
if arr := r.checkStdArrayObj(o); arr != nil {
|
|
for _, val := range arr.values[n:] {
|
|
if searchElement.SameAs(val) {
|
|
return valueTrue
|
|
}
|
|
}
|
|
return valueFalse
|
|
}
|
|
|
|
for ; n < length; n++ {
|
|
idx := valueInt(n)
|
|
val := nilSafe(o.self.getIdx(idx, nil))
|
|
if searchElement.SameAs(val) {
|
|
return valueTrue
|
|
}
|
|
}
|
|
|
|
return valueFalse
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_lastIndexOf(call FunctionCall) Value {
|
|
o := call.This.ToObject(r)
|
|
length := toLength(o.self.getStr("length", nil))
|
|
if length == 0 {
|
|
return intToValue(-1)
|
|
}
|
|
|
|
var fromIndex int64
|
|
|
|
if len(call.Arguments) < 2 {
|
|
fromIndex = length - 1
|
|
} else {
|
|
fromIndex = call.Argument(1).ToInteger()
|
|
if fromIndex >= 0 {
|
|
fromIndex = min(fromIndex, length-1)
|
|
} else {
|
|
fromIndex += length
|
|
}
|
|
}
|
|
|
|
searchElement := call.Argument(0)
|
|
|
|
if arr := r.checkStdArrayObj(o); arr != nil {
|
|
vals := arr.values
|
|
for k := fromIndex; k >= 0; k-- {
|
|
if v := vals[k]; v != nil && searchElement.StrictEquals(v) {
|
|
return intToValue(k)
|
|
}
|
|
}
|
|
return intToValue(-1)
|
|
}
|
|
|
|
for k := fromIndex; k >= 0; k-- {
|
|
idx := valueInt(k)
|
|
if o.self.hasPropertyIdx(idx) {
|
|
if val := o.self.getIdx(idx, nil); val != nil {
|
|
if searchElement.StrictEquals(val) {
|
|
return idx
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return intToValue(-1)
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_every(call FunctionCall) Value {
|
|
o := call.This.ToObject(r)
|
|
length := toLength(o.self.getStr("length", nil))
|
|
callbackFn := r.toCallable(call.Argument(0))
|
|
fc := FunctionCall{
|
|
This: call.Argument(1),
|
|
Arguments: []Value{nil, nil, o},
|
|
}
|
|
for k := int64(0); k < length; k++ {
|
|
idx := valueInt(k)
|
|
if val := o.self.getIdx(idx, nil); val != nil {
|
|
fc.Arguments[0] = val
|
|
fc.Arguments[1] = idx
|
|
if !callbackFn(fc).ToBoolean() {
|
|
return valueFalse
|
|
}
|
|
}
|
|
}
|
|
return valueTrue
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_some(call FunctionCall) Value {
|
|
o := call.This.ToObject(r)
|
|
length := toLength(o.self.getStr("length", nil))
|
|
callbackFn := r.toCallable(call.Argument(0))
|
|
fc := FunctionCall{
|
|
This: call.Argument(1),
|
|
Arguments: []Value{nil, nil, o},
|
|
}
|
|
for k := int64(0); k < length; k++ {
|
|
idx := valueInt(k)
|
|
if val := o.self.getIdx(idx, nil); val != nil {
|
|
fc.Arguments[0] = val
|
|
fc.Arguments[1] = idx
|
|
if callbackFn(fc).ToBoolean() {
|
|
return valueTrue
|
|
}
|
|
}
|
|
}
|
|
return valueFalse
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_forEach(call FunctionCall) Value {
|
|
o := call.This.ToObject(r)
|
|
length := toLength(o.self.getStr("length", nil))
|
|
callbackFn := r.toCallable(call.Argument(0))
|
|
fc := FunctionCall{
|
|
This: call.Argument(1),
|
|
Arguments: []Value{nil, nil, o},
|
|
}
|
|
for k := int64(0); k < length; k++ {
|
|
idx := valueInt(k)
|
|
if val := o.self.getIdx(idx, nil); val != nil {
|
|
fc.Arguments[0] = val
|
|
fc.Arguments[1] = idx
|
|
callbackFn(fc)
|
|
}
|
|
}
|
|
return _undefined
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_map(call FunctionCall) Value {
|
|
o := call.This.ToObject(r)
|
|
length := toLength(o.self.getStr("length", nil))
|
|
callbackFn := r.toCallable(call.Argument(0))
|
|
fc := FunctionCall{
|
|
This: call.Argument(1),
|
|
Arguments: []Value{nil, nil, o},
|
|
}
|
|
a := arraySpeciesCreate(o, length)
|
|
if _, stdSrc := o.self.(*arrayObject); stdSrc {
|
|
if arr, ok := a.self.(*arrayObject); ok {
|
|
values := make([]Value, length)
|
|
for k := int64(0); k < length; k++ {
|
|
idx := valueInt(k)
|
|
if val := o.self.getIdx(idx, nil); val != nil {
|
|
fc.Arguments[0] = val
|
|
fc.Arguments[1] = idx
|
|
values[k] = callbackFn(fc)
|
|
}
|
|
}
|
|
setArrayValues(arr, values)
|
|
return a
|
|
}
|
|
}
|
|
for k := int64(0); k < length; k++ {
|
|
idx := valueInt(k)
|
|
if val := o.self.getIdx(idx, nil); val != nil {
|
|
fc.Arguments[0] = val
|
|
fc.Arguments[1] = idx
|
|
createDataPropertyOrThrow(a, idx, callbackFn(fc))
|
|
}
|
|
}
|
|
return a
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_filter(call FunctionCall) Value {
|
|
o := call.This.ToObject(r)
|
|
length := toLength(o.self.getStr("length", nil))
|
|
callbackFn := call.Argument(0).ToObject(r)
|
|
if callbackFn, ok := callbackFn.self.assertCallable(); ok {
|
|
a := arraySpeciesCreate(o, 0)
|
|
fc := FunctionCall{
|
|
This: call.Argument(1),
|
|
Arguments: []Value{nil, nil, o},
|
|
}
|
|
if _, stdSrc := o.self.(*arrayObject); stdSrc {
|
|
if arr := r.checkStdArrayObj(a); arr != nil {
|
|
var values []Value
|
|
for k := int64(0); k < length; k++ {
|
|
idx := valueInt(k)
|
|
if val := o.self.getIdx(idx, nil); val != nil {
|
|
fc.Arguments[0] = val
|
|
fc.Arguments[1] = idx
|
|
if callbackFn(fc).ToBoolean() {
|
|
values = append(values, val)
|
|
}
|
|
}
|
|
}
|
|
setArrayValues(arr, values)
|
|
return a
|
|
}
|
|
}
|
|
|
|
to := int64(0)
|
|
for k := int64(0); k < length; k++ {
|
|
idx := valueInt(k)
|
|
if val := o.self.getIdx(idx, nil); val != nil {
|
|
fc.Arguments[0] = val
|
|
fc.Arguments[1] = idx
|
|
if callbackFn(fc).ToBoolean() {
|
|
createDataPropertyOrThrow(a, intToValue(to), val)
|
|
to++
|
|
}
|
|
}
|
|
}
|
|
return a
|
|
} else {
|
|
r.typeErrorResult(true, "%s is not a function", call.Argument(0))
|
|
}
|
|
panic("unreachable")
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_reduce(call FunctionCall) Value {
|
|
o := call.This.ToObject(r)
|
|
length := toLength(o.self.getStr("length", nil))
|
|
callbackFn := call.Argument(0).ToObject(r)
|
|
if callbackFn, ok := callbackFn.self.assertCallable(); ok {
|
|
fc := FunctionCall{
|
|
This: _undefined,
|
|
Arguments: []Value{nil, nil, nil, o},
|
|
}
|
|
|
|
var k int64
|
|
|
|
if len(call.Arguments) >= 2 {
|
|
fc.Arguments[0] = call.Argument(1)
|
|
} else {
|
|
for ; k < length; k++ {
|
|
idx := valueInt(k)
|
|
if val := o.self.getIdx(idx, nil); val != nil {
|
|
fc.Arguments[0] = val
|
|
break
|
|
}
|
|
}
|
|
if fc.Arguments[0] == nil {
|
|
r.typeErrorResult(true, "No initial value")
|
|
panic("unreachable")
|
|
}
|
|
k++
|
|
}
|
|
|
|
for ; k < length; k++ {
|
|
idx := valueInt(k)
|
|
if val := o.self.getIdx(idx, nil); val != nil {
|
|
fc.Arguments[1] = val
|
|
fc.Arguments[2] = idx
|
|
fc.Arguments[0] = callbackFn(fc)
|
|
}
|
|
}
|
|
return fc.Arguments[0]
|
|
} else {
|
|
r.typeErrorResult(true, "%s is not a function", call.Argument(0))
|
|
}
|
|
panic("unreachable")
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_reduceRight(call FunctionCall) Value {
|
|
o := call.This.ToObject(r)
|
|
length := toLength(o.self.getStr("length", nil))
|
|
callbackFn := call.Argument(0).ToObject(r)
|
|
if callbackFn, ok := callbackFn.self.assertCallable(); ok {
|
|
fc := FunctionCall{
|
|
This: _undefined,
|
|
Arguments: []Value{nil, nil, nil, o},
|
|
}
|
|
|
|
k := length - 1
|
|
|
|
if len(call.Arguments) >= 2 {
|
|
fc.Arguments[0] = call.Argument(1)
|
|
} else {
|
|
for ; k >= 0; k-- {
|
|
idx := valueInt(k)
|
|
if val := o.self.getIdx(idx, nil); val != nil {
|
|
fc.Arguments[0] = val
|
|
break
|
|
}
|
|
}
|
|
if fc.Arguments[0] == nil {
|
|
r.typeErrorResult(true, "No initial value")
|
|
panic("unreachable")
|
|
}
|
|
k--
|
|
}
|
|
|
|
for ; k >= 0; k-- {
|
|
idx := valueInt(k)
|
|
if val := o.self.getIdx(idx, nil); val != nil {
|
|
fc.Arguments[1] = val
|
|
fc.Arguments[2] = idx
|
|
fc.Arguments[0] = callbackFn(fc)
|
|
}
|
|
}
|
|
return fc.Arguments[0]
|
|
} else {
|
|
r.typeErrorResult(true, "%s is not a function", call.Argument(0))
|
|
}
|
|
panic("unreachable")
|
|
}
|
|
|
|
func arrayproto_reverse_generic_step(o *Object, lower, upper int64) {
|
|
lowerP := valueInt(lower)
|
|
upperP := valueInt(upper)
|
|
var lowerValue, upperValue Value
|
|
lowerExists := o.self.hasPropertyIdx(lowerP)
|
|
if lowerExists {
|
|
lowerValue = nilSafe(o.self.getIdx(lowerP, nil))
|
|
}
|
|
upperExists := o.self.hasPropertyIdx(upperP)
|
|
if upperExists {
|
|
upperValue = nilSafe(o.self.getIdx(upperP, nil))
|
|
}
|
|
if lowerExists && upperExists {
|
|
o.self.setOwnIdx(lowerP, upperValue, true)
|
|
o.self.setOwnIdx(upperP, lowerValue, true)
|
|
} else if !lowerExists && upperExists {
|
|
o.self.setOwnIdx(lowerP, upperValue, true)
|
|
o.self.deleteIdx(upperP, true)
|
|
} else if lowerExists && !upperExists {
|
|
o.self.deleteIdx(lowerP, true)
|
|
o.self.setOwnIdx(upperP, lowerValue, true)
|
|
}
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_reverse_generic(o *Object, start int64) {
|
|
l := toLength(o.self.getStr("length", nil))
|
|
middle := l / 2
|
|
for lower := start; lower != middle; lower++ {
|
|
arrayproto_reverse_generic_step(o, lower, l-lower-1)
|
|
}
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_reverse(call FunctionCall) Value {
|
|
o := call.This.ToObject(r)
|
|
if a := r.checkStdArrayObj(o); a != nil {
|
|
l := len(a.values)
|
|
middle := l / 2
|
|
for lower := 0; lower != middle; lower++ {
|
|
upper := l - lower - 1
|
|
a.values[lower], a.values[upper] = a.values[upper], a.values[lower]
|
|
}
|
|
//TODO: go arrays
|
|
} else {
|
|
r.arrayproto_reverse_generic(o, 0)
|
|
}
|
|
return o
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_shift(call FunctionCall) Value {
|
|
o := call.This.ToObject(r)
|
|
if a := r.checkStdArrayObjWithProto(o); a != nil {
|
|
if len(a.values) == 0 {
|
|
if !a.lengthProp.writable {
|
|
a.setLength(0, true) // will throw
|
|
}
|
|
return _undefined
|
|
}
|
|
first := a.values[0]
|
|
copy(a.values, a.values[1:])
|
|
a.values[len(a.values)-1] = nil
|
|
a.values = a.values[:len(a.values)-1]
|
|
a.length--
|
|
return first
|
|
}
|
|
length := toLength(o.self.getStr("length", nil))
|
|
if length == 0 {
|
|
o.self.setOwnStr("length", intToValue(0), true)
|
|
return _undefined
|
|
}
|
|
first := o.self.getIdx(valueInt(0), nil)
|
|
for i := int64(1); i < length; i++ {
|
|
idxFrom := valueInt(i)
|
|
idxTo := valueInt(i - 1)
|
|
if o.self.hasPropertyIdx(idxFrom) {
|
|
o.self.setOwnIdx(idxTo, nilSafe(o.self.getIdx(idxFrom, nil)), true)
|
|
} else {
|
|
o.self.deleteIdx(idxTo, true)
|
|
}
|
|
}
|
|
|
|
lv := valueInt(length - 1)
|
|
o.self.deleteIdx(lv, true)
|
|
o.self.setOwnStr("length", lv, true)
|
|
|
|
return first
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_values(call FunctionCall) Value {
|
|
return r.createArrayIterator(call.This.ToObject(r), iterationKindValue)
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_keys(call FunctionCall) Value {
|
|
return r.createArrayIterator(call.This.ToObject(r), iterationKindKey)
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_copyWithin(call FunctionCall) Value {
|
|
o := call.This.ToObject(r)
|
|
l := toLength(o.self.getStr("length", nil))
|
|
var relEnd, dir int64
|
|
to := relToIdx(call.Argument(0).ToInteger(), l)
|
|
from := relToIdx(call.Argument(1).ToInteger(), l)
|
|
if end := call.Argument(2); end != _undefined {
|
|
relEnd = end.ToInteger()
|
|
} else {
|
|
relEnd = l
|
|
}
|
|
final := relToIdx(relEnd, l)
|
|
count := min(final-from, l-to)
|
|
if arr := r.checkStdArrayObj(o); arr != nil {
|
|
if count > 0 {
|
|
copy(arr.values[to:to+count], arr.values[from:from+count])
|
|
}
|
|
return o
|
|
}
|
|
if from < to && to < from+count {
|
|
dir = -1
|
|
from = from + count - 1
|
|
to = to + count - 1
|
|
} else {
|
|
dir = 1
|
|
}
|
|
for count > 0 {
|
|
if o.self.hasPropertyIdx(valueInt(from)) {
|
|
o.self.setOwnIdx(valueInt(to), nilSafe(o.self.getIdx(valueInt(from), nil)), true)
|
|
} else {
|
|
o.self.deleteIdx(valueInt(to), true)
|
|
}
|
|
from += dir
|
|
to += dir
|
|
count--
|
|
}
|
|
|
|
return o
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_entries(call FunctionCall) Value {
|
|
return r.createArrayIterator(call.This.ToObject(r), iterationKindKeyValue)
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_fill(call FunctionCall) Value {
|
|
o := call.This.ToObject(r)
|
|
l := toLength(o.self.getStr("length", nil))
|
|
k := relToIdx(call.Argument(1).ToInteger(), l)
|
|
var relEnd int64
|
|
if endArg := call.Argument(2); endArg != _undefined {
|
|
relEnd = endArg.ToInteger()
|
|
} else {
|
|
relEnd = l
|
|
}
|
|
final := relToIdx(relEnd, l)
|
|
value := call.Argument(0)
|
|
if arr := r.checkStdArrayObj(o); arr != nil {
|
|
for ; k < final; k++ {
|
|
arr.values[k] = value
|
|
}
|
|
} else {
|
|
for ; k < final; k++ {
|
|
o.self.setOwnIdx(valueInt(k), value, true)
|
|
}
|
|
}
|
|
return o
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_find(call FunctionCall) Value {
|
|
o := call.This.ToObject(r)
|
|
l := toLength(o.self.getStr("length", nil))
|
|
predicate := r.toCallable(call.Argument(0))
|
|
fc := FunctionCall{
|
|
This: call.Argument(1),
|
|
Arguments: []Value{nil, nil, o},
|
|
}
|
|
for k := int64(0); k < l; k++ {
|
|
idx := valueInt(k)
|
|
kValue := o.self.getIdx(idx, nil)
|
|
fc.Arguments[0], fc.Arguments[1] = kValue, idx
|
|
if predicate(fc).ToBoolean() {
|
|
return kValue
|
|
}
|
|
}
|
|
|
|
return _undefined
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_findIndex(call FunctionCall) Value {
|
|
o := call.This.ToObject(r)
|
|
l := toLength(o.self.getStr("length", nil))
|
|
predicate := r.toCallable(call.Argument(0))
|
|
fc := FunctionCall{
|
|
This: call.Argument(1),
|
|
Arguments: []Value{nil, nil, o},
|
|
}
|
|
for k := int64(0); k < l; k++ {
|
|
idx := valueInt(k)
|
|
kValue := o.self.getIdx(idx, nil)
|
|
fc.Arguments[0], fc.Arguments[1] = kValue, idx
|
|
if predicate(fc).ToBoolean() {
|
|
return idx
|
|
}
|
|
}
|
|
|
|
return intToValue(-1)
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_findLast(call FunctionCall) Value {
|
|
o := call.This.ToObject(r)
|
|
l := toLength(o.self.getStr("length", nil))
|
|
predicate := r.toCallable(call.Argument(0))
|
|
fc := FunctionCall{
|
|
This: call.Argument(1),
|
|
Arguments: []Value{nil, nil, o},
|
|
}
|
|
for k := int64(l - 1); k >= 0; k-- {
|
|
idx := valueInt(k)
|
|
kValue := o.self.getIdx(idx, nil)
|
|
fc.Arguments[0], fc.Arguments[1] = kValue, idx
|
|
if predicate(fc).ToBoolean() {
|
|
return kValue
|
|
}
|
|
}
|
|
|
|
return _undefined
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_findLastIndex(call FunctionCall) Value {
|
|
o := call.This.ToObject(r)
|
|
l := toLength(o.self.getStr("length", nil))
|
|
predicate := r.toCallable(call.Argument(0))
|
|
fc := FunctionCall{
|
|
This: call.Argument(1),
|
|
Arguments: []Value{nil, nil, o},
|
|
}
|
|
for k := int64(l - 1); k >= 0; k-- {
|
|
idx := valueInt(k)
|
|
kValue := o.self.getIdx(idx, nil)
|
|
fc.Arguments[0], fc.Arguments[1] = kValue, idx
|
|
if predicate(fc).ToBoolean() {
|
|
return idx
|
|
}
|
|
}
|
|
|
|
return intToValue(-1)
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_flat(call FunctionCall) Value {
|
|
o := call.This.ToObject(r)
|
|
l := toLength(o.self.getStr("length", nil))
|
|
depthNum := int64(1)
|
|
if len(call.Arguments) > 0 {
|
|
depthNum = call.Argument(0).ToInteger()
|
|
}
|
|
a := arraySpeciesCreate(o, 0)
|
|
r.flattenIntoArray(a, o, l, 0, depthNum, nil, nil)
|
|
return a
|
|
}
|
|
|
|
func (r *Runtime) flattenIntoArray(target, source *Object, sourceLen, start, depth int64, mapperFunction func(FunctionCall) Value, thisArg Value) int64 {
|
|
targetIndex, sourceIndex := start, int64(0)
|
|
for sourceIndex < sourceLen {
|
|
p := intToValue(sourceIndex)
|
|
if source.hasProperty(p.toString()) {
|
|
element := nilSafe(source.get(p, source))
|
|
if mapperFunction != nil {
|
|
element = mapperFunction(FunctionCall{
|
|
This: thisArg,
|
|
Arguments: []Value{element, p, source},
|
|
})
|
|
}
|
|
var elementArray *Object
|
|
if depth > 0 {
|
|
if elementObj, ok := element.(*Object); ok && isArray(elementObj) {
|
|
elementArray = elementObj
|
|
}
|
|
}
|
|
if elementArray != nil {
|
|
elementLen := toLength(elementArray.self.getStr("length", nil))
|
|
targetIndex = r.flattenIntoArray(target, elementArray, elementLen, targetIndex, depth-1, nil, nil)
|
|
} else {
|
|
if targetIndex >= maxInt-1 {
|
|
panic(r.NewTypeError("Invalid array length"))
|
|
}
|
|
createDataPropertyOrThrow(target, intToValue(targetIndex), element)
|
|
targetIndex++
|
|
}
|
|
}
|
|
sourceIndex++
|
|
}
|
|
return targetIndex
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_flatMap(call FunctionCall) Value {
|
|
o := call.This.ToObject(r)
|
|
l := toLength(o.self.getStr("length", nil))
|
|
callbackFn := r.toCallable(call.Argument(0))
|
|
thisArg := Undefined()
|
|
if len(call.Arguments) > 1 {
|
|
thisArg = call.Argument(1)
|
|
}
|
|
a := arraySpeciesCreate(o, 0)
|
|
r.flattenIntoArray(a, o, l, 0, 1, callbackFn, thisArg)
|
|
return a
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_with(call FunctionCall) Value {
|
|
o := call.This.ToObject(r)
|
|
relativeIndex := call.Argument(0).ToInteger()
|
|
value := call.Argument(1)
|
|
length := toLength(o.self.getStr("length", nil))
|
|
|
|
actualIndex := int64(0)
|
|
if relativeIndex >= 0 {
|
|
actualIndex = relativeIndex
|
|
} else {
|
|
actualIndex = length + relativeIndex
|
|
}
|
|
if actualIndex >= length || actualIndex < 0 {
|
|
panic(r.newError(r.getRangeError(), "Invalid index %s", call.Argument(0).String()))
|
|
}
|
|
|
|
if src := r.checkStdArrayObj(o); src != nil {
|
|
a := make([]Value, 0, length)
|
|
for k := int64(0); k < length; k++ {
|
|
pk := valueInt(k)
|
|
var fromValue Value
|
|
if k == actualIndex {
|
|
fromValue = value
|
|
} else {
|
|
fromValue = src.values[pk]
|
|
}
|
|
a = append(a, fromValue)
|
|
}
|
|
return r.newArrayValues(a)
|
|
} else {
|
|
a := r.newArrayLength(length)
|
|
for k := int64(0); k < length; k++ {
|
|
pk := valueInt(k)
|
|
var fromValue Value
|
|
if k == actualIndex {
|
|
fromValue = value
|
|
} else {
|
|
fromValue = o.self.getIdx(pk, nil)
|
|
}
|
|
createDataPropertyOrThrow(a, pk, fromValue)
|
|
}
|
|
return a
|
|
}
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_toReversed(call FunctionCall) Value {
|
|
o := call.This.ToObject(r)
|
|
length := toLength(o.self.getStr("length", nil))
|
|
|
|
if src := r.checkStdArrayObj(o); src != nil {
|
|
a := make([]Value, 0, length)
|
|
for k := int64(0); k < length; k++ {
|
|
from := valueInt(length - k - 1)
|
|
fromValue := src.values[from]
|
|
a = append(a, fromValue)
|
|
}
|
|
return r.newArrayValues(a)
|
|
} else {
|
|
a := r.newArrayLength(length)
|
|
for k := int64(0); k < length; k++ {
|
|
pk := valueInt(k)
|
|
from := valueInt(length - k - 1)
|
|
fromValue := o.self.getIdx(from, nil)
|
|
createDataPropertyOrThrow(a, pk, fromValue)
|
|
}
|
|
return a
|
|
}
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_toSorted(call FunctionCall) Value {
|
|
var compareFn func(FunctionCall) Value
|
|
arg := call.Argument(0)
|
|
if arg != _undefined {
|
|
if arg, ok := arg.(*Object); ok {
|
|
compareFn, _ = arg.self.assertCallable()
|
|
}
|
|
if compareFn == nil {
|
|
panic(r.NewTypeError("The comparison function must be either a function or undefined"))
|
|
}
|
|
}
|
|
|
|
o := call.This.ToObject(r)
|
|
length := toLength(o.self.getStr("length", nil))
|
|
if length >= math.MaxUint32 {
|
|
panic(r.newError(r.getRangeError(), "Invalid array length"))
|
|
}
|
|
var a []Value
|
|
|
|
if src := r.checkStdArrayObj(o); src != nil {
|
|
a = make([]Value, length)
|
|
copy(a, src.values)
|
|
} else {
|
|
a = make([]Value, 0, length)
|
|
for i := int64(0); i < length; i++ {
|
|
idx := valueInt(i)
|
|
a = append(a, nilSafe(o.self.getIdx(idx, nil)))
|
|
}
|
|
}
|
|
|
|
ar := r.newArrayValues(a)
|
|
ctx := arraySortCtx{
|
|
obj: ar.self,
|
|
compare: compareFn,
|
|
}
|
|
|
|
sort.Stable(&ctx)
|
|
return ar
|
|
}
|
|
|
|
func (r *Runtime) arrayproto_toSpliced(call FunctionCall) Value {
|
|
o := call.This.ToObject(r)
|
|
length := toLength(o.self.getStr("length", nil))
|
|
actualStart := relToIdx(call.Argument(0).ToInteger(), length)
|
|
var actualSkipCount int64
|
|
if len(call.Arguments) == 1 {
|
|
actualSkipCount = length - actualStart
|
|
} else if len(call.Arguments) > 1 {
|
|
actualSkipCount = min(max(call.Argument(1).ToInteger(), 0), length-actualStart)
|
|
}
|
|
itemCount := max(int64(len(call.Arguments)-2), 0)
|
|
newLength := length - actualSkipCount + itemCount
|
|
if newLength >= maxInt {
|
|
panic(r.NewTypeError("Invalid array length"))
|
|
}
|
|
|
|
if src := r.checkStdArrayObj(o); src != nil {
|
|
var values []Value
|
|
if itemCount == actualSkipCount {
|
|
values = make([]Value, len(src.values))
|
|
copy(values, src.values)
|
|
} else {
|
|
values = make([]Value, newLength)
|
|
copy(values, src.values[:actualStart])
|
|
copy(values[actualStart+itemCount:], src.values[actualStart+actualSkipCount:])
|
|
}
|
|
if itemCount > 0 {
|
|
copy(values[actualStart:], call.Arguments[2:])
|
|
}
|
|
return r.newArrayValues(values)
|
|
} else {
|
|
a := r.newArrayLength(newLength)
|
|
var i int64
|
|
rl := actualStart + actualSkipCount
|
|
|
|
for i < actualStart {
|
|
pi := valueInt(i)
|
|
iValue := nilSafe(o.self.getIdx(pi, nil))
|
|
createDataPropertyOrThrow(a, pi, iValue)
|
|
i++
|
|
}
|
|
|
|
if itemCount > 0 {
|
|
for _, item := range call.Arguments[2:] {
|
|
createDataPropertyOrThrow(a, valueInt(i), nilSafe(item))
|
|
i++
|
|
}
|
|
}
|
|
|
|
for i < newLength {
|
|
pi := valueInt(i)
|
|
from := valueInt(rl)
|
|
fromValue := nilSafe(o.self.getIdx(from, nil))
|
|
createDataPropertyOrThrow(a, pi, fromValue)
|
|
i++
|
|
rl++
|
|
}
|
|
|
|
return a
|
|
}
|
|
}
|
|
|
|
func (r *Runtime) checkStdArrayObj(obj *Object) *arrayObject {
|
|
if arr, ok := obj.self.(*arrayObject); ok &&
|
|
arr.propValueCount == 0 &&
|
|
arr.length == uint32(len(arr.values)) &&
|
|
uint32(arr.objCount) == arr.length {
|
|
|
|
return arr
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (r *Runtime) checkStdArrayObjWithProto(obj *Object) *arrayObject {
|
|
if arr := r.checkStdArrayObj(obj); arr != nil {
|
|
if p1, ok := arr.prototype.self.(*arrayObject); ok && p1.propValueCount == 0 {
|
|
if p2, ok := p1.prototype.self.(*baseObject); ok && p2.prototype == nil {
|
|
p2.ensurePropOrder()
|
|
if p2.idxPropCount == 0 {
|
|
return arr
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (r *Runtime) checkStdArray(v Value) *arrayObject {
|
|
if obj, ok := v.(*Object); ok {
|
|
return r.checkStdArrayObj(obj)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (r *Runtime) checkStdArrayIter(v Value) *arrayObject {
|
|
if arr := r.checkStdArray(v); arr != nil &&
|
|
arr.getSym(SymIterator, nil) == r.getArrayValues() {
|
|
|
|
return arr
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (r *Runtime) array_from(call FunctionCall) Value {
|
|
var mapFn func(FunctionCall) Value
|
|
if mapFnArg := call.Argument(1); mapFnArg != _undefined {
|
|
if mapFnObj, ok := mapFnArg.(*Object); ok {
|
|
if fn, ok := mapFnObj.self.assertCallable(); ok {
|
|
mapFn = fn
|
|
}
|
|
}
|
|
if mapFn == nil {
|
|
panic(r.NewTypeError("%s is not a function", mapFnArg))
|
|
}
|
|
}
|
|
t := call.Argument(2)
|
|
items := call.Argument(0)
|
|
if mapFn == nil && call.This == r.global.Array { // mapFn may mutate the array
|
|
if arr := r.checkStdArrayIter(items); arr != nil {
|
|
items := make([]Value, len(arr.values))
|
|
copy(items, arr.values)
|
|
return r.newArrayValues(items)
|
|
}
|
|
}
|
|
|
|
var ctor func(args []Value, newTarget *Object) *Object
|
|
if call.This != r.global.Array {
|
|
if o, ok := call.This.(*Object); ok {
|
|
if c := o.self.assertConstructor(); c != nil {
|
|
ctor = c
|
|
}
|
|
}
|
|
}
|
|
var arr *Object
|
|
if usingIterator := toMethod(r.getV(items, SymIterator)); usingIterator != nil {
|
|
if ctor != nil {
|
|
arr = ctor([]Value{}, nil)
|
|
} else {
|
|
arr = r.newArrayValues(nil)
|
|
}
|
|
iter := r.getIterator(items, usingIterator)
|
|
if mapFn == nil {
|
|
if a := r.checkStdArrayObjWithProto(arr); a != nil {
|
|
var values []Value
|
|
iter.iterate(func(val Value) {
|
|
values = append(values, val)
|
|
})
|
|
setArrayValues(a, values)
|
|
return arr
|
|
}
|
|
}
|
|
k := int64(0)
|
|
iter.iterate(func(val Value) {
|
|
if mapFn != nil {
|
|
val = mapFn(FunctionCall{This: t, Arguments: []Value{val, intToValue(k)}})
|
|
}
|
|
createDataPropertyOrThrow(arr, intToValue(k), val)
|
|
k++
|
|
})
|
|
arr.self.setOwnStr("length", intToValue(k), true)
|
|
} else {
|
|
arrayLike := items.ToObject(r)
|
|
l := toLength(arrayLike.self.getStr("length", nil))
|
|
if ctor != nil {
|
|
arr = ctor([]Value{intToValue(l)}, nil)
|
|
} else {
|
|
arr = r.newArrayValues(nil)
|
|
}
|
|
if mapFn == nil {
|
|
if a := r.checkStdArrayObjWithProto(arr); a != nil {
|
|
values := make([]Value, l)
|
|
for k := int64(0); k < l; k++ {
|
|
values[k] = nilSafe(arrayLike.self.getIdx(valueInt(k), nil))
|
|
}
|
|
setArrayValues(a, values)
|
|
return arr
|
|
}
|
|
}
|
|
for k := int64(0); k < l; k++ {
|
|
idx := valueInt(k)
|
|
item := arrayLike.self.getIdx(idx, nil)
|
|
if mapFn != nil {
|
|
item = mapFn(FunctionCall{This: t, Arguments: []Value{item, idx}})
|
|
} else {
|
|
item = nilSafe(item)
|
|
}
|
|
createDataPropertyOrThrow(arr, idx, item)
|
|
}
|
|
arr.self.setOwnStr("length", intToValue(l), true)
|
|
}
|
|
|
|
return arr
|
|
}
|
|
|
|
func (r *Runtime) array_isArray(call FunctionCall) Value {
|
|
if o, ok := call.Argument(0).(*Object); ok {
|
|
if isArray(o) {
|
|
return valueTrue
|
|
}
|
|
}
|
|
return valueFalse
|
|
}
|
|
|
|
func (r *Runtime) array_of(call FunctionCall) Value {
|
|
var ctor func(args []Value, newTarget *Object) *Object
|
|
if call.This != r.global.Array {
|
|
if o, ok := call.This.(*Object); ok {
|
|
if c := o.self.assertConstructor(); c != nil {
|
|
ctor = c
|
|
}
|
|
}
|
|
}
|
|
if ctor == nil {
|
|
values := make([]Value, len(call.Arguments))
|
|
copy(values, call.Arguments)
|
|
return r.newArrayValues(values)
|
|
}
|
|
l := intToValue(int64(len(call.Arguments)))
|
|
arr := ctor([]Value{l}, nil)
|
|
for i, val := range call.Arguments {
|
|
createDataPropertyOrThrow(arr, intToValue(int64(i)), val)
|
|
}
|
|
arr.self.setOwnStr("length", l, true)
|
|
return arr
|
|
}
|
|
|
|
func (r *Runtime) arrayIterProto_next(call FunctionCall) Value {
|
|
thisObj := r.toObject(call.This)
|
|
if iter, ok := thisObj.self.(*arrayIterObject); ok {
|
|
return iter.next()
|
|
}
|
|
panic(r.NewTypeError("Method Array Iterator.prototype.next called on incompatible receiver %s", r.objectproto_toString(FunctionCall{This: thisObj})))
|
|
}
|
|
|
|
func createArrayProtoTemplate() *objectTemplate {
|
|
t := newObjectTemplate()
|
|
t.protoFactory = func(r *Runtime) *Object {
|
|
return r.global.ObjectPrototype
|
|
}
|
|
|
|
t.putStr("length", func(r *Runtime) Value { return valueProp(_positiveZero, true, false, false) })
|
|
|
|
t.putStr("constructor", func(r *Runtime) Value { return valueProp(r.getArray(), true, false, true) })
|
|
|
|
t.putStr("at", func(r *Runtime) Value { return r.methodProp(r.arrayproto_at, "at", 1) })
|
|
t.putStr("concat", func(r *Runtime) Value { return r.methodProp(r.arrayproto_concat, "concat", 1) })
|
|
t.putStr("copyWithin", func(r *Runtime) Value { return r.methodProp(r.arrayproto_copyWithin, "copyWithin", 2) })
|
|
t.putStr("entries", func(r *Runtime) Value { return r.methodProp(r.arrayproto_entries, "entries", 0) })
|
|
t.putStr("every", func(r *Runtime) Value { return r.methodProp(r.arrayproto_every, "every", 1) })
|
|
t.putStr("fill", func(r *Runtime) Value { return r.methodProp(r.arrayproto_fill, "fill", 1) })
|
|
t.putStr("filter", func(r *Runtime) Value { return r.methodProp(r.arrayproto_filter, "filter", 1) })
|
|
t.putStr("find", func(r *Runtime) Value { return r.methodProp(r.arrayproto_find, "find", 1) })
|
|
t.putStr("findIndex", func(r *Runtime) Value { return r.methodProp(r.arrayproto_findIndex, "findIndex", 1) })
|
|
t.putStr("findLast", func(r *Runtime) Value { return r.methodProp(r.arrayproto_findLast, "findLast", 1) })
|
|
t.putStr("findLastIndex", func(r *Runtime) Value { return r.methodProp(r.arrayproto_findLastIndex, "findLastIndex", 1) })
|
|
t.putStr("flat", func(r *Runtime) Value { return r.methodProp(r.arrayproto_flat, "flat", 0) })
|
|
t.putStr("flatMap", func(r *Runtime) Value { return r.methodProp(r.arrayproto_flatMap, "flatMap", 1) })
|
|
t.putStr("forEach", func(r *Runtime) Value { return r.methodProp(r.arrayproto_forEach, "forEach", 1) })
|
|
t.putStr("includes", func(r *Runtime) Value { return r.methodProp(r.arrayproto_includes, "includes", 1) })
|
|
t.putStr("indexOf", func(r *Runtime) Value { return r.methodProp(r.arrayproto_indexOf, "indexOf", 1) })
|
|
t.putStr("join", func(r *Runtime) Value { return r.methodProp(r.arrayproto_join, "join", 1) })
|
|
t.putStr("keys", func(r *Runtime) Value { return r.methodProp(r.arrayproto_keys, "keys", 0) })
|
|
t.putStr("lastIndexOf", func(r *Runtime) Value { return r.methodProp(r.arrayproto_lastIndexOf, "lastIndexOf", 1) })
|
|
t.putStr("map", func(r *Runtime) Value { return r.methodProp(r.arrayproto_map, "map", 1) })
|
|
t.putStr("pop", func(r *Runtime) Value { return r.methodProp(r.arrayproto_pop, "pop", 0) })
|
|
t.putStr("push", func(r *Runtime) Value { return r.methodProp(r.arrayproto_push, "push", 1) })
|
|
t.putStr("reduce", func(r *Runtime) Value { return r.methodProp(r.arrayproto_reduce, "reduce", 1) })
|
|
t.putStr("reduceRight", func(r *Runtime) Value { return r.methodProp(r.arrayproto_reduceRight, "reduceRight", 1) })
|
|
t.putStr("reverse", func(r *Runtime) Value { return r.methodProp(r.arrayproto_reverse, "reverse", 0) })
|
|
t.putStr("shift", func(r *Runtime) Value { return r.methodProp(r.arrayproto_shift, "shift", 0) })
|
|
t.putStr("slice", func(r *Runtime) Value { return r.methodProp(r.arrayproto_slice, "slice", 2) })
|
|
t.putStr("some", func(r *Runtime) Value { return r.methodProp(r.arrayproto_some, "some", 1) })
|
|
t.putStr("sort", func(r *Runtime) Value { return r.methodProp(r.arrayproto_sort, "sort", 1) })
|
|
t.putStr("splice", func(r *Runtime) Value { return r.methodProp(r.arrayproto_splice, "splice", 2) })
|
|
t.putStr("toLocaleString", func(r *Runtime) Value { return r.methodProp(r.arrayproto_toLocaleString, "toLocaleString", 0) })
|
|
t.putStr("toString", func(r *Runtime) Value { return valueProp(r.getArrayToString(), true, false, true) })
|
|
t.putStr("unshift", func(r *Runtime) Value { return r.methodProp(r.arrayproto_unshift, "unshift", 1) })
|
|
t.putStr("with", func(r *Runtime) Value { return r.methodProp(r.arrayproto_with, "with", 2) })
|
|
t.putStr("toReversed", func(r *Runtime) Value { return r.methodProp(r.arrayproto_toReversed, "toReversed", 0) })
|
|
t.putStr("toSorted", func(r *Runtime) Value { return r.methodProp(r.arrayproto_toSorted, "toSorted", 1) })
|
|
t.putStr("toSpliced", func(r *Runtime) Value { return r.methodProp(r.arrayproto_toSpliced, "toSpliced", 2) })
|
|
t.putStr("values", func(r *Runtime) Value { return valueProp(r.getArrayValues(), true, false, true) })
|
|
|
|
t.putSym(SymIterator, func(r *Runtime) Value { return valueProp(r.getArrayValues(), true, false, true) })
|
|
t.putSym(SymUnscopables, func(r *Runtime) Value {
|
|
bl := r.newBaseObject(nil, classObject)
|
|
bl.setOwnStr("copyWithin", valueTrue, true)
|
|
bl.setOwnStr("entries", valueTrue, true)
|
|
bl.setOwnStr("fill", valueTrue, true)
|
|
bl.setOwnStr("find", valueTrue, true)
|
|
bl.setOwnStr("findIndex", valueTrue, true)
|
|
bl.setOwnStr("findLast", valueTrue, true)
|
|
bl.setOwnStr("findLastIndex", valueTrue, true)
|
|
bl.setOwnStr("flat", valueTrue, true)
|
|
bl.setOwnStr("flatMap", valueTrue, true)
|
|
bl.setOwnStr("includes", valueTrue, true)
|
|
bl.setOwnStr("keys", valueTrue, true)
|
|
bl.setOwnStr("values", valueTrue, true)
|
|
bl.setOwnStr("groupBy", valueTrue, true)
|
|
bl.setOwnStr("groupByToMap", valueTrue, true)
|
|
bl.setOwnStr("toReversed", valueTrue, true)
|
|
bl.setOwnStr("toSorted", valueTrue, true)
|
|
bl.setOwnStr("toSpliced", valueTrue, true)
|
|
|
|
return valueProp(bl.val, false, false, true)
|
|
})
|
|
|
|
return t
|
|
}
|
|
|
|
var arrayProtoTemplate *objectTemplate
|
|
var arrayProtoTemplateOnce sync.Once
|
|
|
|
func getArrayProtoTemplate() *objectTemplate {
|
|
arrayProtoTemplateOnce.Do(func() {
|
|
arrayProtoTemplate = createArrayProtoTemplate()
|
|
})
|
|
return arrayProtoTemplate
|
|
}
|
|
|
|
func (r *Runtime) getArrayPrototype() *Object {
|
|
ret := r.global.ArrayPrototype
|
|
if ret == nil {
|
|
ret = &Object{runtime: r}
|
|
r.global.ArrayPrototype = ret
|
|
r.newTemplatedArrayObject(getArrayProtoTemplate(), ret)
|
|
}
|
|
return ret
|
|
}
|
|
|
|
func (r *Runtime) getArray() *Object {
|
|
ret := r.global.Array
|
|
if ret == nil {
|
|
ret = &Object{runtime: r}
|
|
ret.self = r.createArray(ret)
|
|
r.global.Array = ret
|
|
}
|
|
return ret
|
|
}
|
|
|
|
func (r *Runtime) createArray(val *Object) objectImpl {
|
|
o := r.newNativeFuncConstructObj(val, r.builtin_newArray, "Array", r.getArrayPrototype(), 1)
|
|
o._putProp("from", r.newNativeFunc(r.array_from, "from", 1), true, false, true)
|
|
o._putProp("isArray", r.newNativeFunc(r.array_isArray, "isArray", 1), true, false, true)
|
|
o._putProp("of", r.newNativeFunc(r.array_of, "of", 0), true, false, true)
|
|
r.putSpeciesReturnThis(o)
|
|
|
|
return o
|
|
}
|
|
|
|
func (r *Runtime) createArrayIterProto(val *Object) objectImpl {
|
|
o := newBaseObjectObj(val, r.getIteratorPrototype(), classObject)
|
|
|
|
o._putProp("next", r.newNativeFunc(r.arrayIterProto_next, "next", 0), true, false, true)
|
|
o._putSym(SymToStringTag, valueProp(asciiString(classArrayIterator), false, false, true))
|
|
|
|
return o
|
|
}
|
|
|
|
func (r *Runtime) getArrayValues() *Object {
|
|
ret := r.global.arrayValues
|
|
if ret == nil {
|
|
ret = r.newNativeFunc(r.arrayproto_values, "values", 0)
|
|
r.global.arrayValues = ret
|
|
}
|
|
return ret
|
|
}
|
|
|
|
func (r *Runtime) getArrayToString() *Object {
|
|
ret := r.global.arrayToString
|
|
if ret == nil {
|
|
ret = r.newNativeFunc(r.arrayproto_toString, "toString", 0)
|
|
r.global.arrayToString = ret
|
|
}
|
|
return ret
|
|
}
|
|
|
|
func (r *Runtime) getArrayIteratorPrototype() *Object {
|
|
var o *Object
|
|
if o = r.global.ArrayIteratorPrototype; o == nil {
|
|
o = &Object{runtime: r}
|
|
r.global.ArrayIteratorPrototype = o
|
|
o.self = r.createArrayIterProto(o)
|
|
}
|
|
return o
|
|
|
|
}
|
|
|
|
type sortable interface {
|
|
sortLen() int
|
|
sortGet(int) Value
|
|
swap(int, int)
|
|
}
|
|
|
|
type arraySortCtx struct {
|
|
obj sortable
|
|
compare func(FunctionCall) Value
|
|
}
|
|
|
|
func (a *arraySortCtx) sortCompare(x, y Value) int {
|
|
if x == nil && y == nil {
|
|
return 0
|
|
}
|
|
|
|
if x == nil {
|
|
return 1
|
|
}
|
|
|
|
if y == nil {
|
|
return -1
|
|
}
|
|
|
|
if x == _undefined && y == _undefined {
|
|
return 0
|
|
}
|
|
|
|
if x == _undefined {
|
|
return 1
|
|
}
|
|
|
|
if y == _undefined {
|
|
return -1
|
|
}
|
|
|
|
if a.compare != nil {
|
|
f := a.compare(FunctionCall{
|
|
This: _undefined,
|
|
Arguments: []Value{x, y},
|
|
}).ToFloat()
|
|
if f > 0 {
|
|
return 1
|
|
}
|
|
if f < 0 {
|
|
return -1
|
|
}
|
|
if math.Signbit(f) {
|
|
return -1
|
|
}
|
|
return 0
|
|
}
|
|
return x.toString().CompareTo(y.toString())
|
|
}
|
|
|
|
// sort.Interface
|
|
|
|
func (a *arraySortCtx) Len() int {
|
|
return a.obj.sortLen()
|
|
}
|
|
|
|
func (a *arraySortCtx) Less(j, k int) bool {
|
|
return a.sortCompare(a.obj.sortGet(j), a.obj.sortGet(k)) < 0
|
|
}
|
|
|
|
func (a *arraySortCtx) Swap(j, k int) {
|
|
a.obj.swap(j, k)
|
|
}
|