lightsystemdarkgreen
@ 261119.1
current
package dirview

import (
	"strings"
	"unicode"

	"github.com/alecthomas/chroma/v2"
)

// jsTokens lexes JavaScript as chroma's JavaScript lexer does, in one
// pass. Its rules live in chroma's lexers/embedded/javascript.xml; this
// follows them, quirks included: a slash after an operator, a keyword or
// an opening bracket starts a regular expression, and one that does not
// close marks the rest of its line as an error.
func jsTokens(code string) []chroma.Token {
	j := &jsLex{lex: newLex(code)}
	i := 0
	if strings.HasPrefix(code, "#!") {
		if k := strings.IndexByte(code, '\n'); k >= 0 && (strings.HasPrefix(code, "#!/") || strings.HasPrefix(code, "#! /")) {
			j.emit(chroma.CommentHashbang, 0, k+1)
			i = k + 1
		}
	}
	for i < len(code) {
		i = j.step(i, false)
	}
	return j.tokens()
}

type jsLex struct {
	lex
	// regex is chroma's slashstartsregex state: the next slash starts a
	// regular expression.
	regex bool
}

var (
	jsKeywords = setOf("for", "in", "while", "do", "break", "return", "continue", "switch", "case", "default", "if",
		"else", "throw", "try", "catch", "finally", "new", "delete", "typeof", "instanceof", "void", "yield", "this", "of")
	jsDeclarations = setOf("var", "let", "with", "function")
	jsReserved     = setOf("abstract", "async", "await", "boolean", "byte", "char", "class", "const", "debugger",
		"double", "enum", "export", "extends", "final", "float", "goto", "implements", "import", "int", "interface",
		"long", "native", "package", "private", "protected", "public", "short", "static", "super", "synchronized",
		"throws", "transient", "using", "volatile")
	jsConstants = setOf("true", "false", "null", "NaN", "Infinity", "undefined")
	jsBuiltins  = setOf("Array", "Boolean", "Date", "Error", "Function", "Math", "netscape", "Number", "Object",
		"Packages", "RegExp", "String", "Promise", "Proxy", "sun", "decodeURI", "decodeURIComponent", "encodeURI",
		"encodeURIComponent", "eval", "isFinite", "isNaN", "isSafeInteger", "parseFloat", "parseInt", "document",
		"this", "window")
)

// step lexes one token at i and returns where the next begins. In a
// template's ${...}, a } ends the expression; step returns -1-i for it.
func (j *jsLex) step(i int, interp bool) int {
	s := j.src
	c := s[i]
	if i == 0 || s[i-1] == '\n' {
		if r, _ := runeAt(s, i); isSpace(r) || c == '/' || strings.HasPrefix(s[i:], "<!--") {
			j.regex = true
		}
	}
	if r, _ := runeAt(s, i); isSpace(r) {
		e := wordEnd(s, i, isSpace)
		j.emit(chroma.Text, i, e)
		return e
	}
	switch {
	case strings.HasPrefix(s[i:], "<!--"):
		j.emit(chroma.Comment, i, i+4)
		return i + 4
	case strings.HasPrefix(s[i:], "//"):
		e := lineEnd(s, i)
		if e < len(s) {
			e++
		}
		j.emit(chroma.CommentSingle, i, e)
		return e
	case strings.HasPrefix(s[i:], "/*"):
		if k := strings.Index(s[i+2:], "*/"); k >= 0 {
			j.emit(chroma.CommentMultiline, i, i+2+k+2)
			return i + 2 + k + 2
		}
	}
	if j.regex {
		j.regex = false
		if c == '/' {
			if e := jsRegex(s, i); e > i {
				j.emit(chroma.LiteralStringRegex, i, e)
				return e
			}
			// badregex: every rune to the line's end is an error.
			e := lineEnd(s, i)
			for k := i; k < e; {
				_, n := runeAt(s, k)
				j.emit(chroma.Error, k, k+n)
				k += n
			}
			return e
		}
	}
	if interp && c == '}' {
		return -1 - i
	}
	switch {
	case isDigit(c):
		e, t := jsNumber(s, i)
		j.emit(t, i, e)
		return e
	case strings.HasPrefix(s[i:], "...") || strings.HasPrefix(s[i:], "=>"):
		e := i + 3
		if c == '=' {
			e = i + 2
		}
		j.emit(chroma.Punctuation, i, e)
		return e
	}
	if e := jsOperator(s, i); e > i {
		j.emit(chroma.Operator, i, e)
		j.regex = true
		return e
	}
	switch {
	case strings.IndexByte("{([;,", c) >= 0:
		j.emit(chroma.Punctuation, i, i+1)
		j.regex = true
		return i + 1
	case strings.IndexByte("})].", c) >= 0:
		j.emit(chroma.Punctuation, i, i+1)
		return i + 1
	}
	if r, _ := runeAt(s, i); unicode.IsLetter(r) {
		w := s[i:wordEnd(s, i, isWord)]
		switch {
		case jsKeywords[w]:
			j.emit(chroma.Keyword, i, i+len(w))
			j.regex = true
			return i + len(w)
		case jsDeclarations[w]:
			j.emit(chroma.KeywordDeclaration, i, i+len(w))
			j.regex = true
			return i + len(w)
		case jsReserved[w]:
			j.emit(chroma.KeywordReserved, i, i+len(w))
			return i + len(w)
		case jsConstants[w]:
			j.emit(chroma.KeywordConstant, i, i+len(w))
			return i + len(w)
		case jsBuiltins[w]:
			j.emit(chroma.NameBuiltin, i, i+len(w))
			return i + len(w)
		}
	}
	if e := jsName(s, i); e > i {
		j.emit(chroma.NameOther, i, e)
		return e
	}
	switch c {
	case '"', '\'':
		if e := jsString(s, i); e > i {
			j.emit(chroma.LiteralString, i, e)
			return e
		}
	case '`':
		return j.template(i)
	}
	_, n := runeAt(s, i)
	j.emit(chroma.Error, i, i+n)
	return i + n
}

