util/util.go

package util

import (
	"bytes"
	"crypto"
	"crypto/ecdsa"
	"crypto/elliptic"
	"crypto/hmac"
	"crypto/md5"
	"crypto/rand"
	"crypto/rsa"
	"crypto/sha1"
	"crypto/sha256"
	"crypto/sha512"
	"crypto/x509"
	_ "embed"
	"encoding/base64"
	"encoding/hex"
	"encoding/json"
	"encoding/pem"
	"errors"
	"math/big"
	"os"
	"path/filepath"
	"regexp"
	"runtime"
	"strings"
	"text/template"
	"time"

	"apigo.cc/gojs"
	"apigo.cc/gojs/goja"
	"github.com/ZZMarquis/gm/sm3"
	"github.com/ZZMarquis/gm/sm4"
	"github.com/ZZMarquis/gm/util"
	"github.com/emmansun/gmsm/sm2"
	"github.com/emmansun/gmsm/smx509"
	"github.com/obscuren/ecies"
	"github.com/ssgo/u"
	"gopkg.in/yaml.v3"
)

//go:embed util.ts
var utilTS string

//go:embed README.md
var utilMD string

var envConfigs map[string]map[string]any
var confAes = u.NewAes([]byte("?GQ$0K0GgLdO=f+~L68PLm$uhKr4'=tV"), []byte("VFs7@sK61cj^f?HZ"))
var keysIsSet = false

func SetSSKey(key, iv []byte) {
	if !keysIsSet {
		confAes = u.NewAes(key, iv)
		keysIsSet = true
	}
}

