443 lines
12 KiB
Go
443 lines
12 KiB
Go
package js
|
|
|
|
import (
|
|
"bytes"
|
|
"sort"
|
|
|
|
"github.com/tdewolff/parse/v2/js"
|
|
)
|
|
|
|
const identStartLen = 54
|
|
const identContinueLen = 64
|
|
|
|
type renamer struct {
|
|
identStart []byte
|
|
identContinue []byte
|
|
identOrder map[byte]int
|
|
reserved map[string]struct{}
|
|
rename bool
|
|
}
|
|
|
|
func newRenamer(rename, useCharFreq bool) *renamer {
|
|
reserved := make(map[string]struct{}, len(js.Keywords))
|
|
for name := range js.Keywords {
|
|
reserved[name] = struct{}{}
|
|
}
|
|
identStart := []byte("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$")
|
|
identContinue := []byte("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$0123456789")
|
|
if useCharFreq {
|
|
// sorted based on character frequency of a collection of JS samples
|
|
identStart = []byte("etnsoiarclduhmfpgvbjy_wOxCEkASMFTzDNLRPHIBV$WUKqYGXQZJ")
|
|
identContinue = []byte("etnsoiarcldu14023hm8f6pg57v9bjy_wOxCEkASMFTzDNLRPHIBV$WUKqYGXQZJ")
|
|
}
|
|
if len(identStart) != identStartLen || len(identContinue) != identContinueLen {
|
|
panic("bad identStart or identContinue lengths")
|
|
}
|
|
identOrder := map[byte]int{}
|
|
for i, c := range identStart {
|
|
identOrder[c] = i
|
|
}
|
|
return &renamer{
|
|
identStart: identStart,
|
|
identContinue: identContinue,
|
|
identOrder: identOrder,
|
|
reserved: reserved,
|
|
rename: rename,
|
|
}
|
|
}
|
|
|
|
func (r *renamer) renameScope(scope js.Scope) {
|
|
if !r.rename {
|
|
return
|
|
}
|
|
|
|
i := 0
|
|
// keep function argument declaration order to improve GZIP compression
|
|
sort.Sort(js.VarsByUses(scope.Declared[scope.NumFuncArgs:]))
|
|
for _, v := range scope.Declared {
|
|
v.Data = r.getName(v.Data, i)
|
|
i++
|
|
for r.isReserved(v.Data, scope.Undeclared) {
|
|
v.Data = r.getName(v.Data, i)
|
|
i++
|
|
}
|
|
}
|
|
}
|
|
|
|
func (r *renamer) isReserved(name []byte, undeclared js.VarArray) bool {
|
|
if 1 < len(name) { // there are no keywords or known globals that are one character long
|
|
if _, ok := r.reserved[string(name)]; ok {
|
|
return true
|
|
}
|
|
}
|
|
for _, v := range undeclared {
|
|
for v.Link != nil {
|
|
v = v.Link
|
|
}
|
|
if bytes.Equal(v.Data, name) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (r *renamer) getIndex(name []byte) int {
|
|
index := 0
|
|
NameLoop:
|
|
for i := len(name) - 1; 0 <= i; i-- {
|
|
chars := r.identContinue
|
|
if i == 0 {
|
|
chars = r.identStart
|
|
index *= identStartLen
|
|
} else {
|
|
index *= identContinueLen
|
|
}
|
|
for j, c := range chars {
|
|
if name[i] == c {
|
|
index += j
|
|
continue NameLoop
|
|
}
|
|
}
|
|
return -1
|
|
}
|
|
for n := 0; n < len(name)-1; n++ {
|
|
offset := identStartLen
|
|
for i := 0; i < n; i++ {
|
|
offset *= identContinueLen
|
|
}
|
|
index += offset
|
|
}
|
|
return index
|
|
}
|
|
|
|
func (r *renamer) getName(name []byte, index int) []byte {
|
|
// Generate new names for variables where the last character is (a-zA-Z$_) and others are (a-zA-Z).
|
|
// Thus we can have 54 one-character names and 52*54=2808 two-character names for every branch leaf.
|
|
// That is sufficient for virtually all input.
|
|
|
|
// one character
|
|
if index < identStartLen {
|
|
name[0] = r.identStart[index]
|
|
return name[:1]
|
|
}
|
|
index -= identStartLen
|
|
|
|
// two characters or more
|
|
n := 2
|
|
for {
|
|
offset := identStartLen
|
|
for i := 0; i < n-1; i++ {
|
|
offset *= identContinueLen
|
|
}
|
|
if index < offset {
|
|
break
|
|
}
|
|
index -= offset
|
|
n++
|
|
}
|
|
|
|
if cap(name) < n {
|
|
name = make([]byte, n)
|
|
} else {
|
|
name = name[:n]
|
|
}
|
|
name[0] = r.identStart[index%identStartLen]
|
|
index /= identStartLen
|
|
for i := 1; i < n; i++ {
|
|
name[i] = r.identContinue[index%identContinueLen]
|
|
index /= identContinueLen
|
|
}
|
|
return name
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////
|
|
|
|
func hasDefines(v *js.VarDecl) bool {
|
|
for _, item := range v.List {
|
|
if item.Default != nil {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func bindingVars(ibinding js.IBinding) (vs []*js.Var) {
|
|
switch binding := ibinding.(type) {
|
|
case *js.Var:
|
|
vs = append(vs, binding)
|
|
case *js.BindingArray:
|
|
for _, item := range binding.List {
|
|
if item.Binding != nil {
|
|
vs = append(vs, bindingVars(item.Binding)...)
|
|
}
|
|
}
|
|
if binding.Rest != nil {
|
|
vs = append(vs, bindingVars(binding.Rest)...)
|
|
}
|
|
case *js.BindingObject:
|
|
for _, item := range binding.List {
|
|
if item.Value.Binding != nil {
|
|
vs = append(vs, bindingVars(item.Value.Binding)...)
|
|
}
|
|
}
|
|
if binding.Rest != nil {
|
|
vs = append(vs, binding.Rest)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func addDefinition(decl *js.VarDecl, binding js.IBinding, value js.IExpr, forward bool) {
|
|
// see if not already defined in variable declaration list
|
|
// if forward is set, binding=value comes before decl, otherwise the reverse holds true
|
|
vars := bindingVars(binding)
|
|
|
|
// remove variables in destination
|
|
RemoveVarsLoop:
|
|
for _, vbind := range vars {
|
|
for i, item := range decl.List {
|
|
if v, ok := item.Binding.(*js.Var); ok && item.Default == nil && v == vbind {
|
|
v.Uses--
|
|
decl.List = append(decl.List[:i], decl.List[i+1:]...)
|
|
continue RemoveVarsLoop
|
|
}
|
|
}
|
|
|
|
if value != nil {
|
|
// variable declaration must be somewhere else, find and remove it
|
|
for _, decl2 := range decl.Scope.Func.VarDecls {
|
|
for i, item := range decl2.List {
|
|
if v, ok := item.Binding.(*js.Var); ok && item.Default == nil && v == vbind {
|
|
v.Uses--
|
|
decl2.List = append(decl2.List[:i], decl2.List[i+1:]...)
|
|
continue RemoveVarsLoop
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// add declaration to destination
|
|
item := js.BindingElement{Binding: binding, Default: value}
|
|
if forward {
|
|
decl.List = append([]js.BindingElement{item}, decl.List...)
|
|
} else {
|
|
decl.List = append(decl.List, item)
|
|
}
|
|
}
|
|
|
|
func mergeVarDecls(dst, src *js.VarDecl, forward bool) {
|
|
// Merge var declarations by moving declarations from src to dst. If forward is set, src comes first and dst after, otherwise the order is reverse.
|
|
if forward {
|
|
// reverse order so we can iterate from beginning to end, sometimes addDefinition may remove another declaration in the src list
|
|
n := len(src.List) - 1
|
|
for j := 0; j < len(src.List)/2; j++ {
|
|
src.List[j], src.List[n-j] = src.List[n-j], src.List[j]
|
|
}
|
|
}
|
|
for j := 0; j < len(src.List); j++ {
|
|
addDefinition(dst, src.List[j].Binding, src.List[j].Default, forward)
|
|
}
|
|
src.List = src.List[:0]
|
|
}
|
|
|
|
func mergeVarDeclExprStmt(decl *js.VarDecl, exprStmt *js.ExprStmt, forward bool) bool {
|
|
// Merge var declarations with an assignment expression. If forward is set than expr comes first and decl after, otherwise the order is reverse.
|
|
if decl2, ok := exprStmt.Value.(*js.VarDecl); ok {
|
|
// this happens when a variable declarations is converted to an expression due to hoisting
|
|
mergeVarDecls(decl, decl2, forward)
|
|
return true
|
|
} else if commaExpr, ok := exprStmt.Value.(*js.CommaExpr); ok {
|
|
n := 0
|
|
for i := 0; i < len(commaExpr.List); i++ {
|
|
item := commaExpr.List[i]
|
|
if forward {
|
|
item = commaExpr.List[len(commaExpr.List)-i-1]
|
|
}
|
|
if src, ok := item.(*js.VarDecl); ok {
|
|
// this happens when a variable declarations is converted to an expression due to hoisting
|
|
mergeVarDecls(decl, src, forward)
|
|
n++
|
|
continue
|
|
} else if binaryExpr, ok := item.(*js.BinaryExpr); ok && binaryExpr.Op == js.EqToken {
|
|
if v, ok := binaryExpr.X.(*js.Var); ok && v.Decl == js.VariableDecl {
|
|
addDefinition(decl, v, binaryExpr.Y, forward)
|
|
n++
|
|
continue
|
|
}
|
|
}
|
|
break
|
|
}
|
|
merge := n == len(commaExpr.List)
|
|
if !forward {
|
|
commaExpr.List = commaExpr.List[n:]
|
|
} else {
|
|
commaExpr.List = commaExpr.List[:len(commaExpr.List)-n]
|
|
}
|
|
return merge
|
|
} else if binaryExpr, ok := exprStmt.Value.(*js.BinaryExpr); ok && binaryExpr.Op == js.EqToken {
|
|
if v, ok := binaryExpr.X.(*js.Var); ok && v.Decl == js.VariableDecl {
|
|
addDefinition(decl, v, binaryExpr.Y, forward)
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *jsMinifier) countHoistLength(ibinding js.IBinding) int {
|
|
if !m.o.KeepVarNames {
|
|
return len(bindingVars(ibinding)) * 2 // assume that var name will be of length one, +1 for the comma
|
|
}
|
|
|
|
n := 0
|
|
for _, v := range bindingVars(ibinding) {
|
|
n += len(v.Data) + 1 // +1 for the comma when added to other declaration
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *jsMinifier) hoistVars(body *js.BlockStmt) {
|
|
// Hoist all variable declarations in the current module/function scope to the top.
|
|
// If the first statement is a var declaration, expand it. Otherwise prepend a new var declaration.
|
|
// Except for the first var declaration, all others are converted to expressions. This is possible because an ArrayBindingPattern and ObjectBindingPattern can be converted to an ArrayLiteral or ObjectLiteral respectively, as they are supersets of the BindingPatterns.
|
|
if 1 < len(body.Scope.VarDecls) {
|
|
// Select which variable declarations will be hoisted (convert to expression) and which not
|
|
best := 0
|
|
score := make([]int, len(body.Scope.VarDecls)) // savings if hoisted
|
|
hoist := make([]bool, len(body.Scope.VarDecls))
|
|
for i, varDecl := range body.Scope.VarDecls {
|
|
hoist[i] = true
|
|
score[i] = 4 // "var "
|
|
if !varDecl.InForInOf {
|
|
n := 0
|
|
nArrays := 0
|
|
nObjects := 0
|
|
hasDefinitions := false
|
|
for j, item := range varDecl.List {
|
|
if item.Default != nil {
|
|
if _, ok := item.Binding.(*js.BindingObject); ok {
|
|
if j != 0 && nArrays == 0 && nObjects == 0 {
|
|
varDecl.List[0], varDecl.List[j] = varDecl.List[j], varDecl.List[0]
|
|
}
|
|
nObjects++
|
|
} else if _, ok := item.Binding.(*js.BindingArray); ok {
|
|
if j != 0 && nArrays == 0 && nObjects == 0 {
|
|
varDecl.List[0], varDecl.List[j] = varDecl.List[j], varDecl.List[0]
|
|
}
|
|
nArrays++
|
|
}
|
|
score[i] -= m.countHoistLength(item.Binding) // var names and commas
|
|
hasDefinitions = true
|
|
n++
|
|
}
|
|
}
|
|
if !hasDefinitions {
|
|
score[i] = 5 - 1 // 1 for a comma
|
|
if varDecl.InFor {
|
|
score[i]-- // semicolon can be reused
|
|
}
|
|
}
|
|
if nObjects != 0 && !varDecl.InFor && nObjects == n {
|
|
score[i] -= 2 // required parenthesis around braces
|
|
}
|
|
if nArrays != 0 || nObjects != 0 {
|
|
score[i]-- // space after var disappears
|
|
}
|
|
if score[i] < score[best] || body.Scope.VarDecls[best].InForInOf {
|
|
// select var decl with the least savings if hoisted
|
|
best = i
|
|
}
|
|
if score[i] < 0 {
|
|
hoist[i] = false
|
|
}
|
|
}
|
|
}
|
|
if body.Scope.VarDecls[best].InForInOf {
|
|
// no savings possible
|
|
return
|
|
}
|
|
|
|
decl := body.Scope.VarDecls[best]
|
|
if 10000 < len(decl.List) {
|
|
return
|
|
}
|
|
hoist[best] = false
|
|
|
|
// get original declarations
|
|
orig := []*js.Var{}
|
|
for _, item := range decl.List {
|
|
orig = append(orig, bindingVars(item.Binding)...)
|
|
}
|
|
|
|
// hoist other variable declarations in this function scope but don't initialize yet
|
|
j := 0
|
|
for i, varDecl := range body.Scope.VarDecls {
|
|
if hoist[i] {
|
|
varDecl.TokenType = js.ErrorToken
|
|
for _, item := range varDecl.List {
|
|
refs := bindingVars(item.Binding)
|
|
bindingElements := make([]js.BindingElement, 0, len(refs))
|
|
DeclaredLoop:
|
|
for _, ref := range refs {
|
|
for _, v := range orig {
|
|
if ref == v {
|
|
continue DeclaredLoop
|
|
}
|
|
}
|
|
bindingElements = append(bindingElements, js.BindingElement{Binding: ref, Default: nil})
|
|
orig = append(orig, ref)
|
|
|
|
s := decl.Scope
|
|
for s != nil && s != s.Func {
|
|
s.AddUndeclared(ref)
|
|
s = s.Parent
|
|
}
|
|
if item.Default != nil {
|
|
ref.Uses++
|
|
}
|
|
}
|
|
if i < best {
|
|
// prepend
|
|
decl.List = append(decl.List[:j], append(bindingElements, decl.List[j:]...)...)
|
|
j += len(bindingElements)
|
|
} else {
|
|
// append
|
|
decl.List = append(decl.List, bindingElements...)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// rearrange to put array/object first
|
|
var prevRefs []*js.Var
|
|
BeginArrayObject:
|
|
for i, item := range decl.List {
|
|
refs := bindingVars(item.Binding)
|
|
if _, ok := item.Binding.(*js.Var); !ok {
|
|
if i != 0 {
|
|
interferes := false
|
|
if item.Default != nil {
|
|
InterferenceLoop:
|
|
for _, ref := range refs {
|
|
for _, v := range prevRefs {
|
|
if ref == v {
|
|
interferes = true
|
|
break InterferenceLoop
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if !interferes {
|
|
decl.List[0], decl.List[i] = decl.List[i], decl.List[0]
|
|
break BeginArrayObject
|
|
}
|
|
} else {
|
|
break BeginArrayObject
|
|
}
|
|
}
|
|
if item.Default != nil {
|
|
prevRefs = append(prevRefs, refs...)
|
|
}
|
|
}
|
|
}
|
|
}
|