// jsName returns the end of a name at i: a letter, digit, $ or _, or a
// \uXXXX escape, then letters, digits and $ but no _, as chroma reads it.
func jsName(s string, i int) int {
	part := func(i int, start bool) int {
		if strings.HasPrefix(s[i:], `\u`) && i+6 <= len(s) {
			for _, c := range []byte(s[i+2 : i+6]) {
				if !(isDigit(c) || c >= 'a' && c <= 'f' || c >= 'A' && c <= 'F') {
					return i
				}
			}
			return i + 6
		}
		r, n := runeAt(s, i)
		if i < len(s) && (r == '$' || start && r == '_' || unicode.IsLetter(r) || unicode.IsNumber(r)) {
			return i + n
		}
		return i
	}
	e := part(i, true)
	if e == i {
		return i
	}
	for {
		k := part(e, false)
		if k == e {
			return e
		}
		e = k
	}
}

// jsNumber follows chroma's number rules in their order.
func jsNumber(s string, i int) (int, chroma.TokenType) {
	d := i
	for d < len(s) && isDigit(s[d]) {
		d++
	}
	if d < len(s) && s[d] == '.' {
		e := d + 1
		for e < len(s) && isDigit(s[e]) {
			e++
		}
		return e, chroma.LiteralNumberFloat
	}
	if d < len(s) && (s[d] == 'e' || s[d] == 'E') {
		e := d + 1
		if e < len(s) && (s[e] == '+' || s[e] == '-') {
			e++
		}
		if f := e; f < len(s) && isDigit(s[f]) {
			for f < len(s) && isDigit(s[f]) {
				f++
			}
			return f, chroma.LiteralNumberFloat
		}
	}
	if s[i] == '0' && i+2 < len(s) {
		var ok func(byte) bool
		t := chroma.LiteralNumberHex
		switch s[i+1] {
		case 'b', 'B':
			ok, t = func(c byte) bool { return c == '0' || c == '1' }, chroma.LiteralNumberBin
		case 'o', 'O':
			ok, t = func(c byte) bool { return c >= '0' && c <= '7' }, chroma.LiteralNumberOct
		case 'x', 'X':
			ok = func(c byte) bool { return isDigit(c) || c >= 'a' && c <= 'f' || c >= 'A' && c <= 'F' }
		}
		if ok != nil && ok(s[i+2]) {
			e := i + 2
			for e < len(s) && ok(s[e]) {
				e++
			}
			return e, t
		}
	}
	e := i + 1
	for e < len(s) && (isDigit(s[e]) || s[e] == '_') {
		e++
	}
	return e, chroma.LiteralNumberInteger
}