func init() {
	obj := map[string]any{
		"json": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			if r, err := json.Marshal(args.Arguments[0].Export()); err == nil {
				return vm.ToValue(string(r))
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"jsonP": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			if r, err := json.Marshal(args.Arguments[0].Export()); err == nil {
				r1 := bytes.Buffer{}
				if err2 := json.Indent(&r1, r, "", "  "); err2 == nil {
					return vm.ToValue(string(r))
				} else {
					return vm.ToValue(string(r))
				}
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"unJson": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			var r any
			if err := json.Unmarshal(u.Bytes(args.Arguments[0].Export()), &r); err == nil {
				return vm.ToValue(r)
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"yaml": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			if r, err := yaml.Marshal(args.Arguments[0].Export()); err == nil {
				return vm.ToValue(string(r))
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"unYaml": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			var r any
			if err := yaml.Unmarshal(u.Bytes(args.Arguments[0].Export()), &r); err == nil {
				return vm.ToValue(r)
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"save": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(2)
			filename := args.Str(0)
			var data []byte
			var err error
			if strings.HasSuffix(filename, ".yml") || strings.HasSuffix(filename, ".yaml") {
				data, err = yaml.Marshal(args.Any(1))
			} else {
				data, err = json.Marshal(args.Any(1))
			}
			if err == nil {
				if err = u.WriteFileBytes(gojs.FindPath(vm, filename), data); err != nil {
					panic(vm.NewGoError(err))
				}
				return nil
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"load": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			filename := args.Str(0)
			if data, err := u.ReadFileBytes(gojs.FindPath(vm, filename)); err == nil {
				var r any
				if strings.HasSuffix(filename, ".yml") || strings.HasSuffix(filename, ".yaml") {
					err = yaml.Unmarshal(data, &r)
				} else {
					err = json.Unmarshal(data, &r)
				}
				if err == nil {
					return vm.ToValue(r)
				} else {
					panic(vm.NewGoError(err))
				}
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"base64": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			return vm.ToValue(u.Base64(u.Bytes(args.Arguments[0].Export())))
		},
		"unBase64": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			return vm.ToValue(u.UnBase64(args.Str(0)))
		},
		"urlBase64": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			return vm.ToValue(u.UrlBase64String(args.Str(0)))
		},
		"unUrlBase64": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			return vm.ToValue(u.UnUrlBase64(args.Str(0)))
		},
		"hex": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			return vm.ToValue(hex.EncodeToString(u.Bytes(args.Arguments[0].Export())))
		},
		"unHex": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			if r, err := hex.DecodeString(args.Str(0)); err == nil {
				return vm.ToValue(r)
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"aes": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(3)
			if r, err := u.EncryptAesBytes(u.Bytes(args.Arguments[0].Export()), u.Bytes(args.Arguments[1].Export()), u.Bytes(args.Arguments[2].Export())); err == nil {
				return vm.ToValue(r)
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"unAes": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(3)
			if r, err := u.DecryptAesBytes(u.Bytes(args.Arguments[0].Export()), u.Bytes(args.Arguments[1].Export()), u.Bytes(args.Arguments[2].Export())); err == nil {
				return vm.ToValue(r)
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"sm4": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(3)
			if r, err := sm4.CBCEncrypt(u.Bytes(args.Arguments[1].Export())[0:16], u.Bytes(args.Arguments[2].Export())[0:16], util.PKCS5Padding(u.Bytes(args.Arguments[0].Export()), 16)); err == nil {
				return vm.ToValue(r)
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"unSM4": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(3)
			if r, err := sm4.CBCDecrypt(u.Bytes(args.Arguments[1].Export())[0:16], u.Bytes(args.Arguments[2].Export())[0:16], u.Bytes(args.Arguments[0].Export())); err == nil {
				if length := len(r); length > 0 {
					if unpadding := int(r[length-1]); length-unpadding >= 0 {
						r = util.PKCS5UnPadding(r)
					}
				}
				return vm.ToValue(r)
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"genECDSA": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm)
			var curve elliptic.Curve
			switch args.Int(0) {
			case 521:
				curve = elliptic.P521()
			case 384:
				curve = elliptic.P384()
			default:
				curve = elliptic.P256()
			}
			pri, err := ecdsa.GenerateKey(curve, u.GlobalRand2)
			if err != nil {
				panic(vm.NewGoError(err))
			}
			var buf bytes.Buffer
			buf.WriteByte(byte(len(pri.X.Bytes())))
			buf.Write(pri.X.Bytes())
			buf.Write(pri.Y.Bytes())
			return vm.ToValue([][]byte{pri.D.Bytes(), buf.Bytes()})
		},
		"exportECDSAPrivateKey": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			priKey := makeECDSAPriKey(args.Bytes(0))
			priBytes, err := x509.MarshalPKCS8PrivateKey(priKey)
			if err != nil {
				panic(vm.NewGoError(err))
			}
			pemBytes := pem.EncodeToMemory(&pem.Block{
				Type:  "PRIVATE KEY",
				Bytes: priBytes,
			})
			return vm.ToValue(string(pemBytes))
		},
		"exportECDSAPublicKey": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			pubKey := makeECDSAPubKey(args.Bytes(0))
			pubBytes, err := x509.MarshalPKIXPublicKey(pubKey)
			if err != nil {
				panic(vm.NewGoError(err))
			}
			pemBytes := pem.EncodeToMemory(&pem.Block{
				Type:  "PUBLIC KEY",
				Bytes: pubBytes,
			})
			return vm.ToValue(string(pemBytes))
		},
		"importECDSAKey": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			keyText := args.Str(0)
			keyType := args.Str(1)
			var keyBytes []byte
			if strings.Contains(keyText, "-----BEGIN PRIVATE KEY-----") {
				keyType = "private"
				if block, _ := pem.Decode([]byte(keyText)); block == nil {
					panic(vm.NewGoError(errors.New("bad private pem key")))
				} else {
					keyBytes = block.Bytes
				}
			} else if strings.Contains(keyText, "-----BEGIN PUBLIC KEY-----") {
				keyType = "public"
				if block, _ := pem.Decode([]byte(keyText)); block == nil {
					panic(vm.NewGoError(errors.New("bad public pem key")))
				} else {
					keyBytes = block.Bytes
				}
			} else {
				var err error
				if keyBytes, err = base64.StdEncoding.DecodeString(keyText); err != nil {
					panic(vm.NewGoError(err))
				}
			}

			if keyType == "private" {
				if priKey, err := x509.ParsePKCS8PrivateKey(keyBytes); err != nil {
					panic(vm.NewGoError(err))
				} else {
					if ecdsaPriKey, ok := priKey.(*ecdsa.PrivateKey); !ok {
						panic(vm.NewGoError(errors.New("bad private key")))
					} else {
						return vm.ToValue(ecdsaPriKey.D.Bytes())
					}
				}
			} else {
				if pubKey, err := x509.ParsePKIXPublicKey(keyBytes); err != nil {
					panic(vm.NewGoError(err))
				} else {
					if ecdsaPubKey, ok := pubKey.(*ecdsa.PublicKey); !ok {
						panic(vm.NewGoError(errors.New("bad public key")))
					} else {
						var buf bytes.Buffer
						buf.WriteByte(byte(len(ecdsaPubKey.X.Bytes())))
						buf.Write(ecdsaPubKey.X.Bytes())
						buf.Write(ecdsaPubKey.Y.Bytes())
						return vm.ToValue(buf.Bytes())
					}
				}
			}
		},
		"signECDSA": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(2)
			data := args.Bytes(0)
			priKey := makeECDSAPriKey(args.Bytes(1))
			r, s, err := ecdsa.Sign(u.GlobalRand1, priKey, u.Sha256(data))
			if err != nil {
				panic(vm.NewGoError(err))
			}
			var buf bytes.Buffer
			buf.WriteByte(byte(len(r.Bytes())))
			buf.Write(r.Bytes())
			buf.Write(s.Bytes())
			return vm.ToValue(buf.Bytes())
		},
		"verifyECDSA": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(3)
			data := args.Bytes(0)
			signature := args.Bytes(1)
			pubKey := makeECDSAPubKey(args.Bytes(2))
			byteLen := signature[0]
			r := new(big.Int)
			s := new(big.Int)
			r.SetBytes(signature[1 : byteLen+1])
			s.SetBytes(signature[byteLen+1:])
			return vm.ToValue(ecdsa.Verify(pubKey, u.Sha256(data), r, s))
		},
		"encryptECDSA": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(2)
			data := args.Bytes(0)
			pubKey := makeECDSAPubKey(args.Bytes(1))
			eciesPubKey := ecies.ImportECDSAPublic(pubKey)
			if r, err := ecies.Encrypt(u.GlobalRand1, eciesPubKey, data, nil, nil); err != nil {
				panic(vm.NewGoError(err))
			} else {
				return vm.ToValue(r)
			}
		},
		"decryptECDSA": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(2)
			data := args.Bytes(0)
			priKey := makeECDSAPriKey(args.Bytes(1))
			eciesPriKey := ecies.ImportECDSA(priKey)
			if r, err := eciesPriKey.Decrypt(u.GlobalRand1, data, nil, nil); err != nil {
				panic(vm.NewGoError(err))
			} else {
				return vm.ToValue(r)
			}
		},
		"genSM2": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			if pri, err := sm2.GenerateKey(u.GlobalRand2); err == nil {
				var buf bytes.Buffer
				buf.WriteByte(byte(len(pri.X.Bytes())))
				buf.Write(pri.X.Bytes())
				buf.Write(pri.Y.Bytes())
				return vm.ToValue([][]byte{pri.D.Bytes(), buf.Bytes()})
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"exportSM2PrivateKey": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			priKey := makePriKey(args.Bytes(0), sm2.P256())
			priBytes, err := smx509.MarshalECPrivateKey(priKey)
			if err != nil {
				panic(vm.NewGoError(err))
			}
			pemBytes := pem.EncodeToMemory(&pem.Block{
				Type:  "PRIVATE KEY",
				Bytes: priBytes,
			})
			return vm.ToValue(string(pemBytes))
		},
		"exportSM2PublicKey": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			pubKey := makePubKey(args.Bytes(0), sm2.P256())
			pubBytes, err := smx509.MarshalPKIXPublicKey(pubKey)
			if err != nil {
				panic(vm.NewGoError(err))
			}
			pemBytes := pem.EncodeToMemory(&pem.Block{
				Type:  "PUBLIC KEY",
				Bytes: pubBytes,
			})
			return vm.ToValue(string(pemBytes))
		},
		"importSM2Key": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			keyText := args.Str(0)
			keyType := args.Str(1)
			var keyBytes []byte
			if strings.Contains(keyText, "-----BEGIN PRIVATE KEY-----") {
				keyType = "private"
				if block, _ := pem.Decode([]byte(keyText)); block == nil {
					panic(vm.NewGoError(errors.New("bad private pem key")))
				} else {
					keyBytes = block.Bytes
				}
			} else if strings.Contains(keyText, "-----BEGIN PUBLIC KEY-----") {
				keyType = "public"
				if block, _ := pem.Decode([]byte(keyText)); block == nil {
					panic(vm.NewGoError(errors.New("bad public pem key")))
				} else {
					keyBytes = block.Bytes
				}
			} else {
				var err error
				if keyBytes, err = base64.StdEncoding.DecodeString(keyText); err != nil {
					panic(vm.NewGoError(err))
				}
			}

			if keyType == "private" {
				if priKey, err := smx509.ParseECPrivateKey(keyBytes); err != nil {
					panic(vm.NewGoError(err))
				} else {
					return vm.ToValue(priKey.D.Bytes())
				}
			} else {
				if pubKey, err := smx509.ParsePKIXPublicKey(keyBytes); err != nil {
					panic(vm.NewGoError(err))
				} else {
					if sm2PubKey, ok := pubKey.(*ecdsa.PublicKey); !ok {
						panic(vm.NewGoError(errors.New("bad public key")))
					} else {
						var buf bytes.Buffer
						buf.WriteByte(byte(len(sm2PubKey.X.Bytes())))
						buf.Write(sm2PubKey.X.Bytes())
						buf.Write(sm2PubKey.Y.Bytes())
						return vm.ToValue(buf.Bytes())
					}
				}
			}
		},
		"signSM2": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(2)
			data := args.Bytes(0)
			priKey := makePriKey(args.Bytes(1), sm2.P256())
			if r, s, err := sm2.SignWithSM2(u.GlobalRand1, priKey, nil, data); err == nil {
				var buf bytes.Buffer
				buf.WriteByte(byte(len(r.Bytes())))
				buf.Write(r.Bytes())
				buf.Write(s.Bytes())
				return vm.ToValue(buf.Bytes())
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"verifySM2": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(3)
			data := args.Bytes(0)
			signature := args.Bytes(1)
			pubKey := makePubKey(args.Bytes(2), sm2.P256())
			byteLen := signature[0]
			r := new(big.Int)
			s := new(big.Int)
			r.SetBytes(signature[1 : byteLen+1])
			s.SetBytes(signature[byteLen+1:])
			return vm.ToValue(sm2.VerifyWithSM2(pubKey, nil, data, r, s))
		},
		"encryptSM2": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(2)
			data := args.Bytes(0)
			pubKey := makePubKey(args.Bytes(1), sm2.P256())
			if r, err := sm2.Encrypt(u.GlobalRand1, pubKey, data, nil); err == nil {
				return vm.ToValue(r)
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"decryptSM2": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(2)
			data := args.Bytes(0)
			priKey := makePriKey(args.Bytes(1), sm2.P256())
			if r, err := sm2.Decrypt(&sm2.PrivateKey{PrivateKey: *priKey}, data); err == nil {
				return vm.ToValue(r)
			} else {
				panic(vm.NewGoError(err))
			}
		},

		"genRSA": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm)
			size := args.Int(0)
			if size == 0 {
				size = 2048
			}
			key, err := rsa.GenerateKey(rand.Reader, size)
			if err != nil {
				panic(vm.NewGoError(err))
			}
			priBytes := x509.MarshalPKCS1PrivateKey(key)
			pubBytes := x509.MarshalPKCS1PublicKey(&key.PublicKey)
			return vm.ToValue([][]byte{priBytes, pubBytes})
		},
		"exportRSAPrivateKey": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			priKey := makeRSAPriKey(args.Bytes(0))
			priBytes := x509.MarshalPKCS1PrivateKey(priKey)
			pemBytes := pem.EncodeToMemory(&pem.Block{
				Type:  "RSA PRIVATE KEY",
				Bytes: priBytes,
			})
			return vm.ToValue(string(pemBytes))
		},
		"exportRSAPublicKey": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			pubKey := makeRSAPubKey(args.Bytes(0))
			pubBytes := x509.MarshalPKCS1PublicKey(pubKey)
			pemBytes := pem.EncodeToMemory(&pem.Block{
				Type:  "RSA PUBLIC KEY",
				Bytes: pubBytes,
			})
			return vm.ToValue(string(pemBytes))
		},
		"importRSAKey": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			keyText := args.Str(0)
			keyType := args.Str(1)
			var keyBytes []byte
			if strings.Contains(keyText, "-----BEGIN RSA PRIVATE KEY-----") {
				keyType = "private"
				if block, _ := pem.Decode([]byte(keyText)); block == nil {
					panic(vm.NewGoError(errors.New("bad private pem key")))
				} else {
					keyBytes = block.Bytes
				}
			} else if strings.Contains(keyText, "-----BEGIN RSA PUBLIC KEY-----") {
				keyType = "public"
				if block, _ := pem.Decode([]byte(keyText)); block == nil {
					panic(vm.NewGoError(errors.New("bad public pem key")))
				} else {
					keyBytes = block.Bytes
				}
			} else {
				var err error
				if keyBytes, err = base64.StdEncoding.DecodeString(keyText); err != nil {
					panic(vm.NewGoError(err))
				}
			}

			if keyType == "private" {
				if priKey, err := x509.ParsePKCS1PrivateKey(keyBytes); err != nil {
					panic(vm.NewGoError(err))
				} else {
					return vm.ToValue(x509.MarshalPKCS1PrivateKey(priKey))
				}
			} else {
				if pubKey, err := x509.ParsePKCS1PublicKey(keyBytes); err != nil {
					panic(vm.NewGoError(err))
				} else {
					return vm.ToValue(x509.MarshalPKCS1PublicKey(pubKey))
				}
			}
		},
		"signRSA": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(2)
			data := args.Bytes(0)
			priKey := makeRSAPriKey(args.Bytes(1))
			signature, err := rsa.SignPKCS1v15(rand.Reader, priKey, crypto.SHA256, u.Sha256(data))
			if err != nil {
				panic(vm.NewGoError(err))
			}
			return vm.ToValue(signature)
		},
		"verifyRSA": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(3)
			data := args.Bytes(0)
			signature := args.Bytes(1)
			pubKey := makeRSAPubKey(args.Bytes(2))
			err := rsa.VerifyPKCS1v15(pubKey, crypto.SHA256, u.Sha256(data), signature)
			return vm.ToValue(err == nil)
		},
		"encryptRSA": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(2)
			data := args.Bytes(0)
			pubKey := makeRSAPubKey(args.Bytes(1))
			encryptedData, err := rsa.EncryptOAEP(sha256.New(), rand.Reader, pubKey, data, nil)
			if err != nil {
				panic(vm.NewGoError(err))
			}
			return vm.ToValue(encryptedData)
		},
		"decryptRSA": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(2)
			data := args.Bytes(0)
			priKey := makeRSAPriKey(args.Bytes(1))
			decryptedData, err := rsa.DecryptOAEP(sha256.New(), rand.Reader, priKey, data, nil)
			if err != nil {
				panic(vm.NewGoError(err))
			}
			return vm.ToValue(decryptedData)
		},

		"gzip": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			if r, err := u.Gzip(u.Bytes(args.Arguments[0].Export())); err == nil {
				return vm.ToValue(r)
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"gunzip": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			if r, err := u.Gunzip(u.Bytes(args.Arguments[0].Export())); err == nil {
				return vm.ToValue(r)
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"uniqueId": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm)
			size := args.Int(0)
			var id string
			if size >= 20 {
				id = u.UniqueId()
			} else if size >= 16 {
				id = u.UniqueId()[0:16]
			} else if size >= 14 {
				id = u.ShortUniqueId()
			} else if size >= 12 {
				id = u.ShortUniqueId()[0:12]
			} else {
				id = u.UniqueId()
			}
			return vm.ToValue(id)
		},
		"uniqueIdL": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm)
			size := args.Int(0)
			var id string
			if size >= 20 {
				id = u.UniqueId()
			} else if size >= 16 {
				id = u.UniqueId()[0:16]
			} else if size >= 14 {
				id = u.ShortUniqueId()
			} else if size >= 12 {
				id = u.ShortUniqueId()[0:12]
			} else {
				id = u.UniqueId()
			}
			return vm.ToValue(strings.ToLower(id))
		},
		"id": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm)
			size := args.Int(0)
			var id string
			if size >= 12 {
				id = u.Id12()
			} else if size >= 10 {
				id = u.Id10()
			} else if size >= 8 {
				id = u.Id8()
			} else {
				id = u.Id6()
			}
			return vm.ToValue(id)
		},
		"idL": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm)
			size := args.Int(0)
			var id string
			if size >= 12 {
				id = u.Id12()
			} else if size >= 10 {
				id = u.Id10()
			} else if size >= 8 {
				id = u.Id8()
			} else {
				id = u.Id6()
			}
			return vm.ToValue(strings.ToLower(id))
		},
		"token": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm)
			size := args.Int(0)
			if size == 0 {
				size = 20
			}
			return vm.ToValue(u.MakeToken(size))
		},
		"md5": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			hash := md5.New()
			for _, v := range args.Array(0) {
				hash.Write(u.Bytes(v))
			}
			return vm.ToValue(hash.Sum(nil))
		},
		"sha1": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			hash := sha1.New()
			for _, v := range args.Array(0) {
				hash.Write(u.Bytes(v))
			}
			return vm.ToValue(hash.Sum(nil))
		},
		"sha256": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			hash := sha256.New()
			for _, v := range args.Array(0) {
				hash.Write(u.Bytes(v))
			}
			return vm.ToValue(hash.Sum(nil))
		},
		"sha512": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			hash := sha512.New()
			for _, v := range args.Array(0) {
				hash.Write(u.Bytes(v))
			}
			return vm.ToValue(hash.Sum(nil))
		},
		"sm3": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			hash := sm3.New()
			for _, v := range args.Array(0) {
				hash.Write(u.Bytes(v))
			}
			return vm.ToValue(hash.Sum(nil))
		},
		"hmacMD5": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(2)
			hash := hmac.New(md5.New, args.Bytes(0))
			for _, v := range args.Array(1) {
				hash.Write(u.Bytes(v))
			}
			return vm.ToValue(hash.Sum(nil))
		},
		"hmacSHA1": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(2)
			hash := hmac.New(sha1.New, args.Bytes(0))
			for _, v := range args.Array(1) {
				hash.Write(u.Bytes(v))
			}
			return vm.ToValue(hash.Sum(nil))
		},
		"hmacSHA256": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(2)
			hash := hmac.New(sha256.New, args.Bytes(0))
			for _, v := range args.Array(1) {
				hash.Write(u.Bytes(v))
			}
			return vm.ToValue(hash.Sum(nil))
		},
		"hmacSHA512": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(2)
			hash := hmac.New(sha512.New, args.Bytes(0))
			for _, v := range args.Array(1) {
				hash.Write(u.Bytes(v))
			}
			return vm.ToValue(hash.Sum(nil))
		},
		"hmacSM3": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(2)
			hash := hmac.New(sm3.New, args.Bytes(0))
			for _, v := range args.Array(1) {
				hash.Write(u.Bytes(v))
			}
			return vm.ToValue(hash.Sum(nil))
		},
		"tpl": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(2)
			var functions = map[string]any{}
			if len(argsIn.Arguments) > 2 {
				obj := argsIn.Arguments[2].ToObject(vm)
				for _, k := range obj.Keys() {
					v := obj.Get(k)
					if cb, ok := goja.AssertFunction(v); ok {
						functions[k] = func(in string) string {
							if r, err := cb(argsIn.This, vm.ToValue(in)); err == nil {
								return r.String()
							}
							return ""
						}
					}
				}
			}

			buf := bytes.NewBuffer(make([]byte, 0))
			var err error
			tpl := template.New("tpl")
			if len(functions) > 0 {
				tpl.Funcs(functions)
			}
			if tpl, err = tpl.Parse(args.Str(0)); err == nil {
				err = tpl.Execute(buf, args.Arguments[1].Export())
			}
			if err != nil {
				panic(vm.NewGoError(err))
			}
			return vm.ToValue(buf.String())
		},
		"sleep": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			time.Sleep(time.Duration(args.Int64(0)) * time.Millisecond)
			return nil
		},
		"setTimeout": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			callback := args.Func(0)
			timeout := time.Duration(args.Int64(1)) * time.Millisecond
			if callback != nil {
				go func() {
					if timeout > 0 {
						time.Sleep(timeout)
					}
					if _, err := callback(args.This, args.Arguments[2:]...); err != nil {
						args.Logger.Error(err.Error())
					}
				}()
			}
			return nil
		},
		"shell": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			a := make([]string, len(args.Arguments)-1)
			for i := 1; i < len(args.Arguments); i++ {
				a[i-1] = args.Str(i)
			}

			if r, err := u.RunCommand(args.Str(0), a...); err == nil {
				return vm.ToValue(r)
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"formatDate": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			format := args.Str(0)
			var tm time.Time
			if timestamp := args.Int64(1); timestamp > 0 {
				if timestamp < 10000000000 {
					timestamp *= 1000
				}
				tm = time.UnixMilli(timestamp)
			} else {
				tm = time.Now()
			}
			return vm.ToValue(tm.Format(format))
		},
		"timestampMS": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			return vm.ToValue(time.Now().UnixMilli())
		},
		"timestamp": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			return vm.ToValue(time.Now().Unix())
		},
		"toDatetime": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm)
			var tm time.Time
			if timestamp := args.Int64(0); timestamp > 0 {
				if timestamp < 10000000000 {
					timestamp *= 1000
				}
				tm = time.UnixMilli(timestamp)
			} else {
				tm = time.Now()
			}
			return vm.ToValue(tm.Format("2006-01-02 15:04:05"))
		},
		"fromDatetime": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			timeStr := args.Str(0)
			if len(timeStr) > 19 {
				timeStr = timeStr[0:19]
			}
			if strings.ContainsRune(timeStr, 'T') {
				timeStr = strings.ReplaceAll(timeStr, "T", " ")
			}
			if tm, err := time.ParseInLocation("2006-01-02 15:04:05", timeStr, time.Local); err == nil {
				return vm.ToValue(tm.UnixMilli())
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"toDate": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm)
			var tm time.Time
			if timestamp := args.Int64(0); timestamp > 0 {
				if timestamp < 10000000000 {
					timestamp *= 1000
				}
				tm = time.UnixMilli(timestamp)
			} else {
				tm = time.Now()
			}
			return vm.ToValue(tm.Format("2006-01-02"))
		},
		"fromDate": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			timeStr := args.Str(0)
			if len(timeStr) > 10 {
				timeStr = timeStr[0:10]
			}
			if tm, err := time.ParseInLocation("2006-01-02", timeStr, time.Local); err == nil {
				return vm.ToValue(tm.UnixMilli())
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"os": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			return vm.ToValue(runtime.GOOS)
		},
		"arch": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			return vm.ToValue(runtime.GOARCH)
		},
		"joinPath": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			return vm.ToValue(filepath.Join(args.StrArray(0)...))
		},
		"getPathDir": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			return vm.ToValue(filepath.Dir(args.Str(0)))
		},
		"getPathBase": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			return vm.ToValue(filepath.Base(args.Str(0)))
		},
		"getPathVolume": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			return vm.ToValue(filepath.VolumeName(args.Str(0)))
		},
		"absPath": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			r, err := filepath.Abs(args.Str(0))
			if err != nil {
				panic(vm.NewGoError(err))
			}
			return vm.ToValue(r)
		},
		"cleanPath": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			return vm.ToValue(filepath.Clean(args.Str(0)))
		},
		"isLocalPath": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			return vm.ToValue(filepath.IsLocal(args.Str(0)))
		},
		"string": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			return vm.ToValue(u.String(args.Any(0)))
		},
		"int": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			return vm.ToValue(u.Int64(args.Any(0)))
		},
		"float": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			return vm.ToValue(u.Float64(args.Any(0)))
		},
		"bytes": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			return vm.ToValue(u.Bytes(args.Any(0)))
		},
		"bool": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			return vm.ToValue(u.Bool(args.Any(0)))
		},
		"searchFile": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			filename := args.Str(0)
			searchPath := args.Str(1)
			findFile := ""
			if searchPath != "" {
				findFile = searchFile(searchPath, filename)
			} else {
				findFile = searchFileFromCurrent(vm, filename)
			}
			return vm.ToValue(findFile)
		},
		"loadConfig": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			if envConfigs == nil {
				envConfigs = map[string]map[string]any{}
				envFile := searchFileFromCurrent(vm, "env.yml")
				if envFile == "" {
					envFile = searchFileFromCurrent(vm, "env.json")
				}
				if envFile != "" {
					u.LoadX(envFile, &envConfigs)
				}
			}

			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			confName := args.Str(0)
			conf := map[string]any{}
			confFile := searchFileFromCurrent(vm, confName+".yml")
			if confFile == "" {
				confFile = searchFileFromCurrent(vm, confName+".json")
			}
			if confFile != "" {
				u.LoadX(confFile, &conf)
			}
			if envConf, ok := envConfigs[confName]; ok {
				u.Convert(envConf, &conf)
			}

			decTimes := 0
			confStr := encryptdMatcher.ReplaceAllStringFunc(u.Json(conf), func(str string) string {
				if buf, err := base64.URLEncoding.DecodeString(str[1 : len(str)-1]); err == nil {
					if buf1, err1 := confAes.DecryptBytes(buf); err1 == nil && len(buf1) > 0 {
						decTimes++
						return "\"" + string(buf1) + "\""
					}
				}
				return str
			})
			if decTimes > 0 {
				u.UnJson(confStr, &conf)
			}

			return vm.ToValue(conf)
		},
	}

	gojs.Register("apigo.cc/gojs/util", gojs.Module{
		Object:   obj,
		TsCode:   utilTS,
		Example:  utilMD,
		SetSSKey: SetSSKey,
		JsCode: `
$MOD$.keysBy = function (obj, ...fieldAndValues) {
    let keys = []
    for (let k in obj) {
        let match = true
        if (fieldAndValues.length === 1) {
            // 查找一位数组
            if (obj[k] != fieldAndValues[0]) {
                match = false
            }
        } else {
            // 查找二维数组
            for (let i = 0; i < fieldAndValues.length; i += 2) {
                if (obj[k][fieldAndValues[i]] != fieldAndValues[i + 1]) {
                    match = false
                    break
                }
            }
        }
        if (match) {
            keys.push(k)
        }
    }
    return keys
}

$MOD$.countBy = function (obj, ...fieldAndValues) {
    let keys = $MOD$.keysBy(obj, ...fieldAndValues)
    l(obj, keys)
    return keys.length
}

$MOD$.listBy = function (obj, ...fieldAndValues) {
    let list = obj.length !== undefined ? [] : {}
    let keys = $MOD$.keysBy(obj, ...fieldAndValues)
    for (let k of keys) {
        if (obj.length !== undefined) {
            list.push(obj[k])
        } else {
            list[k] = obj[k]
        }
    }
    return list
}

$MOD$.hasBy = function (obj, ...fieldAndValues) {
    let keys = $MOD$.keysBy(obj, ...fieldAndValues)
    return keys.length > 0
}

$MOD$.getBy = function (obj, ...fieldAndValues) {
    let keys = $MOD$.keysBy(obj, ...fieldAndValues)
    if (keys.length > 0) return obj[keys[0]]
    return null
}

$MOD$.setBy = function (obj, value, ...fieldAndValues) {
    let keys = $MOD$.keysBy(obj, ...fieldAndValues)
    if (keys.length > 0) obj[keys[0]] = value
}

$MOD$.indexBy = function (obj, ...fieldAndValues) {
    let keys = $MOD$.keysBy(obj, ...fieldAndValues)
    if (keys.length > 0) {
        return obj.length !== undefined ? $MOD$.int(keys[0]) : keys[0]
    }
    return -1
}

$MOD$.removeBy = function (obj, ...fieldAndValues) {
    let keys = $MOD$.keysBy(obj, ...fieldAndValues)
    let n = 0
    for (let i = keys.length - 1; i >= 0; i--) {
        let k = keys[i]
        if (obj.length !== undefined) {
            obj.splice(k, 1)
        } else {
            delete obj[k]
        }
        n++
    }
    return n
}

$MOD$.removeArrayItem = function (list, item) {
    let pos = list.indexOf(item)
    if (pos !== -1) list.splice(pos, 1)
}

$MOD$.last = function (arr) {
    if (arr && arr.length) {
        return arr[arr.length - 1]
    }
    return null
}

$MOD$.len = function (obj) {
    if (obj.length !== undefined) {
        return obj.length
    } else {
        let n = 0
        for (let k in obj) n++
        return n
    }
}

$MOD$.mergeBy = function (olds, news, ...fields) {
    if (!olds) return news
    for (let newItem of news) {
        let fieldAndValues = []
        for (let field of fields) {
            fieldAndValues.push(field, newItem[field])
        }
        let oldIndex = $MOD$.indexBy(olds, ...fieldAndValues)
        if (oldIndex === -1) {
            olds.push(newItem)
        } else {
            olds[oldIndex] = newItem
        }
    }
    return olds
}

$MOD$.sortBy = function (obj, field, isReverse = false, sortType) {
    let list = obj.length !== undefined ? [] : {}
    let sortedKeys = {}
    let sortArr = []
    for (let k in obj) {
        let v = ''
        if (field.length !== undefined) {
            for (let f of field) v += obj[k][f]
        } else {
            v = obj[k][field]
        }
        if (!sortedKeys[v]) {
            sortedKeys[v] = true
            sortArr.push(v)
        }
    }
    sortArr.sort((a, b) => {
        if (sortType === 'int') {
            a = $MOD$.int(a)
            b = $MOD$.int(b)
        } else if (sortType === 'float') {
            a = $MOD$.float(a)
            b = $MOD$.float(b)
        }
        if (a == b) return 0
        if (typeof a === 'number' && typeof b === 'number') {
            return isReverse ? b - a : a - b
        } else {
            return (isReverse ? a < b : a > b) ? 1 : -1
        }
    })
    for (let sortKey of sortArr) {
        for (let k in obj) {
            let v = ''
            if (field.length !== undefined) {
                for (let f of field) v += obj[k][f]
            } else {
                v = obj[k][field]
            }

            if (obj.length !== undefined) {
                if (v == sortKey) list.push(obj[k])
            } else {
                if (v == sortKey) list[k] = obj[k]
            }
        }
    }
    return list
}

$MOD$.in = function (v1, v2) {
    if (!(v1.length !== undefined)) v1 = $MOD$.split(v1, /,\s*/)
    return v1.indexOf(String(v2)) !== -1
}

$MOD$.uniquePush = function (arr, ...values) {
    for (let v of values) {
        if (arr.indexOf(v) === -1) arr.push(v)
    }
}

$MOD$.clearEmpty = function (arr) {
    let a = []
    for (let v of arr) if (v) a.push(v)
    return a
}

$MOD$.split = function (v1, v2, n) {
    let a = $MOD$.string(v1).split(v2)
    if (!n || n < a.length - 1) return a
    let a2 = a.slice(0, n)
    a2[n - 1] = a.slice(n - 1).join(v2)
    return a2
}

$MOD$.splitWithoutEmpty = function (v1, v2, n) {
    let a = $MOD$.clearEmpty($MOD$.string(v1).split(v2))
    if (!n || n < a.length - 1) return a
    let a2 = a.slice(0, n)
    a2[n - 1] = a.slice(n - 1).join(v2)
    return a2
}

$MOD$.joinWithoutEmpty = function (arr, separator) {
    return $MOD$.clearEmpty(arr).join(separator)
}

$MOD$.makeDefault = function (item, defaults) {
    for (let k in defaults) {
        if (!item[k]) item[k] = defaults[k]
    }
}

$MOD$._copy = function (obj, isDeepCopy) {
    let newObj
    if (obj.length !== undefined) {
        newObj = []
        for (let o of obj) {
            if (isDeepCopy && typeof o === 'object' && o) o = $MOD$.copy(o)
            newObj.push(o)
        }
    } else {
        newObj = {}
        for (let k in obj) {
            let v = obj[k]
            if (isDeepCopy && typeof v === 'object' && v) v = $MOD$.copy(v)
            newObj[k] = v
        }
    }

    return newObj
}

$MOD$.copy = function (obj) {
    return $MOD$._copy(obj, false)
}

$MOD$.deepCopy = function (obj) {
    return $MOD$._copy(obj, true)
}

$MOD$.isNumber = function (v) {
    const numberMatcher = /^\d*\.?\d+$/
    if (typeof v === 'number' || v instanceof Number) return true
    if (typeof v === 'string') return numberMatcher.test(v)
    if (typeof v === 'object' && v.toString) numberMatcher.test(v.toString())
    return false
}

$MOD$.isInt = function (v) {
    const intMatcher = /^\d+$/
    if (typeof v === 'number' || v instanceof Number) return $MOD$.int(v) === v
    if (typeof v === 'string') return intMatcher.test(v)
    if (typeof v === 'object' && v.toString) intMatcher.test(v.toString())
    return false
}

$MOD$.isFloat = function (v) {
    const floatMatcher = /^\d*\.\d+$/
    if (typeof v === 'float' || v instanceof Number) return $MOD$.int(v) !== v
    if (typeof v === 'string') return floatMatcher.test(v)
    if (typeof v === 'object' && v.toString) floatMatcher.test(v.toString())
    return false
}

$MOD$.getByKey = function (obj, ...keys) {
    if( keys.length === 1 && keys[0].length ) keys = keys[0]
    let o = {}
    for (let k in obj) {
        if (keys.indexOf(k) >= 0) {
            o[k] = obj[k]
        }
    }
    return o
}

$MOD$.excludeByKey = function (obj, ...keys) {
    if( keys.length === 1 && keys[0].length ) keys = keys[0]
    let o = {}
    for (let k in obj) {
        if (keys.indexOf(k) < 0) {
            o[k] = obj[k]
        }
    }
    return o
}
`,
	})
}

