mirror of
https://github.com/cwinfo/matterbridge.git
synced 2024-11-14 09:40:26 +00:00
334 lines
6.9 KiB
Go
334 lines
6.9 KiB
Go
// A modified version of Go's JSON implementation.
|
|
|
|
// Copyright 2010, 2020 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package json
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/base64"
|
|
"errors"
|
|
"math"
|
|
"strconv"
|
|
"unicode/utf8"
|
|
|
|
"github.com/d5/tengo/v2"
|
|
)
|
|
|
|
// safeSet holds the value true if the ASCII character with the given array
|
|
// position can be represented inside a JSON string without any further
|
|
// escaping.
|
|
//
|
|
// All values are true except for the ASCII control characters (0-31), the
|
|
// double quote ("), and the backslash character ("\").
|
|
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"
|
|
|
|
// Encode returns the JSON encoding of the object.
|
|
func Encode(o tengo.Object) ([]byte, error) {
|
|
var b []byte
|
|
|
|
switch o := o.(type) {
|
|
case *tengo.Array:
|
|
b = append(b, '[')
|
|
len1 := len(o.Value) - 1
|
|
for idx, elem := range o.Value {
|
|
eb, err := Encode(elem)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
b = append(b, eb...)
|
|
if idx < len1 {
|
|
b = append(b, ',')
|
|
}
|
|
}
|
|
b = append(b, ']')
|
|
case *tengo.ImmutableArray:
|
|
b = append(b, '[')
|
|
len1 := len(o.Value) - 1
|
|
for idx, elem := range o.Value {
|
|
eb, err := Encode(elem)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
b = append(b, eb...)
|
|
if idx < len1 {
|
|
b = append(b, ',')
|
|
}
|
|
}
|
|
b = append(b, ']')
|
|
case *tengo.Map:
|
|
b = append(b, '{')
|
|
len1 := len(o.Value) - 1
|
|
idx := 0
|
|
for key, value := range o.Value {
|
|
b = encodeString(b, key)
|
|
b = append(b, ':')
|
|
eb, err := Encode(value)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
b = append(b, eb...)
|
|
if idx < len1 {
|
|
b = append(b, ',')
|
|
}
|
|
idx++
|
|
}
|
|
b = append(b, '}')
|
|
case *tengo.ImmutableMap:
|
|
b = append(b, '{')
|
|
len1 := len(o.Value) - 1
|
|
idx := 0
|
|
for key, value := range o.Value {
|
|
b = encodeString(b, key)
|
|
b = append(b, ':')
|
|
eb, err := Encode(value)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
b = append(b, eb...)
|
|
if idx < len1 {
|
|
b = append(b, ',')
|
|
}
|
|
idx++
|
|
}
|
|
b = append(b, '}')
|
|
case *tengo.Bool:
|
|
if o.IsFalsy() {
|
|
b = strconv.AppendBool(b, false)
|
|
} else {
|
|
b = strconv.AppendBool(b, true)
|
|
}
|
|
case *tengo.Bytes:
|
|
b = append(b, '"')
|
|
encodedLen := base64.StdEncoding.EncodedLen(len(o.Value))
|
|
dst := make([]byte, encodedLen)
|
|
base64.StdEncoding.Encode(dst, o.Value)
|
|
b = append(b, dst...)
|
|
b = append(b, '"')
|
|
case *tengo.Char:
|
|
b = strconv.AppendInt(b, int64(o.Value), 10)
|
|
case *tengo.Float:
|
|
var y []byte
|
|
|
|
f := o.Value
|
|
if math.IsInf(f, 0) || math.IsNaN(f) {
|
|
return nil, errors.New("unsupported float value")
|
|
}
|
|
|
|
// Convert as if by ES6 number to string conversion.
|
|
// This matches most other JSON generators.
|
|
abs := math.Abs(f)
|
|
fmt := byte('f')
|
|
if abs != 0 {
|
|
if abs < 1e-6 || abs >= 1e21 {
|
|
fmt = 'e'
|
|
}
|
|
}
|
|
y = strconv.AppendFloat(y, f, fmt, -1, 64)
|
|
if fmt == 'e' {
|
|
// clean up e-09 to e-9
|
|
n := len(y)
|
|
if n >= 4 && y[n-4] == 'e' && y[n-3] == '-' && y[n-2] == '0' {
|
|
y[n-2] = y[n-1]
|
|
y = y[:n-1]
|
|
}
|
|
}
|
|
|
|
b = append(b, y...)
|
|
case *tengo.Int:
|
|
b = strconv.AppendInt(b, o.Value, 10)
|
|
case *tengo.String:
|
|
// string encoding bug is fixed with newly introduced function
|
|
// encodeString(). See: https://github.com/d5/tengo/issues/268
|
|
b = encodeString(b, o.Value)
|
|
case *tengo.Time:
|
|
y, err := o.Value.MarshalJSON()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
b = append(b, y...)
|
|
case *tengo.Undefined:
|
|
b = append(b, "null"...)
|
|
default:
|
|
// unknown type: ignore
|
|
}
|
|
return b, nil
|
|
}
|
|
|
|
// encodeString encodes given string as JSON string according to
|
|
// https://www.json.org/img/string.png
|
|
// Implementation is inspired by https://github.com/json-iterator/go
|
|
// See encodeStringSlowPath() for more information.
|
|
func encodeString(b []byte, val string) []byte {
|
|
valLen := len(val)
|
|
buf := bytes.NewBuffer(b)
|
|
buf.WriteByte('"')
|
|
|
|
// write string, the fast path, without utf8 and escape support
|
|
i := 0
|
|
for ; i < valLen; i++ {
|
|
c := val[i]
|
|
if c > 31 && c != '"' && c != '\\' {
|
|
buf.WriteByte(c)
|
|
} else {
|
|
break
|
|
}
|
|
}
|
|
if i == valLen {
|
|
buf.WriteByte('"')
|
|
return buf.Bytes()
|
|
}
|
|
encodeStringSlowPath(buf, i, val, valLen)
|
|
buf.WriteByte('"')
|
|
return buf.Bytes()
|
|
}
|
|
|
|
// encodeStringSlowPath is ported from Go 1.14.2 encoding/json package.
|
|
// U+2028 U+2029 JSONP security holes can be fixed with addition call to
|
|
// json.html_escape() thus it is removed from the implementation below.
|
|
// Note: Invalid runes are not checked as they are checked in original
|
|
// implementation.
|
|
func encodeStringSlowPath(buf *bytes.Buffer, i int, val string, valLen int) {
|
|
start := i
|
|
for i < valLen {
|
|
if b := val[i]; b < utf8.RuneSelf {
|
|
if safeSet[b] {
|
|
i++
|
|
continue
|
|
}
|
|
if start < i {
|
|
buf.WriteString(val[start:i])
|
|
}
|
|
buf.WriteByte('\\')
|
|
switch b {
|
|
case '\\', '"':
|
|
buf.WriteByte(b)
|
|
case '\n':
|
|
buf.WriteByte('n')
|
|
case '\r':
|
|
buf.WriteByte('r')
|
|
case '\t':
|
|
buf.WriteByte('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.
|
|
buf.WriteString(`u00`)
|
|
buf.WriteByte(hex[b>>4])
|
|
buf.WriteByte(hex[b&0xF])
|
|
}
|
|
i++
|
|
start = i
|
|
continue
|
|
}
|
|
i++
|
|
continue
|
|
}
|
|
if start < valLen {
|
|
buf.WriteString(val[start:])
|
|
}
|
|
}
|