// jsOperator returns the end of an operator at i, as chroma's operator
// rule matches it, or i.
func jsOperator(s string, i int) int {
	for _, op := range []string{"++", "--", "~", "&&", "?", ":", "||"} {
		if strings.HasPrefix(s[i:], op) {
			return i + len(op)
		}
	}
	if s[i] == '\\' && i+1 < len(s) && s[i+1] == '\n' {
		return i + 1
	}
	e := i
	switch {
	case strings.HasPrefix(s[i:], ">>>"):
		e = i + 3
	case strings.HasPrefix(s[i:], "<<"), strings.HasPrefix(s[i:], ">>"), strings.HasPrefix(s[i:], "=="),
		strings.HasPrefix(s[i:], "!="):
		e = i + 2
	case strings.IndexByte("=!-<>+*%&|^/", s[i]) >= 0:
		e = i + 1
	default:
		return i
	}
	if e < len(s) && s[e] == '=' {
		e++
	}
	return e
}

// jsRegex returns the end of a regular expression literal at i, flags
// included, or i when chroma's pattern does not match there.
func jsRegex(s string, i int) int {
	k := i + 1
	body := false
	for k < len(s) {
		c := s[k]
		switch {
		case c == '\\' && k+1 < len(s):
			_, n := runeAt(s, k+1)
			k += 1 + n
		case c == '[':
			m := k + 1
			for m < len(s) && s[m] != ']' && s[m] != '\n' {
				if s[m] == '\\' {
					if m+1 >= len(s) {
						return i
					}
					_, n := runeAt(s, m+1)
					m += n
				}
				m++
			}
			if m >= len(s) || s[m] != ']' {
				return i
			}
			k = m + 1
		case c == '/' || c == '\n':
			if c == '\n' || !body {
				return i
			}
			e := k + 1
			f := e
			for f < len(s) && strings.IndexByte("gimuy", s[f]) >= 0 {
				f++
			}
			next, _ := runeAt(s, f)
			if f > e && (f == len(s) || !isWord(next)) {
				return f
			}
			if r, _ := runeAt(s, e); e == len(s) || !isWord(r) {
				return e
			}
			return i
		default:
			_, n := runeAt(s, k)
			k += n
		}
		body = true
	}
	return i
}

// jsString returns the end of a quoted string at i. A string may span
// lines. One that never closes ends at the last escaped quote, where
// chroma's pattern backtracks to, or does not match at all.
func jsString(s string, i int) int {
	q := s[i]
	last := -1
	for k := i + 1; k < len(s); k++ {
		switch s[k] {
		case '\\':
			if k+1 < len(s) && (s[k+1] == '\\' || s[k+1] == q) {
				if s[k+1] == q {
					last = k + 1
				}
				k++
			}
		case q:
			return k + 1
		}
	}
	if last >= 0 {
		return last + 1
	}
	return i
}

// template lexes a template literal at i, its ${...} expressions as
// code. The first } in an expression ends it, as in chroma.
func (j *jsLex) template(i int) int {
	s := j.src
	j.emit(chroma.LiteralStringBacktick, i, i+1)
	k := i + 1
	for k < len(s) {
		switch {
		case s[k] == '`':
			j.emit(chroma.LiteralStringBacktick, k, k+1)
			return k + 1
		case s[k] == '\\' && k+1 < len(s):
			_, n := runeAt(s, k+1)
			j.emit(chroma.LiteralStringBacktick, k, k+1+n)
			k += 1 + n
		case strings.HasPrefix(s[k:], "${"):
			j.emit(chroma.LiteralStringInterpol, k, k+2)
			saved := j.regex
			j.regex = false
			k += 2
			for k < len(s) {
				n := j.step(k, true)
				if n < 0 {
					k = -1 - n
					j.emit(chroma.LiteralStringInterpol, k, k+1)
					k++
					break
				}
				k = n
			}
			j.regex = saved
		default:
			j.emit(chroma.LiteralStringBacktick, k, k+1)
			k++
		}
	}
	return k
}