var encryptdMatcher = regexp.MustCompile(`"([\w-=]+)"`)

func makeECDSAPriKey(priKey []byte) *ecdsa.PrivateKey {
	if len(priKey) >= 60 {
		return makePriKey(priKey, elliptic.P521())
	} else if len(priKey) >= 40 {
		return makePriKey(priKey, elliptic.P384())
	} else {
		return makePriKey(priKey, elliptic.P256())
	}
}

func makeECDSAPubKey(pubKey []byte) *ecdsa.PublicKey {
	if len(pubKey) >= 130 {
		return makePubKey(pubKey, elliptic.P521())
	} else if len(pubKey) >= 90 {
		return makePubKey(pubKey, elliptic.P384())
	} else {
		return makePubKey(pubKey, elliptic.P256())
	}
}

func makePriKey(priKey []byte, curve elliptic.Curve) *ecdsa.PrivateKey {
	x, y := curve.ScalarBaseMult(priKey)
	return &ecdsa.PrivateKey{
		D: new(big.Int).SetBytes(priKey),
		PublicKey: ecdsa.PublicKey{
			Curve: curve,
			X:     x,
			Y:     y,
		},
	}
}

func makePubKey(pubKey []byte, curve elliptic.Curve) *ecdsa.PublicKey {
	keyLen := pubKey[0]
	x := new(big.Int)
	y := new(big.Int)
	x.SetBytes(pubKey[1 : keyLen+1])
	y.SetBytes(pubKey[keyLen+1:])
	return &ecdsa.PublicKey{Curve: curve, X: x, Y: y}
}

