[chore] remove vendor

13 files changed, 0 insertions, 5145 deletions

diff --git a/vendor/github.com/bytedance/sonic/ast/api.go b/vendor/github.com/bytedance/sonic/ast/api.go
deleted file mode 100644
index 7c8253aa1..000000000
--- a/vendor/github.com/bytedance/sonic/ast/api.go
+++ /dev/null
@@ -1,135 +0,0 @@
-//go:build (amd64 && go1.17 && !go1.24) || (arm64 && go1.20 && !go1.24)
-// +build amd64,go1.17,!go1.24 arm64,go1.20,!go1.24
-
-/*
- * Copyright 2022 ByteDance Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package ast
-
-import (
-    `runtime`
-    `unsafe`
-
-    `github.com/bytedance/sonic/encoder`
-    `github.com/bytedance/sonic/internal/native`
-    `github.com/bytedance/sonic/internal/native/types`
-    `github.com/bytedance/sonic/internal/rt`
-    uq `github.com/bytedance/sonic/unquote`
-    `github.com/bytedance/sonic/utf8`
-)
-
-var typeByte = rt.UnpackEface(byte(0)).Type
-
-//go:nocheckptr
-func quote(buf *[]byte, val string) {
-    *buf = append(*buf, '"')
-    if len(val) == 0 {
-        *buf = append(*buf, '"')
-        return
-    }
-
-    sp := rt.IndexChar(val, 0)
-    nb := len(val)
-    b := (*rt.GoSlice)(unsafe.Pointer(buf))
-
-    // input buffer
-    for nb > 0 {
-        // output buffer
-        dp := unsafe.Pointer(uintptr(b.Ptr) + uintptr(b.Len))
-        dn := b.Cap - b.Len
-        // call native.Quote, dn is byte count it outputs
-        ret := native.Quote(sp, nb, dp, &dn, 0)
-        // update *buf length
-        b.Len += dn
-
-        // no need more output
-        if ret >= 0 {
-            break
-        }
-
-        // double buf size
-        *b = rt.GrowSlice(typeByte, *b, b.Cap*2)
-        // ret is the complement of consumed input
-        ret = ^ret
-        // update input buffer
-        nb -= ret
-        sp = unsafe.Pointer(uintptr(sp) + uintptr(ret))
-    }
-
-    runtime.KeepAlive(buf)
-    runtime.KeepAlive(sp)
-    *buf = append(*buf, '"')
-}
-
-func unquote(src string) (string, types.ParsingError) {
-    return uq.String(src)
-}
-
-func (self *Parser) decodeValue() (val types.JsonState) {
-    sv := (*rt.GoString)(unsafe.Pointer(&self.s))
-    flag := types.F_USE_NUMBER
-    if self.dbuf != nil {
-        flag = 0
-        val.Dbuf = self.dbuf
-        val.Dcap = types.MaxDigitNums
-    }
-    self.p = native.Value(sv.Ptr, sv.Len, self.p, &val, uint64(flag))
-    return
-}
-
-func (self *Parser) skip() (int, types.ParsingError) {
-    fsm := types.NewStateMachine()
-    start := native.SkipOne(&self.s, &self.p, fsm, 0)
-    types.FreeStateMachine(fsm)
-
-    if start < 0 {
-        return self.p, types.ParsingError(-start)
-    }
-    return start, 0
-}
-
-func (self *Node) encodeInterface(buf *[]byte) error {
-    //WARN: NOT compatible with json.Encoder
-    return encoder.EncodeInto(buf, self.packAny(), encoder.NoEncoderNewline)
-}
-
-func (self *Parser) skipFast() (int, types.ParsingError) {
-    start := native.SkipOneFast(&self.s, &self.p)
-    if start < 0 {
-        return self.p, types.ParsingError(-start)
-    }
-    return start, 0
-}
-
-func (self *Parser) getByPath(validate bool, path ...interface{}) (int, types.ParsingError) {
-    var fsm *types.StateMachine
-    if validate {
-        fsm = types.NewStateMachine()
-    }
-    start := native.GetByPath(&self.s, &self.p, &path, fsm)
-    if validate {
-        types.FreeStateMachine(fsm)
-    }
-    runtime.KeepAlive(path)
-    if start < 0 {
-        return self.p, types.ParsingError(-start)
-    }
-    return start, 0
-}
-
-func validate_utf8(str string) bool {
-    return utf8.ValidateString(str)
-}
diff --git a/vendor/github.com/bytedance/sonic/ast/api_compat.go b/vendor/github.com/bytedance/sonic/ast/api_compat.go
deleted file mode 100644
index 6541e219d..000000000
--- a/vendor/github.com/bytedance/sonic/ast/api_compat.go
+++ /dev/null
@@ -1,114 +0,0 @@
-// +build !amd64,!arm64 go1.24 !go1.17 arm64,!go1.20
-
-/*
-* Copyright 2022 ByteDance Inc.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-
-package ast
-
-import (
-    `encoding/json`
-    `unicode/utf8`
-
-    `github.com/bytedance/sonic/internal/native/types`
-    `github.com/bytedance/sonic/internal/rt`
-)
-
-func init() {
-    println("WARNING:(ast) sonic only supports go1.17~1.23, but your environment is not suitable")
-}
-
-func quote(buf *[]byte, val string) {
-    quoteString(buf, val)
-}
-
-// unquote unescapes an internal JSON string (it doesn't count quotas at the beginning and end)
-func unquote(src string) (string, types.ParsingError) {
-    sp := rt.IndexChar(src, -1)
-    out, ok := unquoteBytes(rt.BytesFrom(sp, len(src)+2, len(src)+2))
-    if !ok {
-        return "", types.ERR_INVALID_ESCAPE
-    }
-    return rt.Mem2Str(out), 0
-}
-
-
-func (self *Parser) decodeValue() (val types.JsonState) {
-    e, v := decodeValue(self.s, self.p, self.dbuf == nil)
-    if e < 0 {
-        return v
-    }
-    self.p = e
-    return v
-}
-
-func (self *Parser) skip() (int, types.ParsingError) {
-    e, s := skipValue(self.s, self.p)
-    if e < 0 {
-        return self.p, types.ParsingError(-e)
-    }
-    self.p = e
-    return s, 0
-}
-
-func (self *Parser) skipFast() (int, types.ParsingError) {
-    e, s := skipValueFast(self.s, self.p)
-    if e < 0 {
-        return self.p, types.ParsingError(-e)
-    }
-    self.p = e
-    return s, 0
-}
-
-func (self *Node) encodeInterface(buf *[]byte) error {
-    out, err := json.Marshal(self.packAny())
-    if err != nil {
-        return err
-    }
-    *buf = append(*buf, out...)
-    return nil
-}
-
-func (self *Parser) getByPath(validate bool, path ...interface{}) (int, types.ParsingError) {
-    for _, p := range path {
-        if idx, ok := p.(int); ok && idx >= 0 {
-            if err := self.searchIndex(idx); err != 0 {
-                return self.p, err
-            }
-        } else if key, ok := p.(string); ok {
-            if err := self.searchKey(key); err != 0 {
-                return self.p, err
-            }
-        } else {
-            panic("path must be either int(>=0) or string")
-        }
-    }
-
-    var start int
-    var e types.ParsingError
-    if validate {
-        start, e = self.skip()
-    } else {
-        start, e = self.skipFast()
-    }
-    if e != 0 {
-        return self.p, e
-    }
-    return start, 0
-}
-
-func validate_utf8(str string) bool {
-    return utf8.ValidString(str)
-}
diff --git a/vendor/github.com/bytedance/sonic/ast/asm.s b/vendor/github.com/bytedance/sonic/ast/asm.s
deleted file mode 100644
index e69de29bb..000000000
--- a/vendor/github.com/bytedance/sonic/ast/asm.s
+++ /dev/null
diff --git a/vendor/github.com/bytedance/sonic/ast/buffer.go b/vendor/github.com/bytedance/sonic/ast/buffer.go
deleted file mode 100644
index 04701ef5b..000000000
--- a/vendor/github.com/bytedance/sonic/ast/buffer.go
+++ /dev/null
@@ -1,470 +0,0 @@
-/**
- * Copyright 2023 ByteDance Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package ast
-
-import (
-	"sort"
-	"unsafe"
-
-	"github.com/bytedance/sonic/internal/caching"
-)
-
-type nodeChunk [_DEFAULT_NODE_CAP]Node
-
-type linkedNodes struct {
-    head   nodeChunk
-    tail   []*nodeChunk
-    size   int
-}
-
-func (self *linkedNodes) Cap() int {
-    if self == nil {
-        return 0
-    }
-    return (len(self.tail)+1)*_DEFAULT_NODE_CAP 
-}
-
-func (self *linkedNodes) Len() int {
-    if self == nil {
-        return 0
-    }
-    return self.size 
-}
-
-func (self *linkedNodes) At(i int) (*Node) {
-    if self == nil {
-        return nil
-    }
-    if i >= 0 && i<self.size && i < _DEFAULT_NODE_CAP {
-        return &self.head[i]
-    } else if i >= _DEFAULT_NODE_CAP && i<self.size  {
-        a, b := i/_DEFAULT_NODE_CAP-1, i%_DEFAULT_NODE_CAP
-        if a < len(self.tail) {
-            return &self.tail[a][b]
-        }
-    }
-    return nil
-}
-
-func (self *linkedNodes) MoveOne(source int,  target int) {
-    if source == target {
-        return
-    }
-    if source < 0 || source >= self.size || target < 0 || target >= self.size {
-        return
-    }
-    // reserve source
-    n := *self.At(source)
-    if source < target {
-        // move every element (source,target] one step back
-        for i:=source; i<target; i++ {
-            *self.At(i) = *self.At(i+1)
-        } 
-    } else {
-        // move every element [target,source) one step forward
-        for i:=source; i>target; i-- {
-            *self.At(i) = *self.At(i-1)
-        }
-    } 
-    // set target
-    *self.At(target) = n
-}
-
-func (self *linkedNodes) Pop() {
-    if self == nil || self.size == 0 {
-        return
-    }
-    self.Set(self.size-1, Node{})
-    self.size--
-}
-
-func (self *linkedNodes) Push(v Node) {
-    self.Set(self.size, v)
-}
-
-
-func (self *linkedNodes) Set(i int, v Node) {
-    if i < _DEFAULT_NODE_CAP {
-        self.head[i] = v
-        if self.size <= i {
-            self.size = i+1
-        }
-        return
-    }
-    a, b := i/_DEFAULT_NODE_CAP-1, i%_DEFAULT_NODE_CAP
-    if a < 0 {
-        self.head[b] = v
-    } else {
-        self.growTailLength(a+1)
-        var n = &self.tail[a]
-        if *n == nil {
-            *n = new(nodeChunk)
-        }
-        (*n)[b] = v
-    }
-    if self.size <= i {
-        self.size = i+1
-    }
-}
-
-func (self *linkedNodes) growTailLength(l int) {
-    if l <= len(self.tail) {
-        return
-    }
-    c := cap(self.tail)
-    for c < l {
-        c += 1 + c>>_APPEND_GROW_SHIFT
-    }
-    if c == cap(self.tail) {
-        self.tail = self.tail[:l]
-        return
-    }
-    tmp := make([]*nodeChunk, l, c)
-    copy(tmp, self.tail)
-    self.tail = tmp
-}
-
-func (self *linkedNodes) ToSlice(con []Node) {
-    if len(con) < self.size {
-        return
-    }
-    i := (self.size-1)
-    a, b := i/_DEFAULT_NODE_CAP-1, i%_DEFAULT_NODE_CAP
-    if a < 0 {
-        copy(con, self.head[:b+1])
-        return
-    } else {
-        copy(con, self.head[:])
-        con = con[_DEFAULT_NODE_CAP:]
-    }
-
-    for i:=0; i<a; i++ {
-        copy(con, self.tail[i][:])
-        con = con[_DEFAULT_NODE_CAP:]
-    }
-    copy(con, self.tail[a][:b+1])
-}
-
-func (self *linkedNodes) FromSlice(con []Node) {
-    self.size = len(con)
-    i := self.size-1
-    a, b := i/_DEFAULT_NODE_CAP-1, i%_DEFAULT_NODE_CAP
-    if a < 0 {
-        copy(self.head[:b+1], con)
-        return
-    } else {
-        copy(self.head[:], con)
-        con = con[_DEFAULT_NODE_CAP:]
-    }
-
-    if cap(self.tail) <= a {
-        c := (a+1) + (a+1)>>_APPEND_GROW_SHIFT
-        self.tail = make([]*nodeChunk, a+1, c)
-    }
-    self.tail = self.tail[:a+1]
-
-    for i:=0; i<a; i++ {
-        self.tail[i] = new(nodeChunk)
-        copy(self.tail[i][:], con)
-        con = con[_DEFAULT_NODE_CAP:]
-    }
-
-    self.tail[a] = new(nodeChunk)
-    copy(self.tail[a][:b+1], con)
-}
-
-type pairChunk [_DEFAULT_NODE_CAP]Pair
-
-type linkedPairs struct {
-    index map[uint64]int
-    head pairChunk
-    tail []*pairChunk
-    size int
-}
-
-func (self *linkedPairs) BuildIndex() {
-    if self.index == nil {
-        self.index = make(map[uint64]int, self.size)
-    }
-    for i:=0; i<self.size; i++ {
-        p := self.At(i)
-        self.index[p.hash] = i
-    }
-}
-
-func (self *linkedPairs) Cap() int {
-    if self == nil {
-        return 0
-    }
-    return (len(self.tail)+1)*_DEFAULT_NODE_CAP 
-}
-
-func (self *linkedPairs) Len() int {
-    if self == nil {
-        return 0
-    }
-    return self.size 
-}
-
-func (self *linkedPairs) At(i int) *Pair {
-    if self == nil {
-        return nil
-    }
-    if i >= 0 && i < _DEFAULT_NODE_CAP && i<self.size {
-        return &self.head[i]
-    } else if i >= _DEFAULT_NODE_CAP && i<self.size {
-        a, b := i/_DEFAULT_NODE_CAP-1, i%_DEFAULT_NODE_CAP
-        if a < len(self.tail) {
-            return &self.tail[a][b]
-        }
-    }
-    return nil
-}
-
-func (self *linkedPairs) Push(v Pair) {
-    self.Set(self.size, v)
-}
-
-func (self *linkedPairs) Pop() {
-    if self == nil || self.size == 0 {
-        return
-    }
-    self.Unset(self.size-1)
-    self.size--
-}
-
-func (self *linkedPairs) Unset(i int) {
-    if self.index != nil {
-        p := self.At(i)
-        delete(self.index, p.hash)
-    }
-    self.set(i, Pair{}) 
-}
-
-func (self *linkedPairs) Set(i int, v Pair) {
-    if self.index != nil {
-        h := v.hash
-        self.index[h] = i
-    }
-    self.set(i, v)
-}
-
-func (self *linkedPairs) set(i int, v Pair) {
-    if i < _DEFAULT_NODE_CAP {
-        self.head[i] = v
-        if self.size <= i {
-            self.size = i+1
-        }
-        return
-    }
-    a, b := i/_DEFAULT_NODE_CAP-1, i%_DEFAULT_NODE_CAP
-    if a < 0 {
-        self.head[b] = v
-    } else {
-        self.growTailLength(a+1)
-        var n = &self.tail[a]
-        if *n == nil {
-            *n = new(pairChunk)
-        }
-        (*n)[b] = v
-    }
-    if self.size <= i {
-        self.size = i+1
-    }
-}
-
-func (self *linkedPairs) growTailLength(l int) {
-    if l <= len(self.tail) {
-        return
-    }
-    c := cap(self.tail)
-    for c < l {
-        c += 1 + c>>_APPEND_GROW_SHIFT
-    }
-    if c == cap(self.tail) {
-        self.tail = self.tail[:l]
-        return
-    }
-    tmp := make([]*pairChunk, l, c)
-    copy(tmp, self.tail)
-    self.tail = tmp
-}
-
-// linear search
-func (self *linkedPairs) Get(key string) (*Pair, int) {
-    if self.index != nil {
-        // fast-path
-        i, ok := self.index[caching.StrHash(key)]
-        if ok {
-            n := self.At(i)
-            if n.Key == key {
-                return n, i
-            }
-            // hash conflicts
-            goto linear_search
-        } else {
-            return nil, -1
-        }
-    }
-linear_search:
-    for i:=0; i<self.size; i++ {
-        if n := self.At(i); n.Key == key {
-            return n, i
-        }
-    }
-    return nil, -1
-}
-
-func (self *linkedPairs) ToSlice(con []Pair) {
-    if len(con) < self.size {
-        return
-    }
-    i := self.size-1
-    a, b := i/_DEFAULT_NODE_CAP-1, i%_DEFAULT_NODE_CAP
-
-    if a < 0 {
-        copy(con, self.head[:b+1])
-        return
-    } else {
-        copy(con, self.head[:])
-        con = con[_DEFAULT_NODE_CAP:]
-    }
-
-    for i:=0; i<a; i++ {
-        copy(con, self.tail[i][:])
-        con = con[_DEFAULT_NODE_CAP:]
-    }
-    copy(con, self.tail[a][:b+1])
-}
-
-func (self *linkedPairs) ToMap(con map[string]Node) {
-    for i:=0; i<self.size; i++ {
-        n := self.At(i)
-        con[n.Key] = n.Value
-    }
-}
-
-func (self *linkedPairs) copyPairs(to []Pair, from []Pair, l int) {
-    copy(to, from)
-    if self.index != nil {
-        for i:=0; i<l; i++ {
-            // NOTICE: in case of user not pass hash, just cal it
-            h := caching.StrHash(from[i].Key)
-            from[i].hash = h
-            self.index[h] = i
-        }
-    }
-}
-
-func (self *linkedPairs) FromSlice(con []Pair) {
-    self.size = len(con)
-    i := self.size-1
-    a, b := i/_DEFAULT_NODE_CAP-1, i%_DEFAULT_NODE_CAP
-    if a < 0 {
-        self.copyPairs(self.head[:b+1], con, b+1)
-        return
-    } else {
-        self.copyPairs(self.head[:], con, len(self.head))
-        con = con[_DEFAULT_NODE_CAP:]
-    }
-
-    if cap(self.tail) <= a {
-        c := (a+1) + (a+1)>>_APPEND_GROW_SHIFT
-        self.tail = make([]*pairChunk, a+1, c)
-    }
-    self.tail = self.tail[:a+1]
-
-    for i:=0; i<a; i++ {
-        self.tail[i] = new(pairChunk)
-        self.copyPairs(self.tail[i][:], con, len(self.tail[i]))
-        con = con[_DEFAULT_NODE_CAP:]
-    }
-
-    self.tail[a] = new(pairChunk)
-    self.copyPairs(self.tail[a][:b+1], con, b+1)
-}
-
-func (self *linkedPairs) Less(i, j int) bool {
-    return lessFrom(self.At(i).Key, self.At(j).Key, 0)
-}
-
-func (self *linkedPairs) Swap(i, j int) {
-    a, b := self.At(i), self.At(j)
-    if self.index != nil {
-        self.index[a.hash] = j
-        self.index[b.hash] = i
-    }
-    *a, *b = *b, *a
-}
-
-func (self *linkedPairs) Sort() {
-    sort.Stable(self)
-}
-
-// Compare two strings from the pos d.
-func lessFrom(a, b string, d int) bool {
-    l := len(a)
-    if l > len(b) {
-        l = len(b)
-    }
-    for i := d; i < l; i++ {
-        if a[i] == b[i] {
-            continue
-        }
-        return a[i] < b[i]
-    }
-    return len(a) < len(b)
-}
-
-type parseObjectStack struct {
-    parser Parser
-    v      linkedPairs
-}
-
-type parseArrayStack struct {
-    parser Parser
-    v      linkedNodes
-}
-
-func newLazyArray(p *Parser) Node {
-    s := new(parseArrayStack)
-    s.parser = *p
-    return Node{
-        t: _V_ARRAY_LAZY,
-        p: unsafe.Pointer(s),
-    }
-}
-
-func newLazyObject(p *Parser) Node {
-    s := new(parseObjectStack)
-    s.parser = *p
-    return Node{
-        t: _V_OBJECT_LAZY,
-        p: unsafe.Pointer(s),
-    }
-}
-
-func (self *Node) getParserAndArrayStack() (*Parser, *parseArrayStack) {
-    stack := (*parseArrayStack)(self.p)
-    return &stack.parser, stack
-}
-
-func (self *Node) getParserAndObjectStack() (*Parser, *parseObjectStack) {
-    stack := (*parseObjectStack)(self.p)
-    return &stack.parser, stack
-}
-
diff --git a/vendor/github.com/bytedance/sonic/ast/decode.go b/vendor/github.com/bytedance/sonic/ast/decode.go
deleted file mode 100644
index 135ee6eb8..000000000
--- a/vendor/github.com/bytedance/sonic/ast/decode.go
+++ /dev/null
@@ -1,562 +0,0 @@
-/*
- * Copyright 2022 ByteDance Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package ast
-
-import (
-	"encoding/base64"
-	"runtime"
-	"strconv"
-	"unsafe"
-
-	"github.com/bytedance/sonic/internal/native/types"
-	"github.com/bytedance/sonic/internal/rt"
-	"github.com/bytedance/sonic/internal/utils"
-)
-
-// Hack: this is used for both checking space and cause friendly compile errors in 32-bit arch.
-const _Sonic_Not_Support_32Bit_Arch__Checking_32Bit_Arch_Here = (1 << ' ') | (1 << '\t') | (1 << '\r') | (1 << '\n')
-
-var bytesNull   = []byte("null")
-
-const (
-    strNull   = "null"
-    bytesTrue   = "true"
-    bytesFalse  = "false"
-    bytesObject = "{}"
-    bytesArray  = "[]"
-)
-
-func isSpace(c byte) bool {
-    return (int(1<<c) & _Sonic_Not_Support_32Bit_Arch__Checking_32Bit_Arch_Here) != 0
-}
-
-//go:nocheckptr
-func skipBlank(src string, pos int) int {
-    se := uintptr(rt.IndexChar(src, len(src)))
-    sp := uintptr(rt.IndexChar(src, pos))
-
-    for sp < se {
-        if !isSpace(*(*byte)(unsafe.Pointer(sp))) {
-            break
-        }
-        sp += 1
-    }
-    if sp >= se {
-        return -int(types.ERR_EOF)
-    }
-    runtime.KeepAlive(src)
-    return int(sp - uintptr(rt.IndexChar(src, 0)))
-}
-
-func decodeNull(src string, pos int) (ret int) {
-    ret = pos + 4
-    if ret > len(src) {
-        return -int(types.ERR_EOF)
-    }
-    if src[pos:ret] == strNull {
-        return ret
-    } else {
-        return -int(types.ERR_INVALID_CHAR)
-    }
-}
-
-func decodeTrue(src string, pos int) (ret int) {
-    ret = pos + 4
-    if ret > len(src) {
-        return -int(types.ERR_EOF)
-    }
-    if src[pos:ret] == bytesTrue {
-        return ret
-    } else {
-        return -int(types.ERR_INVALID_CHAR)
-    }
-
-}
-
-func decodeFalse(src string, pos int) (ret int) {
-    ret = pos + 5
-    if ret > len(src) {
-        return -int(types.ERR_EOF)
-    }
-    if src[pos:ret] == bytesFalse {
-        return ret
-    }
-    return -int(types.ERR_INVALID_CHAR)
-}
-
-//go:nocheckptr
-func decodeString(src string, pos int) (ret int, v string) {
-    ret, ep := skipString(src, pos)
-    if ep == -1 {
-        (*rt.GoString)(unsafe.Pointer(&v)).Ptr = rt.IndexChar(src, pos+1)
-        (*rt.GoString)(unsafe.Pointer(&v)).Len = ret - pos - 2
-        return ret, v
-    }
-
-    vv, ok := unquoteBytes(rt.Str2Mem(src[pos:ret]))
-    if !ok {
-        return -int(types.ERR_INVALID_CHAR), ""
-    }
-
-    runtime.KeepAlive(src)
-    return ret, rt.Mem2Str(vv)
-}
-
-func decodeBinary(src string, pos int) (ret int, v []byte) {
-    var vv string
-    ret, vv = decodeString(src, pos)
-    if ret < 0 {
-        return ret, nil
-    }
-    var err error
-    v, err = base64.StdEncoding.DecodeString(vv)
-    if err != nil {
-        return -int(types.ERR_INVALID_CHAR), nil
-    }
-    return ret, v
-}
-
-func isDigit(c byte) bool {
-    return c >= '0' && c <= '9'
-}
-
-//go:nocheckptr
-func decodeInt64(src string, pos int) (ret int, v int64, err error) {
-    sp := uintptr(rt.IndexChar(src, pos))
-    ss := uintptr(sp)
-    se := uintptr(rt.IndexChar(src, len(src)))
-    if uintptr(sp) >= se {
-        return -int(types.ERR_EOF), 0, nil
-    }
-
-    if c := *(*byte)(unsafe.Pointer(sp)); c == '-' {
-        sp += 1
-    }
-    if sp == se {
-        return -int(types.ERR_EOF), 0, nil
-    }
-
-    for ; sp < se; sp += uintptr(1) {
-        if !isDigit(*(*byte)(unsafe.Pointer(sp))) {
-            break
-        }
-    }
-
-    if sp < se {
-        if c := *(*byte)(unsafe.Pointer(sp)); c == '.' || c == 'e' || c == 'E' {
-            return -int(types.ERR_INVALID_NUMBER_FMT), 0, nil
-        }
-    }
-
-    var vv string
-    ret = int(uintptr(sp) - uintptr((*rt.GoString)(unsafe.Pointer(&src)).Ptr))
-    (*rt.GoString)(unsafe.Pointer(&vv)).Ptr = unsafe.Pointer(ss)
-    (*rt.GoString)(unsafe.Pointer(&vv)).Len = ret - pos
-
-    v, err = strconv.ParseInt(vv, 10, 64)
-    if err != nil {
-        //NOTICE: allow overflow here
-        if err.(*strconv.NumError).Err == strconv.ErrRange {
-            return ret, 0, err
-        }
-        return -int(types.ERR_INVALID_CHAR), 0, err
-    }
-
-    runtime.KeepAlive(src)
-    return ret, v, nil
-}
-
-func isNumberChars(c byte) bool {
-    return (c >= '0' && c <= '9') || c == '+' || c == '-' || c == 'e' || c == 'E' || c == '.'
-}
-
-//go:nocheckptr
-func decodeFloat64(src string, pos int) (ret int, v float64, err error) {
-    sp := uintptr(rt.IndexChar(src, pos))
-    ss := uintptr(sp)
-    se := uintptr(rt.IndexChar(src, len(src)))
-    if uintptr(sp) >= se {
-        return -int(types.ERR_EOF), 0, nil
-    }
-
-    if c := *(*byte)(unsafe.Pointer(sp)); c == '-' {
-        sp += 1
-    }
-    if sp == se {
-        return -int(types.ERR_EOF), 0, nil
-    }
-
-    for ; sp < se; sp += uintptr(1) {
-        if !isNumberChars(*(*byte)(unsafe.Pointer(sp))) {
-            break
-        }
-    }
-
-    var vv string
-    ret = int(uintptr(sp) - uintptr((*rt.GoString)(unsafe.Pointer(&src)).Ptr))
-    (*rt.GoString)(unsafe.Pointer(&vv)).Ptr = unsafe.Pointer(ss)
-    (*rt.GoString)(unsafe.Pointer(&vv)).Len = ret - pos
-
-    v, err = strconv.ParseFloat(vv, 64)
-    if err != nil {
-        //NOTICE: allow overflow here
-        if err.(*strconv.NumError).Err == strconv.ErrRange {
-            return ret, 0, err
-        }
-        return -int(types.ERR_INVALID_CHAR), 0, err
-    }
-
-    runtime.KeepAlive(src)
-    return ret, v, nil
-}
-
-func decodeValue(src string, pos int, skipnum bool) (ret int, v types.JsonState) {
-    pos = skipBlank(src, pos)
-    if pos < 0 {
-        return pos, types.JsonState{Vt: types.ValueType(pos)}
-    }
-    switch c := src[pos]; c {
-    case 'n':
-        ret = decodeNull(src, pos)
-        if ret < 0 {
-            return ret, types.JsonState{Vt: types.ValueType(ret)}
-        }
-        return ret, types.JsonState{Vt: types.V_NULL}
-    case '"':
-        var ep int
-        ret, ep = skipString(src, pos)
-        if ret < 0 {
-            return ret, types.JsonState{Vt: types.ValueType(ret)}
-        }
-        return ret, types.JsonState{Vt: types.V_STRING, Iv: int64(pos + 1), Ep: ep}
-    case '{':
-        return pos + 1, types.JsonState{Vt: types.V_OBJECT}
-    case '[':
-        return pos + 1, types.JsonState{Vt: types.V_ARRAY}
-    case 't':
-        ret = decodeTrue(src, pos)
-        if ret < 0 {
-            return ret, types.JsonState{Vt: types.ValueType(ret)}
-        }
-        return ret, types.JsonState{Vt: types.V_TRUE}
-    case 'f':
-        ret = decodeFalse(src, pos)
-        if ret < 0 {
-            return ret, types.JsonState{Vt: types.ValueType(ret)}
-        }
-        return ret, types.JsonState{Vt: types.V_FALSE}
-    case '-', '+', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
-        if skipnum {
-            ret = skipNumber(src, pos)
-            if ret >= 0 {
-                return ret, types.JsonState{Vt: types.V_DOUBLE, Iv: 0, Ep: pos}
-            } else {
-                return ret, types.JsonState{Vt: types.ValueType(ret)}
-            }
-        } else {
-            var iv int64
-            ret, iv, _ = decodeInt64(src, pos)
-            if ret >= 0 {
-                return ret, types.JsonState{Vt: types.V_INTEGER, Iv: iv, Ep: pos}
-            } else if ret != -int(types.ERR_INVALID_NUMBER_FMT) {
-                return ret, types.JsonState{Vt: types.ValueType(ret)}
-            }
-            var fv float64
-            ret, fv, _ = decodeFloat64(src, pos)
-            if ret >= 0 {
-                return ret, types.JsonState{Vt: types.V_DOUBLE, Dv: fv, Ep: pos}
-            } else {
-                return ret, types.JsonState{Vt: types.ValueType(ret)}
-            }
-        }
-        
-    default:
-        return -int(types.ERR_INVALID_CHAR), types.JsonState{Vt:-types.ValueType(types.ERR_INVALID_CHAR)}
-    }
-}
-
-//go:nocheckptr
-func skipNumber(src string, pos int) (ret int) {
-    return utils.SkipNumber(src, pos)
-}
-
-//go:nocheckptr
-func skipString(src string, pos int) (ret int, ep int) {
-    if pos+1 >= len(src) {
-        return -int(types.ERR_EOF), -1
-    }
-
-    sp := uintptr(rt.IndexChar(src, pos))
-    se := uintptr(rt.IndexChar(src, len(src)))
-
-    // not start with quote
-    if *(*byte)(unsafe.Pointer(sp)) != '"' {
-        return -int(types.ERR_INVALID_CHAR), -1
-    }
-    sp += 1
-
-    ep = -1
-    for sp < se {
-        c := *(*byte)(unsafe.Pointer(sp))
-        if c == '\\' {
-            if ep == -1 {
-                ep = int(uintptr(sp) - uintptr((*rt.GoString)(unsafe.Pointer(&src)).Ptr))
-            }
-            sp += 2
-            continue
-        }
-        sp += 1
-        if c == '"' {
-            return int(uintptr(sp) - uintptr((*rt.GoString)(unsafe.Pointer(&src)).Ptr)), ep
-        }
-    }
-
-    runtime.KeepAlive(src)
-    // not found the closed quote until EOF
-    return -int(types.ERR_EOF), -1
-}
-
-//go:nocheckptr
-func skipPair(src string, pos int, lchar byte, rchar byte) (ret int) {
-    if pos+1 >= len(src) {
-        return -int(types.ERR_EOF)
-    }
-
-    sp := uintptr(rt.IndexChar(src, pos))
-    se := uintptr(rt.IndexChar(src, len(src)))
-
-    if *(*byte)(unsafe.Pointer(sp)) != lchar {
-        return -int(types.ERR_INVALID_CHAR)
-    }
-
-    sp += 1
-    nbrace := 1
-    inquote := false
-
-    for sp < se {
-        c := *(*byte)(unsafe.Pointer(sp))
-        if c == '\\' {
-            sp += 2
-            continue
-        } else if c == '"' {
-            inquote = !inquote
-        } else if c == lchar {
-            if !inquote {
-                nbrace += 1
-            }
-        } else if c == rchar {
-            if !inquote {
-                nbrace -= 1
-                if nbrace == 0 {
-                    sp += 1
-                    break
-                }
-            }
-        }
-        sp += 1
-    }
-
-    if nbrace != 0 {
-        return -int(types.ERR_INVALID_CHAR)
-    }
-
-    runtime.KeepAlive(src)
-    return int(uintptr(sp) - uintptr((*rt.GoString)(unsafe.Pointer(&src)).Ptr))
-}
-
-func skipValueFast(src string, pos int) (ret int, start int) {
-    pos = skipBlank(src, pos)
-    if pos < 0 {
-        return pos, -1
-    }
-    switch c := src[pos]; c {
-    case 'n':
-        ret = decodeNull(src, pos)
-    case '"':
-        ret, _ = skipString(src, pos)
-    case '{':
-        ret = skipPair(src, pos, '{', '}')
-    case '[':
-        ret = skipPair(src, pos, '[', ']')
-    case 't':
-        ret = decodeTrue(src, pos)
-    case 'f':
-        ret = decodeFalse(src, pos)
-    case '-', '+', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
-        ret = skipNumber(src, pos)
-    default:
-        ret = -int(types.ERR_INVALID_CHAR)
-    }
-    return ret, pos
-}
-
-func skipValue(src string, pos int) (ret int, start int) {
-    pos = skipBlank(src, pos)
-    if pos < 0 {
-        return pos, -1
-    }
-    switch c := src[pos]; c {
-    case 'n':
-        ret = decodeNull(src, pos)
-    case '"':
-        ret, _ = skipString(src, pos)
-    case '{':
-        ret, _ = skipObject(src, pos)
-    case '[':
-        ret, _ = skipArray(src, pos)
-    case 't':
-        ret = decodeTrue(src, pos)
-    case 'f':
-        ret = decodeFalse(src, pos)
-    case '-', '+', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
-        ret = skipNumber(src, pos)
-    default:
-        ret = -int(types.ERR_INVALID_CHAR)
-    }
-    return ret, pos
-}
-
-func skipObject(src string, pos int) (ret int, start int) {
-    start = skipBlank(src, pos)
-    if start < 0 {
-        return start, -1
-    }
-
-    if src[start] != '{' {
-        return -int(types.ERR_INVALID_CHAR), -1
-    }
-
-    pos = start + 1
-    pos = skipBlank(src, pos)
-    if pos < 0 {
-        return pos, -1
-    }
-    if src[pos] == '}' {
-        return pos + 1, start
-    }
-
-    for {
-        pos, _ = skipString(src, pos)
-        if pos < 0 {
-            return pos, -1
-        }
-
-        pos = skipBlank(src, pos)
-        if pos < 0 {
-            return pos, -1
-        }
-        if src[pos] != ':' {
-            return -int(types.ERR_INVALID_CHAR), -1
-        }
-
-        pos++
-        pos, _ = skipValue(src, pos)
-        if pos < 0 {
-            return pos, -1
-        }
-
-        pos = skipBlank(src, pos)
-        if pos < 0 {
-            return pos, -1
-        }
-        if src[pos] == '}' {
-            return pos + 1, start
-        }
-        if src[pos] != ',' {
-            return -int(types.ERR_INVALID_CHAR), -1
-        }
-
-        pos++
-        pos = skipBlank(src, pos)
-        if pos < 0 {
-            return pos, -1
-        }
-
-    }
-}
-
-func skipArray(src string, pos int) (ret int, start int) {
-    start = skipBlank(src, pos)
-    if start < 0 {
-        return start, -1
-    }
-
-    if src[start] != '[' {
-        return -int(types.ERR_INVALID_CHAR), -1
-    }
-
-    pos = start + 1
-    pos = skipBlank(src, pos)
-    if pos < 0 {
-        return pos, -1
-    }
-    if src[pos] == ']' {
-        return pos + 1, start
-    }
-
-    for {
-        pos, _ = skipValue(src, pos)
-        if pos < 0 {
-            return pos, -1
-        }
-
-        pos = skipBlank(src, pos)
-        if pos < 0 {
-            return pos, -1
-        }
-        if src[pos] == ']' {
-            return pos + 1, start
-        }
-        if src[pos] != ',' {
-            return -int(types.ERR_INVALID_CHAR), -1
-        }
-        pos++
-    }
-}
-
-// DecodeString decodes a JSON string from pos and return golang string.
-//   - needEsc indicates if to unescaped escaping chars
-//   - hasEsc tells if the returned string has escaping chars
-//   - validStr enables validating UTF8 charset
-//
-func _DecodeString(src string, pos int, needEsc bool, validStr bool) (v string, ret int, hasEsc bool) {
-    p := NewParserObj(src)
-    p.p = pos
-    switch val := p.decodeValue(); val.Vt {
-    case types.V_STRING:
-        str := p.s[val.Iv : p.p-1]
-        if validStr && !validate_utf8(str) {
-           return "", -int(types.ERR_INVALID_UTF8), false
-        }
-        /* fast path: no escape sequence */
-        if val.Ep == -1 {
-            return str, p.p, false
-        } else if !needEsc {
-            return str, p.p, true
-        }
-        /* unquote the string */
-        out, err := unquote(str)
-        /* check for errors */
-        if err != 0 {
-            return "", -int(err), true
-        } else {
-            return out, p.p, true
-        }
-    default:
-        return "", -int(_ERR_UNSUPPORT_TYPE), false
-    }
-}
diff --git a/vendor/github.com/bytedance/sonic/ast/encode.go b/vendor/github.com/bytedance/sonic/ast/encode.go
deleted file mode 100644
index eae0bd258..000000000
--- a/vendor/github.com/bytedance/sonic/ast/encode.go
+++ /dev/null
@@ -1,274 +0,0 @@
-/*
- * Copyright 2021 ByteDance Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package ast
-
-import (
-	"sync"
-	"unicode/utf8"
-
-	"github.com/bytedance/sonic/internal/rt"
-    "github.com/bytedance/sonic/option"
-)
-
-func quoteString(e *[]byte, s string) {
-    *e = append(*e, '"')
-    start := 0
-    for i := 0; i < len(s); {
-        if b := s[i]; b < utf8.RuneSelf {
-            if rt.SafeSet[b] {
-                i++
-                continue
-            }
-            if start < i {
-                *e = append(*e, s[start:i]...)
-            }
-            *e = append(*e, '\\')
-            switch b {
-            case '\\', '"':
-                *e = append(*e, b)
-            case '\n':
-                *e = append(*e, 'n')
-            case '\r':
-                *e = append(*e, 'r')
-            case '\t':
-                *e = append(*e, 't')
-            default:
-                // This encodes bytes < 0x20 except for \t, \n and \r.
-                // If escapeHTML is set, it also escapes <, >, and &
-                // because they can lead to security holes when
-                // user-controlled strings are rendered into JSON
-                // and served to some browsers.
-                *e = append(*e, `u00`...)
-                *e = append(*e, rt.Hex[b>>4])
-                *e = append(*e, rt.Hex[b&0xF])
-            }
-            i++
-            start = i
-            continue
-        }
-        c, size := utf8.DecodeRuneInString(s[i:])
-        // if c == utf8.RuneError && size == 1 {
-        //     if start < i {
-        //         e.Write(s[start:i])
-        //     }
-        //     e.WriteString(`\ufffd`)
-        //     i += size
-        //     start = i
-        //     continue
-        // }
-        if c == '\u2028' || c == '\u2029' {
-            if start < i {
-                *e = append(*e, s[start:i]...)
-            }
-            *e = append(*e, `\u202`...)
-            *e = append(*e, rt.Hex[c&0xF])
-            i += size
-            start = i
-            continue
-        }
-        i += size
-    }
-    if start < len(s) {
-        *e = append(*e, s[start:]...)
-    }
-    *e = append(*e, '"')
-}
-
-var bytesPool   = sync.Pool{}
-
-func (self *Node) MarshalJSON() ([]byte, error) {
-	if self == nil {
-		return bytesNull, nil
-	}
-
-    buf := newBuffer()
-    err := self.encode(buf)
-    if err != nil {
-        freeBuffer(buf)
-        return nil, err
-    }
-    var ret []byte
-    if !rt.CanSizeResue(cap(*buf)) {
-        ret = *buf
-    } else {
-        ret = make([]byte, len(*buf))
-        copy(ret, *buf)
-        freeBuffer(buf)
-    }
-    return ret, err
-}
-
-func newBuffer() *[]byte {
-    if ret := bytesPool.Get(); ret != nil {
-        return ret.(*[]byte)
-    } else {
-        buf := make([]byte, 0, option.DefaultAstBufferSize)
-        return &buf
-    }
-}
-
-func freeBuffer(buf *[]byte) {
-    if !rt.CanSizeResue(cap(*buf)) {
-        return
-    }
-    *buf = (*buf)[:0]
-    bytesPool.Put(buf)
-}
-
-func (self *Node) encode(buf *[]byte) error {
-    if self.isRaw() {
-        return self.encodeRaw(buf)
-    }
-    switch int(self.itype()) {
-        case V_NONE  : return ErrNotExist
-        case V_ERROR : return self.Check()
-        case V_NULL  : return self.encodeNull(buf)
-        case V_TRUE  : return self.encodeTrue(buf)
-        case V_FALSE : return self.encodeFalse(buf)
-        case V_ARRAY : return self.encodeArray(buf)
-        case V_OBJECT: return self.encodeObject(buf)
-        case V_STRING: return self.encodeString(buf)
-        case V_NUMBER: return self.encodeNumber(buf)
-        case V_ANY   : return self.encodeInterface(buf)
-        default      : return ErrUnsupportType 
-    }
-}
-
-func (self *Node) encodeRaw(buf *[]byte) error {
-    lock := self.rlock()
-    if !self.isRaw() {
-        self.runlock()
-        return self.encode(buf)
-    }
-    raw := self.toString()
-    if lock {
-        self.runlock()
-    }
-    *buf = append(*buf, raw...)
-    return nil
-}
-
-func (self *Node) encodeNull(buf *[]byte) error {
-    *buf = append(*buf, strNull...)
-    return nil
-}
-
-func (self *Node) encodeTrue(buf *[]byte) error {
-    *buf = append(*buf, bytesTrue...)
-    return nil
-}
-
-func (self *Node) encodeFalse(buf *[]byte) error {
-    *buf = append(*buf, bytesFalse...)
-    return nil
-}
-
-func (self *Node) encodeNumber(buf *[]byte) error {
-    str := self.toString()
-    *buf = append(*buf, str...)
-    return nil
-}
-
-func (self *Node) encodeString(buf *[]byte) error {
-    if self.l == 0 {
-        *buf = append(*buf, '"', '"')
-        return nil
-    }
-
-    quote(buf, self.toString())
-    return nil
-}
-
-func (self *Node) encodeArray(buf *[]byte) error {
-    if self.isLazy() {
-        if err := self.skipAllIndex(); err != nil {
-            return err
-        }
-    }
-
-    nb := self.len()
-    if nb == 0 {
-        *buf = append(*buf, bytesArray...)
-        return nil
-    }
-    
-    *buf = append(*buf, '[')
-
-    var started bool
-    for i := 0; i < nb; i++ {
-        n := self.nodeAt(i)
-        if !n.Exists() {
-            continue
-        }
-        if started {
-            *buf = append(*buf, ',')
-        }
-        started = true
-        if err := n.encode(buf); err != nil {
-            return err
-        }
-    }
-
-    *buf = append(*buf, ']')
-    return nil
-}
-
-func (self *Pair) encode(buf *[]byte) error {
-    if len(*buf) == 0 {
-        *buf = append(*buf, '"', '"', ':')
-        return self.Value.encode(buf)
-    }
-
-    quote(buf, self.Key)
-    *buf = append(*buf, ':')
-
-    return self.Value.encode(buf)
-}
-
-func (self *Node) encodeObject(buf *[]byte) error {
-    if self.isLazy() {
-        if err := self.skipAllKey(); err != nil {
-            return err
-        }
-    }
-    
-    nb := self.len()
-    if nb == 0 {
-        *buf = append(*buf, bytesObject...)
-        return nil
-    }
-    
-    *buf = append(*buf, '{')
-
-    var started bool
-    for i := 0; i < nb; i++ {
-        n := self.pairAt(i)
-        if n == nil || !n.Value.Exists() {
-            continue
-        }
-        if started {
-            *buf = append(*buf, ',')
-        }
-        started = true
-        if err := n.encode(buf); err != nil {
-            return err
-        }
-    }
-
-    *buf = append(*buf, '}')
-    return nil
-}
diff --git a/vendor/github.com/bytedance/sonic/ast/error.go b/vendor/github.com/bytedance/sonic/ast/error.go
deleted file mode 100644
index 3716e7a91..000000000
--- a/vendor/github.com/bytedance/sonic/ast/error.go
+++ /dev/null
@@ -1,134 +0,0 @@
-package ast
-
-import (
-    `fmt`
-    `strings`
-    `unsafe`
-
-    `github.com/bytedance/sonic/internal/native/types`
-)
-
-
-func newError(err types.ParsingError, msg string) *Node {
-    return &Node{
-        t: V_ERROR,
-        l: uint(err),
-        p: unsafe.Pointer(&msg),
-    }
-}
-
-func newErrorPair(err SyntaxError) *Pair {
-   return &Pair{0, "", *newSyntaxError(err)}
-}
-
-// Error returns error message if the node is invalid
-func (self Node) Error() string {
-    if self.t != V_ERROR {
-        return ""
-    } else {
-        return *(*string)(self.p)
-    } 
-}
-
-func newSyntaxError(err SyntaxError) *Node {
-    msg := err.Description()
-    return &Node{
-        t: V_ERROR,
-        l: uint(err.Code),
-        p: unsafe.Pointer(&msg),
-    }
-}
-
-func (self *Parser) syntaxError(err types.ParsingError) SyntaxError {
-    return SyntaxError{
-        Pos : self.p,
-        Src : self.s,
-        Code: err,
-    }
-}
-
-func unwrapError(err error) *Node {
-    if se, ok := err.(*Node); ok {
-        return se
-    }else if sse, ok := err.(Node); ok {
-        return &sse
-    } else {
-        msg := err.Error()
-        return &Node{
-            t: V_ERROR,
-            p: unsafe.Pointer(&msg),
-        }
-    }
-}
-
-type SyntaxError struct {
-    Pos  int
-    Src  string
-    Code types.ParsingError
-    Msg  string
-}
-
-func (self SyntaxError) Error() string {
-    return fmt.Sprintf("%q", self.Description())
-}
-
-func (self SyntaxError) Description() string {
-    return "Syntax error " + self.description()
-}
-
-func (self SyntaxError) description() string {
-    i := 16
-    p := self.Pos - i
-    q := self.Pos + i
-
-    /* check for empty source */
-    if self.Src == "" {
-        return fmt.Sprintf("no sources available, the input json is empty: %#v", self)
-    }
-
-    /* prevent slicing before the beginning */
-    if p < 0 {
-        p, q, i = 0, q - p, i + p
-    }
-
-    /* prevent slicing beyond the end */
-    if n := len(self.Src); q > n {
-        n = q - n
-        q = len(self.Src)
-
-        /* move the left bound if possible */
-        if p > n {
-            i += n
-            p -= n
-        }
-    }
-
-    /* left and right length */
-    x := clamp_zero(i)
-    y := clamp_zero(q - p - i - 1)
-
-    /* compose the error description */
-    return fmt.Sprintf(
-        "at index %d: %s\n\n\t%s\n\t%s^%s\n",
-        self.Pos,
-        self.Message(),
-        self.Src[p:q],
-        strings.Repeat(".", x),
-        strings.Repeat(".", y),
-    )
-}
-
-func (self SyntaxError) Message() string {
-    if self.Msg == "" {
-        return self.Code.Message()
-    }
-    return self.Msg
-}
-
-func clamp_zero(v int) int {
-    if v < 0 {
-        return 0
-    } else {
-        return v
-    }
-}
diff --git a/vendor/github.com/bytedance/sonic/ast/iterator.go b/vendor/github.com/bytedance/sonic/ast/iterator.go
deleted file mode 100644
index 1052dd0a0..000000000
--- a/vendor/github.com/bytedance/sonic/ast/iterator.go
+++ /dev/null
@@ -1,216 +0,0 @@
-/*
- * Copyright 2021 ByteDance Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package ast
-
-import (
-	"fmt"
-
-	"github.com/bytedance/sonic/internal/caching"
-	"github.com/bytedance/sonic/internal/native/types"
-)
-
-type Pair struct {
-    hash  uint64
-    Key   string
-    Value Node
-}
-
-func NewPair(key string, val Node) Pair {
-    return Pair{
-        hash: caching.StrHash(key),
-        Key: key,
-        Value: val,
-    }
-}
-
-// Values returns iterator for array's children traversal
-func (self *Node) Values() (ListIterator, error) {
-    if err := self.should(types.V_ARRAY); err != nil {
-        return ListIterator{}, err
-    }
-    return self.values(), nil
-}
-
-func (self *Node) values() ListIterator {
-    return ListIterator{Iterator{p: self}}
-}
-
-// Properties returns iterator for object's children traversal
-func (self *Node) Properties() (ObjectIterator, error) {
-    if err := self.should(types.V_OBJECT); err != nil {
-        return ObjectIterator{}, err
-    }
-    return self.properties(), nil
-}
-
-func (self *Node) properties() ObjectIterator {
-    return ObjectIterator{Iterator{p: self}}
-}
-
-type Iterator struct {
-    i int
-    p *Node
-}
-
-func (self *Iterator) Pos() int {
-    return self.i
-}
-
-func (self *Iterator) Len() int {
-    return self.p.len()
-}
-
-// HasNext reports if it is the end of iteration or has error.
-func (self *Iterator) HasNext() bool {
-    if !self.p.isLazy() {
-        return self.p.Valid() && self.i < self.p.len()
-    } else if self.p.t == _V_ARRAY_LAZY {
-        return self.p.skipNextNode().Valid()
-    } else if self.p.t == _V_OBJECT_LAZY {
-        pair := self.p.skipNextPair()
-        if pair == nil {
-            return false
-        }
-        return pair.Value.Valid()
-    }
-    return false
-}
-
-// ListIterator is specialized iterator for V_ARRAY
-type ListIterator struct {
-    Iterator
-}
-
-// ObjectIterator is specialized iterator for V_ARRAY
-type ObjectIterator struct {
-    Iterator
-}
-
-func (self *ListIterator) next() *Node {
-next_start:
-    if !self.HasNext() {
-        return nil
-    } else {
-        n := self.p.nodeAt(self.i)
-        self.i++
-        if !n.Exists() {
-            goto next_start
-        }
-        return n
-    }
-}
-
-// Next scans through children of underlying V_ARRAY, 
-// copies each child to v, and returns .HasNext().
-func (self *ListIterator) Next(v *Node) bool {
-    n := self.next()
-    if n == nil {
-        return false
-    }
-    *v = *n
-    return true
-}
-
-func (self *ObjectIterator) next() *Pair {
-next_start:
-    if !self.HasNext() {
-        return nil
-    } else {
-        n := self.p.pairAt(self.i)
-        self.i++
-        if n == nil || !n.Value.Exists() {
-            goto next_start
-        }
-        return n
-    }
-}
-
-// Next scans through children of underlying V_OBJECT, 
-// copies each child to v, and returns .HasNext().
-func (self *ObjectIterator) Next(p *Pair) bool {
-    n := self.next()
-    if n == nil {
-        return false
-    }
-    *p = *n
-    return true
-}
-
-// Sequence represents scanning path of single-layer nodes.
-// Index indicates the value's order in both V_ARRAY and V_OBJECT json.
-// Key is the value's key (for V_OBJECT json only, otherwise it will be nil).
-type Sequence struct {
-    Index int 
-    Key *string
-    // Level int
-}
-
-// String is string representation of one Sequence
-func (s Sequence) String() string {
-    k := ""
-    if s.Key != nil {
-        k = *s.Key
-    }
-    return fmt.Sprintf("Sequence(%d, %q)", s.Index, k)
-}
-
-type Scanner func(path Sequence, node *Node) bool
-
-// ForEach scans one V_OBJECT node's children from JSON head to tail, 
-// and pass the Sequence and Node of corresponding JSON value.
-//
-// Especially, if the node is not V_ARRAY or V_OBJECT,
-// the node itself will be returned and Sequence.Index == -1.
-// 
-// NOTICE: A unsetted node WON'T trigger sc, but its index still counts into Path.Index
-func (self *Node) ForEach(sc Scanner) error {
-    if err := self.checkRaw(); err != nil {
-        return err
-    }
-    switch self.itype() {
-    case types.V_ARRAY:
-        iter, err := self.Values()
-        if err != nil {
-            return err
-        }
-        v := iter.next()
-        for v != nil {
-            if !sc(Sequence{iter.i-1, nil}, v) {
-                return nil
-            }
-            v = iter.next()
-        }
-    case types.V_OBJECT:
-        iter, err := self.Properties()
-        if err != nil {
-            return err
-        }
-        v := iter.next()
-        for v != nil {
-            if !sc(Sequence{iter.i-1, &v.Key}, &v.Value) {
-                return nil
-            }
-            v = iter.next()
-        }
-    default:
-        if self.Check() != nil {
-            return self
-        }
-        sc(Sequence{-1, nil}, self)
-    }
-    return nil
-}
diff --git a/vendor/github.com/bytedance/sonic/ast/node.go b/vendor/github.com/bytedance/sonic/ast/node.go
deleted file mode 100644
index 2bb504850..000000000
--- a/vendor/github.com/bytedance/sonic/ast/node.go
+++ /dev/null
@@ -1,1843 +0,0 @@
-/*
- * Copyright 2021 ByteDance Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package ast
-
-import (
-	"encoding/json"
-	"fmt"
-	"strconv"
-	"sync"
-	"sync/atomic"
-	"unsafe"
-
-	"github.com/bytedance/sonic/internal/native/types"
-	"github.com/bytedance/sonic/internal/rt"
-)
-
-const (
-    _V_NONE         types.ValueType = 0
-    _V_NODE_BASE    types.ValueType = 1 << 5
-    _V_LAZY         types.ValueType = 1 << 7
-    _V_RAW          types.ValueType = 1 << 8
-    _V_NUMBER                       = _V_NODE_BASE + 1
-    _V_ANY                          = _V_NODE_BASE + 2
-    _V_ARRAY_LAZY                   = _V_LAZY | types.V_ARRAY
-    _V_OBJECT_LAZY                  = _V_LAZY | types.V_OBJECT
-    _MASK_LAZY                      = _V_LAZY - 1
-    _MASK_RAW                      = _V_RAW - 1
-)
-
-const (
-    V_NONE   = 0
-    V_ERROR  = 1
-    V_NULL   = int(types.V_NULL)
-    V_TRUE   = int(types.V_TRUE)
-    V_FALSE  = int(types.V_FALSE)
-    V_ARRAY  = int(types.V_ARRAY)
-    V_OBJECT = int(types.V_OBJECT)
-    V_STRING = int(types.V_STRING)
-    V_NUMBER = int(_V_NUMBER)
-    V_ANY    = int(_V_ANY)
-)
-
-type Node struct {
-    t types.ValueType
-    l uint
-    p unsafe.Pointer
-    m *sync.RWMutex
-}
-
-// UnmarshalJSON is just an adapter to json.Unmarshaler.
-// If you want better performance, use Searcher.GetByPath() directly
-func (self *Node) UnmarshalJSON(data []byte) (err error) {
-    *self = NewRaw(string(data))
-    return self.Check()
-}
-
-/** Node Type Accessor **/
-
-// Type returns json type represented by the node
-// It will be one of belows:
-//    V_NONE   = 0 (empty node, key not exists)
-//    V_ERROR  = 1 (error node)
-//    V_NULL   = 2 (json value `null`, key exists)
-//    V_TRUE   = 3 (json value `true`)
-//    V_FALSE  = 4 (json value `false`)
-//    V_ARRAY  = 5 (json value array)
-//    V_OBJECT = 6 (json value object)
-//    V_STRING = 7 (json value string)
-//    V_NUMBER = 33 (json value number )
-//    V_ANY    = 34 (golang interface{})
-//
-// Deprecated: not concurrent safe. Use TypeSafe instead
-func (self Node) Type() int {
-    return int(self.t & _MASK_LAZY & _MASK_RAW)
-}
-
-// Type concurrently-safe returns json type represented by the node
-// It will be one of belows:
-//    V_NONE   = 0 (empty node, key not exists)
-//    V_ERROR  = 1 (error node)
-//    V_NULL   = 2 (json value `null`, key exists)
-//    V_TRUE   = 3 (json value `true`)
-//    V_FALSE  = 4 (json value `false`)
-//    V_ARRAY  = 5 (json value array)
-//    V_OBJECT = 6 (json value object)
-//    V_STRING = 7 (json value string)
-//    V_NUMBER = 33 (json value number )
-//    V_ANY    = 34 (golang interface{})
-func (self *Node) TypeSafe() int {
-    return int(self.loadt() & _MASK_LAZY & _MASK_RAW)
-}
-
-func (self *Node) itype() types.ValueType {
-    return self.t & _MASK_LAZY & _MASK_RAW
-}
-
-// Exists returns false only if the self is nil or empty node V_NONE
-func (self *Node) Exists() bool {
-    if self == nil {
-        return false
-    }
-    t := self.loadt()
-    return t != V_ERROR && t != _V_NONE
-}
-
-// Valid reports if self is NOT V_ERROR or nil
-func (self *Node) Valid() bool {
-    if self == nil {
-        return false
-    }
-    return self.loadt() != V_ERROR
-}
-
-// Check checks if the node itself is valid, and return:
-//   - ErrNotExist If the node is nil
-//   - Its underlying error If the node is V_ERROR
-func (self *Node)  Check() error {
-    if self == nil {
-        return ErrNotExist
-    } else if self.loadt() != V_ERROR {
-        return nil
-    } else {
-        return self
-    }
-}
-
-// isRaw returns true if node's underlying value is raw json
-//
-// Deprecated: not concurrent safe
-func (self Node) IsRaw() bool {
-    return self.t & _V_RAW != 0
-}
-
-// IsRaw returns true if node's underlying value is raw json
-func (self *Node) isRaw() bool {
-    return self.loadt() & _V_RAW != 0
-}
-
-func (self *Node) isLazy() bool {
-    return self != nil && self.t & _V_LAZY != 0
-}
-
-func (self *Node) isAny() bool {
-    return self != nil && self.loadt() == _V_ANY
-}
-
-/** Simple Value Methods **/
-
-// Raw returns json representation of the node,
-func (self *Node) Raw() (string, error) {
-    if self == nil {
-        return "", ErrNotExist
-    }
-    lock := self.rlock()
-    if !self.isRaw() {
-        if lock {
-            self.runlock()
-        }
-        buf, err := self.MarshalJSON()
-        return rt.Mem2Str(buf), err
-    }
-    ret := self.toString()
-    if lock {
-        self.runlock()
-    }
-    return ret, nil
-}
-
-func (self *Node) checkRaw() error {
-    if err := self.Check(); err != nil {
-        return err
-    }
-    if self.isRaw() {
-        self.parseRaw(false)
-    }
-    return self.Check()
-}
-
-// Bool returns bool value represented by this node, 
-// including types.V_TRUE|V_FALSE|V_NUMBER|V_STRING|V_ANY|V_NULL, 
-// V_NONE will return error
-func (self *Node) Bool() (bool, error) {
-    if err := self.checkRaw(); err != nil {
-        return false, err
-    }
-    switch self.t {
-        case types.V_TRUE  : return true , nil
-        case types.V_FALSE : return false, nil
-        case types.V_NULL  : return false, nil
-        case _V_NUMBER     : 
-            if i, err := self.toInt64(); err == nil {
-                return i != 0, nil
-            } else if f, err := self.toFloat64(); err == nil {
-                return f != 0, nil
-            } else {
-                return false, err
-            }
-        case types.V_STRING: return strconv.ParseBool(self.toString())
-        case _V_ANY        :   
-            any := self.packAny()     
-            switch v := any.(type) {
-                case bool   : return v, nil
-                case int    : return v != 0, nil
-                case int8   : return v != 0, nil
-                case int16  : return v != 0, nil
-                case int32  : return v != 0, nil
-                case int64  : return v != 0, nil
-                case uint   : return v != 0, nil
-                case uint8  : return v != 0, nil
-                case uint16 : return v != 0, nil
-                case uint32 : return v != 0, nil
-                case uint64 : return v != 0, nil
-                case float32: return v != 0, nil
-                case float64: return v != 0, nil
-                case string : return strconv.ParseBool(v)
-                case json.Number: 
-                    if i, err := v.Int64(); err == nil {
-                        return i != 0, nil
-                    } else if f, err := v.Float64(); err == nil {
-                        return f != 0, nil
-                    } else {
-                        return false, err
-                    }
-                default: return false, ErrUnsupportType
-            }
-        default            : return false, ErrUnsupportType
-    }
-}
-
-// Int64 casts the node to int64 value, 
-// including V_NUMBER|V_TRUE|V_FALSE|V_ANY|V_STRING
-// V_NONE it will return error
-func (self *Node) Int64() (int64, error) {
-    if err := self.checkRaw(); err != nil {
-        return 0, err
-    }
-    switch self.t {
-        case _V_NUMBER, types.V_STRING :
-            if i, err := self.toInt64(); err == nil {
-                return i, nil
-            } else if f, err := self.toFloat64(); err == nil {
-                return int64(f), nil
-            } else {
-                return 0, err
-            }
-        case types.V_TRUE     : return 1, nil
-        case types.V_FALSE    : return 0, nil
-        case types.V_NULL     : return 0, nil
-        case _V_ANY           :  
-            any := self.packAny()
-            switch v := any.(type) {
-                case bool   : if v { return 1, nil } else { return 0, nil }
-                case int    : return int64(v), nil
-                case int8   : return int64(v), nil
-                case int16  : return int64(v), nil
-                case int32  : return int64(v), nil
-                case int64  : return int64(v), nil
-                case uint   : return int64(v), nil
-                case uint8  : return int64(v), nil
-                case uint16 : return int64(v), nil
-                case uint32 : return int64(v), nil
-                case uint64 : return int64(v), nil
-                case float32: return int64(v), nil
-                case float64: return int64(v), nil
-                case string : 
-                    if i, err := strconv.ParseInt(v, 10, 64); err == nil {
-                        return i, nil
-                    } else if f, err := strconv.ParseFloat(v, 64); err == nil {
-                        return int64(f), nil
-                    } else {
-                        return 0, err
-                    }
-                case json.Number: 
-                    if i, err := v.Int64(); err == nil {
-                        return i, nil
-                    } else if f, err := v.Float64(); err == nil {
-                        return int64(f), nil
-                    } else {
-                        return 0, err
-                    }
-                default: return 0, ErrUnsupportType
-            }
-        default               : return 0, ErrUnsupportType
-    }
-}
-
-// StrictInt64 exports underlying int64 value, including V_NUMBER, V_ANY
-func (self *Node) StrictInt64() (int64, error) {
-    if err := self.checkRaw(); err != nil {
-        return 0, err
-    }
-    switch self.t {
-        case _V_NUMBER        : return self.toInt64()
-        case _V_ANY           :  
-            any := self.packAny()
-            switch v := any.(type) {
-                case int   : return int64(v), nil
-                case int8  : return int64(v), nil
-                case int16 : return int64(v), nil
-                case int32 : return int64(v), nil
-                case int64 : return int64(v), nil
-                case uint  : return int64(v), nil
-                case uint8 : return int64(v), nil
-                case uint16: return int64(v), nil
-                case uint32: return int64(v), nil
-                case uint64: return int64(v), nil
-                case json.Number: 
-                    if i, err := v.Int64(); err == nil {
-                        return i, nil
-                    } else {
-                        return 0, err
-                    }
-                default: return 0, ErrUnsupportType
-            }
-        default               : return 0, ErrUnsupportType
-    }
-}
-
-func castNumber(v bool) json.Number {
-    if v {
-        return json.Number("1")
-    } else {
-        return json.Number("0")
-    }
-}
-
-// Number casts node to float64, 
-// including V_NUMBER|V_TRUE|V_FALSE|V_ANY|V_STRING|V_NULL,
-// V_NONE it will return error
-func (self *Node) Number() (json.Number, error) {
-    if err := self.checkRaw(); err != nil {
-        return json.Number(""), err
-    }
-    switch self.t {
-        case _V_NUMBER        : return self.toNumber(), nil
-        case types.V_STRING : 
-            if _, err := self.toInt64(); err == nil {
-                return self.toNumber(), nil
-            } else if _, err := self.toFloat64(); err == nil {
-                return self.toNumber(), nil
-            } else {
-                return json.Number(""), err
-            }
-        case types.V_TRUE     : return json.Number("1"), nil
-        case types.V_FALSE    : return json.Number("0"), nil
-        case types.V_NULL     : return json.Number("0"), nil
-        case _V_ANY           :        
-            any := self.packAny()
-            switch v := any.(type) {
-                case bool   : return castNumber(v), nil
-                case int    : return castNumber(v != 0), nil
-                case int8   : return castNumber(v != 0), nil
-                case int16  : return castNumber(v != 0), nil
-                case int32  : return castNumber(v != 0), nil
-                case int64  : return castNumber(v != 0), nil
-                case uint   : return castNumber(v != 0), nil
-                case uint8  : return castNumber(v != 0), nil
-                case uint16 : return castNumber(v != 0), nil
-                case uint32 : return castNumber(v != 0), nil
-                case uint64 : return castNumber(v != 0), nil
-                case float32: return castNumber(v != 0), nil
-                case float64: return castNumber(v != 0), nil
-                case string : 
-                    if _, err := strconv.ParseFloat(v, 64); err == nil {
-                        return json.Number(v), nil
-                    } else {
-                        return json.Number(""), err
-                    }
-                case json.Number: return v, nil
-                default: return json.Number(""), ErrUnsupportType
-            }
-        default               : return json.Number(""), ErrUnsupportType
-    }
-}
-
-// Number exports underlying float64 value, including V_NUMBER, V_ANY of json.Number
-func (self *Node) StrictNumber() (json.Number, error) {
-    if err := self.checkRaw(); err != nil {
-        return json.Number(""), err
-    }
-    switch self.t {
-        case _V_NUMBER        : return self.toNumber()  , nil
-        case _V_ANY        :        
-            if v, ok := self.packAny().(json.Number); ok {
-                return v, nil
-            } else {
-                return json.Number(""), ErrUnsupportType
-            }
-        default               : return json.Number(""), ErrUnsupportType
-    }
-}
-
-// String cast node to string, 
-// including V_NUMBER|V_TRUE|V_FALSE|V_ANY|V_STRING|V_NULL,
-// V_NONE it will return error
-func (self *Node) String() (string, error) {
-    if err := self.checkRaw(); err != nil {
-        return "", err
-    }
-    switch self.t {
-        case types.V_NULL    : return "" , nil
-        case types.V_TRUE    : return "true" , nil
-        case types.V_FALSE   : return "false", nil
-        case types.V_STRING, _V_NUMBER  : return self.toString(), nil
-        case _V_ANY          :        
-        any := self.packAny()
-        switch v := any.(type) {
-            case bool   : return strconv.FormatBool(v), nil
-            case int    : return strconv.Itoa(v), nil
-            case int8   : return strconv.Itoa(int(v)), nil
-            case int16  : return strconv.Itoa(int(v)), nil
-            case int32  : return strconv.Itoa(int(v)), nil
-            case int64  : return strconv.Itoa(int(v)), nil
-            case uint   : return strconv.Itoa(int(v)), nil
-            case uint8  : return strconv.Itoa(int(v)), nil
-            case uint16 : return strconv.Itoa(int(v)), nil
-            case uint32 : return strconv.Itoa(int(v)), nil
-            case uint64 : return strconv.Itoa(int(v)), nil
-            case float32: return strconv.FormatFloat(float64(v), 'g', -1, 64), nil
-            case float64: return strconv.FormatFloat(float64(v), 'g', -1, 64), nil
-            case string : return v, nil 
-            case json.Number: return v.String(), nil
-            default: return "", ErrUnsupportType
-        }
-        default              : return ""     , ErrUnsupportType
-    }
-}
-
-// StrictString returns string value (unescaped), including V_STRING, V_ANY of string.
-// In other cases, it will return empty string.
-func (self *Node) StrictString() (string, error) {
-    if err := self.checkRaw(); err != nil {
-        return "", err
-    }
-    switch self.t {
-        case types.V_STRING  : return self.toString(), nil
-        case _V_ANY          :        
-            if v, ok := self.packAny().(string); ok {
-                return v, nil
-            } else {
-                return "", ErrUnsupportType
-            }
-        default              : return "", ErrUnsupportType
-    }
-}
-
-// Float64 cast node to float64, 
-// including V_NUMBER|V_TRUE|V_FALSE|V_ANY|V_STRING|V_NULL,
-// V_NONE it will return error
-func (self *Node) Float64() (float64, error) {
-    if err := self.checkRaw(); err != nil {
-        return 0.0, err
-    }
-    switch self.t {
-        case _V_NUMBER, types.V_STRING : return self.toFloat64()
-        case types.V_TRUE    : return 1.0, nil
-        case types.V_FALSE   : return 0.0, nil
-        case types.V_NULL    : return 0.0, nil
-        case _V_ANY          :        
-            any := self.packAny()
-            switch v := any.(type) {
-                case bool    : 
-                    if v {
-                        return 1.0, nil
-                    } else {
-                        return 0.0, nil
-                    }
-                case int    : return float64(v), nil
-                case int8   : return float64(v), nil
-                case int16  : return float64(v), nil
-                case int32  : return float64(v), nil
-                case int64  : return float64(v), nil
-                case uint   : return float64(v), nil
-                case uint8  : return float64(v), nil
-                case uint16 : return float64(v), nil
-                case uint32 : return float64(v), nil
-                case uint64 : return float64(v), nil
-                case float32: return float64(v), nil
-                case float64: return float64(v), nil
-                case string : 
-                    if f, err := strconv.ParseFloat(v, 64); err == nil {
-                        return float64(f), nil
-                    } else {
-                        return 0, err
-                    }
-                case json.Number: 
-                    if f, err := v.Float64(); err == nil {
-                        return float64(f), nil
-                    } else {
-                        return 0, err
-                    }
-                default     : return 0, ErrUnsupportType
-            }
-        default             : return 0.0, ErrUnsupportType
-    }
-}
-
-// Float64 exports underlying float64 value, including V_NUMBER, V_ANY
-func (self *Node) StrictFloat64() (float64, error) {
-    if err := self.checkRaw(); err != nil {
-        return 0.0, err
-    }
-    switch self.t {
-        case _V_NUMBER       : return self.toFloat64()
-        case _V_ANY        :        
-            any := self.packAny()
-            switch v := any.(type) {
-                case float32 : return float64(v), nil
-                case float64 : return float64(v), nil
-                default      : return 0, ErrUnsupportType
-            }
-        default              : return 0.0, ErrUnsupportType
-    }
-}
-
-/** Sequential Value Methods **/
-
-// Len returns children count of a array|object|string node
-// WARN: For partially loaded node, it also works but only counts the parsed children
-func (self *Node) Len() (int, error) {
-    if err := self.checkRaw(); err != nil {
-        return 0, err
-    }
-    if self.t == types.V_ARRAY || self.t == types.V_OBJECT || self.t == _V_ARRAY_LAZY || self.t == _V_OBJECT_LAZY || self.t == types.V_STRING {
-        return int(self.l), nil
-    } else if self.t == _V_NONE || self.t == types.V_NULL {
-        return 0, nil
-    } else {
-        return 0, ErrUnsupportType
-    }
-}
-
-func (self *Node) len() int {
-    return int(self.l)
-}
-
-// Cap returns malloc capacity of a array|object node for children
-func (self *Node) Cap() (int, error) {
-    if err := self.checkRaw(); err != nil {
-        return 0, err
-    }
-    switch self.t {
-    case types.V_ARRAY: return (*linkedNodes)(self.p).Cap(), nil
-    case types.V_OBJECT: return (*linkedPairs)(self.p).Cap(), nil
-    case _V_ARRAY_LAZY: return (*parseArrayStack)(self.p).v.Cap(), nil
-    case _V_OBJECT_LAZY: return (*parseObjectStack)(self.p).v.Cap(), nil
-    case _V_NONE, types.V_NULL: return 0, nil
-    default: return 0, ErrUnsupportType
-    }
-}
-
-// Set sets the node of given key under self, and reports if the key has existed.
-//
-// If self is V_NONE or V_NULL, it becomes V_OBJECT and sets the node at the key.
-func (self *Node) Set(key string, node Node) (bool, error) {
-    if err := self.checkRaw(); err != nil {
-        return false, err
-    }
-    if err := node.Check(); err != nil {
-        return false, err 
-    }
-    
-    if self.t == _V_NONE || self.t == types.V_NULL {
-        *self = NewObject([]Pair{NewPair(key, node)})
-        return false, nil
-    } else if self.itype() != types.V_OBJECT {
-        return false, ErrUnsupportType
-    }
-
-    p := self.Get(key)
-
-    if !p.Exists() {
-        // self must be fully-loaded here
-        if self.len() == 0 {
-            *self = newObject(new(linkedPairs))
-        }
-        s := (*linkedPairs)(self.p)
-        s.Push(NewPair(key, node))
-        self.l++
-        return false, nil
-
-    } else if err := p.Check(); err != nil {
-        return false, err
-    } 
-
-    *p = node
-    return true, nil
-}
-
-// SetAny wraps val with V_ANY node, and Set() the node.
-func (self *Node) SetAny(key string, val interface{}) (bool, error) {
-    return self.Set(key, NewAny(val))
-}
-
-// Unset REMOVE (soft) the node of given key under object parent, and reports if the key has existed.
-func (self *Node) Unset(key string) (bool, error) {
-    if err := self.should(types.V_OBJECT); err != nil {
-        return false, err
-    }
-    // NOTICE: must get accurate length before deduct
-    if err := self.skipAllKey(); err != nil {
-        return false, err
-    }
-    p, i := self.skipKey(key)
-    if !p.Exists() {
-        return false, nil
-    } else if err := p.Check(); err != nil {
-        return false, err
-    }
-    self.removePairAt(i)
-    return true, nil
-}
-
-// SetByIndex sets the node of given index, and reports if the key has existed.
-//
-// The index must be within self's children.
-func (self *Node) SetByIndex(index int, node Node) (bool, error) {
-    if err := self.checkRaw(); err != nil {
-        return false, err 
-    }
-    if err := node.Check(); err != nil {
-        return false, err 
-    }
-
-    if index == 0 && (self.t == _V_NONE || self.t == types.V_NULL) {
-        *self = NewArray([]Node{node})
-        return false, nil
-    }
-
-    p := self.Index(index)
-    if !p.Exists() {
-        return false, ErrNotExist
-    } else if err := p.Check(); err != nil {
-        return false, err
-    }
-
-    *p = node
-    return true, nil
-}
-
-// SetAny wraps val with V_ANY node, and SetByIndex() the node.
-func (self *Node) SetAnyByIndex(index int, val interface{}) (bool, error) {
-    return self.SetByIndex(index, NewAny(val))
-}
-
-// UnsetByIndex REMOVE (softly) the node of given index.
-//
-// WARN: this will change address of elements, which is a dangerous action.
-// Use Unset() for object or Pop() for array instead.
-func (self *Node) UnsetByIndex(index int) (bool, error) {
-    if err := self.checkRaw(); err != nil {
-        return false, err
-    }
-
-    var p *Node
-    it := self.itype()
-
-    if it == types.V_ARRAY {
-        if err := self.skipAllIndex(); err != nil {
-            return false, err
-        }
-        p = self.nodeAt(index)
-    } else if it == types.V_OBJECT {
-        if err := self.skipAllKey(); err != nil {
-            return false, err
-        }
-        pr := self.pairAt(index)
-        if pr == nil {
-           return false, ErrNotExist
-        }
-        p = &pr.Value
-    } else {
-        return false, ErrUnsupportType
-    }
-
-    if !p.Exists() {
-        return false, ErrNotExist
-    }
-
-    // last elem
-    if index == self.len() - 1 {
-        return true, self.Pop()
-    }
-
-    // not last elem, self.len() change but linked-chunk not change
-    if it == types.V_ARRAY {
-        self.removeNode(index)
-    }else if it == types.V_OBJECT {
-        self.removePair(index)
-    }
-    return true, nil
-}
-
-// Add appends the given node under self.
-//
-// If self is V_NONE or V_NULL, it becomes V_ARRAY and sets the node at index 0.
-func (self *Node) Add(node Node) error {
-    if err := self.checkRaw(); err != nil {
-        return err
-    }
-
-    if self != nil && (self.t == _V_NONE || self.t == types.V_NULL) {
-        *self = NewArray([]Node{node})
-        return nil
-    }
-    if err := self.should(types.V_ARRAY); err != nil {
-        return err
-    }
-
-    s, err := self.unsafeArray()
-    if err != nil {
-        return err
-    }
-
-    // Notice: array won't have unset node in tail
-    s.Push(node)
-    self.l++
-    return nil
-}
-
-// Pop remove the last child of the V_Array or V_Object node.
-func (self *Node) Pop() error {
-    if err := self.checkRaw(); err != nil {
-        return err
-    }
-
-    if it := self.itype(); it == types.V_ARRAY {
-        s, err := self.unsafeArray()
-        if err != nil {
-            return err
-        }
-        // remove tail unset nodes
-        for i := s.Len()-1; i >= 0; i-- {
-            if s.At(i).Exists() {
-                s.Pop()
-                self.l--
-                break
-            }
-            s.Pop()
-        }
-
-    } else if it == types.V_OBJECT {
-        s, err := self.unsafeMap()
-        if err != nil {
-            return err
-        }
-        // remove tail unset nodes
-        for i := s.Len()-1; i >= 0; i-- {
-            if p := s.At(i); p != nil && p.Value.Exists() {
-                s.Pop()
-                self.l--
-                break
-            }
-            s.Pop()
-        }
-
-    } else {
-        return ErrUnsupportType
-    }
-
-    return nil
-}
-
-// Move moves the child at src index to dst index,
-// meanwhile slides sliblings from src+1 to dst.
-// 
-// WARN: this will change address of elements, which is a dangerous action.
-func (self *Node) Move(dst, src int) error {
-    if err := self.should(types.V_ARRAY); err != nil {
-        return err
-    }
-
-    s, err := self.unsafeArray()
-    if err != nil {
-        return err
-    }
-
-    // check if any unset node exists
-    if l :=  s.Len(); self.len() != l {
-        di, si := dst, src
-        // find real pos of src and dst
-        for i := 0; i < l; i++ {
-            if s.At(i).Exists() {
-                di--
-                si--
-            }
-            if di == -1 {
-                dst = i
-                di--
-            } 
-            if si == -1 {
-                src = i
-                si--
-            }
-            if di == -2 && si == -2 {
-                break
-            }
-        }
-    }
-
-    s.MoveOne(src, dst)
-    return nil
-}
-
-// SetAny wraps val with V_ANY node, and Add() the node.
-func (self *Node) AddAny(val interface{}) error {
-    return self.Add(NewAny(val))
-}
-
-// GetByPath load given path on demands,
-// which only ensure nodes before this path got parsed.
-//
-// Note, the api expects the json is well-formed at least,
-// otherwise it may return unexpected result.
-func (self *Node) GetByPath(path ...interface{}) *Node {
-    if !self.Valid() {
-        return self
-    }
-    var s = self
-    for _, p := range path {
-        switch p := p.(type) {
-        case int:
-            s = s.Index(p)
-            if !s.Valid() {
-                return s
-            }
-        case string:
-            s = s.Get(p)
-            if !s.Valid() {
-                return s
-            }
-        default:
-            panic("path must be either int or string")
-        }
-    }
-    return s
-}
-
-// Get loads given key of an object node on demands
-func (self *Node) Get(key string) *Node {
-    if err := self.should(types.V_OBJECT); err != nil {
-        return unwrapError(err)
-    }
-    n, _ := self.skipKey(key)
-    return n
-}
-
-// Index indexies node at given idx,
-// node type CAN be either V_OBJECT or V_ARRAY
-func (self *Node) Index(idx int) *Node {
-    if err := self.checkRaw(); err != nil {
-        return unwrapError(err)
-    }
-
-    it := self.itype()
-    if it == types.V_ARRAY {
-        return self.skipIndex(idx)
-
-    }else if it == types.V_OBJECT {
-        pr := self.skipIndexPair(idx)
-        if pr == nil {
-           return newError(_ERR_NOT_FOUND, "value not exists")
-        }
-        return &pr.Value
-
-    } else {
-        return newError(_ERR_UNSUPPORT_TYPE, fmt.Sprintf("unsupported type: %v", self.itype()))
-    }
-}
-
-// IndexPair indexies pair at given idx,
-// node type MUST be either V_OBJECT
-func (self *Node) IndexPair(idx int) *Pair {
-    if err := self.should(types.V_OBJECT); err != nil {
-        return nil
-    }
-    return self.skipIndexPair(idx)
-}
-
-func (self *Node) indexOrGet(idx int, key string) (*Node, int) {
-    if err := self.should(types.V_OBJECT); err != nil {
-        return unwrapError(err), idx
-    }
-
-    pr := self.skipIndexPair(idx)
-    if pr != nil && pr.Key == key {
-        return &pr.Value, idx
-    }
-
-    return self.skipKey(key)
-}
-
-// IndexOrGet firstly use idx to index a value and check if its key matches
-// If not, then use the key to search value
-func (self *Node) IndexOrGet(idx int, key string) *Node {
-    node, _ := self.indexOrGet(idx, key)
-    return node
-}
-
-// IndexOrGetWithIdx attempts to retrieve a node by index and key, returning the node and its correct index.
-// If the key does not match at the given index, it searches by key and returns the node with its updated index.
-func (self *Node) IndexOrGetWithIdx(idx int, key string) (*Node, int) {
-    return self.indexOrGet(idx, key)
-}
-
-/** Generic Value Converters **/
-
-// Map loads all keys of an object node
-func (self *Node) Map() (map[string]interface{}, error) {
-    if self.isAny() {
-        any := self.packAny()
-        if v, ok := any.(map[string]interface{}); ok {
-            return v, nil
-        } else {
-            return nil, ErrUnsupportType
-        }
-    }
-    if err := self.should(types.V_OBJECT); err != nil {
-        return nil, err
-    }
-    if err := self.loadAllKey(false); err != nil {
-        return nil, err
-    }
-    return self.toGenericObject()
-}
-
-// MapUseNumber loads all keys of an object node, with numeric nodes casted to json.Number
-func (self *Node) MapUseNumber() (map[string]interface{}, error) {
-    if self.isAny() {
-        any := self.packAny()
-        if v, ok := any.(map[string]interface{}); ok {
-            return v, nil
-        } else {
-            return nil, ErrUnsupportType
-        }
-    }
-    if err := self.should(types.V_OBJECT); err != nil {
-        return nil, err
-    }
-    if err := self.loadAllKey(false); err != nil {
-        return nil, err
-    }
-    return self.toGenericObjectUseNumber()
-}
-
-// MapUseNode scans both parsed and non-parsed children nodes,
-// and map them by their keys
-func (self *Node) MapUseNode() (map[string]Node, error) {
-    if self.isAny() {
-        any := self.packAny()
-        if v, ok := any.(map[string]Node); ok {
-            return v, nil
-        } else {
-            return nil, ErrUnsupportType
-        }
-    }
-    if err := self.should(types.V_OBJECT); err != nil {
-        return nil, err
-    }
-    if err := self.skipAllKey(); err != nil {
-        return nil, err
-    }
-    return self.toGenericObjectUseNode()
-}
-
-// MapUnsafe exports the underlying pointer to its children map
-// WARN: don't use it unless you know what you are doing
-//
-// Deprecated:  this API now returns copied nodes instead of directly reference, 
-// func (self *Node) UnsafeMap() ([]Pair, error) {
-//     if err := self.should(types.V_OBJECT, "an object"); err != nil {
-//         return nil, err
-//     }
-//     if err := self.skipAllKey(); err != nil {
-//         return nil, err
-//     }
-//     return self.toGenericObjectUsePair()
-// }
-
-//go:nocheckptr
-func (self *Node) unsafeMap() (*linkedPairs, error) {
-    if err := self.skipAllKey(); err != nil {
-        return nil, err
-    }
-    if self.p == nil {
-        *self = newObject(new(linkedPairs))
-    }
-    return (*linkedPairs)(self.p), nil
-}
-
-// SortKeys sorts children of a V_OBJECT node in ascending key-order.
-// If recurse is true, it recursively sorts children's children as long as a V_OBJECT node is found.
-func (self *Node) SortKeys(recurse bool) error {
-    // check raw node first
-    if err := self.checkRaw(); err != nil {
-        return err
-    }
-    if self.itype() == types.V_OBJECT {
-        return self.sortKeys(recurse)
-    } else if self.itype() == types.V_ARRAY {
-        var err error
-        err2 := self.ForEach(func(path Sequence, node *Node) bool {
-            it := node.itype()
-            if it == types.V_ARRAY || it == types.V_OBJECT {
-                err = node.SortKeys(recurse)
-                if err != nil {
-                    return false
-                }
-            }
-            return true
-        })
-        if err != nil {
-            return err
-        }
-        return err2
-    } else {
-        return nil
-    }
-}
-
-func (self *Node) sortKeys(recurse bool) (err error) {
-    // check raw node first
-    if err := self.checkRaw(); err != nil {
-        return err
-    }
-    ps, err := self.unsafeMap()
-    if err != nil {
-        return err
-    }
-    ps.Sort()
-    if recurse {
-        var sc Scanner
-        sc = func(path Sequence, node *Node) bool {
-            if node.itype() == types.V_OBJECT {
-                if err := node.sortKeys(recurse); err != nil {
-                    return false
-                }
-            }
-            if node.itype() == types.V_ARRAY {
-                if err := node.ForEach(sc); err != nil {
-                    return false
-                }
-            }
-            return true
-        }
-        if err := self.ForEach(sc); err != nil {
-            return err
-        }
-    }
-    return nil
-}
-
-// Array loads all indexes of an array node
-func (self *Node) Array() ([]interface{}, error) {
-    if self.isAny() {
-        any := self.packAny()
-        if v, ok := any.([]interface{}); ok {
-            return v, nil
-        } else {
-            return nil, ErrUnsupportType
-        }
-    }
-    if err := self.should(types.V_ARRAY); err != nil {
-        return nil, err
-    }
-    if err := self.loadAllIndex(false); err != nil {
-        return nil, err
-    }
-    return self.toGenericArray()
-}
-
-// ArrayUseNumber loads all indexes of an array node, with numeric nodes casted to json.Number
-func (self *Node) ArrayUseNumber() ([]interface{}, error) {
-    if self.isAny() {
-        any := self.packAny()
-        if v, ok := any.([]interface{}); ok {
-            return v, nil
-        } else {
-            return nil, ErrUnsupportType
-        }
-    }
-    if err := self.should(types.V_ARRAY); err != nil {
-        return nil, err
-    }
-    if err := self.loadAllIndex(false); err != nil {
-        return nil, err
-    }
-    return self.toGenericArrayUseNumber()
-}
-
-// ArrayUseNode copies both parsed and non-parsed children nodes,
-// and indexes them by original order
-func (self *Node) ArrayUseNode() ([]Node, error) {
-    if self.isAny() {
-        any := self.packAny()
-        if v, ok := any.([]Node); ok {
-            return v, nil
-        } else {
-            return nil, ErrUnsupportType
-        }
-    }
-    if err := self.should(types.V_ARRAY); err != nil {
-        return nil, err
-    }
-    if err := self.skipAllIndex(); err != nil {
-        return nil, err
-    }
-    return self.toGenericArrayUseNode()
-}
-
-// ArrayUnsafe exports the underlying pointer to its children array
-// WARN: don't use it unless you know what you are doing
-//
-// Deprecated:  this API now returns copied nodes instead of directly reference, 
-// which has no difference with ArrayUseNode
-// func (self *Node) UnsafeArray() ([]Node, error) {
-//     if err := self.should(types.V_ARRAY, "an array"); err != nil {
-//         return nil, err
-//     }
-//     if err := self.skipAllIndex(); err != nil {
-//         return nil, err
-//     }
-//     return self.toGenericArrayUseNode()
-// }
-
-func (self *Node) unsafeArray() (*linkedNodes, error) {
-    if err := self.skipAllIndex(); err != nil {
-        return nil, err
-    }
-    if self.p == nil {
-        *self = newArray(new(linkedNodes))
-    }
-    return (*linkedNodes)(self.p), nil
-}
-
-// Interface loads all children under all paths from this node,
-// and converts itself as generic type.
-// WARN: all numeric nodes are casted to float64
-func (self *Node) Interface() (interface{}, error) {
-    if err := self.checkRaw(); err != nil {
-        return nil, err
-    }
-    switch self.t {
-        case V_ERROR         : return nil, self.Check()
-        case types.V_NULL    : return nil, nil
-        case types.V_TRUE    : return true, nil
-        case types.V_FALSE   : return false, nil
-        case types.V_ARRAY   : return self.toGenericArray()
-        case types.V_OBJECT  : return self.toGenericObject()
-        case types.V_STRING  : return self.toString(), nil
-        case _V_NUMBER       : 
-            v, err := self.toFloat64()
-            if err != nil {
-                return nil, err
-            }
-            return v, nil
-        case _V_ARRAY_LAZY   :
-            if err := self.loadAllIndex(false); err != nil {
-                return nil, err
-            }
-            return self.toGenericArray()
-        case _V_OBJECT_LAZY  :
-            if err := self.loadAllKey(false); err != nil {
-                return nil, err
-            }
-            return self.toGenericObject()
-        case _V_ANY:
-            switch v := self.packAny().(type) {
-                case Node : return v.Interface()
-                case *Node: return v.Interface()
-                default   : return v, nil
-            }
-        default              : return nil,  ErrUnsupportType
-    }
-}
-
-func (self *Node) packAny() interface{} {
-    return *(*interface{})(self.p)
-}
-
-// InterfaceUseNumber works same with Interface()
-// except numeric nodes are casted to json.Number
-func (self *Node) InterfaceUseNumber() (interface{}, error) {
-    if err := self.checkRaw(); err != nil {
-        return nil, err
-    }
-    switch self.t {
-        case V_ERROR         : return nil, self.Check()
-        case types.V_NULL    : return nil, nil
-        case types.V_TRUE    : return true, nil
-        case types.V_FALSE   : return false, nil
-        case types.V_ARRAY   : return self.toGenericArrayUseNumber()
-        case types.V_OBJECT  : return self.toGenericObjectUseNumber()
-        case types.V_STRING  : return self.toString(), nil
-        case _V_NUMBER       : return self.toNumber(), nil
-        case _V_ARRAY_LAZY   :
-            if err := self.loadAllIndex(false); err != nil {
-                return nil, err
-            }
-            return self.toGenericArrayUseNumber()
-        case _V_OBJECT_LAZY  :
-            if err := self.loadAllKey(false); err != nil {
-                return nil, err
-            }
-            return self.toGenericObjectUseNumber()
-        case _V_ANY          : return self.packAny(), nil
-        default              : return nil, ErrUnsupportType
-    }
-}
-
-// InterfaceUseNode clone itself as a new node, 
-// or its children as map[string]Node (or []Node)
-func (self *Node) InterfaceUseNode() (interface{}, error) {
-    if err := self.checkRaw(); err != nil {
-        return nil, err
-    }
-    switch self.t {
-        case types.V_ARRAY   : return self.toGenericArrayUseNode()
-        case types.V_OBJECT  : return self.toGenericObjectUseNode()
-        case _V_ARRAY_LAZY   :
-            if err := self.skipAllIndex(); err != nil {
-                return nil, err
-            }
-            return self.toGenericArrayUseNode()
-        case _V_OBJECT_LAZY  :
-            if err := self.skipAllKey(); err != nil {
-                return nil, err
-            }
-            return self.toGenericObjectUseNode()
-        default              : return *self, self.Check()
-    }
-}
-
-// LoadAll loads the node's children 
-// and ensure all its children can be READ concurrently (include its children's children)
-func (self *Node) LoadAll() error {
-    return self.Load()
-}
-
-// Load loads the node's children as parsed.
-// and ensure all its children can be READ concurrently (include its children's children)
-func (self *Node) Load() error {
-    switch self.t {
-        case _V_ARRAY_LAZY: self.loadAllIndex(true)
-        case _V_OBJECT_LAZY: self.loadAllKey(true)
-        case V_ERROR: return self
-        case V_NONE: return nil
-    }
-    if self.m == nil {
-        self.m = new(sync.RWMutex)
-    }
-    return self.checkRaw()
-}
-
-/**---------------------------------- Internal Helper Methods ----------------------------------**/
-
-func (self *Node) should(t types.ValueType) error {
-    if err := self.checkRaw(); err != nil {
-        return err
-    }
-    if  self.itype() != t {
-        return ErrUnsupportType
-    }
-    return nil
-}
-
-func (self *Node) nodeAt(i int) *Node {
-    var p *linkedNodes
-    if self.isLazy() {
-        _, stack := self.getParserAndArrayStack()
-        p = &stack.v
-    } else {
-        p = (*linkedNodes)(self.p)
-        if l := p.Len(); l != self.len() {
-            // some nodes got unset, iterate to skip them
-            for j:=0; j<l; j++ {
-                v := p.At(j)
-                if v.Exists() {
-                    i--
-                }
-                if i < 0 {
-                    return v
-                }
-            }
-            return nil
-        } 
-    }
-    return p.At(i)
-}
-
-func (self *Node) pairAt(i int) *Pair {
-    var p *linkedPairs
-    if self.isLazy() {
-        _, stack := self.getParserAndObjectStack()
-        p = &stack.v
-    } else {
-        p = (*linkedPairs)(self.p)
-        if l := p.Len(); l != self.len() {
-            // some nodes got unset, iterate to skip them
-            for j:=0; j<l; j++ {
-                v := p.At(j)
-                if v != nil && v.Value.Exists() {
-                    i--
-                }
-                if i < 0 {
-                    return v
-                }
-            }
-           return nil
-       } 
-    }
-    return p.At(i)
-}
-
-func (self *Node) skipAllIndex() error {
-    if !self.isLazy() {
-        return nil
-    }
-    var err types.ParsingError
-    parser, stack := self.getParserAndArrayStack()
-    parser.skipValue = true
-    parser.noLazy = true
-    *self, err = parser.decodeArray(&stack.v)
-    if err != 0 {
-        return parser.ExportError(err)
-    }
-    return nil
-}
-
-func (self *Node) skipAllKey() error {
-    if !self.isLazy() {
-        return nil
-    }
-    var err types.ParsingError
-    parser, stack := self.getParserAndObjectStack()
-    parser.skipValue = true
-    parser.noLazy = true
-    *self, err = parser.decodeObject(&stack.v)
-    if err != 0 {
-        return parser.ExportError(err)
-    }
-    return nil
-}
-
-func (self *Node) skipKey(key string) (*Node, int) {
-    nb := self.len()
-    lazy := self.isLazy()
-
-    if nb > 0 {
-        /* linear search */
-        var p *Pair
-        var i int
-        if lazy {
-            s := (*parseObjectStack)(self.p)
-            p, i = s.v.Get(key)
-        } else {
-            p, i = (*linkedPairs)(self.p).Get(key)
-        }
-
-        if p != nil {
-            return &p.Value, i
-        }
-    }
-
-    /* not found */
-    if !lazy {
-        return nil, -1
-    }
-
-    // lazy load
-    for last, i := self.skipNextPair(), nb; last != nil; last, i = self.skipNextPair(), i+1 {
-        if last.Value.Check() != nil {
-            return &last.Value, -1
-        }
-        if last.Key == key {
-            return &last.Value, i
-        }
-    }
-
-    return nil, -1
-}
-
-func (self *Node) skipIndex(index int) *Node {
-    nb := self.len()
-    if nb > index {
-        v := self.nodeAt(index)
-        return v
-    }
-    if !self.isLazy() {
-        return nil
-    }
-
-    // lazy load
-    for last := self.skipNextNode(); last != nil; last = self.skipNextNode(){
-        if last.Check() != nil {
-            return last
-        }
-        if self.len() > index {
-            return last
-        }
-    }
-
-    return nil
-}
-
-func (self *Node) skipIndexPair(index int) *Pair {
-    nb := self.len()
-    if nb > index {
-        return self.pairAt(index)
-    }
-    if !self.isLazy() {
-        return nil
-    }
-
-    // lazy load
-    for last := self.skipNextPair(); last != nil; last = self.skipNextPair(){
-        if last.Value.Check() != nil {
-            return last
-        }
-        if self.len() > index {
-            return last
-        }
-    }
-
-    return nil
-}
-
-func (self *Node) loadAllIndex(loadOnce bool) error {
-    if !self.isLazy() {
-        return nil
-    }
-    var err types.ParsingError
-    parser, stack := self.getParserAndArrayStack()
-    if !loadOnce {
-        parser.noLazy = true
-    } else {
-        parser.loadOnce = true
-    }
-    *self, err = parser.decodeArray(&stack.v)
-    if err != 0 {
-        return parser.ExportError(err)
-    }
-    return nil
-}
-
-func (self *Node) loadAllKey(loadOnce bool) error {
-    if !self.isLazy() {
-        return nil
-    }
-    var err types.ParsingError
-    parser, stack := self.getParserAndObjectStack()
-    if !loadOnce {
-        parser.noLazy = true
-        *self, err = parser.decodeObject(&stack.v)
-    } else {
-        parser.loadOnce = true
-        *self, err = parser.decodeObject(&stack.v)
-    }
-    if err != 0 {
-        return parser.ExportError(err)
-    }
-    return nil
-}
-
-func (self *Node) removeNode(i int) {
-    node := self.nodeAt(i)
-    if node == nil {
-        return
-    }
-    *node = Node{}
-    // NOTICE: not be consistent with linkedNode.Len()
-    self.l--
-}
-
-func (self *Node) removePair(i int) {
-    last := self.pairAt(i)
-    if last == nil {
-        return
-    }
-    *last = Pair{}
-    // NOTICE: should be consistent with linkedPair.Len()
-    self.l--
-}
-
-func (self *Node) removePairAt(i int) {
-    p := (*linkedPairs)(self.p).At(i)
-    if p == nil {
-        return
-    }
-    *p = Pair{}
-    // NOTICE: should be consistent with linkedPair.Len()
-    self.l--
-}
-
-func (self *Node) toGenericArray() ([]interface{}, error) {
-    nb := self.len()
-    if nb == 0 {
-        return []interface{}{}, nil
-    }
-    ret := make([]interface{}, 0, nb)
-    
-    /* convert each item */
-    it := self.values()
-    for v := it.next(); v != nil; v = it.next() {
-        vv, err := v.Interface()
-        if err != nil {
-            return nil, err
-        }
-        ret = append(ret, vv)
-    }
-
-    /* all done */
-    return ret, nil
-}
-
-func (self *Node) toGenericArrayUseNumber() ([]interface{}, error) {
-    nb := self.len()
-    if nb == 0 {
-        return []interface{}{}, nil
-    }
-    ret := make([]interface{}, 0, nb)
-
-    /* convert each item */
-    it := self.values()
-    for v := it.next(); v != nil; v = it.next() {
-        vv, err := v.InterfaceUseNumber()
-        if err != nil {
-            return nil, err
-        }
-        ret = append(ret, vv)
-    }
-
-    /* all done */
-    return ret, nil
-}
-
-func (self *Node) toGenericArrayUseNode() ([]Node, error) {
-    var nb = self.len()
-    if nb == 0 {
-        return []Node{}, nil
-    }
-
-    var s = (*linkedNodes)(self.p)
-    var out = make([]Node, nb)
-    s.ToSlice(out)
-
-    return out, nil
-}
-
-func (self *Node) toGenericObject() (map[string]interface{}, error) {
-    nb := self.len()
-    if nb == 0 {
-        return map[string]interface{}{}, nil
-    }
-    ret := make(map[string]interface{}, nb)
-
-    /* convert each item */
-    it := self.properties()
-    for v := it.next(); v != nil; v = it.next() {
-        vv, err := v.Value.Interface()
-        if err != nil {
-            return nil, err
-        }
-        ret[v.Key] = vv
-    }
-
-    /* all done */
-    return ret, nil
-}
-
-
-func (self *Node) toGenericObjectUseNumber() (map[string]interface{}, error) {
-    nb := self.len()
-    if nb == 0 {
-        return map[string]interface{}{}, nil
-    }
-    ret := make(map[string]interface{}, nb)
-
-    /* convert each item */
-    it := self.properties()
-    for v := it.next(); v != nil; v = it.next() {
-        vv, err := v.Value.InterfaceUseNumber()
-        if err != nil {
-            return nil, err
-        }
-        ret[v.Key] = vv
-    }
-
-    /* all done */
-    return ret, nil
-}
-
-func (self *Node) toGenericObjectUseNode() (map[string]Node, error) {
-    var nb = self.len()
-    if nb == 0 {
-        return map[string]Node{}, nil
-    }
-
-    var s = (*linkedPairs)(self.p)
-    var out = make(map[string]Node, nb)
-    s.ToMap(out)
-
-    /* all done */
-    return out, nil
-}
-
-/**------------------------------------ Factory Methods ------------------------------------**/
-
-var (
-    nullNode  = Node{t: types.V_NULL}
-    trueNode  = Node{t: types.V_TRUE}
-    falseNode = Node{t: types.V_FALSE}
-)
-
-// NewRaw creates a node of raw json.
-// If the input json is invalid, NewRaw returns a error Node.
-func NewRaw(json string) Node {
-    parser := NewParserObj(json)
-    start, err := parser.skip()
-    if err != 0 {
-        return *newError(err, err.Message()) 
-    }
-    it := switchRawType(parser.s[start])
-    if it == _V_NONE {
-        return Node{}
-    }
-    return newRawNode(parser.s[start:parser.p], it, false)
-}
-
-// NewRawConcurrentRead creates a node of raw json, which can be READ 
-// (GetByPath/Get/Index/GetOrIndex/Int64/Bool/Float64/String/Number/Interface/Array/Map/Raw/MarshalJSON) concurrently.
-// If the input json is invalid, NewRaw returns a error Node.
-func NewRawConcurrentRead(json string) Node {
-    parser := NewParserObj(json)
-    start, err := parser.skip()
-    if err != 0 {
-        return *newError(err, err.Message()) 
-    }
-    it := switchRawType(parser.s[start])
-    if it == _V_NONE {
-        return Node{}
-    }
-    return newRawNode(parser.s[start:parser.p], it, true)
-}
-
-// NewAny creates a node of type V_ANY if any's type isn't Node or *Node, 
-// which stores interface{} and can be only used for `.Interface()`\`.MarshalJSON()`.
-func NewAny(any interface{}) Node {
-    switch n := any.(type) {
-    case Node:
-        return n
-    case *Node:
-        return *n
-    default:
-        return Node{
-            t: _V_ANY,
-            p: unsafe.Pointer(&any),
-        }
-    }
-}
-
-// NewBytes encodes given src with Base64 (RFC 4648), and creates a node of type V_STRING.
-func NewBytes(src []byte) Node {
-    if len(src) == 0 {
-        panic("empty src bytes")
-    }
-    out := rt.EncodeBase64(src)
-    return NewString(out)
-}
-
-// NewNull creates a node of type V_NULL
-func NewNull() Node {
-    return Node{
-        p: nil,
-        t: types.V_NULL,
-    }
-}
-
-// NewBool creates a node of type bool:
-//  If v is true, returns V_TRUE node
-//  If v is false, returns V_FALSE node
-func NewBool(v bool) Node {
-    var t = types.V_FALSE
-    if v {
-        t = types.V_TRUE
-    }
-    return Node{
-        p: nil,
-        t: t,
-    }
-}
-
-// NewNumber creates a json.Number node
-// v must be a decimal string complying with RFC8259
-func NewNumber(v string) Node {
-    return Node{
-        l: uint(len(v)),
-        p: rt.StrPtr(v),
-        t: _V_NUMBER,
-    }
-}
-
-func (node *Node) toNumber() json.Number {
-    return json.Number(rt.StrFrom(node.p, int64(node.l)))
-}
-
-func (self *Node) toString() string {
-    return rt.StrFrom(self.p, int64(self.l))
-}
-
-func (node *Node) toFloat64() (float64, error) {
-    ret, err := node.toNumber().Float64()
-    if err != nil {
-        return 0, err
-    }
-    return ret, nil
-}
-
-func (node *Node) toInt64() (int64, error) {
-    ret,err := node.toNumber().Int64()
-    if err != nil {
-        return 0, err
-    }
-    return ret, nil
-}
-
-func newBytes(v []byte) Node {
-    return Node{
-        t: types.V_STRING,
-        p: mem2ptr(v),
-        l: uint(len(v)),
-    }
-}
-
-// NewString creates a node of type V_STRING. 
-// v is considered to be a valid UTF-8 string,
-// which means it won't be validated and unescaped.
-// when the node is encoded to json, v will be escaped.
-func NewString(v string) Node {
-    return Node{
-        t: types.V_STRING,
-        p: rt.StrPtr(v),
-        l: uint(len(v)),
-    }
-}
-
-// NewArray creates a node of type V_ARRAY,
-// using v as its underlying children
-func NewArray(v []Node) Node {
-    s := new(linkedNodes)
-    s.FromSlice(v)
-    return newArray(s)
-}
-
-const _Threshold_Index = 16
-
-func newArray(v *linkedNodes) Node {
-    return Node{
-        t: types.V_ARRAY,
-        l: uint(v.Len()),
-        p: unsafe.Pointer(v),
-    }
-}
-
-func (self *Node) setArray(v *linkedNodes) {
-    self.t = types.V_ARRAY
-    self.l = uint(v.Len())
-    self.p = unsafe.Pointer(v)
-}
-
-// NewObject creates a node of type V_OBJECT,
-// using v as its underlying children
-func NewObject(v []Pair) Node {
-    s := new(linkedPairs)
-    s.FromSlice(v)
-    return newObject(s)
-}
-
-func newObject(v *linkedPairs) Node {
-    if v.size > _Threshold_Index {
-        v.BuildIndex()
-    }
-    return Node{
-        t: types.V_OBJECT,
-        l: uint(v.Len()),
-        p: unsafe.Pointer(v),
-    }
-}
-
-func (self *Node) setObject(v *linkedPairs) {
-    if v.size > _Threshold_Index {
-        v.BuildIndex()
-    }
-    self.t = types.V_OBJECT
-    self.l = uint(v.Len())
-    self.p = unsafe.Pointer(v)
-}
-
-func (self *Node) parseRaw(full bool) {
-    lock := self.lock()
-    defer self.unlock()
-    if !self.isRaw() {
-        return
-    }
-    raw := self.toString()
-    parser := NewParserObj(raw)
-    var e types.ParsingError
-    if full {
-        parser.noLazy = true
-        *self, e = parser.Parse()
-    } else if lock {
-        var n Node
-        parser.noLazy = true
-        parser.loadOnce = true
-        n, e = parser.Parse()
-        self.assign(n)
-    } else {
-        *self, e = parser.Parse()
-    }
-    if e != 0 {
-        *self = *newSyntaxError(parser.syntaxError(e))
-    }
-}
-
-func (self *Node) assign(n Node) {
-    self.l = n.l
-    self.p = n.p
-    atomic.StoreInt64(&self.t, n.t)
-}
diff --git a/vendor/github.com/bytedance/sonic/ast/parser.go b/vendor/github.com/bytedance/sonic/ast/parser.go
deleted file mode 100644
index 30bd1f451..000000000
--- a/vendor/github.com/bytedance/sonic/ast/parser.go
+++ /dev/null
@@ -1,766 +0,0 @@
-/*
- * Copyright 2021 ByteDance Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package ast
-
-import (
-	"fmt"
-	"sync"
-	"sync/atomic"
-
-	"github.com/bytedance/sonic/internal/native/types"
-	"github.com/bytedance/sonic/internal/rt"
-)
-
-const (
-    _DEFAULT_NODE_CAP int = 16
-    _APPEND_GROW_SHIFT = 1
-)
-
-const (
-    _ERR_NOT_FOUND      types.ParsingError = 33
-    _ERR_UNSUPPORT_TYPE types.ParsingError = 34
-)
-
-var (
-    // ErrNotExist means both key and value doesn't exist 
-    ErrNotExist error = newError(_ERR_NOT_FOUND, "value not exists")
-
-    // ErrUnsupportType means API on the node is unsupported
-    ErrUnsupportType error = newError(_ERR_UNSUPPORT_TYPE, "unsupported type")
-)
-
-type Parser struct {
-    p           int
-    s           string
-    noLazy      bool
-    loadOnce  bool
-    skipValue   bool
-    dbuf        *byte
-}
-
-/** Parser Private Methods **/
-
-func (self *Parser) delim() types.ParsingError {
-    n := len(self.s)
-    p := self.lspace(self.p)
-
-    /* check for EOF */
-    if p >= n {
-        return types.ERR_EOF
-    }
-
-    /* check for the delimtier */
-    if self.s[p] != ':' {
-        return types.ERR_INVALID_CHAR
-    }
-
-    /* update the read pointer */
-    self.p = p + 1
-    return 0
-}
-
-func (self *Parser) object() types.ParsingError {
-    n := len(self.s)
-    p := self.lspace(self.p)
-
-    /* check for EOF */
-    if p >= n {
-        return types.ERR_EOF
-    }
-
-    /* check for the delimtier */
-    if self.s[p] != '{' {
-        return types.ERR_INVALID_CHAR
-    }
-
-    /* update the read pointer */
-    self.p = p + 1
-    return 0
-}
-
-func (self *Parser) array() types.ParsingError {
-    n := len(self.s)
-    p := self.lspace(self.p)
-
-    /* check for EOF */
-    if p >= n {
-        return types.ERR_EOF
-    }
-
-    /* check for the delimtier */
-    if self.s[p] != '[' {
-        return types.ERR_INVALID_CHAR
-    }
-
-    /* update the read pointer */
-    self.p = p + 1
-    return 0
-}
-
-func (self *Parser) lspace(sp int) int {
-    ns := len(self.s)
-    for ; sp<ns && isSpace(self.s[sp]); sp+=1 {}
-
-    return sp
-}
-
-func (self *Parser) backward() {
-    for ; self.p >= 0 && isSpace(self.s[self.p]); self.p-=1 {}
-}
-
-func (self *Parser) decodeArray(ret *linkedNodes) (Node, types.ParsingError) {
-    sp := self.p
-    ns := len(self.s)
-
-    /* check for EOF */
-    if self.p = self.lspace(sp); self.p >= ns {
-        return Node{}, types.ERR_EOF
-    }
-
-    /* check for empty array */
-    if self.s[self.p] == ']' {
-        self.p++
-        return Node{t: types.V_ARRAY}, 0
-    }
-
-    /* allocate array space and parse every element */
-    for {
-        var val Node
-        var err types.ParsingError
-
-        if self.skipValue {
-            /* skip the value */
-            var start int
-            if start, err = self.skipFast(); err != 0 {
-                return Node{}, err
-            }
-            if self.p > ns {
-                return Node{}, types.ERR_EOF
-            }
-            t := switchRawType(self.s[start])
-            if t == _V_NONE {
-                return Node{}, types.ERR_INVALID_CHAR
-            }
-            val = newRawNode(self.s[start:self.p], t, false)
-        }else{
-            /* decode the value */
-            if val, err = self.Parse(); err != 0 {
-                return Node{}, err
-            }
-        }
-
-        /* add the value to result */
-        ret.Push(val)
-        self.p = self.lspace(self.p)
-
-        /* check for EOF */
-        if self.p >= ns {
-            return Node{}, types.ERR_EOF
-        }
-
-        /* check for the next character */
-        switch self.s[self.p] {
-            case ',' : self.p++
-            case ']' : self.p++; return newArray(ret), 0
-            default:
-                // if val.isLazy() {
-                //     return newLazyArray(self, ret), 0
-                // }
-                return Node{}, types.ERR_INVALID_CHAR
-        }
-    }
-}
-
-func (self *Parser) decodeObject(ret *linkedPairs) (Node, types.ParsingError) {
-    sp := self.p
-    ns := len(self.s)
-
-    /* check for EOF */
-    if self.p = self.lspace(sp); self.p >= ns {
-        return Node{}, types.ERR_EOF
-    }
-
-    /* check for empty object */
-    if self.s[self.p] == '}' {
-        self.p++
-        return Node{t: types.V_OBJECT}, 0
-    }
-
-    /* decode each pair */
-    for {
-        var val Node
-        var njs types.JsonState
-        var err types.ParsingError
-
-        /* decode the key */
-        if njs = self.decodeValue(); njs.Vt != types.V_STRING {
-            return Node{}, types.ERR_INVALID_CHAR
-        }
-
-        /* extract the key */
-        idx := self.p - 1
-        key := self.s[njs.Iv:idx]
-
-        /* check for escape sequence */
-        if njs.Ep != -1 {
-            if key, err = unquote(key); err != 0 {
-                return Node{}, err
-            }
-        }
-
-        /* expect a ':' delimiter */
-        if err = self.delim(); err != 0 {
-            return Node{}, err
-        }
-
-        
-        if self.skipValue {
-            /* skip the value */
-            var start int
-            if start, err = self.skipFast(); err != 0 {
-                return Node{}, err
-            }
-            if self.p > ns {
-                return Node{}, types.ERR_EOF
-            }
-            t := switchRawType(self.s[start])
-            if t == _V_NONE {
-                return Node{}, types.ERR_INVALID_CHAR
-            }
-            val = newRawNode(self.s[start:self.p], t, false)
-        } else {
-            /* decode the value */
-            if val, err = self.Parse(); err != 0 {
-                return Node{}, err
-            }
-        }
-
-        /* add the value to result */
-        // FIXME: ret's address may change here, thus previous referred node in ret may be invalid !!
-        ret.Push(NewPair(key, val))
-        self.p = self.lspace(self.p)
-
-        /* check for EOF */
-        if self.p >= ns {
-            return Node{}, types.ERR_EOF
-        }
-
-        /* check for the next character */
-        switch self.s[self.p] {
-            case ',' : self.p++
-            case '}' : self.p++; return newObject(ret), 0
-        default:
-            // if val.isLazy() {
-            //     return newLazyObject(self, ret), 0
-            // }
-            return Node{}, types.ERR_INVALID_CHAR
-        }
-    }
-}
-
-func (self *Parser) decodeString(iv int64, ep int) (Node, types.ParsingError) {
-    p := self.p - 1
-    s := self.s[iv:p]
-
-    /* fast path: no escape sequence */
-    if ep == -1 {
-        return NewString(s), 0
-    }
-
-    /* unquote the string */
-    out, err := unquote(s)
-
-    /* check for errors */
-    if err != 0 {
-        return Node{}, err
-    } else {
-        return newBytes(rt.Str2Mem(out)), 0
-    }
-}
-
-/** Parser Interface **/
-
-func (self *Parser) Pos() int {
-    return self.p
-}
-
-
-// Parse returns a ast.Node representing the parser's JSON.
-// NOTICE: the specific parsing lazy dependens parser's option
-// It only parse first layer and first child for Object or Array be default
-func (self *Parser) Parse() (Node, types.ParsingError) {
-    switch val := self.decodeValue(); val.Vt {
-        case types.V_EOF     : return Node{}, types.ERR_EOF
-        case types.V_NULL    : return nullNode, 0
-        case types.V_TRUE    : return trueNode, 0
-        case types.V_FALSE   : return falseNode, 0
-        case types.V_STRING  : return self.decodeString(val.Iv, val.Ep)
-        case types.V_ARRAY:
-            s := self.p - 1;
-            if p := skipBlank(self.s, self.p); p >= self.p && self.s[p] == ']' {
-                self.p = p + 1
-                return Node{t: types.V_ARRAY}, 0
-            }
-            if self.noLazy {
-                if self.loadOnce {
-                    self.noLazy = false
-                }
-                return self.decodeArray(new(linkedNodes))
-            }
-            // NOTICE: loadOnce always keep raw json for object or array
-            if self.loadOnce {
-                self.p = s
-                s, e := self.skipFast()
-                if e != 0 {
-                    return Node{}, e
-                }
-                return newRawNode(self.s[s:self.p], types.V_ARRAY, true), 0
-            }
-            return newLazyArray(self), 0
-        case types.V_OBJECT:
-            s := self.p - 1;
-            if p := skipBlank(self.s, self.p); p >= self.p && self.s[p] == '}' {
-                self.p = p + 1
-                return Node{t: types.V_OBJECT}, 0
-            }
-            // NOTICE: loadOnce always keep raw json for object or array
-            if self.noLazy {
-                if self.loadOnce {
-                    self.noLazy = false
-                }
-                return self.decodeObject(new(linkedPairs))
-            }
-            if self.loadOnce {
-                self.p = s
-                s, e := self.skipFast()
-                if e != 0 {
-                    return Node{}, e
-                }
-                return newRawNode(self.s[s:self.p], types.V_OBJECT, true), 0
-            }
-            return newLazyObject(self), 0
-        case types.V_DOUBLE  : return NewNumber(self.s[val.Ep:self.p]), 0
-        case types.V_INTEGER : return NewNumber(self.s[val.Ep:self.p]), 0
-        default              : return Node{}, types.ParsingError(-val.Vt)
-    }
-}
-
-func (self *Parser) searchKey(match string) types.ParsingError {
-    ns := len(self.s)
-    if err := self.object(); err != 0 {
-        return err
-    }
-
-    /* check for EOF */
-    if self.p = self.lspace(self.p); self.p >= ns {
-        return types.ERR_EOF
-    }
-
-    /* check for empty object */
-    if self.s[self.p] == '}' {
-        self.p++
-        return _ERR_NOT_FOUND
-    }
-
-    var njs types.JsonState
-    var err types.ParsingError
-    /* decode each pair */
-    for {
-
-        /* decode the key */
-        if njs = self.decodeValue(); njs.Vt != types.V_STRING {
-            return types.ERR_INVALID_CHAR
-        }
-
-        /* extract the key */
-        idx := self.p - 1
-        key := self.s[njs.Iv:idx]
-
-        /* check for escape sequence */
-        if njs.Ep != -1 {
-            if key, err = unquote(key); err != 0 {
-                return err
-            }
-        }
-
-        /* expect a ':' delimiter */
-        if err = self.delim(); err != 0 {
-            return err
-        }
-
-        /* skip value */
-        if key != match {
-            if _, err = self.skipFast(); err != 0 {
-                return err
-            }
-        } else {
-            return 0
-        }
-
-        /* check for EOF */
-        self.p = self.lspace(self.p)
-        if self.p >= ns {
-            return types.ERR_EOF
-        }
-
-        /* check for the next character */
-        switch self.s[self.p] {
-        case ',':
-            self.p++
-        case '}':
-            self.p++
-            return _ERR_NOT_FOUND
-        default:
-            return types.ERR_INVALID_CHAR
-        }
-    }
-}
-
-func (self *Parser) searchIndex(idx int) types.ParsingError {
-    ns := len(self.s)
-    if err := self.array(); err != 0 {
-        return err
-    }
-
-    /* check for EOF */
-    if self.p = self.lspace(self.p); self.p >= ns {
-        return types.ERR_EOF
-    }
-
-    /* check for empty array */
-    if self.s[self.p] == ']' {
-        self.p++
-        return _ERR_NOT_FOUND
-    }
-
-    var err types.ParsingError
-    /* allocate array space and parse every element */
-    for i := 0; i < idx; i++ {
-
-        /* decode the value */
-        if _, err = self.skipFast(); err != 0 {
-            return err
-        }
-
-        /* check for EOF */
-        self.p = self.lspace(self.p)
-        if self.p >= ns {
-            return types.ERR_EOF
-        }
-
-        /* check for the next character */
-        switch self.s[self.p] {
-        case ',':
-            self.p++
-        case ']':
-            self.p++
-            return _ERR_NOT_FOUND
-        default:
-            return types.ERR_INVALID_CHAR
-        }
-    }
-
-    return 0
-}
-
-func (self *Node) skipNextNode() *Node {
-    if !self.isLazy() {
-        return nil
-    }
-
-    parser, stack := self.getParserAndArrayStack()
-    ret := &stack.v
-    sp := parser.p
-    ns := len(parser.s)
-
-    /* check for EOF */
-    if parser.p = parser.lspace(sp); parser.p >= ns {
-        return newSyntaxError(parser.syntaxError(types.ERR_EOF))
-    }
-
-    /* check for empty array */
-    if parser.s[parser.p] == ']' {
-        parser.p++
-        self.setArray(ret)
-        return nil
-    }
-
-    var val Node
-    /* skip the value */
-    if start, err := parser.skipFast(); err != 0 {
-        return newSyntaxError(parser.syntaxError(err))
-    } else {
-        t := switchRawType(parser.s[start])
-        if t == _V_NONE {
-            return newSyntaxError(parser.syntaxError(types.ERR_INVALID_CHAR))
-        }
-        val = newRawNode(parser.s[start:parser.p], t, false)
-    }
-
-    /* add the value to result */
-    ret.Push(val)
-    self.l++
-    parser.p = parser.lspace(parser.p)
-
-    /* check for EOF */
-    if parser.p >= ns {
-        return newSyntaxError(parser.syntaxError(types.ERR_EOF))
-    }
-
-    /* check for the next character */
-    switch parser.s[parser.p] {
-    case ',':
-        parser.p++
-        return ret.At(ret.Len()-1)
-    case ']':
-        parser.p++
-        self.setArray(ret)
-        return ret.At(ret.Len()-1)
-    default:
-        return newSyntaxError(parser.syntaxError(types.ERR_INVALID_CHAR))
-    }
-}
-
-func (self *Node) skipNextPair() (*Pair) {
-    if !self.isLazy() {
-        return nil
-    }
-
-    parser, stack := self.getParserAndObjectStack()
-    ret := &stack.v
-    sp := parser.p
-    ns := len(parser.s)
-
-    /* check for EOF */
-    if parser.p = parser.lspace(sp); parser.p >= ns {
-        return newErrorPair(parser.syntaxError(types.ERR_EOF))
-    }
-
-    /* check for empty object */
-    if parser.s[parser.p] == '}' {
-        parser.p++
-        self.setObject(ret)
-        return nil
-    }
-
-    /* decode one pair */
-    var val Node
-    var njs types.JsonState
-    var err types.ParsingError
-
-    /* decode the key */
-    if njs = parser.decodeValue(); njs.Vt != types.V_STRING {
-        return newErrorPair(parser.syntaxError(types.ERR_INVALID_CHAR))
-    }
-
-    /* extract the key */
-    idx := parser.p - 1
-    key := parser.s[njs.Iv:idx]
-
-    /* check for escape sequence */
-    if njs.Ep != -1 {
-        if key, err = unquote(key); err != 0 {
-            return newErrorPair(parser.syntaxError(err))
-        }
-    }
-
-    /* expect a ':' delimiter */
-    if err = parser.delim(); err != 0 {
-        return newErrorPair(parser.syntaxError(err))
-    }
-
-    /* skip the value */
-    if start, err := parser.skipFast(); err != 0 {
-        return newErrorPair(parser.syntaxError(err))
-    } else {
-        t := switchRawType(parser.s[start])
-        if t == _V_NONE {
-            return newErrorPair(parser.syntaxError(types.ERR_INVALID_CHAR))
-        }
-        val = newRawNode(parser.s[start:parser.p], t, false)
-    }
-
-    /* add the value to result */
-    ret.Push(NewPair(key, val))
-    self.l++
-    parser.p = parser.lspace(parser.p)
-
-    /* check for EOF */
-    if parser.p >= ns {
-        return newErrorPair(parser.syntaxError(types.ERR_EOF))
-    }
-
-    /* check for the next character */
-    switch parser.s[parser.p] {
-    case ',':
-        parser.p++
-        return ret.At(ret.Len()-1)
-    case '}':
-        parser.p++
-        self.setObject(ret)
-        return ret.At(ret.Len()-1)
-    default:
-        return newErrorPair(parser.syntaxError(types.ERR_INVALID_CHAR))
-    }
-}
-
-
-/** Parser Factory **/
-
-// Loads parse all json into interface{}
-func Loads(src string) (int, interface{}, error) {
-    ps := &Parser{s: src}
-    np, err := ps.Parse()
-
-    /* check for errors */
-    if err != 0 {
-        return 0, nil, ps.ExportError(err)
-    } else {
-        x, err := np.Interface()
-        if err != nil {
-            return 0, nil, err
-        }
-        return ps.Pos(), x, nil
-    }
-}
-
-// LoadsUseNumber parse all json into interface{}, with numeric nodes casted to json.Number
-func LoadsUseNumber(src string) (int, interface{}, error) {
-    ps := &Parser{s: src}
-    np, err := ps.Parse()
-
-    /* check for errors */
-    if err != 0 {
-        return 0, nil, err
-    } else {
-        x, err := np.InterfaceUseNumber()
-        if err != nil {
-            return 0, nil, err
-        }
-        return ps.Pos(), x, nil
-    }
-}
-
-// NewParser returns pointer of new allocated parser
-func NewParser(src string) *Parser {
-    return &Parser{s: src}
-}
-
-// NewParser returns new allocated parser
-func NewParserObj(src string) Parser {
-    return Parser{s: src}
-}
-
-// decodeNumber controls if parser decodes the number values instead of skip them
-//   WARN: once you set decodeNumber(true), please set decodeNumber(false) before you drop the parser 
-//   otherwise the memory CANNOT be reused
-func (self *Parser) decodeNumber(decode bool) {
-    if !decode && self.dbuf != nil {
-        types.FreeDbuf(self.dbuf)
-        self.dbuf = nil
-        return
-    }
-    if decode && self.dbuf == nil {
-        self.dbuf = types.NewDbuf()
-    }
-}
-
-// ExportError converts types.ParsingError to std Error
-func (self *Parser) ExportError(err types.ParsingError) error {
-    if err == _ERR_NOT_FOUND {
-        return ErrNotExist
-    }
-    return fmt.Errorf("%q", SyntaxError{
-        Pos : self.p,
-        Src : self.s,
-        Code: err,
-    }.Description())
-}
-
-func backward(src string, i int) int {
-    for ; i>=0 && isSpace(src[i]); i-- {}
-    return i
-}
-
-
-func newRawNode(str string, typ types.ValueType, lock bool) Node {
-    ret := Node{
-        t: typ | _V_RAW,
-        p: rt.StrPtr(str),
-        l: uint(len(str)),
-    }
-    if lock {
-        ret.m = new(sync.RWMutex)
-    }
-    return ret
-}
-
-var typeJumpTable = [256]types.ValueType{
-    '"' : types.V_STRING,
-    '-' : _V_NUMBER,
-    '0' : _V_NUMBER,
-    '1' : _V_NUMBER,
-    '2' : _V_NUMBER,
-    '3' : _V_NUMBER,
-    '4' : _V_NUMBER,
-    '5' : _V_NUMBER,
-    '6' : _V_NUMBER,
-    '7' : _V_NUMBER,
-    '8' : _V_NUMBER,
-    '9' : _V_NUMBER,
-    '[' : types.V_ARRAY,
-    'f' : types.V_FALSE,
-    'n' : types.V_NULL,
-    't' : types.V_TRUE,
-    '{' : types.V_OBJECT,
-}
-
-func switchRawType(c byte) types.ValueType {
-    return typeJumpTable[c]
-}
-
-func (self *Node) loadt() types.ValueType {
-    return (types.ValueType)(atomic.LoadInt64(&self.t))
-}
-
-func (self *Node) lock() bool {
-    if m := self.m; m != nil {
-        m.Lock()
-        return true
-    }
-    return false
-}
-
-func (self *Node) unlock() {
-    if m := self.m; m != nil {
-        m.Unlock()
-    }
-}
-
-func (self *Node) rlock() bool {
-    if m := self.m; m != nil {
-        m.RLock()
-        return true
-    }
-    return false
-}
-
-func (self *Node) runlock() {
-    if m := self.m; m != nil {
-        m.RUnlock()
-    }
-}
diff --git a/vendor/github.com/bytedance/sonic/ast/search.go b/vendor/github.com/bytedance/sonic/ast/search.go
deleted file mode 100644
index 9a5fb9420..000000000
--- a/vendor/github.com/bytedance/sonic/ast/search.go
+++ /dev/null
@@ -1,157 +0,0 @@
-/*
- * Copyright 2021 ByteDance Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package ast
-
-import (
-    `github.com/bytedance/sonic/internal/rt`
-    `github.com/bytedance/sonic/internal/native/types`
-)
-
-// SearchOptions controls Searcher's behavior
-type SearchOptions struct {
-    // ValidateJSON indicates the searcher to validate the entire JSON
-    ValidateJSON bool
-
-    // CopyReturn indicates the searcher to copy the result JSON instead of refer from the input
-    // This can help to reduce memory usage if you cache the results
-    CopyReturn bool
-
-    // ConcurrentRead indicates the searcher to return a concurrently-READ-safe node,
-    // including: GetByPath/Get/Index/GetOrIndex/Int64/Bool/Float64/String/Number/Interface/Array/Map/Raw/MarshalJSON
-    ConcurrentRead bool
-}
-
-type Searcher struct {
-    parser Parser
-    SearchOptions
-}
-
-func NewSearcher(str string) *Searcher {
-    return &Searcher{
-        parser: Parser{
-            s:      str,
-            noLazy: false,
-        },
-        SearchOptions: SearchOptions{
-            ValidateJSON: true,
-        },
-    }
-}
-
-// GetByPathCopy search in depth from top json and returns a **Copied** json node at the path location
-func (self *Searcher) GetByPathCopy(path ...interface{}) (Node, error) {
-    self.CopyReturn = true
-    return self.getByPath(path...)
-}
-
-// GetByPathNoCopy search in depth from top json and returns a **Referenced** json node at the path location
-//
-// WARN: this search directly refer partial json from top json, which has faster speed,
-// may consumes more memory.
-func (self *Searcher) GetByPath(path ...interface{}) (Node, error) {
-    return self.getByPath(path...)
-}
-
-func (self *Searcher) getByPath(path ...interface{}) (Node, error) {
-    var err types.ParsingError
-    var start int
-
-    self.parser.p = 0
-    start, err = self.parser.getByPath(self.ValidateJSON, path...)
-    if err != 0 {
-        // for compatibility with old version
-        if err == types.ERR_NOT_FOUND {
-            return Node{}, ErrNotExist
-        }
-        if err == types.ERR_UNSUPPORT_TYPE {
-            panic("path must be either int(>=0) or string")
-        }
-        return Node{}, self.parser.syntaxError(err)
-    }
-
-    t := switchRawType(self.parser.s[start])
-    if t == _V_NONE {
-        return Node{}, self.parser.ExportError(err)
-    }
-
-    // copy string to reducing memory usage
-    var raw string
-    if self.CopyReturn {
-        raw = rt.Mem2Str([]byte(self.parser.s[start:self.parser.p]))
-    } else {
-        raw = self.parser.s[start:self.parser.p]
-    }
-    return newRawNode(raw, t, self.ConcurrentRead), nil
-}
-
-// GetByPath searches a path and returns relaction and types of target
-func _GetByPath(src string, path ...interface{}) (start int, end int, typ int, err error) {
-	p := NewParserObj(src)
-	s, e := p.getByPath(false, path...)
-	if e != 0 {
-		// for compatibility with old version
-		if e == types.ERR_NOT_FOUND {
-			return -1, -1, 0, ErrNotExist
-		}
-		if e == types.ERR_UNSUPPORT_TYPE {
-			panic("path must be either int(>=0) or string")
-		}
-		return -1, -1, 0, p.syntaxError(e)
-	}
-
-	t := switchRawType(p.s[s])
-	if t == _V_NONE {
-		return -1, -1, 0, ErrNotExist
-	}
-    if t == _V_NUMBER {
-        p.p = 1 + backward(p.s, p.p-1)
-    }
-	return s, p.p, int(t), nil
-}
-
-// ValidSyntax check if a json has a valid JSON syntax,
-// while not validate UTF-8 charset
-func _ValidSyntax(json string) bool {
-	p := NewParserObj(json)
-    _, e := p.skip()
-	if e != 0 {
-        return false
-    }
-   if skipBlank(p.s, p.p) != -int(types.ERR_EOF) {
-        return false
-   }
-   return true
-}
-
-// SkipFast skip a json value in fast-skip algs, 
-// while not strictly validate JSON syntax and UTF-8 charset.
-func _SkipFast(src string, i int) (int, int, error) {
-    p := NewParserObj(src)
-    p.p = i
-    s, e := p.skipFast()
-    if e != 0 {
-        return -1, -1, p.ExportError(e)
-    }
-    t := switchRawType(p.s[s])
-	if t == _V_NONE {
-		return -1, -1, ErrNotExist
-	}
-    if t == _V_NUMBER {
-        p.p = 1 + backward(p.s, p.p-1)
-    }
-    return s, p.p, nil
-}
diff --git a/vendor/github.com/bytedance/sonic/ast/stubs.go b/vendor/github.com/bytedance/sonic/ast/stubs.go
deleted file mode 100644
index 53bf3b8aa..000000000
--- a/vendor/github.com/bytedance/sonic/ast/stubs.go
+++ /dev/null
@@ -1,142 +0,0 @@
-/*
- * Copyright 2021 ByteDance Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package ast
-
-import (
-	"unicode/utf8"
-	"unsafe"
-
-	"github.com/bytedance/sonic/internal/rt"
-)
-
-//go:noescape
-//go:linkname memmove runtime.memmove
-//goland:noinspection GoUnusedParameter
-func memmove(to unsafe.Pointer, from unsafe.Pointer, n uintptr)
-
-//go:linkname unsafe_NewArray reflect.unsafe_NewArray
-//goland:noinspection GoUnusedParameter
-func unsafe_NewArray(typ *rt.GoType, n int) unsafe.Pointer
-
-//go:nosplit
-func mem2ptr(s []byte) unsafe.Pointer {
-    return (*rt.GoSlice)(unsafe.Pointer(&s)).Ptr
-}
-
-var safeSet = [utf8.RuneSelf]bool{
-	' ':      true,
-	'!':      true,
-	'"':      false,
-	'#':      true,
-	'$':      true,
-	'%':      true,
-	'&':      true,
-	'\'':     true,
-	'(':      true,
-	')':      true,
-	'*':      true,
-	'+':      true,
-	',':      true,
-	'-':      true,
-	'.':      true,
-	'/':      true,
-	'0':      true,
-	'1':      true,
-	'2':      true,
-	'3':      true,
-	'4':      true,
-	'5':      true,
-	'6':      true,
-	'7':      true,
-	'8':      true,
-	'9':      true,
-	':':      true,
-	';':      true,
-	'<':      true,
-	'=':      true,
-	'>':      true,
-	'?':      true,
-	'@':      true,
-	'A':      true,
-	'B':      true,
-	'C':      true,
-	'D':      true,
-	'E':      true,
-	'F':      true,
-	'G':      true,
-	'H':      true,
-	'I':      true,
-	'J':      true,
-	'K':      true,
-	'L':      true,
-	'M':      true,
-	'N':      true,
-	'O':      true,
-	'P':      true,
-	'Q':      true,
-	'R':      true,
-	'S':      true,
-	'T':      true,
-	'U':      true,
-	'V':      true,
-	'W':      true,
-	'X':      true,
-	'Y':      true,
-	'Z':      true,
-	'[':      true,
-	'\\':     false,
-	']':      true,
-	'^':      true,
-	'_':      true,
-	'`':      true,
-	'a':      true,
-	'b':      true,
-	'c':      true,
-	'd':      true,
-	'e':      true,
-	'f':      true,
-	'g':      true,
-	'h':      true,
-	'i':      true,
-	'j':      true,
-	'k':      true,
-	'l':      true,
-	'm':      true,
-	'n':      true,
-	'o':      true,
-	'p':      true,
-	'q':      true,
-	'r':      true,
-	's':      true,
-	't':      true,
-	'u':      true,
-	'v':      true,
-	'w':      true,
-	'x':      true,
-	'y':      true,
-	'z':      true,
-	'{':      true,
-	'|':      true,
-	'}':      true,
-	'~':      true,
-	'\u007f': true,
-}
-
-var hex = "0123456789abcdef"
-
-//go:linkname unquoteBytes encoding/json.unquoteBytes
-func unquoteBytes(s []byte) (t []byte, ok bool)
diff --git a/vendor/github.com/bytedance/sonic/ast/visitor.go b/vendor/github.com/bytedance/sonic/ast/visitor.go
deleted file mode 100644
index dc0478513..000000000
--- a/vendor/github.com/bytedance/sonic/ast/visitor.go
+++ /dev/null
@@ -1,332 +0,0 @@
-/*
- * Copyright 2021 ByteDance Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package ast
-
-import (
-    `encoding/json`
-    `errors`
-
-    `github.com/bytedance/sonic/internal/native/types`
-)
-
-// Visitor handles the callbacks during preorder traversal of a JSON AST.
-//
-// According to the JSON RFC8259, a JSON AST can be defined by
-// the following rules without separator / whitespace tokens.
-//
-//  JSON-AST  = value
-//  value     = false / null / true / object / array / number / string
-//  object    = begin-object [ member *( member ) ] end-object
-//  member    = string value
-//  array     = begin-array [ value *( value ) ] end-array
-//
-type Visitor interface {
-
-    // OnNull handles a JSON null value.
-    OnNull() error
-
-    // OnBool handles a JSON true / false value.
-    OnBool(v bool) error
-
-    // OnString handles a JSON string value.
-    OnString(v string) error
-
-    // OnInt64 handles a JSON number value with int64 type.
-    OnInt64(v int64, n json.Number) error
-
-    // OnFloat64 handles a JSON number value with float64 type.
-    OnFloat64(v float64, n json.Number) error
-
-    // OnObjectBegin handles the beginning of a JSON object value with a
-    // suggested capacity that can be used to make your custom object container.
-    //
-    // After this point the visitor will receive a sequence of callbacks like
-    // [string, value, string, value, ......, ObjectEnd].
-    //
-    // Note:
-    // 1. This is a recursive definition which means the value can
-    // also be a JSON object / array described by a sequence of callbacks.
-    // 2. The suggested capacity will be 0 if current object is empty.
-    // 3. Currently sonic use a fixed capacity for non-empty object (keep in
-    // sync with ast.Node) which might not be very suitable. This may be
-    // improved in future version.
-    OnObjectBegin(capacity int) error
-
-    // OnObjectKey handles a JSON object key string in member.
-    OnObjectKey(key string) error
-
-    // OnObjectEnd handles the ending of a JSON object value.
-    OnObjectEnd() error
-
-    // OnArrayBegin handles the beginning of a JSON array value with a
-    // suggested capacity that can be used to make your custom array container.
-    //
-    // After this point the visitor will receive a sequence of callbacks like
-    // [value, value, value, ......, ArrayEnd].
-    //
-    // Note:
-    // 1. This is a recursive definition which means the value can
-    // also be a JSON object / array described by a sequence of callbacks.
-    // 2. The suggested capacity will be 0 if current array is empty.
-    // 3. Currently sonic use a fixed capacity for non-empty array (keep in
-    // sync with ast.Node) which might not be very suitable. This may be
-    // improved in future version.
-    OnArrayBegin(capacity int) error
-
-    // OnArrayEnd handles the ending of a JSON array value.
-    OnArrayEnd() error
-}
-
-// VisitorOptions contains all Visitor's options. The default value is an
-// empty VisitorOptions{}.
-type VisitorOptions struct {
-    // OnlyNumber indicates parser to directly return number value without
-    // conversion, then the first argument of OnInt64 / OnFloat64 will always
-    // be zero.
-    OnlyNumber bool
-}
-
-var defaultVisitorOptions = &VisitorOptions{}
-
-// Preorder decodes the whole JSON string and callbacks each AST node to visitor
-// during preorder traversal. Any visitor method with an error returned will
-// break the traversal and the given error will be directly returned. The opts
-// argument can be reused after every call.
-func Preorder(str string, visitor Visitor, opts *VisitorOptions) error {
-    if opts == nil {
-        opts = defaultVisitorOptions
-    }
-    // process VisitorOptions first to guarantee that all options will be
-    // constant during decoding and make options more readable.
-    var (
-        optDecodeNumber = !opts.OnlyNumber
-    )
-
-    tv := &traverser{
-        parser: Parser{
-            s:         str,
-            noLazy:    true,
-            skipValue: false,
-        },
-        visitor: visitor,
-    }
-
-    if optDecodeNumber {
-        tv.parser.decodeNumber(true)
-    }
-
-    err := tv.decodeValue()
-
-    if optDecodeNumber {
-        tv.parser.decodeNumber(false)
-    }
-    return err
-}
-
-type traverser struct {
-    parser  Parser
-    visitor Visitor
-}
-
-// NOTE: keep in sync with (*Parser).Parse method.
-func (self *traverser) decodeValue() error {
-    switch val := self.parser.decodeValue(); val.Vt {
-    case types.V_EOF:
-        return types.ERR_EOF
-    case types.V_NULL:
-        return self.visitor.OnNull()
-    case types.V_TRUE:
-        return self.visitor.OnBool(true)
-    case types.V_FALSE:
-        return self.visitor.OnBool(false)
-    case types.V_STRING:
-        return self.decodeString(val.Iv, val.Ep)
-    case types.V_DOUBLE:
-        return self.visitor.OnFloat64(val.Dv,
-            json.Number(self.parser.s[val.Ep:self.parser.p]))
-    case types.V_INTEGER:
-        return self.visitor.OnInt64(val.Iv,
-            json.Number(self.parser.s[val.Ep:self.parser.p]))
-    case types.V_ARRAY:
-        return self.decodeArray()
-    case types.V_OBJECT:
-        return self.decodeObject()
-    default:
-        return types.ParsingError(-val.Vt)
-    }
-}
-
-// NOTE: keep in sync with (*Parser).decodeArray method.
-func (self *traverser) decodeArray() error {
-    sp := self.parser.p
-    ns := len(self.parser.s)
-
-    /* allocate array space and parse every element */
-    if err := self.visitor.OnArrayBegin(_DEFAULT_NODE_CAP); err != nil {
-        if err == VisitOPSkip {
-            // NOTICE: for user needs to skip entiry object
-            self.parser.p -= 1
-            if _, e := self.parser.skipFast(); e != 0 {
-                return e
-            }
-            return self.visitor.OnArrayEnd()
-        }
-        return err
-    }
-
-    /* check for EOF */
-    self.parser.p = self.parser.lspace(sp)
-    if self.parser.p >= ns {
-        return types.ERR_EOF
-    }
-
-    /* check for empty array */
-    if self.parser.s[self.parser.p] == ']' {
-        self.parser.p++
-        return self.visitor.OnArrayEnd()
-    }
-
-    for {
-        /* decode the value */
-        if err := self.decodeValue(); err != nil {
-            return err
-        }
-        self.parser.p = self.parser.lspace(self.parser.p)
-
-        /* check for EOF */
-        if self.parser.p >= ns {
-            return types.ERR_EOF
-        }
-
-        /* check for the next character */
-        switch self.parser.s[self.parser.p] {
-        case ',':
-            self.parser.p++
-        case ']':
-            self.parser.p++
-            return self.visitor.OnArrayEnd()
-        default:
-            return types.ERR_INVALID_CHAR
-        }
-    }
-}
-
-// NOTE: keep in sync with (*Parser).decodeObject method.
-func (self *traverser) decodeObject() error {
-    sp := self.parser.p
-    ns := len(self.parser.s)
-
-    /* allocate object space and decode each pair */
-    if err := self.visitor.OnObjectBegin(_DEFAULT_NODE_CAP); err != nil {
-        if err == VisitOPSkip {
-            // NOTICE: for user needs to skip entiry object
-            self.parser.p -= 1
-            if _, e := self.parser.skipFast(); e != 0 {
-                return e
-            }
-            return self.visitor.OnObjectEnd()
-        }
-        return err
-    }
-
-    /* check for EOF */
-    self.parser.p = self.parser.lspace(sp)
-    if self.parser.p >= ns {
-        return types.ERR_EOF
-    }
-
-    /* check for empty object */
-    if self.parser.s[self.parser.p] == '}' {
-        self.parser.p++
-        return self.visitor.OnObjectEnd()
-    }
-
-    for {
-        var njs types.JsonState
-        var err types.ParsingError
-
-        /* decode the key */
-        if njs = self.parser.decodeValue(); njs.Vt != types.V_STRING {
-            return types.ERR_INVALID_CHAR
-        }
-
-        /* extract the key */
-        idx := self.parser.p - 1
-        key := self.parser.s[njs.Iv:idx]
-
-        /* check for escape sequence */
-        if njs.Ep != -1 {
-            if key, err = unquote(key); err != 0 {
-                return err
-            }
-        }
-
-        if err := self.visitor.OnObjectKey(key); err != nil {
-            return err
-        }
-
-        /* expect a ':' delimiter */
-        if err = self.parser.delim(); err != 0 {
-            return err
-        }
-
-        /* decode the value */
-        if err := self.decodeValue(); err != nil {
-            return err
-        }
-
-        self.parser.p = self.parser.lspace(self.parser.p)
-
-        /* check for EOF */
-        if self.parser.p >= ns {
-            return types.ERR_EOF
-        }
-
-        /* check for the next character */
-        switch self.parser.s[self.parser.p] {
-        case ',':
-            self.parser.p++
-        case '}':
-            self.parser.p++
-            return self.visitor.OnObjectEnd()
-        default:
-            return types.ERR_INVALID_CHAR
-        }
-    }
-}
-
-// NOTE: keep in sync with (*Parser).decodeString method.
-func (self *traverser) decodeString(iv int64, ep int) error {
-    p := self.parser.p - 1
-    s := self.parser.s[iv:p]
-
-    /* fast path: no escape sequence */
-    if ep == -1 {
-        return self.visitor.OnString(s)
-    }
-
-    /* unquote the string */
-    out, err := unquote(s)
-    if err != 0 {
-        return err
-    }
-    return self.visitor.OnString(out)
-}
-
-// If visitor return this error on `OnObjectBegin()` or `OnArrayBegin()`,
-// the transverer will skip entiry object or array
-var VisitOPSkip = errors.New("")