381 lines
9.6 KiB
Go
381 lines
9.6 KiB
Go
// Package stringutil Exports common rune utilities for parsing and emitting javascript
|
||
package stringutil
|
||
|
||
import (
|
||
"regexp"
|
||
"strings"
|
||
"unicode"
|
||
"unicode/utf16"
|
||
"unicode/utf8"
|
||
)
|
||
|
||
func IsWhiteSpaceLike(ch rune) bool {
|
||
return IsWhiteSpaceSingleLine(ch) || IsLineBreak(ch)
|
||
}
|
||
|
||
func IsWhiteSpaceSingleLine(ch rune) bool {
|
||
// Note: nextLine is in the Zs space, and should be considered to be a whitespace.
|
||
// It is explicitly not a line-break as it isn't in the exact set specified by EcmaScript.
|
||
switch ch {
|
||
case
|
||
' ', // space
|
||
'\t', // tab
|
||
'\v', // verticalTab
|
||
'\f', // formFeed
|
||
0x0085, // nextLine
|
||
0x00A0, // nonBreakingSpace
|
||
0x1680, // ogham
|
||
0x2000, // enQuad
|
||
0x2001, // emQuad
|
||
0x2002, // enSpace
|
||
0x2003, // emSpace
|
||
0x2004, // threePerEmSpace
|
||
0x2005, // fourPerEmSpace
|
||
0x2006, // sixPerEmSpace
|
||
0x2007, // figureSpace
|
||
0x2008, // punctuationEmSpace
|
||
0x2009, // thinSpace
|
||
0x200A, // hairSpace
|
||
0x200B, // zeroWidthSpace
|
||
0x202F, // narrowNoBreakSpace
|
||
0x205F, // mathematicalSpace
|
||
0x3000, // ideographicSpace
|
||
0xFEFF: // byteOrderMark
|
||
return true
|
||
}
|
||
return false
|
||
}
|
||
|
||
func IsLineBreak(ch rune) bool {
|
||
// ES5 7.3:
|
||
// The ECMAScript line terminator characters are listed in Table 3.
|
||
// Table 3: Line Terminator Characters
|
||
// Code Unit Value Name Formal Name
|
||
// \u000A Line Feed <LF>
|
||
// \u000D Carriage Return <CR>
|
||
// \u2028 Line separator <LS>
|
||
// \u2029 Paragraph separator <PS>
|
||
// Only the characters in Table 3 are treated as line terminators. Other new line or line
|
||
// breaking characters are treated as white space but not as line terminators.
|
||
switch ch {
|
||
case
|
||
'\n', // lineFeed
|
||
'\r', // carriageReturn
|
||
0x2028, // lineSeparator
|
||
0x2029: // paragraphSeparator
|
||
return true
|
||
}
|
||
return false
|
||
}
|
||
|
||
func IsDigit(ch rune) bool {
|
||
return ch >= '0' && ch <= '9'
|
||
}
|
||
|
||
func IsOctalDigit(ch rune) bool {
|
||
return ch >= '0' && ch <= '7'
|
||
}
|
||
|
||
func IsHexDigit(ch rune) bool {
|
||
return ch >= '0' && ch <= '9' || ch >= 'A' && ch <= 'F' || ch >= 'a' && ch <= 'f'
|
||
}
|
||
|
||
func IsASCIILetter(ch rune) bool {
|
||
return ch >= 'A' && ch <= 'Z' || ch >= 'a' && ch <= 'z'
|
||
}
|
||
|
||
func ContainsNonASCII(s string) bool {
|
||
for i := range len(s) {
|
||
if s[i] >= utf8.RuneSelf {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
func SplitLines(text string) []string {
|
||
lines := make([]string, 0, strings.Count(text, "\n")+1) // preallocate
|
||
start := 0
|
||
pos := 0
|
||
for pos < len(text) {
|
||
switch text[pos] {
|
||
case '\r':
|
||
if pos+1 < len(text) && text[pos+1] == '\n' {
|
||
lines = append(lines, text[start:pos])
|
||
pos += 2
|
||
start = pos
|
||
continue
|
||
}
|
||
fallthrough
|
||
case '\n':
|
||
lines = append(lines, text[start:pos])
|
||
pos++
|
||
start = pos
|
||
continue
|
||
}
|
||
pos++
|
||
}
|
||
if start < len(text) {
|
||
lines = append(lines, text[start:])
|
||
}
|
||
return lines
|
||
}
|
||
|
||
func GuessIndentation(lines []string) int {
|
||
const MAX_SMI_X86 int = 0x3fff_ffff
|
||
indentation := MAX_SMI_X86
|
||
for _, line := range lines {
|
||
if len(line) == 0 {
|
||
continue
|
||
}
|
||
i := 0
|
||
for i < len(line) && i < indentation {
|
||
ch, size := utf8.DecodeRuneInString(line[i:])
|
||
if !IsWhiteSpaceLike(ch) {
|
||
break
|
||
}
|
||
i += size
|
||
}
|
||
if i < indentation {
|
||
indentation = i
|
||
}
|
||
if indentation == 0 {
|
||
return 0
|
||
}
|
||
}
|
||
if indentation == MAX_SMI_X86 {
|
||
return 0
|
||
}
|
||
return indentation
|
||
}
|
||
|
||
// https://tc39.es/ecma262/multipage/global-object.html#sec-encodeuri-uri
|
||
func EncodeURI(s string) string {
|
||
var builder strings.Builder
|
||
for i := range len(s) {
|
||
b := s[i]
|
||
if !shouldEscapeForEncodeURI(b) {
|
||
builder.WriteByte(b)
|
||
continue
|
||
}
|
||
|
||
for _, escaped := range []byte(s[i : i+1]) {
|
||
builder.WriteByte('%')
|
||
builder.WriteByte(upperhex[escaped>>4])
|
||
builder.WriteByte(upperhex[escaped&0x0f])
|
||
}
|
||
}
|
||
return builder.String()
|
||
}
|
||
|
||
const upperhex = "0123456789ABCDEF"
|
||
|
||
func shouldEscapeForEncodeURI(b byte) bool {
|
||
switch {
|
||
case b >= 'A' && b <= 'Z':
|
||
return false
|
||
case b >= 'a' && b <= 'z':
|
||
return false
|
||
case b >= '0' && b <= '9':
|
||
return false
|
||
}
|
||
|
||
switch b {
|
||
case ';', '/', '?', ':', '@', '&', '=', '+', '$', ',', '#', '-', '_', '.', '!', '~', '*', '\'', '(', ')':
|
||
return false
|
||
default:
|
||
return true
|
||
}
|
||
}
|
||
|
||
func getByteOrderMarkLength(text string) int {
|
||
if len(text) >= 1 {
|
||
ch0 := text[0]
|
||
if ch0 == 0xfe {
|
||
if len(text) >= 2 && text[1] == 0xff {
|
||
return 2 // utf16be
|
||
}
|
||
return 0
|
||
}
|
||
if ch0 == 0xff {
|
||
if len(text) >= 2 && text[1] == 0xfe {
|
||
return 2 // utf16le
|
||
}
|
||
return 0
|
||
}
|
||
if ch0 == 0xef {
|
||
if len(text) >= 3 && text[1] == 0xbb && text[2] == 0xbf {
|
||
return 3 // utf8
|
||
}
|
||
return 0
|
||
}
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func RemoveByteOrderMark(text string) string {
|
||
length := getByteOrderMarkLength(text)
|
||
if length > 0 {
|
||
return text[length:]
|
||
}
|
||
return text
|
||
}
|
||
|
||
func AddUTF8ByteOrderMark(text string) string {
|
||
if getByteOrderMarkLength(text) == 0 {
|
||
return "\xEF\xBB\xBF" + text
|
||
}
|
||
return text
|
||
}
|
||
|
||
func StripQuotes(name string) string {
|
||
if len(name) < 2 {
|
||
return name
|
||
}
|
||
firstChar, _ := utf8.DecodeRuneInString(name)
|
||
lastChar, _ := utf8.DecodeLastRuneInString(name)
|
||
if firstChar == lastChar && (firstChar == '\'' || firstChar == '"' || firstChar == '`') {
|
||
return name[1 : len(name)-1]
|
||
}
|
||
return name
|
||
}
|
||
|
||
var matchSlashSomething = regexp.MustCompile(`\\.`)
|
||
|
||
func matchSlashReplacer(in string) string {
|
||
return in[1:]
|
||
}
|
||
|
||
func UnquoteString(str string) string {
|
||
// strconv.Unquote is insufficient as that only handles a single character inside single quotes, as those are character literals in go
|
||
inner := StripQuotes(str)
|
||
// In strada we do str.replace(/\\./g, s => s.substring(1)) - which is to say, replace all backslash-something with just something
|
||
// That's replicated here faithfully, but it seems wrong! This should probably be an actual unquote operation?
|
||
return matchSlashSomething.ReplaceAllStringFunc(inner, matchSlashReplacer)
|
||
}
|
||
|
||
func LowerFirstChar(str string) string {
|
||
char, size := utf8.DecodeRuneInString(str)
|
||
if size > 0 {
|
||
return string(unicode.ToLower(char)) + str[size:]
|
||
}
|
||
return str
|
||
}
|
||
|
||
func TruncateByRunes(str string, maxLength int) string {
|
||
if len(str) < maxLength {
|
||
return str
|
||
}
|
||
if maxLength <= 0 {
|
||
return ""
|
||
}
|
||
var runeCount int
|
||
for i := range str {
|
||
runeCount++
|
||
if runeCount > maxLength {
|
||
return str[:i]
|
||
}
|
||
}
|
||
return str
|
||
}
|
||
|
||
const (
|
||
// SurrogateLowStart is the boundary between the high and low halves of the
|
||
// UTF-16 surrogate range. unicode/utf16 only exposes IsSurrogate for the
|
||
// whole range, so this split point is defined here to distinguish the two.
|
||
SurrogateLowStart = 0xDC00
|
||
)
|
||
|
||
func IsHighSurrogate(ch rune) bool {
|
||
return utf16.IsSurrogate(ch) && ch < SurrogateLowStart
|
||
}
|
||
|
||
func IsLowSurrogate(ch rune) bool {
|
||
return utf16.IsSurrogate(ch) && ch >= SurrogateLowStart
|
||
}
|
||
|
||
func IsSurrogate(ch rune) bool {
|
||
return utf16.IsSurrogate(ch)
|
||
}
|
||
|
||
func SurrogatePairToCodePoint(high rune, low rune) rune {
|
||
return utf16.DecodeRune(high, low)
|
||
}
|
||
|
||
func CodePointToSurrogatePair(ch rune) (high rune, low rune) {
|
||
return utf16.EncodeRune(ch)
|
||
}
|
||
|
||
const (
|
||
// A lone surrogate (U+D800–U+DFFF) cannot be represented in valid UTF-8, so
|
||
// EncodeJSStringRune stores it as the 3-byte CESU-8/WTF-8 sentinel that UTF-8
|
||
// would use for that code point if surrogates were encodable. unicode/utf8
|
||
// and unicode/utf16 deliberately refuse to encode or decode surrogates, so
|
||
// the byte math is spelled out here.
|
||
//
|
||
// Byte layout for a code point cp in U+D000–U+DFFF (lead nibble 0xD):
|
||
// byte0 = 0xE0 | (cp >> 12) == 0xED
|
||
// byte1 = 0x80 | ((cp >> 6) & 0x3F)
|
||
// byte2 = 0x80 | (cp & 0x3F)
|
||
surrogateUTF8Lead = 0xED // byte0, shared by the whole U+D000–U+DFFF block
|
||
surrogateUTF8LeadBits = 0xD000 // (surrogateUTF8Lead & 0x0F) << 12, byte0's decoded contribution
|
||
utf8ContMarker = 0x80 // continuation byte marker / min value (10xxxxxx)
|
||
utf8ContMax = 0xBF // continuation byte max value
|
||
utf8ContMask = 0x3F // data bits carried by a continuation byte
|
||
|
||
// byte1 bounds that pin the block down to the surrogate range U+D800–U+DFFF:
|
||
// 0xD800 -> 0xA0, 0xDFFF -> 0xBF.
|
||
surrogateUTF8Byte1Min = 0xA0
|
||
surrogateUTF8Byte1Max = 0xBF
|
||
)
|
||
|
||
func EncodeJSStringRune(ch rune) string {
|
||
if IsSurrogate(ch) {
|
||
return string([]byte{
|
||
surrogateUTF8Lead,
|
||
byte(utf8ContMarker | ((ch >> 6) & utf8ContMask)),
|
||
byte(utf8ContMarker | (ch & utf8ContMask)),
|
||
})
|
||
}
|
||
return string(ch)
|
||
}
|
||
|
||
func DecodeJSStringRune(s string) (rune, int) {
|
||
if len(s) >= 3 &&
|
||
s[0] == surrogateUTF8Lead &&
|
||
s[1] >= surrogateUTF8Byte1Min && s[1] <= surrogateUTF8Byte1Max &&
|
||
s[2] >= utf8ContMarker && s[2] <= utf8ContMax {
|
||
return surrogateUTF8LeadBits | rune(s[1]&utf8ContMask)<<6 | rune(s[2]&utf8ContMask), 3
|
||
}
|
||
return utf8.DecodeRuneInString(s)
|
||
}
|
||
|
||
// CombineSurrogatePairs canonicalizes a JS-string value produced by
|
||
// concatenation, merging any adjacent high+low surrogate sentinel pair (as
|
||
// written by EncodeJSStringRune) into the single supplementary code point they
|
||
// represent. This mirrors how concatenating two UTF-16 code units forms a
|
||
// surrogate pair in a JavaScript string. It must be applied wherever separately
|
||
// scanned string values are joined, since each half is only a lone surrogate
|
||
// until it meets its partner. Strings without a lone-surrogate sentinel (the
|
||
// common case) are returned unchanged.
|
||
func CombineSurrogatePairs(s string) string {
|
||
if strings.IndexByte(s, surrogateUTF8Lead) < 0 {
|
||
return s
|
||
}
|
||
var b strings.Builder
|
||
b.Grow(len(s))
|
||
for i := 0; i < len(s); {
|
||
r, size := DecodeJSStringRune(s[i:])
|
||
if IsHighSurrogate(r) {
|
||
if low, lowSize := DecodeJSStringRune(s[i+size:]); IsLowSurrogate(low) {
|
||
b.WriteRune(SurrogatePairToCodePoint(r, low))
|
||
i += size + lowSize
|
||
continue
|
||
}
|
||
}
|
||
b.WriteString(s[i : i+size])
|
||
i += size
|
||
}
|
||
return b.String()
|
||
}
|