func makeRSAPriKey(keyBytes []byte) *rsa.PrivateKey {
	priKey, err := x509.ParsePKCS1PrivateKey(keyBytes)
	if err != nil {
		return nil
	}
	return priKey
}

func makeRSAPubKey(keyBytes []byte) *rsa.PublicKey {
	pubKey, err := x509.ParsePKCS1PublicKey(keyBytes)
	if err != nil {
		return nil
	}
	return pubKey
}

func searchFile(searchPath, name string) string {
	searched := map[string]bool{}
	return _searchFile(searchPath, name, &searched)
}

func searchFileFromCurrent(vm *goja.Runtime, name string) string {
	searched := map[string]bool{}
	startPath := u.String(vm.GoData["startPath"])
	filename := _searchFile(startPath, name, &searched)
	if filename == "" {
		currentPath, _ := os.Getwd()
		filename = _searchFile(currentPath, name, &searched)
	}
	return filename
}

func _searchFile(checkPath, name string, searched *map[string]bool) string {
	for {
		if !(*searched)[checkPath] {
			(*searched)[checkPath] = true
			filename := filepath.Join(checkPath, name)
			if u.FileExists(filename) {
				return filename
			}
		}
		oldPath := checkPath
		checkPath = filepath.Dir(oldPath)
		if oldPath == checkPath {
			return ""
		}
	}
}