unicode: update table using new generator in x/text

The changes in Unicode 11 exposes a bug in maketables.go.
We update the Unicode 10 tables using a new generator
to minimize the changes upgrading to Unicode 11.

This change switches over the generation from core to that in
x/text. To properly update the tables one needs to run the generate
in x/text anyway, so this makes that official.

The RangeTable generator in x/text also generates slightly compacter
tables.

Updates golang/go#27945

See CL 154443

Change-Id: I6c59e082d5b8cd9e9332a32d8971061228581d66
Reviewed-on: https://go-review.googlesource.com/c/go/+/169617
Run-TryBot: Marcel van Lohuizen <mpvl@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

3 files changed, 507 insertions, 2166 deletions

diff --git a/src/unicode/letter.go b/src/unicode/letter.go
index 8be9a7b7c9..a57566f0a5 100644
--- a/src/unicode/letter.go
+++ b/src/unicode/letter.go
@@ -6,9 +6,6 @@
 // Unicode code points.
 package unicode
 
-// Tables are regenerated each time we update the Unicode version.
-//go:generate go run maketables.go -tables=all -output tables.go
-
 const (
 	MaxRune         = '\U0010FFFF' // Maximum valid Unicode code point.
 	ReplacementChar = '\uFFFD'     // Represents invalid code points.
diff --git a/src/unicode/maketables.go b/src/unicode/maketables.go
deleted file mode 100644
index a1f15869ea..0000000000
--- a/src/unicode/maketables.go
+++ /dev/null
@@ -1,1452 +0,0 @@
-// Copyright 2009 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.
-
-// +build ignore
-
-// Unicode table generator.
-// Data read from the web.
-
-package main
-
-import (
-	"bufio"
-	"flag"
-	"fmt"
-	"io"
-	"log"
-	"net/http"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"regexp"
-	"sort"
-	"strconv"
-	"strings"
-	"unicode"
-)
-
-func main() {
-	flag.Parse()
-	setupOutput()
-	loadChars() // always needed
-	loadCasefold()
-	printCategories()
-	printScriptOrProperty(false)
-	printScriptOrProperty(true)
-	printCases()
-	printLatinProperties()
-	printCasefold()
-	printSizes()
-	flushOutput()
-}
-
-func defaultVersion() string {
-	if v := os.Getenv("UNICODE_VERSION"); v != "" {
-		return v
-	}
-	return unicode.Version
-}
-
-var dataURL = flag.String("data", "", "full URL for UnicodeData.txt; defaults to --url/UnicodeData.txt")
-var casefoldingURL = flag.String("casefolding", "", "full URL for CaseFolding.txt; defaults to --url/CaseFolding.txt")
-var url = flag.String("url",
-	"http://www.unicode.org/Public/"+defaultVersion()+"/ucd/",
-	"URL of Unicode database directory")
-var tablelist = flag.String("tables",
-	"all",
-	"comma-separated list of which tables to generate; can be letter")
-var scriptlist = flag.String("scripts",
-	"all",
-	"comma-separated list of which script tables to generate")
-var proplist = flag.String("props",
-	"all",
-	"comma-separated list of which property tables to generate")
-var cases = flag.Bool("cases",
-	true,
-	"generate case tables")
-var test = flag.Bool("test",
-	false,
-	"test existing tables; can be used to compare web data with package data")
-var localFiles = flag.Bool("local",
-	false,
-	"data files have been copied to current directory; for debugging only")
-var outputFile = flag.String("output",
-	"",
-	"output file for generated tables; default stdout")
-
-var scriptRe = regexp.MustCompile(`^([0-9A-F]+)(\.\.[0-9A-F]+)? *; ([A-Za-z_]+)$`)
-var logger = log.New(os.Stderr, "", log.Lshortfile)
-
-var output *bufio.Writer // points to os.Stdout or to "gofmt > outputFile"
-
-func setupOutput() {
-	output = bufio.NewWriter(startGofmt())
-}
-
-// startGofmt connects output to a gofmt process if -output is set.
-func startGofmt() io.Writer {
-	if *outputFile == "" {
-		return os.Stdout
-	}
-	stdout, err := os.Create(*outputFile)
-	if err != nil {
-		logger.Fatal(err)
-	}
-	// Pipe output to gofmt.
-	gofmt := exec.Command("gofmt")
-	fd, err := gofmt.StdinPipe()
-	if err != nil {
-		logger.Fatal(err)
-	}
-	gofmt.Stdout = stdout
-	gofmt.Stderr = os.Stderr
-	err = gofmt.Start()
-	if err != nil {
-		logger.Fatal(err)
-	}
-	return fd
-}
-
-func flushOutput() {
-	err := output.Flush()
-	if err != nil {
-		logger.Fatal(err)
-	}
-}
-
-func printf(format string, args ...interface{}) {
-	fmt.Fprintf(output, format, args...)
-}
-
-func print(args ...interface{}) {
-	fmt.Fprint(output, args...)
-}
-
-func println(args ...interface{}) {
-	fmt.Fprintln(output, args...)
-}
-
-type reader struct {
-	*bufio.Reader
-	fd   *os.File
-	resp *http.Response
-}
-
-func open(url string) *reader {
-	file := filepath.Base(url)
-	if *localFiles {
-		fd, err := os.Open(file)
-		if err != nil {
-			logger.Fatal(err)
-		}
-		return &reader{bufio.NewReader(fd), fd, nil}
-	}
-	resp, err := http.Get(url)
-	if err != nil {
-		logger.Fatal(err)
-	}
-	if resp.StatusCode != 200 {
-		logger.Fatalf("bad GET status for %s: %d", file, resp.Status)
-	}
-	return &reader{bufio.NewReader(resp.Body), nil, resp}
-
-}
-
-func (r *reader) close() {
-	if r.fd != nil {
-		r.fd.Close()
-	} else {
-		r.resp.Body.Close()
-	}
-}
-
-var category = map[string]bool{
-	// Nd Lu etc.
-	// We use one-character names to identify merged categories
-	"L": true, // Lu Ll Lt Lm Lo
-	"P": true, // Pc Pd Ps Pe Pu Pf Po
-	"M": true, // Mn Mc Me
-	"N": true, // Nd Nl No
-	"S": true, // Sm Sc Sk So
-	"Z": true, // Zs Zl Zp
-	"C": true, // Cc Cf Cs Co Cn
-}
-
-// UnicodeData.txt has form:
-//	0037;DIGIT SEVEN;Nd;0;EN;;7;7;7;N;;;;;
-//	007A;LATIN SMALL LETTER Z;Ll;0;L;;;;;N;;;005A;;005A
-// See https://www.unicode.org/reports/tr44/ for a full explanation
-// The fields:
-const (
-	FCodePoint = iota
-	FName
-	FGeneralCategory
-	FCanonicalCombiningClass
-	FBidiClass
-	FDecompositionTypeAndMapping
-	FNumericType
-	FNumericDigit // If a decimal digit.
-	FNumericValue // Includes non-decimal, e.g. U+2155=1/5
-	FBidiMirrored
-	FUnicode1Name
-	FISOComment
-	FSimpleUppercaseMapping
-	FSimpleLowercaseMapping
-	FSimpleTitlecaseMapping
-	NumField
-
-	MaxChar = 0x10FFFF // anything above this shouldn't exist
-)
-
-var fieldName = []string{
-	FCodePoint:                   "CodePoint",
-	FName:                        "Name",
-	FGeneralCategory:             "GeneralCategory",
-	FCanonicalCombiningClass:     "CanonicalCombiningClass",
-	FBidiClass:                   "BidiClass",
-	FDecompositionTypeAndMapping: "DecompositionTypeAndMapping",
-	FNumericType:                 "NumericType",
-	FNumericDigit:                "NumericDigit",
-	FNumericValue:                "NumericValue",
-	FBidiMirrored:                "BidiMirrored",
-	FUnicode1Name:                "Unicode1Name",
-	FISOComment:                  "ISOComment",
-	FSimpleUppercaseMapping:      "SimpleUppercaseMapping",
-	FSimpleLowercaseMapping:      "SimpleLowercaseMapping",
-	FSimpleTitlecaseMapping:      "SimpleTitlecaseMapping",
-}
-
-// This contains only the properties we're interested in.
-type Char struct {
-	field     []string // debugging only; could be deleted if we take out char.dump()
-	codePoint rune     // if zero, this index is not a valid code point.
-	category  string
-	upperCase rune
-	lowerCase rune
-	titleCase rune
-	foldCase  rune // simple case folding
-	caseOrbit rune // next in simple case folding orbit
-}
-
-// Scripts.txt has form:
-//	A673          ; Cyrillic # Po       SLAVONIC ASTERISK
-//	A67C..A67D    ; Cyrillic # Mn   [2] COMBINING CYRILLIC KAVYKA..COMBINING CYRILLIC PAYEROK
-// See https://www.unicode.org/Public/5.1.0/ucd/UCD.html for full explanation
-
-type Script struct {
-	lo, hi uint32 // range of code points
-	script string
-}
-
-var chars = make([]Char, MaxChar+1)
-var scripts = make(map[string][]Script)
-var props = make(map[string][]Script) // a property looks like a script; can share the format
-
-var lastChar rune = 0
-
-// In UnicodeData.txt, some ranges are marked like this:
-//	3400;<CJK Ideograph Extension A, First>;Lo;0;L;;;;;N;;;;;
-//	4DB5;<CJK Ideograph Extension A, Last>;Lo;0;L;;;;;N;;;;;
-// parseCategory returns a state variable indicating the weirdness.
-type State int
-
-const (
-	SNormal State = iota // known to be zero for the type
-	SFirst
-	SLast
-	SMissing
-)
-
-func parseCategory(line string) (state State) {
-	field := strings.Split(line, ";")
-	if len(field) != NumField {
-		logger.Fatalf("%5s: %d fields (expected %d)\n", line, len(field), NumField)
-	}
-	point, err := strconv.ParseUint(field[FCodePoint], 16, 64)
-	if err != nil {
-		logger.Fatalf("%.5s...: %s", line, err)
-	}
-	lastChar = rune(point)
-	if point > MaxChar {
-		return
-	}
-	char := &chars[point]
-	char.field = field
-	if char.codePoint != 0 {
-		logger.Fatalf("point %U reused", point)
-	}
-	char.codePoint = lastChar
-	char.category = field[FGeneralCategory]
-	category[char.category] = true
-	switch char.category {
-	case "Nd":
-		// Decimal digit
-		_, err := strconv.Atoi(field[FNumericValue])
-		if err != nil {
-			logger.Fatalf("%U: bad numeric field: %s", point, err)
-		}
-	case "Lu":
-		char.letter(field[FCodePoint], field[FSimpleLowercaseMapping], field[FSimpleTitlecaseMapping])
-	case "Ll":
-		char.letter(field[FSimpleUppercaseMapping], field[FCodePoint], field[FSimpleTitlecaseMapping])
-	case "Lt":
-		char.letter(field[FSimpleUppercaseMapping], field[FSimpleLowercaseMapping], field[FCodePoint])
-	default:
-		char.letter(field[FSimpleUppercaseMapping], field[FSimpleLowercaseMapping], field[FSimpleTitlecaseMapping])
-	}
-	switch {
-	case strings.Index(field[FName], ", First>") > 0:
-		state = SFirst
-	case strings.Index(field[FName], ", Last>") > 0:
-		state = SLast
-	}
-	return
-}
-
-func (char *Char) dump(s string) {
-	print(s, " ")
-	for i := 0; i < len(char.field); i++ {
-		printf("%s:%q ", fieldName[i], char.field[i])
-	}
-	print("\n")
-}
-
-func (char *Char) letter(u, l, t string) {
-	char.upperCase = char.letterValue(u, "U")
-	char.lowerCase = char.letterValue(l, "L")
-	char.titleCase = char.letterValue(t, "T")
-}
-
-func (char *Char) letterValue(s string, cas string) rune {
-	if s == "" {
-		return 0
-	}
-	v, err := strconv.ParseUint(s, 16, 64)
-	if err != nil {
-		char.dump(cas)
-		logger.Fatalf("%U: bad letter(%s): %s", char.codePoint, s, err)
-	}
-	return rune(v)
-}
-
-func allCategories() []string {
-	a := make([]string, 0, len(category))
-	for k := range category {
-		a = append(a, k)
-	}
-	sort.Strings(a)
-	return a
-}
-
-func all(scripts map[string][]Script) []string {
-	a := make([]string, 0, len(scripts))
-	for k := range scripts {
-		a = append(a, k)
-	}
-	sort.Strings(a)
-	return a
-}
-
-func allCatFold(m map[string]map[rune]bool) []string {
-	a := make([]string, 0, len(m))
-	for k := range m {
-		a = append(a, k)
-	}
-	sort.Strings(a)
-	return a
-}
-
-// Extract the version number from the URL
-func version() string {
-	// Break on slashes and look for the first numeric field
-	fields := strings.Split(*url, "/")
-	for _, f := range fields {
-		if len(f) > 0 && '0' <= f[0] && f[0] <= '9' {
-			return f
-		}
-	}
-	logger.Fatal("unknown version")
-	return "Unknown"
-}
-
-func categoryOp(code rune, class uint8) bool {
-	category := chars[code].category
-	return len(category) > 0 && category[0] == class
-}
-
-func loadChars() {
-	if *dataURL == "" {
-		flag.Set("data", *url+"UnicodeData.txt")
-	}
-	input := open(*dataURL)
-	defer input.close()
-	scanner := bufio.NewScanner(input)
-	var first rune = 0
-	for scanner.Scan() {
-		switch parseCategory(scanner.Text()) {
-		case SNormal:
-			if first != 0 {
-				logger.Fatalf("bad state normal at %U", lastChar)
-			}
-		case SFirst:
-			if first != 0 {
-				logger.Fatalf("bad state first at %U", lastChar)
-			}
-			first = lastChar
-		case SLast:
-			if first == 0 {
-				logger.Fatalf("bad state last at %U", lastChar)
-			}
-			for i := first + 1; i <= lastChar; i++ {
-				chars[i] = chars[first]
-				chars[i].codePoint = i
-			}
-			first = 0
-		}
-	}
-	if scanner.Err() != nil {
-		logger.Fatal(scanner.Err())
-	}
-}
-
-func loadCasefold() {
-	if *casefoldingURL == "" {
-		flag.Set("casefolding", *url+"CaseFolding.txt")
-	}
-	input := open(*casefoldingURL)
-	defer input.close()
-	scanner := bufio.NewScanner(input)
-	for scanner.Scan() {
-		line := scanner.Text()
-		if len(line) == 0 || line[0] == '#' || len(strings.TrimSpace(line)) == 0 {
-			continue
-		}
-		field := strings.Split(line, "; ")
-		if len(field) != 4 {
-			logger.Fatalf("CaseFolding.txt %.5s...: %d fields (expected %d)\n", line, len(field), 4)
-		}
-		kind := field[1]
-		if kind != "C" && kind != "S" {
-			// Only care about 'common' and 'simple' foldings.
-			continue
-		}
-		p1, err := strconv.ParseUint(field[0], 16, 64)
-		if err != nil {
-			logger.Fatalf("CaseFolding.txt %.5s...: %s", line, err)
-		}
-		p2, err := strconv.ParseUint(field[2], 16, 64)
-		if err != nil {
-			logger.Fatalf("CaseFolding.txt %.5s...: %s", line, err)
-		}
-		chars[p1].foldCase = rune(p2)
-	}
-	if scanner.Err() != nil {
-		logger.Fatal(scanner.Err())
-	}
-}
-
-const progHeader = `// Copyright 2013 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.
-
-// Code generated by maketables; DO NOT EDIT.
-// To regenerate, run:
-//	maketables --tables=%s --data=%s --casefolding=%s
-
-package unicode
-
-`
-
-var categoryMapping = map[string]string{
-	"Lu": "Letter, uppercase",
-	"Ll": "Letter, lowercase",
-	"Lt": "Letter, titlecase",
-	"Lm": "Letter, modifier",
-	"Lo": "Letter, other",
-	"Mn": "Mark, nonspacing",
-	"Mc": "Mark, spacing combining",
-	"Me": "Mark, enclosing",
-	"Nd": "Number, decimal digit",
-	"Nl": "Number, letter",
-	"No": "Number, other",
-	"Pc": "Punctuation, connector",
-	"Pd": "Punctuation, dash",
-	"Ps": "Punctuation, open",
-	"Pe": "Punctuation, close",
-	"Pi": "Punctuation, initial quote",
-	"Pf": "Punctuation, final quote",
-	"Po": "Punctuation, other",
-	"Sm": "Symbol, math",
-	"Sc": "Symbol, currency",
-	"Sk": "Symbol, modifier",
-	"So": "Symbol, other",
-	"Zs": "Separator, space",
-	"Zl": "Separator, line",
-	"Zp": "Separator, paragraph",
-	"Cc": "Other, control",
-	"Cf": "Other, format",
-	"Cs": "Other, surrogate",
-	"Co": "Other, private use",
-	"Cn": "Other, not assigned",
-}
-
-func printCategories() {
-	if *tablelist == "" {
-		return
-	}
-	// Find out which categories to dump
-	list := strings.Split(*tablelist, ",")
-	if *tablelist == "all" {
-		list = allCategories()
-	}
-	if *test {
-		fullCategoryTest(list)
-		return
-	}
-	printf(progHeader, *tablelist, *dataURL, *casefoldingURL)
-
-	println("// Version is the Unicode edition from which the tables are derived.")
-	printf("const Version = %q\n\n", version())
-
-	if *tablelist == "all" {
-		println("// Categories is the set of Unicode category tables.")
-		println("var Categories = map[string] *RangeTable {")
-		for _, k := range allCategories() {
-			printf("\t%q: %s,\n", k, k)
-		}
-		print("}\n\n")
-	}
-
-	decl := make(sort.StringSlice, len(list))
-	ndecl := 0
-	for _, name := range list {
-		if _, ok := category[name]; !ok {
-			logger.Fatal("unknown category", name)
-		}
-		// We generate an UpperCase name to serve as concise documentation and an _UnderScored
-		// name to store the data. This stops godoc dumping all the tables but keeps them
-		// available to clients.
-		// Cases deserving special comments
-		varDecl := ""
-		switch name {
-		case "C":
-			varDecl = "\tOther = _C;	// Other/C is the set of Unicode control and special characters, category C.\n"
-			varDecl += "\tC = _C\n"
-		case "L":
-			varDecl = "\tLetter = _L;	// Letter/L is the set of Unicode letters, category L.\n"
-			varDecl += "\tL = _L\n"
-		case "M":
-			varDecl = "\tMark = _M;	// Mark/M is the set of Unicode mark characters, category M.\n"
-			varDecl += "\tM = _M\n"
-		case "N":
-			varDecl = "\tNumber = _N;	// Number/N is the set of Unicode number characters, category N.\n"
-			varDecl += "\tN = _N\n"
-		case "P":
-			varDecl = "\tPunct = _P;	// Punct/P is the set of Unicode punctuation characters, category P.\n"
-			varDecl += "\tP = _P\n"
-		case "S":
-			varDecl = "\tSymbol = _S;	// Symbol/S is the set of Unicode symbol characters, category S.\n"
-			varDecl += "\tS = _S\n"
-		case "Z":
-			varDecl = "\tSpace = _Z;	// Space/Z is the set of Unicode space characters, category Z.\n"
-			varDecl += "\tZ = _Z\n"
-		case "Nd":
-			varDecl = "\tDigit = _Nd;	// Digit is the set of Unicode characters with the \"decimal digit\" property.\n"
-		case "Lu":
-			varDecl = "\tUpper = _Lu;	// Upper is the set of Unicode upper case letters.\n"
-		case "Ll":
-			varDecl = "\tLower = _Ll;	// Lower is the set of Unicode lower case letters.\n"
-		case "Lt":
-			varDecl = "\tTitle = _Lt;	// Title is the set of Unicode title case letters.\n"
-		}
-		if len(name) > 1 {
-			desc, ok := categoryMapping[name]
-			if ok {
-				varDecl += fmt.Sprintf(
-					"\t%s = _%s;	// %s is the set of Unicode characters in category %s (%s).\n",
-					name, name, name, name, desc)
-			} else {
-				varDecl += fmt.Sprintf(
-					"\t%s = _%s;	// %s is the set of Unicode characters in category %s.\n",
-					name, name, name, name)
-			}
-		}
-		decl[ndecl] = varDecl
-		ndecl++
-		if len(name) == 1 { // unified categories
-			decl := fmt.Sprintf("var _%s = &RangeTable{\n", name)
-			dumpRange(
-				decl,
-				func(code rune) bool { return categoryOp(code, name[0]) })
-			continue
-		}
-		dumpRange(
-			fmt.Sprintf("var _%s = &RangeTable{\n", name),
-			func(code rune) bool { return chars[code].category == name })
-	}
-	decl.Sort()
-	println("// These variables have type *RangeTable.")
-	println("var (")
-	for _, d := range decl {
-		print(d)
-	}
-	print(")\n\n")
-}
-
-type Op func(code rune) bool
-
-const format = "\t\t{0x%04x, 0x%04x, %d},\n"
-
-func dumpRange(header string, inCategory Op) {
-	print(header)
-	next := rune(0)
-	latinOffset := 0
-	print("\tR16: []Range16{\n")
-	// one Range for each iteration
-	count := &range16Count
-	size := 16
-	for {
-		// look for start of range
-		for next < rune(len(chars)) && !inCategory(next) {
-			next++
-		}
-		if next >= rune(len(chars)) {
-			// no characters remain
-			break
-		}
-
-		// start of range
-		lo := next
-		hi := next
-		stride := rune(1)
-		// accept lo
-		next++
-		// look for another character to set the stride
-		for next < rune(len(chars)) && !inCategory(next) {
-			next++
-		}
-		if next >= rune(len(chars)) {
-			// no more characters
-			printf(format, lo, hi, stride)
-			break
-		}
-		// set stride
-		stride = next - lo
-		// check for length of run. next points to first jump in stride
-		for i := next; i < rune(len(chars)); i++ {
-			if inCategory(i) == (((i - lo) % stride) == 0) {
-				// accept
-				if inCategory(i) {
-					hi = i
-				}
-			} else {
-				// no more characters in this run
-				break
-			}
-		}
-		if uint32(hi) <= unicode.MaxLatin1 {
-			latinOffset++
-		}
-		size, count = printRange(uint32(lo), uint32(hi), uint32(stride), size, count)
-		// next range: start looking where this range ends
-		next = hi + 1
-	}
-	print("\t},\n")
-	if latinOffset > 0 {
-		printf("\tLatinOffset: %d,\n", latinOffset)
-	}
-	print("}\n\n")
-}
-
-func printRange(lo, hi, stride uint32, size int, count *int) (int, *int) {
-	if size == 16 && hi >= 1<<16 {
-		if lo < 1<<16 {
-			if lo+stride != hi {
-				logger.Fatalf("unexpected straddle: %U %U %d", lo, hi, stride)
-			}
-			// No range contains U+FFFF as an instance, so split
-			// the range into two entries. That way we can maintain
-			// the invariant that R32 contains only >= 1<<16.
-			printf(format, lo, lo, 1)
-			lo = hi
-			stride = 1
-			*count++
-		}
-		print("\t},\n")
-		print("\tR32: []Range32{\n")
-		size = 32
-		count = &range32Count
-	}
-	printf(format, lo, hi, stride)
-	*count++
-	return size, count
-}
-
-func fullCategoryTest(list []string) {
-	for _, name := range list {
-		if _, ok := category[name]; !ok {
-			logger.Fatal("unknown category", name)
-		}
-		r, ok := unicode.Categories[name]
-		if !ok && len(name) > 1 {
-			logger.Fatalf("unknown table %q", name)
-		}
-		if len(name) == 1 {
-			verifyRange(name, func(code rune) bool { return categoryOp(code, name[0]) }, r)
-		} else {
-			verifyRange(
-				name,
-				func(code rune) bool { return chars[code].category == name },
-				r)
-		}
-	}
-}
-
-func verifyRange(name string, inCategory Op, table *unicode.RangeTable) {
-	count := 0
-	for j := range chars {
-		i := rune(j)
-		web := inCategory(i)
-		pkg := unicode.Is(table, i)
-		if web != pkg {
-			fmt.Fprintf(os.Stderr, "%s: %U: web=%t pkg=%t\n", name, i, web, pkg)
-			count++
-			if count > 10 {
-				break
-			}
-		}
-	}
-}
-
-func parseScript(line string, scripts map[string][]Script) {
-	comment := strings.Index(line, "#")
-	if comment >= 0 {
-		line = line[0:comment]
-	}
-	line = strings.TrimSpace(line)
-	if len(line) == 0 {
-		return
-	}
-	field := strings.Split(line, ";")
-	if len(field) != 2 {
-		logger.Fatalf("%s: %d fields (expected 2)\n", line, len(field))
-	}
-	matches := scriptRe.FindStringSubmatch(line)
-	if len(matches) != 4 {
-		logger.Fatalf("%s: %d matches (expected 3)\n", line, len(matches))
-	}
-	lo, err := strconv.ParseUint(matches[1], 16, 64)
-	if err != nil {
-		logger.Fatalf("%.5s...: %s", line, err)
-	}
-	hi := lo
-	if len(matches[2]) > 2 { // ignore leading ..
-		hi, err = strconv.ParseUint(matches[2][2:], 16, 64)
-		if err != nil {
-			logger.Fatalf("%.5s...: %s", line, err)
-		}
-	}
-	name := matches[3]
-	scripts[name] = append(scripts[name], Script{uint32(lo), uint32(hi), name})
-}
-
-// The script tables have a lot of adjacent elements. Fold them together.
-func foldAdjacent(r []Script) []unicode.Range32 {
-	s := make([]unicode.Range32, 0, len(r))
-	j := 0
-	for i := 0; i < len(r); i++ {
-		if j > 0 && r[i].lo == s[j-1].Hi+1 {
-			s[j-1].Hi = r[i].hi
-		} else {
-			s = s[0 : j+1]
-			s[j] = unicode.Range32{
-				Lo:     uint32(r[i].lo),
-				Hi:     uint32(r[i].hi),
-				Stride: 1,
-			}
-			j++
-		}
-	}
-	return s
-}
-
-func fullScriptTest(list []string, installed map[string]*unicode.RangeTable, scripts map[string][]Script) {
-	for _, name := range list {
-		if _, ok := scripts[name]; !ok {
-			logger.Fatal("unknown script", name)
-		}
-		_, ok := installed[name]
-		if !ok {
-			logger.Fatal("unknown table", name)
-		}
-		for _, script := range scripts[name] {
-			for r := script.lo; r <= script.hi; r++ {
-				if !unicode.Is(installed[name], rune(r)) {
-					fmt.Fprintf(os.Stderr, "%U: not in script %s\n", r, name)
-				}
-			}
-		}
-	}
-}
-
-var deprecatedAliases = map[string]string{
-	"Sentence_Terminal": "STerm",
-}
-
-// PropList.txt has the same format as Scripts.txt so we can share its parser.
-func printScriptOrProperty(doProps bool) {
-	flag := "scripts"
-	flaglist := *scriptlist
-	file := "Scripts.txt"
-	table := scripts
-	installed := unicode.Scripts
-	if doProps {
-		flag = "props"
-		flaglist = *proplist
-		file = "PropList.txt"
-		table = props
-		installed = unicode.Properties
-	}
-	if flaglist == "" {
-		return
-	}
-	input := open(*url + file)
-	scanner := bufio.NewScanner(input)
-	for scanner.Scan() {
-		parseScript(scanner.Text(), table)
-	}
-	if scanner.Err() != nil {
-		logger.Fatal(scanner.Err())
-	}
-	input.close()
-
-	// Find out which scripts to dump
-	list := strings.Split(flaglist, ",")
-	if flaglist == "all" {
-		list = all(table)
-	}
-	if *test {
-		fullScriptTest(list, installed, table)
-		return
-	}
-
-	printf(
-		"// Generated by running\n"+
-			"//	maketables --%s=%s --url=%s\n"+
-			"// DO NOT EDIT\n\n",
-		flag,
-		flaglist,
-		*url)
-	if flaglist == "all" {
-		if doProps {
-			println("// Properties is the set of Unicode property tables.")
-			println("var Properties = map[string] *RangeTable{")
-		} else {
-			println("// Scripts is the set of Unicode script tables.")
-			println("var Scripts = map[string] *RangeTable{")
-		}
-		for _, k := range all(table) {
-			printf("\t%q: %s,\n", k, k)
-			if alias, ok := deprecatedAliases[k]; ok {
-				printf("\t%q: %s,\n", alias, k)
-			}
-		}
-		print("}\n\n")
-	}
-
-	decl := make(sort.StringSlice, len(list)+len(deprecatedAliases))
-	ndecl := 0
-	for _, name := range list {
-		if doProps {
-			decl[ndecl] = fmt.Sprintf(
-				"\t%s = _%s;\t// %s is the set of Unicode characters with property %s.\n",
-				name, name, name, name)
-		} else {
-			decl[ndecl] = fmt.Sprintf(
-				"\t%s = _%s;\t// %s is the set of Unicode characters in script %s.\n",
-				name, name, name, name)
-		}
-		ndecl++
-		if alias, ok := deprecatedAliases[name]; ok {
-			decl[ndecl] = fmt.Sprintf(
-				"\t%[1]s = _%[2]s;\t// %[1]s is an alias for %[2]s.\n",
-				alias, name)
-			ndecl++
-		}
-		printf("var _%s = &RangeTable {\n", name)
-		ranges := foldAdjacent(table[name])
-		print("\tR16: []Range16{\n")
-		size := 16
-		count := &range16Count
-		for _, s := range ranges {
-			size, count = printRange(s.Lo, s.Hi, s.Stride, size, count)
-		}
-		print("\t},\n")
-		if off := findLatinOffset(ranges); off > 0 {
-			printf("\tLatinOffset: %d,\n", off)
-		}
-		print("}\n\n")
-	}
-	decl.Sort()
-	println("// These variables have type *RangeTable.")
-	println("var (")
-	for _, d := range decl {
-		print(d)
-	}
-	print(")\n\n")
-}
-
-func findLatinOffset(ranges []unicode.Range32) int {
-	i := 0
-	for i < len(ranges) && ranges[i].Hi <= unicode.MaxLatin1 {
-		i++
-	}
-	return i
-}
-
-const (
-	CaseUpper = 1 << iota
-	CaseLower
-	CaseTitle
-	CaseNone    = 0  // must be zero
-	CaseMissing = -1 // character not present; not a valid case state
-)
-
-type caseState struct {
-	point        rune
-	_case        int
-	deltaToUpper rune
-	deltaToLower rune
-	deltaToTitle rune
-}
-
-// Is d a continuation of the state of c?
-func (c *caseState) adjacent(d *caseState) bool {
-	if d.point < c.point {
-		c, d = d, c
-	}
-	switch {
-	case d.point != c.point+1: // code points not adjacent (shouldn't happen)
-		return false
-	case d._case != c._case: // different cases
-		return c.upperLowerAdjacent(d)
-	case c._case == CaseNone:
-		return false
-	case c._case == CaseMissing:
-		return false
-	case d.deltaToUpper != c.deltaToUpper:
-		return false
-	case d.deltaToLower != c.deltaToLower:
-		return false
-	case d.deltaToTitle != c.deltaToTitle:
-		return false
-	}
-	return true
-}
-
-// Is d the same as c, but opposite in upper/lower case? this would make it
-// an element of an UpperLower sequence.
-func (c *caseState) upperLowerAdjacent(d *caseState) bool {
-	// check they're a matched case pair.  we know they have adjacent values
-	switch {
-	case c._case == CaseUpper && d._case != CaseLower:
-		return false
-	case c._case == CaseLower && d._case != CaseUpper:
-		return false
-	}
-	// matched pair (at least in upper/lower).  make the order Upper Lower
-	if c._case == CaseLower {
-		c, d = d, c
-	}
-	// for an Upper Lower sequence the deltas have to be in order
-	//	c: 0 1 0
-	//	d: -1 0 -1
-	switch {
-	case c.deltaToUpper != 0:
-		return false
-	case c.deltaToLower != 1:
-		return false
-	case c.deltaToTitle != 0:
-		return false
-	case d.deltaToUpper != -1:
-		return false
-	case d.deltaToLower != 0:
-		return false
-	case d.deltaToTitle != -1:
-		return false
-	}
-	return true
-}
-
-// Does this character start an UpperLower sequence?
-func (c *caseState) isUpperLower() bool {
-	// for an Upper Lower sequence the deltas have to be in order
-	//	c: 0 1 0
-	switch {
-	case c.deltaToUpper != 0:
-		return false
-	case c.deltaToLower != 1:
-		return false
-	case c.deltaToTitle != 0:
-		return false
-	}
-	return true
-}
-
-// Does this character start a LowerUpper sequence?
-func (c *caseState) isLowerUpper() bool {
-	// for an Upper Lower sequence the deltas have to be in order
-	//	c: -1 0 -1
-	switch {
-	case c.deltaToUpper != -1:
-		return false
-	case c.deltaToLower != 0:
-		return false
-	case c.deltaToTitle != -1:
-		return false
-	}
-	return true
-}
-
-func getCaseState(i rune) (c *caseState) {
-	c = &caseState{point: i, _case: CaseNone}
-	ch := &chars[i]
-	switch ch.codePoint {
-	case 0:
-		c._case = CaseMissing // Will get NUL wrong but that doesn't matter
-		return
-	case ch.upperCase:
-		c._case = CaseUpper
-	case ch.lowerCase:
-		c._case = CaseLower
-	case ch.titleCase:
-		c._case = CaseTitle
-	}
-	// Some things such as roman numeral U+2161 don't describe themselves
-	// as upper case, but have a lower case. Second-guess them.
-	if c._case == CaseNone && ch.lowerCase != 0 {
-		c._case = CaseUpper
-	}
-	// Same in the other direction.
-	if c._case == CaseNone && ch.upperCase != 0 {
-		c._case = CaseLower
-	}
-
-	if ch.upperCase != 0 {
-		c.deltaToUpper = ch.upperCase - i
-	}
-	if ch.lowerCase != 0 {
-		c.deltaToLower = ch.lowerCase - i
-	}
-	if ch.titleCase != 0 {
-		c.deltaToTitle = ch.titleCase - i
-	}
-	return
-}
-
-func printCases() {
-	if !*cases {
-		return
-	}
-	if *test {
-		fullCaseTest()
-		return
-	}
-	printf(
-		"// Generated by running\n"+
-			"//	maketables --data=%s --casefolding=%s\n"+
-			"// DO NOT EDIT\n\n"+
-			"// CaseRanges is the table describing case mappings for all letters with\n"+
-			"// non-self mappings.\n"+
-			"var CaseRanges = _CaseRanges\n"+
-			"var _CaseRanges = []CaseRange {\n",
-		*dataURL, *casefoldingURL)
-
-	var startState *caseState    // the start of a run; nil for not active
-	var prevState = &caseState{} // the state of the previous character
-	for i := range chars {
-		state := getCaseState(rune(i))
-		if state.adjacent(prevState) {
-			prevState = state
-			continue
-		}
-		// end of run (possibly)
-		printCaseRange(startState, prevState)
-		startState = nil
-		if state._case != CaseMissing && state._case != CaseNone {
-			startState = state
-		}
-		prevState = state
-	}
-	print("}\n")
-}
-
-func printCaseRange(lo, hi *caseState) {
-	if lo == nil {
-		return
-	}
-	if lo.deltaToUpper == 0 && lo.deltaToLower == 0 && lo.deltaToTitle == 0 {
-		// character represents itself in all cases - no need to mention it
-		return
-	}
-	switch {
-	case hi.point > lo.point && lo.isUpperLower():
-		printf("\t{0x%04X, 0x%04X, d{UpperLower, UpperLower, UpperLower}},\n",
-			lo.point, hi.point)
-	case hi.point > lo.point && lo.isLowerUpper():
-		logger.Fatalf("LowerUpper sequence: should not happen: %U.  If it's real, need to fix To()", lo.point)
-		printf("\t{0x%04X, 0x%04X, d{LowerUpper, LowerUpper, LowerUpper}},\n",
-			lo.point, hi.point)
-	default:
-		printf("\t{0x%04X, 0x%04X, d{%d, %d, %d}},\n",
-			lo.point, hi.point,
-			lo.deltaToUpper, lo.deltaToLower, lo.deltaToTitle)
-	}
-}
-
-// If the cased value in the Char is 0, it means use the rune itself.
-func caseIt(r, cased rune) rune {
-	if cased == 0 {
-		return r
-	}
-	return cased
-}
-
-func fullCaseTest() {
-	for j, c := range chars {
-		i := rune(j)
-		lower := unicode.ToLower(i)
-		want := caseIt(i, c.lowerCase)
-		if lower != want {
-			fmt.Fprintf(os.Stderr, "lower %U should be %U is %U\n", i, want, lower)
-		}
-		upper := unicode.ToUpper(i)
-		want = caseIt(i, c.upperCase)
-		if upper != want {
-			fmt.Fprintf(os.Stderr, "upper %U should be %U is %U\n", i, want, upper)
-		}
-		title := unicode.ToTitle(i)
-		want = caseIt(i, c.titleCase)
-		if title != want {
-			fmt.Fprintf(os.Stderr, "title %U should be %U is %U\n", i, want, title)
-		}
-	}
-}
-
-func printLatinProperties() {
-	if *test {
-		return
-	}
-	println("var properties = [MaxLatin1+1]uint8{")
-	for code := 0; code <= unicode.MaxLatin1; code++ {
-		var property string
-		switch chars[code].category {
-		case "Cc", "": // NUL has no category.
-			property = "pC"
-		case "Cf": // soft hyphen, unique category, not printable.
-			property = "0"
-		case "Ll":
-			property = "pLl | pp"
-		case "Lo":
-			property = "pLo | pp"
-		case "Lu":
-			property = "pLu | pp"
-		case "Nd", "No":
-			property = "pN | pp"
-		case "Pc", "Pd", "Pe", "Pf", "Pi", "Po", "Ps":
-			property = "pP | pp"
-		case "Sc", "Sk", "Sm", "So":
-			property = "pS | pp"
-		case "Zs":
-			property = "pZ"
-		default:
-			logger.Fatalf("%U has unknown category %q", code, chars[code].category)
-		}
-		// Special case
-		if code == ' ' {
-			property = "pZ | pp"
-		}
-		printf("\t0x%02X: %s, // %q\n", code, property, code)
-	}
-	printf("}\n\n")
-}
-
-func printCasefold() {
-	// Build list of case-folding groups attached to each canonical folded char (typically lower case).
-	var caseOrbit = make([][]rune, MaxChar+1)
-	for j := range chars {
-		i := rune(j)
-		c := &chars[i]
-		if c.foldCase == 0 {
-			continue
-		}
-		orb := caseOrbit[c.foldCase]
-		if orb == nil {
-			orb = append(orb, c.foldCase)
-		}
-		caseOrbit[c.foldCase] = append(orb, i)
-	}
-
-	// Insert explicit 1-element groups when assuming [lower, upper] would be wrong.
-	for j := range chars {
-		i := rune(j)
-		c := &chars[i]
-		f := c.foldCase
-		if f == 0 {
-			f = i
-		}
-		orb := caseOrbit[f]
-		if orb == nil && (c.upperCase != 0 && c.upperCase != i || c.lowerCase != 0 && c.lowerCase != i) {
-			// Default assumption of [upper, lower] is wrong.
-			caseOrbit[i] = []rune{i}
-		}
-	}
-
-	// Delete the groups for which assuming [lower, upper] or [upper, lower] is right.
-	for i, orb := range caseOrbit {
-		if len(orb) == 2 && chars[orb[0]].upperCase == orb[1] && chars[orb[1]].lowerCase == orb[0] {
-			caseOrbit[i] = nil
-		}
-		if len(orb) == 2 && chars[orb[1]].upperCase == orb[0] && chars[orb[0]].lowerCase == orb[1] {
-			caseOrbit[i] = nil
-		}
-	}
-
-	// Record orbit information in chars.
-	for _, orb := range caseOrbit {
-		if orb == nil {
-			continue
-		}
-		sort.Slice(orb, func(i, j int) bool {
-			return orb[i] < orb[j]
-		})
-		c := orb[len(orb)-1]
-		for _, d := range orb {
-			chars[c].caseOrbit = d
-			c = d
-		}
-	}
-
-	printAsciiFold()
-	printCaseOrbit()
-
-	// Tables of category and script folding exceptions: code points
-	// that must be added when interpreting a particular category/script
-	// in a case-folding context.
-	cat := make(map[string]map[rune]bool)
-	for name := range category {
-		if x := foldExceptions(inCategory(name)); len(x) > 0 {
-			cat[name] = x
-		}
-	}
-
-	scr := make(map[string]map[rune]bool)
-	for name := range scripts {
-		if x := foldExceptions(inScript(name)); len(x) > 0 {
-			scr[name] = x
-		}
-	}
-
-	printCatFold("FoldCategory", cat)
-	printCatFold("FoldScript", scr)
-}
-
-// inCategory returns a list of all the runes in the category.
-func inCategory(name string) []rune {
-	var x []rune
-	for j := range chars {
-		i := rune(j)
-		c := &chars[i]
-		if c.category == name || len(name) == 1 && len(c.category) > 1 && c.category[0] == name[0] {
-			x = append(x, i)
-		}
-	}
-	return x
-}
-
-// inScript returns a list of all the runes in the script.
-func inScript(name string) []rune {
-	var x []rune
-	for _, s := range scripts[name] {
-		for c := s.lo; c <= s.hi; c++ {
-			x = append(x, rune(c))
-		}
-	}
-	return x
-}
-
-// foldExceptions returns a list of all the runes fold-equivalent
-// to runes in class but not in class themselves.
-func foldExceptions(class []rune) map[rune]bool {
-	// Create map containing class and all fold-equivalent chars.
-	m := make(map[rune]bool)
-	for _, r := range class {
-		c := &chars[r]
-		if c.caseOrbit == 0 {
-			// Just upper and lower.
-			if u := c.upperCase; u != 0 {
-				m[u] = true
-			}
-			if l := c.lowerCase; l != 0 {
-				m[l] = true
-			}
-			m[r] = true
-			continue
-		}
-		// Otherwise walk orbit.
-		r0 := r
-		for {
-			m[r] = true
-			r = chars[r].caseOrbit
-			if r == r0 {
-				break
-			}
-		}
-	}
-
-	// Remove class itself.
-	for _, r := range class {
-		delete(m, r)
-	}
-
-	// What's left is the exceptions.
-	return m
-}
-
-var comment = map[string]string{
-	"FoldCategory": "// FoldCategory maps a category name to a table of\n" +
-		"// code points outside the category that are equivalent under\n" +
-		"// simple case folding to code points inside the category.\n" +
-		"// If there is no entry for a category name, there are no such points.\n",
-
-	"FoldScript": "// FoldScript maps a script name to a table of\n" +
-		"// code points outside the script that are equivalent under\n" +
-		"// simple case folding to code points inside the script.\n" +
-		"// If there is no entry for a script name, there are no such points.\n",
-}
-
-func printAsciiFold() {
-	printf("var asciiFold = [MaxASCII + 1]uint16{\n")
-	for i := rune(0); i <= unicode.MaxASCII; i++ {
-		c := chars[i]
-		f := c.caseOrbit
-		if f == 0 {
-			if c.lowerCase != i && c.lowerCase != 0 {
-				f = c.lowerCase
-			} else if c.upperCase != i && c.upperCase != 0 {
-				f = c.upperCase
-			} else {
-				f = i
-			}
-		}
-		printf("\t0x%04X,\n", f)
-	}
-	printf("}\n\n")
-}
-
-func printCaseOrbit() {
-	if *test {
-		for j := range chars {
-			i := rune(j)
-			c := &chars[i]
-			f := c.caseOrbit
-			if f == 0 {
-				if c.lowerCase != i && c.lowerCase != 0 {
-					f = c.lowerCase
-				} else if c.upperCase != i && c.upperCase != 0 {
-					f = c.upperCase
-				} else {
-					f = i
-				}
-			}
-			if g := unicode.SimpleFold(i); g != f {
-				fmt.Fprintf(os.Stderr, "unicode.SimpleFold(%#U) = %#U, want %#U\n", i, g, f)
-			}
-		}
-		return
-	}
-
-	printf("var caseOrbit = []foldPair{\n")
-	for i := range chars {
-		c := &chars[i]
-		if c.caseOrbit != 0 {
-			printf("\t{0x%04X, 0x%04X},\n", i, c.caseOrbit)
-			foldPairCount++
-		}
-	}
-	printf("}\n\n")
-}
-
-func printCatFold(name string, m map[string]map[rune]bool) {
-	if *test {
-		var pkgMap map[string]*unicode.RangeTable
-		if name == "FoldCategory" {
-			pkgMap = unicode.FoldCategory
-		} else {
-			pkgMap = unicode.FoldScript
-		}
-		if len(pkgMap) != len(m) {
-			fmt.Fprintf(os.Stderr, "unicode.%s has %d elements, want %d\n", name, len(pkgMap), len(m))
-			return
-		}
-		for k, v := range m {
-			t, ok := pkgMap[k]
-			if !ok {
-				fmt.Fprintf(os.Stderr, "unicode.%s[%q] missing\n", name, k)
-				continue
-			}
-			n := 0
-			for _, r := range t.R16 {
-				for c := rune(r.Lo); c <= rune(r.Hi); c += rune(r.Stride) {
-					if !v[c] {
-						fmt.Fprintf(os.Stderr, "unicode.%s[%q] contains %#U, should not\n", name, k, c)
-					}
-					n++
-				}
-			}
-			for _, r := range t.R32 {
-				for c := rune(r.Lo); c <= rune(r.Hi); c += rune(r.Stride) {
-					if !v[c] {
-						fmt.Fprintf(os.Stderr, "unicode.%s[%q] contains %#U, should not\n", name, k, c)
-					}
-					n++
-				}
-			}
-			if n != len(v) {
-				fmt.Fprintf(os.Stderr, "unicode.%s[%q] has %d code points, want %d\n", name, k, n, len(v))
-			}
-		}
-		return
-	}
-
-	print(comment[name])
-	printf("var %s = map[string]*RangeTable{\n", name)
-	for _, name := range allCatFold(m) {
-		printf("\t%q: fold%s,\n", name, name)
-	}
-	printf("}\n\n")
-	for _, name := range allCatFold(m) {
-		class := m[name]
-		dumpRange(
-			fmt.Sprintf("var fold%s = &RangeTable{\n", name),
-			func(code rune) bool { return class[code] })
-	}
-}
-
-var range16Count = 0  // Number of entries in the 16-bit range tables.
-var range32Count = 0  // Number of entries in the 32-bit range tables.
-var foldPairCount = 0 // Number of fold pairs in the exception tables.
-
-func printSizes() {
-	if *test {
-		return
-	}
-	println()
-	printf("// Range entries: %d 16-bit, %d 32-bit, %d total.\n", range16Count, range32Count, range16Count+range32Count)
-	range16Bytes := range16Count * 3 * 2
-	range32Bytes := range32Count * 3 * 4
-	printf("// Range bytes: %d 16-bit, %d 32-bit, %d total.\n", range16Bytes, range32Bytes, range16Bytes+range32Bytes)
-	println()
-	printf("// Fold orbit bytes: %d pairs, %d bytes\n", foldPairCount, foldPairCount*2*2)
-}
diff --git a/src/unicode/tables.go b/src/unicode/tables.go
index ce85b128ca..90bfa10064 100644
--- a/src/unicode/tables.go
+++ b/src/unicode/tables.go
@@ -1,10 +1,4 @@
-// Copyright 2013 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.
-
-// Code generated by maketables; DO NOT EDIT.
-// To regenerate, run:
-//	maketables --tables=all --data=http://www.unicode.org/Public/10.0.0/ucd/UnicodeData.txt --casefolding=http://www.unicode.org/Public/10.0.0/ucd/CaseFolding.txt
+// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
 
 package unicode
 
@@ -885,8 +879,7 @@ var _Lm = &RangeTable{
 		{0xff9f, 0xff9f, 1},
 	},
 	R32: []Range32{
-		{0x16b40, 0x16b40, 1},
-		{0x16b41, 0x16b43, 1},
+		{0x16b40, 0x16b43, 1},
 		{0x16f93, 0x16f9f, 1},
 		{0x16fe0, 0x16fe1, 1},
 	},
@@ -2799,8 +2792,7 @@ var _Po = &RangeTable{
 		{0xff65, 0xff65, 1},
 	},
 	R32: []Range32{
-		{0x10100, 0x10100, 1},
-		{0x10101, 0x10102, 1},
+		{0x10100, 0x10102, 1},
 		{0x1039f, 0x103d0, 49},
 		{0x1056f, 0x10857, 744},
 		{0x1091f, 0x1093f, 32},
@@ -3114,8 +3106,7 @@ var _Sk = &RangeTable{
 		{0xffe3, 0xffe3, 1},
 	},
 	R32: []Range32{
-		{0x1f3fb, 0x1f3fb, 1},
-		{0x1f3fc, 0x1f3ff, 1},
+		{0x1f3fb, 0x1f3ff, 1},
 	},
 	LatinOffset: 3,
 }
@@ -3281,8 +3272,7 @@ var _So = &RangeTable{
 		{0xfffd, 0xfffd, 1},
 	},
 	R32: []Range32{
-		{0x10137, 0x10137, 1},
-		{0x10138, 0x1013f, 1},
+		{0x10137, 0x1013f, 1},
 		{0x10179, 0x10189, 1},
 		{0x1018c, 0x1018e, 1},
 		{0x10190, 0x1019b, 1},
@@ -3429,10 +3419,6 @@ var (
 	Zs     = _Zs // Zs is the set of Unicode characters in category Zs (Separator, space).
 )
 
-// Generated by running
-//	maketables --scripts=all --url=http://www.unicode.org/Public/10.0.0/ucd/
-// DO NOT EDIT
-
 // Scripts is the set of Unicode script tables.
 var Scripts = map[string]*RangeTable{
 	"Adlam":                  Adlam,
@@ -3608,9 +3594,8 @@ var _Arabic = &RangeTable{
 		{0x0600, 0x0604, 1},
 		{0x0606, 0x060b, 1},
 		{0x060d, 0x061a, 1},
-		{0x061c, 0x061c, 1},
-		{0x061e, 0x061e, 1},
-		{0x0620, 0x063f, 1},
+		{0x061c, 0x0620, 2},
+		{0x0621, 0x063f, 1},
 		{0x0641, 0x064a, 1},
 		{0x0656, 0x066f, 1},
 		{0x0671, 0x06dc, 1},
@@ -3633,32 +3618,23 @@ var _Arabic = &RangeTable{
 		{0x1ee00, 0x1ee03, 1},
 		{0x1ee05, 0x1ee1f, 1},
 		{0x1ee21, 0x1ee22, 1},
-		{0x1ee24, 0x1ee24, 1},
-		{0x1ee27, 0x1ee27, 1},
+		{0x1ee24, 0x1ee27, 3},
 		{0x1ee29, 0x1ee32, 1},
 		{0x1ee34, 0x1ee37, 1},
-		{0x1ee39, 0x1ee39, 1},
-		{0x1ee3b, 0x1ee3b, 1},
-		{0x1ee42, 0x1ee42, 1},
-		{0x1ee47, 0x1ee47, 1},
-		{0x1ee49, 0x1ee49, 1},
-		{0x1ee4b, 0x1ee4b, 1},
-		{0x1ee4d, 0x1ee4f, 1},
+		{0x1ee39, 0x1ee3b, 2},
+		{0x1ee42, 0x1ee47, 5},
+		{0x1ee49, 0x1ee4d, 2},
+		{0x1ee4e, 0x1ee4f, 1},
 		{0x1ee51, 0x1ee52, 1},
-		{0x1ee54, 0x1ee54, 1},
-		{0x1ee57, 0x1ee57, 1},
-		{0x1ee59, 0x1ee59, 1},
-		{0x1ee5b, 0x1ee5b, 1},
-		{0x1ee5d, 0x1ee5d, 1},
-		{0x1ee5f, 0x1ee5f, 1},
-		{0x1ee61, 0x1ee62, 1},
-		{0x1ee64, 0x1ee64, 1},
+		{0x1ee54, 0x1ee57, 3},
+		{0x1ee59, 0x1ee61, 2},
+		{0x1ee62, 0x1ee64, 2},
 		{0x1ee67, 0x1ee6a, 1},
 		{0x1ee6c, 0x1ee72, 1},
 		{0x1ee74, 0x1ee77, 1},
 		{0x1ee79, 0x1ee7c, 1},
-		{0x1ee7e, 0x1ee7e, 1},
-		{0x1ee80, 0x1ee89, 1},
+		{0x1ee7e, 0x1ee80, 2},
+		{0x1ee81, 0x1ee89, 1},
 		{0x1ee8b, 0x1ee9b, 1},
 		{0x1eea1, 0x1eea3, 1},
 		{0x1eea5, 0x1eea9, 1},
@@ -3672,8 +3648,8 @@ var _Armenian = &RangeTable{
 		{0x0531, 0x0556, 1},
 		{0x0559, 0x055f, 1},
 		{0x0561, 0x0587, 1},
-		{0x058a, 0x058a, 1},
-		{0x058d, 0x058f, 1},
+		{0x058a, 0x058d, 3},
+		{0x058e, 0x058f, 1},
 		{0xfb13, 0xfb17, 1},
 	},
 }
@@ -3724,14 +3700,14 @@ var _Bengali = &RangeTable{
 		{0x098f, 0x0990, 1},
 		{0x0993, 0x09a8, 1},
 		{0x09aa, 0x09b0, 1},
-		{0x09b2, 0x09b2, 1},
-		{0x09b6, 0x09b9, 1},
+		{0x09b2, 0x09b6, 4},
+		{0x09b7, 0x09b9, 1},
 		{0x09bc, 0x09c4, 1},
 		{0x09c7, 0x09c8, 1},
 		{0x09cb, 0x09ce, 1},
-		{0x09d7, 0x09d7, 1},
-		{0x09dc, 0x09dd, 1},
-		{0x09df, 0x09e3, 1},
+		{0x09d7, 0x09dc, 5},
+		{0x09dd, 0x09df, 2},
+		{0x09e0, 0x09e3, 1},
 		{0x09e6, 0x09fd, 1},
 	},
 }
@@ -3836,34 +3812,26 @@ var _Common = &RangeTable{
 		{0x007b, 0x00a9, 1},
 		{0x00ab, 0x00b9, 1},
 		{0x00bb, 0x00bf, 1},
-		{0x00d7, 0x00d7, 1},
-		{0x00f7, 0x00f7, 1},
+		{0x00d7, 0x00f7, 32},
 		{0x02b9, 0x02df, 1},
 		{0x02e5, 0x02e9, 1},
 		{0x02ec, 0x02ff, 1},
-		{0x0374, 0x0374, 1},
-		{0x037e, 0x037e, 1},
-		{0x0385, 0x0385, 1},
-		{0x0387, 0x0387, 1},
-		{0x0589, 0x0589, 1},
-		{0x0605, 0x0605, 1},
-		{0x060c, 0x060c, 1},
-		{0x061b, 0x061b, 1},
-		{0x061f, 0x061f, 1},
-		{0x0640, 0x0640, 1},
-		{0x06dd, 0x06dd, 1},
-		{0x08e2, 0x08e2, 1},
+		{0x0374, 0x037e, 10},
+		{0x0385, 0x0387, 2},
+		{0x0589, 0x0605, 124},
+		{0x060c, 0x061b, 15},
+		{0x061f, 0x0640, 33},
+		{0x06dd, 0x08e2, 517},
 		{0x0964, 0x0965, 1},
-		{0x0e3f, 0x0e3f, 1},
-		{0x0fd5, 0x0fd8, 1},
-		{0x10fb, 0x10fb, 1},
-		{0x16eb, 0x16ed, 1},
+		{0x0e3f, 0x0fd5, 406},
+		{0x0fd6, 0x0fd8, 1},
+		{0x10fb, 0x16eb, 1520},
+		{0x16ec, 0x16ed, 1},
 		{0x1735, 0x1736, 1},
 		{0x1802, 0x1803, 1},
-		{0x1805, 0x1805, 1},
-		{0x1cd3, 0x1cd3, 1},
-		{0x1ce1, 0x1ce1, 1},
-		{0x1ce9, 0x1cec, 1},
+		{0x1805, 0x1cd3, 1230},
+		{0x1ce1, 0x1ce9, 8},
+		{0x1cea, 0x1cec, 1},
 		{0x1cee, 0x1cf3, 1},
 		{0x1cf5, 0x1cf7, 1},
 		{0x2000, 0x200b, 1},
@@ -3890,14 +3858,14 @@ var _Common = &RangeTable{
 		{0x2e00, 0x2e49, 1},
 		{0x2ff0, 0x2ffb, 1},
 		{0x3000, 0x3004, 1},
-		{0x3006, 0x3006, 1},
-		{0x3008, 0x3020, 1},
+		{0x3006, 0x3008, 2},
+		{0x3009, 0x3020, 1},
 		{0x3030, 0x3037, 1},
 		{0x303c, 0x303f, 1},
 		{0x309b, 0x309c, 1},
-		{0x30a0, 0x30a0, 1},
-		{0x30fb, 0x30fc, 1},
-		{0x3190, 0x319f, 1},
+		{0x30a0, 0x30fb, 91},
+		{0x30fc, 0x3190, 148},
+		{0x3191, 0x319f, 1},
 		{0x31c0, 0x31e3, 1},
 		{0x3220, 0x325f, 1},
 		{0x327f, 0x32cf, 1},
@@ -3906,21 +3874,20 @@ var _Common = &RangeTable{
 		{0xa700, 0xa721, 1},
 		{0xa788, 0xa78a, 1},
 		{0xa830, 0xa839, 1},
-		{0xa92e, 0xa92e, 1},
-		{0xa9cf, 0xa9cf, 1},
-		{0xab5b, 0xab5b, 1},
-		{0xfd3e, 0xfd3f, 1},
-		{0xfe10, 0xfe19, 1},
+		{0xa92e, 0xa9cf, 161},
+		{0xab5b, 0xfd3e, 20963},
+		{0xfd3f, 0xfe10, 209},
+		{0xfe11, 0xfe19, 1},
 		{0xfe30, 0xfe52, 1},
 		{0xfe54, 0xfe66, 1},
 		{0xfe68, 0xfe6b, 1},
-		{0xfeff, 0xfeff, 1},
-		{0xff01, 0xff20, 1},
+		{0xfeff, 0xff01, 2},
+		{0xff02, 0xff20, 1},
 		{0xff3b, 0xff40, 1},
 		{0xff5b, 0xff65, 1},
-		{0xff70, 0xff70, 1},
-		{0xff9e, 0xff9f, 1},
-		{0xffe0, 0xffe6, 1},
+		{0xff70, 0xff9e, 46},
+		{0xff9f, 0xffe0, 65},
+		{0xffe1, 0xffe6, 1},
 		{0xffe8, 0xffee, 1},
 		{0xfff9, 0xfffd, 1},
 	},
@@ -3944,12 +3911,12 @@ var _Common = &RangeTable{
 		{0x1d400, 0x1d454, 1},
 		{0x1d456, 0x1d49c, 1},
 		{0x1d49e, 0x1d49f, 1},
-		{0x1d4a2, 0x1d4a2, 1},
-		{0x1d4a5, 0x1d4a6, 1},
-		{0x1d4a9, 0x1d4ac, 1},
+		{0x1d4a2, 0x1d4a5, 3},
+		{0x1d4a6, 0x1d4a9, 3},
+		{0x1d4aa, 0x1d4ac, 1},
 		{0x1d4ae, 0x1d4b9, 1},
-		{0x1d4bb, 0x1d4bb, 1},
-		{0x1d4bd, 0x1d4c3, 1},
+		{0x1d4bb, 0x1d4bd, 2},
+		{0x1d4be, 0x1d4c3, 1},
 		{0x1d4c5, 0x1d505, 1},
 		{0x1d507, 0x1d50a, 1},
 		{0x1d50d, 0x1d514, 1},
@@ -3957,8 +3924,8 @@ var _Common = &RangeTable{
 		{0x1d51e, 0x1d539, 1},
 		{0x1d53b, 0x1d53e, 1},
 		{0x1d540, 0x1d544, 1},
-		{0x1d546, 0x1d546, 1},
-		{0x1d54a, 0x1d550, 1},
+		{0x1d546, 0x1d54a, 4},
+		{0x1d54b, 0x1d550, 1},
 		{0x1d552, 0x1d6a5, 1},
 		{0x1d6a8, 0x1d7cb, 1},
 		{0x1d7ce, 0x1d7ff, 1},
@@ -3993,12 +3960,12 @@ var _Common = &RangeTable{
 		{0x1f940, 0x1f94c, 1},
 		{0x1f950, 0x1f96b, 1},
 		{0x1f980, 0x1f997, 1},
-		{0x1f9c0, 0x1f9c0, 1},
-		{0x1f9d0, 0x1f9e6, 1},
-		{0xe0001, 0xe0001, 1},
-		{0xe0020, 0xe007f, 1},
+		{0x1f9c0, 0x1f9d0, 16},
+		{0x1f9d1, 0x1f9e6, 1},
+		{0xe0001, 0xe0020, 31},
+		{0xe0021, 0xe007f, 1},
 	},
-	LatinOffset: 7,
+	LatinOffset: 6,
 }
 
 var _Coptic = &RangeTable{
@@ -4023,11 +3990,10 @@ var _Cypriot = &RangeTable{
 	R16: []Range16{},
 	R32: []Range32{
 		{0x10800, 0x10805, 1},
-		{0x10808, 0x10808, 1},
-		{0x1080a, 0x10835, 1},
+		{0x10808, 0x1080a, 2},
+		{0x1080b, 0x10835, 1},
 		{0x10837, 0x10838, 1},
-		{0x1083c, 0x1083c, 1},
-		{0x1083f, 0x1083f, 1},
+		{0x1083c, 0x1083f, 3},
 	},
 }
 
@@ -4036,8 +4002,7 @@ var _Cyrillic = &RangeTable{
 		{0x0400, 0x0484, 1},
 		{0x0487, 0x052f, 1},
 		{0x1c80, 0x1c88, 1},
-		{0x1d2b, 0x1d2b, 1},
-		{0x1d78, 0x1d78, 1},
+		{0x1d2b, 0x1d78, 77},
 		{0x2de0, 0x2dff, 1},
 		{0xa640, 0xa69f, 1},
 		{0xfe2e, 0xfe2f, 1},
@@ -4090,15 +4055,15 @@ var _Ethiopic = &RangeTable{
 		{0x1200, 0x1248, 1},
 		{0x124a, 0x124d, 1},
 		{0x1250, 0x1256, 1},
-		{0x1258, 0x1258, 1},
-		{0x125a, 0x125d, 1},
+		{0x1258, 0x125a, 2},
+		{0x125b, 0x125d, 1},
 		{0x1260, 0x1288, 1},
 		{0x128a, 0x128d, 1},
 		{0x1290, 0x12b0, 1},
 		{0x12b2, 0x12b5, 1},
 		{0x12b8, 0x12be, 1},
-		{0x12c0, 0x12c0, 1},
-		{0x12c2, 0x12c5, 1},
+		{0x12c0, 0x12c2, 2},
+		{0x12c3, 0x12c5, 1},
 		{0x12c8, 0x12d6, 1},
 		{0x12d8, 0x1310, 1},
 		{0x1312, 0x1315, 1},
@@ -4125,13 +4090,11 @@ var _Ethiopic = &RangeTable{
 var _Georgian = &RangeTable{
 	R16: []Range16{
 		{0x10a0, 0x10c5, 1},
-		{0x10c7, 0x10c7, 1},
-		{0x10cd, 0x10cd, 1},
+		{0x10c7, 0x10cd, 6},
 		{0x10d0, 0x10fa, 1},
 		{0x10fc, 0x10ff, 1},
 		{0x2d00, 0x2d25, 1},
-		{0x2d27, 0x2d27, 1},
-		{0x2d2d, 0x2d2d, 1},
+		{0x2d27, 0x2d2d, 6},
 	},
 }
 
@@ -4169,8 +4132,7 @@ var _Grantha = &RangeTable{
 		{0x1133c, 0x11344, 1},
 		{0x11347, 0x11348, 1},
 		{0x1134b, 0x1134d, 1},
-		{0x11350, 0x11350, 1},
-		{0x11357, 0x11357, 1},
+		{0x11350, 0x11357, 7},
 		{0x1135d, 0x11363, 1},
 		{0x11366, 0x1136c, 1},
 		{0x11370, 0x11374, 1},
@@ -4182,27 +4144,24 @@ var _Greek = &RangeTable{
 		{0x0370, 0x0373, 1},
 		{0x0375, 0x0377, 1},
 		{0x037a, 0x037d, 1},
-		{0x037f, 0x037f, 1},
-		{0x0384, 0x0384, 1},
-		{0x0386, 0x0386, 1},
-		{0x0388, 0x038a, 1},
-		{0x038c, 0x038c, 1},
-		{0x038e, 0x03a1, 1},
+		{0x037f, 0x0384, 5},
+		{0x0386, 0x0388, 2},
+		{0x0389, 0x038a, 1},
+		{0x038c, 0x038e, 2},
+		{0x038f, 0x03a1, 1},
 		{0x03a3, 0x03e1, 1},
 		{0x03f0, 0x03ff, 1},
 		{0x1d26, 0x1d2a, 1},
 		{0x1d5d, 0x1d61, 1},
 		{0x1d66, 0x1d6a, 1},
-		{0x1dbf, 0x1dbf, 1},
-		{0x1f00, 0x1f15, 1},
+		{0x1dbf, 0x1f00, 321},
+		{0x1f01, 0x1f15, 1},
 		{0x1f18, 0x1f1d, 1},
 		{0x1f20, 0x1f45, 1},
 		{0x1f48, 0x1f4d, 1},
 		{0x1f50, 0x1f57, 1},
-		{0x1f59, 0x1f59, 1},
-		{0x1f5b, 0x1f5b, 1},
-		{0x1f5d, 0x1f5d, 1},
-		{0x1f5f, 0x1f7d, 1},
+		{0x1f59, 0x1f5f, 2},
+		{0x1f60, 0x1f7d, 1},
 		{0x1f80, 0x1fb4, 1},
 		{0x1fb6, 0x1fc4, 1},
 		{0x1fc6, 0x1fd3, 1},
@@ -4210,13 +4169,12 @@ var _Greek = &RangeTable{
 		{0x1fdd, 0x1fef, 1},
 		{0x1ff2, 0x1ff4, 1},
 		{0x1ff6, 0x1ffe, 1},
-		{0x2126, 0x2126, 1},
-		{0xab65, 0xab65, 1},
+		{0x2126, 0xab65, 35391},
 	},
 	R32: []Range32{
 		{0x10140, 0x1018e, 1},
-		{0x101a0, 0x101a0, 1},
-		{0x1d200, 0x1d245, 1},
+		{0x101a0, 0x1d200, 53344},
+		{0x1d201, 0x1d245, 1},
 	},
 }
 
@@ -4232,8 +4190,8 @@ var _Gujarati = &RangeTable{
 		{0x0abc, 0x0ac5, 1},
 		{0x0ac7, 0x0ac9, 1},
 		{0x0acb, 0x0acd, 1},
-		{0x0ad0, 0x0ad0, 1},
-		{0x0ae0, 0x0ae3, 1},
+		{0x0ad0, 0x0ae0, 16},
+		{0x0ae1, 0x0ae3, 1},
 		{0x0ae6, 0x0af1, 1},
 		{0x0af9, 0x0aff, 1},
 	},
@@ -4249,14 +4207,14 @@ var _Gurmukhi = &RangeTable{
 		{0x0a32, 0x0a33, 1},
 		{0x0a35, 0x0a36, 1},
 		{0x0a38, 0x0a39, 1},
-		{0x0a3c, 0x0a3c, 1},
-		{0x0a3e, 0x0a42, 1},
+		{0x0a3c, 0x0a3e, 2},
+		{0x0a3f, 0x0a42, 1},
 		{0x0a47, 0x0a48, 1},
 		{0x0a4b, 0x0a4d, 1},
-		{0x0a51, 0x0a51, 1},
-		{0x0a59, 0x0a5c, 1},
-		{0x0a5e, 0x0a5e, 1},
-		{0x0a66, 0x0a75, 1},
+		{0x0a51, 0x0a59, 8},
+		{0x0a5a, 0x0a5c, 1},
+		{0x0a5e, 0x0a66, 8},
+		{0x0a67, 0x0a75, 1},
 	},
 }
 
@@ -4265,8 +4223,7 @@ var _Han = &RangeTable{
 		{0x2e80, 0x2e99, 1},
 		{0x2e9b, 0x2ef3, 1},
 		{0x2f00, 0x2fd5, 1},
-		{0x3005, 0x3005, 1},
-		{0x3007, 0x3007, 1},
+		{0x3005, 0x3007, 2},
 		{0x3021, 0x3029, 1},
 		{0x3038, 0x303b, 1},
 		{0x3400, 0x4db5, 1},
@@ -4325,10 +4282,10 @@ var _Hebrew = &RangeTable{
 		{0x05f0, 0x05f4, 1},
 		{0xfb1d, 0xfb36, 1},
 		{0xfb38, 0xfb3c, 1},
-		{0xfb3e, 0xfb3e, 1},
-		{0xfb40, 0xfb41, 1},
-		{0xfb43, 0xfb44, 1},
-		{0xfb46, 0xfb4f, 1},
+		{0xfb3e, 0xfb40, 2},
+		{0xfb41, 0xfb43, 2},
+		{0xfb44, 0xfb46, 2},
+		{0xfb47, 0xfb4f, 1},
 	},
 }
 
@@ -4356,14 +4313,13 @@ var _Inherited = &RangeTable{
 		{0x0300, 0x036f, 1},
 		{0x0485, 0x0486, 1},
 		{0x064b, 0x0655, 1},
-		{0x0670, 0x0670, 1},
-		{0x0951, 0x0952, 1},
-		{0x1ab0, 0x1abe, 1},
+		{0x0670, 0x0951, 737},
+		{0x0952, 0x1ab0, 4446},
+		{0x1ab1, 0x1abe, 1},
 		{0x1cd0, 0x1cd2, 1},
 		{0x1cd4, 0x1ce0, 1},
 		{0x1ce2, 0x1ce8, 1},
-		{0x1ced, 0x1ced, 1},
-		{0x1cf4, 0x1cf4, 1},
+		{0x1ced, 0x1cf4, 7},
 		{0x1cf8, 0x1cf9, 1},
 		{0x1dc0, 0x1df9, 1},
 		{0x1dfb, 0x1dff, 1},
@@ -4375,8 +4331,7 @@ var _Inherited = &RangeTable{
 		{0xfe20, 0xfe2d, 1},
 	},
 	R32: []Range32{
-		{0x101fd, 0x101fd, 1},
-		{0x102e0, 0x102e0, 1},
+		{0x101fd, 0x102e0, 227},
 		{0x1d167, 0x1d169, 1},
 		{0x1d17b, 0x1d182, 1},
 		{0x1d185, 0x1d18b, 1},
@@ -4428,8 +4383,8 @@ var _Kannada = &RangeTable{
 		{0x0cc6, 0x0cc8, 1},
 		{0x0cca, 0x0ccd, 1},
 		{0x0cd5, 0x0cd6, 1},
-		{0x0cde, 0x0cde, 1},
-		{0x0ce0, 0x0ce3, 1},
+		{0x0cde, 0x0ce0, 2},
+		{0x0ce1, 0x0ce3, 1},
 		{0x0ce6, 0x0cef, 1},
 		{0x0cf1, 0x0cf2, 1},
 	},
@@ -4499,21 +4454,19 @@ var _Khudawadi = &RangeTable{
 var _Lao = &RangeTable{
 	R16: []Range16{
 		{0x0e81, 0x0e82, 1},
-		{0x0e84, 0x0e84, 1},
-		{0x0e87, 0x0e88, 1},
-		{0x0e8a, 0x0e8a, 1},
-		{0x0e8d, 0x0e8d, 1},
-		{0x0e94, 0x0e97, 1},
+		{0x0e84, 0x0e87, 3},
+		{0x0e88, 0x0e8a, 2},
+		{0x0e8d, 0x0e94, 7},
+		{0x0e95, 0x0e97, 1},
 		{0x0e99, 0x0e9f, 1},
 		{0x0ea1, 0x0ea3, 1},
-		{0x0ea5, 0x0ea5, 1},
-		{0x0ea7, 0x0ea7, 1},
+		{0x0ea5, 0x0ea7, 2},
 		{0x0eaa, 0x0eab, 1},
 		{0x0ead, 0x0eb9, 1},
 		{0x0ebb, 0x0ebd, 1},
 		{0x0ec0, 0x0ec4, 1},
-		{0x0ec6, 0x0ec6, 1},
-		{0x0ec8, 0x0ecd, 1},
+		{0x0ec6, 0x0ec8, 2},
+		{0x0ec9, 0x0ecd, 1},
 		{0x0ed0, 0x0ed9, 1},
 		{0x0edc, 0x0edf, 1},
 	},
@@ -4523,8 +4476,7 @@ var _Latin = &RangeTable{
 	R16: []Range16{
 		{0x0041, 0x005a, 1},
 		{0x0061, 0x007a, 1},
-		{0x00aa, 0x00aa, 1},
-		{0x00ba, 0x00ba, 1},
+		{0x00aa, 0x00ba, 16},
 		{0x00c0, 0x00d6, 1},
 		{0x00d8, 0x00f6, 1},
 		{0x00f8, 0x02b8, 1},
@@ -4535,12 +4487,10 @@ var _Latin = &RangeTable{
 		{0x1d6b, 0x1d77, 1},
 		{0x1d79, 0x1dbe, 1},
 		{0x1e00, 0x1eff, 1},
-		{0x2071, 0x2071, 1},
-		{0x207f, 0x207f, 1},
+		{0x2071, 0x207f, 14},
 		{0x2090, 0x209c, 1},
 		{0x212a, 0x212b, 1},
-		{0x2132, 0x2132, 1},
-		{0x214e, 0x214e, 1},
+		{0x2132, 0x214e, 28},
 		{0x2160, 0x2188, 1},
 		{0x2c60, 0x2c7f, 1},
 		{0xa722, 0xa787, 1},
@@ -4553,7 +4503,7 @@ var _Latin = &RangeTable{
 		{0xff21, 0xff3a, 1},
 		{0xff41, 0xff5a, 1},
 	},
-	LatinOffset: 6,
+	LatinOffset: 5,
 }
 
 var _Lepcha = &RangeTable{
@@ -4569,8 +4519,8 @@ var _Limbu = &RangeTable{
 		{0x1900, 0x191e, 1},
 		{0x1920, 0x192b, 1},
 		{0x1930, 0x193b, 1},
-		{0x1940, 0x1940, 1},
-		{0x1944, 0x194f, 1},
+		{0x1940, 0x1944, 4},
+		{0x1945, 0x194f, 1},
 	},
 }
 
@@ -4667,9 +4617,9 @@ var _Masaram_Gondi = &RangeTable{
 		{0x11d00, 0x11d06, 1},
 		{0x11d08, 0x11d09, 1},
 		{0x11d0b, 0x11d36, 1},
-		{0x11d3a, 0x11d3a, 1},
-		{0x11d3c, 0x11d3d, 1},
-		{0x11d3f, 0x11d47, 1},
+		{0x11d3a, 0x11d3c, 2},
+		{0x11d3d, 0x11d3f, 2},
+		{0x11d40, 0x11d47, 1},
 		{0x11d50, 0x11d59, 1},
 	},
 }
@@ -4726,8 +4676,8 @@ var _Modi = &RangeTable{
 var _Mongolian = &RangeTable{
 	R16: []Range16{
 		{0x1800, 0x1801, 1},
-		{0x1804, 0x1804, 1},
-		{0x1806, 0x180e, 1},
+		{0x1804, 0x1806, 2},
+		{0x1807, 0x180e, 1},
 		{0x1810, 0x1819, 1},
 		{0x1820, 0x1877, 1},
 		{0x1880, 0x18aa, 1},
@@ -4750,8 +4700,8 @@ var _Multani = &RangeTable{
 	R16: []Range16{},
 	R32: []Range32{
 		{0x11280, 0x11286, 1},
-		{0x11288, 0x11288, 1},
-		{0x1128a, 0x1128d, 1},
+		{0x11288, 0x1128a, 2},
+		{0x1128b, 0x1128d, 1},
 		{0x1128f, 0x1129d, 1},
 		{0x1129f, 0x112a9, 1},
 	},
@@ -4786,8 +4736,7 @@ var _Newa = &RangeTable{
 	R16: []Range16{},
 	R32: []Range32{
 		{0x11400, 0x11459, 1},
-		{0x1145b, 0x1145b, 1},
-		{0x1145d, 0x1145d, 1},
+		{0x1145b, 0x1145d, 2},
 	},
 }
 
@@ -4800,8 +4749,8 @@ var _Nko = &RangeTable{
 var _Nushu = &RangeTable{
 	R16: []Range16{},
 	R32: []Range32{
-		{0x16fe1, 0x16fe1, 1},
-		{0x1b170, 0x1b2fb, 1},
+		{0x16fe1, 0x1b170, 16783},
+		{0x1b171, 0x1b2fb, 1},
 	},
 }
 
@@ -5019,12 +4968,12 @@ var _Sinhala = &RangeTable{
 		{0x0d85, 0x0d96, 1},
 		{0x0d9a, 0x0db1, 1},
 		{0x0db3, 0x0dbb, 1},
-		{0x0dbd, 0x0dbd, 1},
-		{0x0dc0, 0x0dc6, 1},
-		{0x0dca, 0x0dca, 1},
-		{0x0dcf, 0x0dd4, 1},
-		{0x0dd6, 0x0dd6, 1},
-		{0x0dd8, 0x0ddf, 1},
+		{0x0dbd, 0x0dc0, 3},
+		{0x0dc1, 0x0dc6, 1},
+		{0x0dca, 0x0dcf, 5},
+		{0x0dd0, 0x0dd4, 1},
+		{0x0dd6, 0x0dd8, 2},
+		{0x0dd9, 0x0ddf, 1},
 		{0x0de6, 0x0def, 1},
 		{0x0df2, 0x0df4, 1},
 	},
@@ -5126,16 +5075,15 @@ var _Tamil = &RangeTable{
 		{0x0b8e, 0x0b90, 1},
 		{0x0b92, 0x0b95, 1},
 		{0x0b99, 0x0b9a, 1},
-		{0x0b9c, 0x0b9c, 1},
-		{0x0b9e, 0x0b9f, 1},
-		{0x0ba3, 0x0ba4, 1},
-		{0x0ba8, 0x0baa, 1},
+		{0x0b9c, 0x0b9e, 2},
+		{0x0b9f, 0x0ba3, 4},
+		{0x0ba4, 0x0ba8, 4},
+		{0x0ba9, 0x0baa, 1},
 		{0x0bae, 0x0bb9, 1},
 		{0x0bbe, 0x0bc2, 1},
 		{0x0bc6, 0x0bc8, 1},
 		{0x0bca, 0x0bcd, 1},
-		{0x0bd0, 0x0bd0, 1},
-		{0x0bd7, 0x0bd7, 1},
+		{0x0bd0, 0x0bd7, 7},
 		{0x0be6, 0x0bfa, 1},
 	},
 }
@@ -5143,8 +5091,8 @@ var _Tamil = &RangeTable{
 var _Tangut = &RangeTable{
 	R16: []Range16{},
 	R32: []Range32{
-		{0x16fe0, 0x16fe0, 1},
-		{0x17000, 0x187ec, 1},
+		{0x16fe0, 0x17000, 32},
+		{0x17001, 0x187ec, 1},
 		{0x18800, 0x18af2, 1},
 	},
 }
@@ -5389,10 +5337,6 @@ var (
 	Zanabazar_Square       = _Zanabazar_Square       // Zanabazar_Square is the set of Unicode characters in script Zanabazar_Square.
 )
 
-// Generated by running
-//	maketables --props=all --url=http://www.unicode.org/Public/10.0.0/ucd/
-// DO NOT EDIT
-
 // Properties is the set of Unicode property tables.
 var Properties = map[string]*RangeTable{
 	"ASCII_Hex_Digit":                    ASCII_Hex_Digit,
@@ -5443,46 +5387,35 @@ var _ASCII_Hex_Digit = &RangeTable{
 
 var _Bidi_Control = &RangeTable{
 	R16: []Range16{
-		{0x061c, 0x061c, 1},
-		{0x200e, 0x200f, 1},
-		{0x202a, 0x202e, 1},
+		{0x061c, 0x200e, 6642},
+		{0x200f, 0x202a, 27},
+		{0x202b, 0x202e, 1},
 		{0x2066, 0x2069, 1},
 	},
 }
 
 var _Dash = &RangeTable{
 	R16: []Range16{
-		{0x002d, 0x002d, 1},
-		{0x058a, 0x058a, 1},
-		{0x05be, 0x05be, 1},
-		{0x1400, 0x1400, 1},
-		{0x1806, 0x1806, 1},
-		{0x2010, 0x2015, 1},
-		{0x2053, 0x2053, 1},
-		{0x207b, 0x207b, 1},
-		{0x208b, 0x208b, 1},
-		{0x2212, 0x2212, 1},
-		{0x2e17, 0x2e17, 1},
-		{0x2e1a, 0x2e1a, 1},
+		{0x002d, 0x058a, 1373},
+		{0x05be, 0x1400, 3650},
+		{0x1806, 0x2010, 2058},
+		{0x2011, 0x2015, 1},
+		{0x2053, 0x207b, 40},
+		{0x208b, 0x2212, 391},
+		{0x2e17, 0x2e1a, 3},
 		{0x2e3a, 0x2e3b, 1},
-		{0x2e40, 0x2e40, 1},
-		{0x301c, 0x301c, 1},
-		{0x3030, 0x3030, 1},
-		{0x30a0, 0x30a0, 1},
+		{0x2e40, 0x301c, 476},
+		{0x3030, 0x30a0, 112},
 		{0xfe31, 0xfe32, 1},
-		{0xfe58, 0xfe58, 1},
-		{0xfe63, 0xfe63, 1},
+		{0xfe58, 0xfe63, 11},
 		{0xff0d, 0xff0d, 1},
 	},
-	LatinOffset: 1,
 }
 
 var _Deprecated = &RangeTable{
 	R16: []Range16{
-		{0x0149, 0x0149, 1},
-		{0x0673, 0x0673, 1},
-		{0x0f77, 0x0f77, 1},
-		{0x0f79, 0x0f79, 1},
+		{0x0149, 0x0673, 1322},
+		{0x0f77, 0x0f79, 2},
 		{0x17a3, 0x17a4, 1},
 		{0x206a, 0x206f, 1},
 		{0x2329, 0x232a, 1},
@@ -5494,25 +5427,22 @@ var _Deprecated = &RangeTable{
 
 var _Diacritic = &RangeTable{
 	R16: []Range16{
-		{0x005e, 0x005e, 1},
-		{0x0060, 0x0060, 1},
-		{0x00a8, 0x00a8, 1},
-		{0x00af, 0x00af, 1},
-		{0x00b4, 0x00b4, 1},
-		{0x00b7, 0x00b8, 1},
-		{0x02b0, 0x034e, 1},
+		{0x005e, 0x0060, 2},
+		{0x00a8, 0x00af, 7},
+		{0x00b4, 0x00b7, 3},
+		{0x00b8, 0x02b0, 504},
+		{0x02b1, 0x034e, 1},
 		{0x0350, 0x0357, 1},
 		{0x035d, 0x0362, 1},
 		{0x0374, 0x0375, 1},
-		{0x037a, 0x037a, 1},
-		{0x0384, 0x0385, 1},
-		{0x0483, 0x0487, 1},
-		{0x0559, 0x0559, 1},
-		{0x0591, 0x05a1, 1},
+		{0x037a, 0x0384, 10},
+		{0x0385, 0x0483, 254},
+		{0x0484, 0x0487, 1},
+		{0x0559, 0x0591, 56},
+		{0x0592, 0x05a1, 1},
 		{0x05a3, 0x05bd, 1},
-		{0x05bf, 0x05bf, 1},
-		{0x05c1, 0x05c2, 1},
-		{0x05c4, 0x05c4, 1},
+		{0x05bf, 0x05c1, 2},
+		{0x05c2, 0x05c4, 2},
 		{0x064b, 0x0652, 1},
 		{0x0657, 0x0658, 1},
 		{0x06df, 0x06e0, 1},
@@ -5523,129 +5453,104 @@ var _Diacritic = &RangeTable{
 		{0x07eb, 0x07f5, 1},
 		{0x0818, 0x0819, 1},
 		{0x08e3, 0x08fe, 1},
-		{0x093c, 0x093c, 1},
-		{0x094d, 0x094d, 1},
+		{0x093c, 0x094d, 17},
 		{0x0951, 0x0954, 1},
-		{0x0971, 0x0971, 1},
-		{0x09bc, 0x09bc, 1},
-		{0x09cd, 0x09cd, 1},
-		{0x0a3c, 0x0a3c, 1},
-		{0x0a4d, 0x0a4d, 1},
-		{0x0abc, 0x0abc, 1},
-		{0x0acd, 0x0acd, 1},
-		{0x0afd, 0x0aff, 1},
-		{0x0b3c, 0x0b3c, 1},
-		{0x0b4d, 0x0b4d, 1},
-		{0x0bcd, 0x0bcd, 1},
-		{0x0c4d, 0x0c4d, 1},
-		{0x0cbc, 0x0cbc, 1},
-		{0x0ccd, 0x0ccd, 1},
+		{0x0971, 0x09bc, 75},
+		{0x09cd, 0x0a3c, 111},
+		{0x0a4d, 0x0abc, 111},
+		{0x0acd, 0x0afd, 48},
+		{0x0afe, 0x0aff, 1},
+		{0x0b3c, 0x0b4d, 17},
+		{0x0bcd, 0x0c4d, 128},
+		{0x0cbc, 0x0ccd, 17},
 		{0x0d3b, 0x0d3c, 1},
-		{0x0d4d, 0x0d4d, 1},
-		{0x0dca, 0x0dca, 1},
-		{0x0e47, 0x0e4c, 1},
-		{0x0e4e, 0x0e4e, 1},
-		{0x0ec8, 0x0ecc, 1},
+		{0x0d4d, 0x0e47, 125},
+		{0x0e48, 0x0e4c, 1},
+		{0x0e4e, 0x0ec8, 122},
+		{0x0ec9, 0x0ecc, 1},
 		{0x0f18, 0x0f19, 1},
-		{0x0f35, 0x0f35, 1},
-		{0x0f37, 0x0f37, 1},
-		{0x0f39, 0x0f39, 1},
+		{0x0f35, 0x0f39, 2},
 		{0x0f3e, 0x0f3f, 1},
 		{0x0f82, 0x0f84, 1},
 		{0x0f86, 0x0f87, 1},
-		{0x0fc6, 0x0fc6, 1},
-		{0x1037, 0x1037, 1},
+		{0x0fc6, 0x1037, 113},
 		{0x1039, 0x103a, 1},
 		{0x1087, 0x108d, 1},
-		{0x108f, 0x108f, 1},
-		{0x109a, 0x109b, 1},
-		{0x17c9, 0x17d3, 1},
-		{0x17dd, 0x17dd, 1},
-		{0x1939, 0x193b, 1},
+		{0x108f, 0x109a, 11},
+		{0x109b, 0x17c9, 1838},
+		{0x17ca, 0x17d3, 1},
+		{0x17dd, 0x1939, 348},
+		{0x193a, 0x193b, 1},
 		{0x1a75, 0x1a7c, 1},
-		{0x1a7f, 0x1a7f, 1},
-		{0x1ab0, 0x1abd, 1},
-		{0x1b34, 0x1b34, 1},
-		{0x1b44, 0x1b44, 1},
+		{0x1a7f, 0x1ab0, 49},
+		{0x1ab1, 0x1abd, 1},
+		{0x1b34, 0x1b44, 16},
 		{0x1b6b, 0x1b73, 1},
 		{0x1baa, 0x1bab, 1},
 		{0x1c36, 0x1c37, 1},
 		{0x1c78, 0x1c7d, 1},
 		{0x1cd0, 0x1ce8, 1},
-		{0x1ced, 0x1ced, 1},
-		{0x1cf4, 0x1cf4, 1},
+		{0x1ced, 0x1cf4, 7},
 		{0x1cf7, 0x1cf9, 1},
 		{0x1d2c, 0x1d6a, 1},
 		{0x1dc4, 0x1dcf, 1},
 		{0x1df5, 0x1df9, 1},
 		{0x1dfd, 0x1dff, 1},
-		{0x1fbd, 0x1fbd, 1},
-		{0x1fbf, 0x1fc1, 1},
+		{0x1fbd, 0x1fbf, 2},
+		{0x1fc0, 0x1fc1, 1},
 		{0x1fcd, 0x1fcf, 1},
 		{0x1fdd, 0x1fdf, 1},
 		{0x1fed, 0x1fef, 1},
 		{0x1ffd, 0x1ffe, 1},
 		{0x2cef, 0x2cf1, 1},
-		{0x2e2f, 0x2e2f, 1},
-		{0x302a, 0x302f, 1},
+		{0x2e2f, 0x302a, 507},
+		{0x302b, 0x302f, 1},
 		{0x3099, 0x309c, 1},
-		{0x30fc, 0x30fc, 1},
-		{0xa66f, 0xa66f, 1},
+		{0x30fc, 0xa66f, 30067},
 		{0xa67c, 0xa67d, 1},
-		{0xa67f, 0xa67f, 1},
-		{0xa69c, 0xa69d, 1},
-		{0xa6f0, 0xa6f1, 1},
-		{0xa717, 0xa721, 1},
-		{0xa788, 0xa788, 1},
-		{0xa7f8, 0xa7f9, 1},
-		{0xa8c4, 0xa8c4, 1},
+		{0xa67f, 0xa69c, 29},
+		{0xa69d, 0xa6f0, 83},
+		{0xa6f1, 0xa717, 38},
+		{0xa718, 0xa721, 1},
+		{0xa788, 0xa7f8, 112},
+		{0xa7f9, 0xa8c4, 203},
 		{0xa8e0, 0xa8f1, 1},
 		{0xa92b, 0xa92e, 1},
-		{0xa953, 0xa953, 1},
-		{0xa9b3, 0xa9b3, 1},
-		{0xa9c0, 0xa9c0, 1},
-		{0xa9e5, 0xa9e5, 1},
+		{0xa953, 0xa9b3, 96},
+		{0xa9c0, 0xa9e5, 37},
 		{0xaa7b, 0xaa7d, 1},
 		{0xaabf, 0xaac2, 1},
-		{0xaaf6, 0xaaf6, 1},
-		{0xab5b, 0xab5f, 1},
+		{0xaaf6, 0xab5b, 101},
+		{0xab5c, 0xab5f, 1},
 		{0xabec, 0xabed, 1},
-		{0xfb1e, 0xfb1e, 1},
-		{0xfe20, 0xfe2f, 1},
-		{0xff3e, 0xff3e, 1},
-		{0xff40, 0xff40, 1},
-		{0xff70, 0xff70, 1},
-		{0xff9e, 0xff9f, 1},
-		{0xffe3, 0xffe3, 1},
+		{0xfb1e, 0xfe20, 770},
+		{0xfe21, 0xfe2f, 1},
+		{0xff3e, 0xff40, 2},
+		{0xff70, 0xff9e, 46},
+		{0xff9f, 0xffe3, 68},
 	},
 	R32: []Range32{
-		{0x102e0, 0x102e0, 1},
-		{0x10ae5, 0x10ae6, 1},
-		{0x110b9, 0x110ba, 1},
-		{0x11133, 0x11134, 1},
-		{0x11173, 0x11173, 1},
-		{0x111c0, 0x111c0, 1},
-		{0x111ca, 0x111cc, 1},
+		{0x102e0, 0x10ae5, 2053},
+		{0x10ae6, 0x110b9, 1491},
+		{0x110ba, 0x11133, 121},
+		{0x11134, 0x11173, 63},
+		{0x111c0, 0x111ca, 10},
+		{0x111cb, 0x111cc, 1},
 		{0x11235, 0x11236, 1},
 		{0x112e9, 0x112ea, 1},
-		{0x1133c, 0x1133c, 1},
-		{0x1134d, 0x1134d, 1},
+		{0x1133c, 0x1134d, 17},
 		{0x11366, 0x1136c, 1},
 		{0x11370, 0x11374, 1},
-		{0x11442, 0x11442, 1},
-		{0x11446, 0x11446, 1},
+		{0x11442, 0x11446, 4},
 		{0x114c2, 0x114c3, 1},
 		{0x115bf, 0x115c0, 1},
-		{0x1163f, 0x1163f, 1},
-		{0x116b6, 0x116b7, 1},
-		{0x1172b, 0x1172b, 1},
-		{0x11a34, 0x11a34, 1},
-		{0x11a47, 0x11a47, 1},
-		{0x11a99, 0x11a99, 1},
-		{0x11c3f, 0x11c3f, 1},
-		{0x11d42, 0x11d42, 1},
-		{0x11d44, 0x11d45, 1},
-		{0x16af0, 0x16af4, 1},
+		{0x1163f, 0x116b6, 119},
+		{0x116b7, 0x1172b, 116},
+		{0x11a34, 0x11a47, 19},
+		{0x11a99, 0x11c3f, 422},
+		{0x11d42, 0x11d44, 2},
+		{0x11d45, 0x16af0, 19883},
+		{0x16af1, 0x16af4, 1},
 		{0x16f8f, 0x16f9f, 1},
 		{0x1d167, 0x1d169, 1},
 		{0x1d16d, 0x1d172, 1},
@@ -5656,44 +5561,35 @@ var _Diacritic = &RangeTable{
 		{0x1e944, 0x1e946, 1},
 		{0x1e948, 0x1e94a, 1},
 	},
-	LatinOffset: 6,
+	LatinOffset: 3,
 }
 
 var _Extender = &RangeTable{
 	R16: []Range16{
-		{0x00b7, 0x00b7, 1},
-		{0x02d0, 0x02d1, 1},
-		{0x0640, 0x0640, 1},
-		{0x07fa, 0x07fa, 1},
-		{0x0e46, 0x0e46, 1},
-		{0x0ec6, 0x0ec6, 1},
-		{0x180a, 0x180a, 1},
-		{0x1843, 0x1843, 1},
-		{0x1aa7, 0x1aa7, 1},
-		{0x1c36, 0x1c36, 1},
-		{0x1c7b, 0x1c7b, 1},
-		{0x3005, 0x3005, 1},
-		{0x3031, 0x3035, 1},
+		{0x00b7, 0x02d0, 537},
+		{0x02d1, 0x0640, 879},
+		{0x07fa, 0x0e46, 1612},
+		{0x0ec6, 0x180a, 2372},
+		{0x1843, 0x1aa7, 612},
+		{0x1c36, 0x1c7b, 69},
+		{0x3005, 0x3031, 44},
+		{0x3032, 0x3035, 1},
 		{0x309d, 0x309e, 1},
 		{0x30fc, 0x30fe, 1},
-		{0xa015, 0xa015, 1},
-		{0xa60c, 0xa60c, 1},
-		{0xa9cf, 0xa9cf, 1},
-		{0xa9e6, 0xa9e6, 1},
-		{0xaa70, 0xaa70, 1},
-		{0xaadd, 0xaadd, 1},
+		{0xa015, 0xa60c, 1527},
+		{0xa9cf, 0xa9e6, 23},
+		{0xaa70, 0xaadd, 109},
 		{0xaaf3, 0xaaf4, 1},
 		{0xff70, 0xff70, 1},
 	},
 	R32: []Range32{
-		{0x1135d, 0x1135d, 1},
-		{0x115c6, 0x115c8, 1},
-		{0x11a98, 0x11a98, 1},
-		{0x16b42, 0x16b43, 1},
-		{0x16fe0, 0x16fe1, 1},
-		{0x1e944, 0x1e946, 1},
+		{0x1135d, 0x115c6, 617},
+		{0x115c7, 0x115c8, 1},
+		{0x11a98, 0x16b42, 20650},
+		{0x16b43, 0x16fe0, 1181},
+		{0x16fe1, 0x1e944, 31075},
+		{0x1e945, 0x1e946, 1},
 	},
-	LatinOffset: 1,
 }
 
 var _Hex_Digit = &RangeTable{
@@ -5710,18 +5606,14 @@ var _Hex_Digit = &RangeTable{
 
 var _Hyphen = &RangeTable{
 	R16: []Range16{
-		{0x002d, 0x002d, 1},
-		{0x00ad, 0x00ad, 1},
-		{0x058a, 0x058a, 1},
-		{0x1806, 0x1806, 1},
+		{0x002d, 0x00ad, 128},
+		{0x058a, 0x1806, 4732},
 		{0x2010, 0x2011, 1},
-		{0x2e17, 0x2e17, 1},
-		{0x30fb, 0x30fb, 1},
-		{0xfe63, 0xfe63, 1},
-		{0xff0d, 0xff0d, 1},
+		{0x2e17, 0x30fb, 740},
+		{0xfe63, 0xff0d, 170},
 		{0xff65, 0xff65, 1},
 	},
-	LatinOffset: 2,
+	LatinOffset: 1,
 }
 
 var _IDS_Binary_Operator = &RangeTable{
@@ -5771,9 +5663,8 @@ var _Logical_Order_Exception = &RangeTable{
 		{0x0e40, 0x0e44, 1},
 		{0x0ec0, 0x0ec4, 1},
 		{0x19b5, 0x19b7, 1},
-		{0x19ba, 0x19ba, 1},
-		{0xaab5, 0xaab6, 1},
-		{0xaab9, 0xaab9, 1},
+		{0x19ba, 0xaab5, 37115},
+		{0xaab6, 0xaab9, 3},
 		{0xaabb, 0xaabc, 1},
 	},
 }
@@ -5805,21 +5696,19 @@ var _Noncharacter_Code_Point = &RangeTable{
 
 var _Other_Alphabetic = &RangeTable{
 	R16: []Range16{
-		{0x0345, 0x0345, 1},
-		{0x05b0, 0x05bd, 1},
-		{0x05bf, 0x05bf, 1},
-		{0x05c1, 0x05c2, 1},
-		{0x05c4, 0x05c5, 1},
-		{0x05c7, 0x05c7, 1},
+		{0x0345, 0x05b0, 619},
+		{0x05b1, 0x05bd, 1},
+		{0x05bf, 0x05c1, 2},
+		{0x05c2, 0x05c4, 2},
+		{0x05c5, 0x05c7, 2},
 		{0x0610, 0x061a, 1},
 		{0x064b, 0x0657, 1},
 		{0x0659, 0x065f, 1},
-		{0x0670, 0x0670, 1},
-		{0x06d6, 0x06dc, 1},
+		{0x0670, 0x06d6, 102},
+		{0x06d7, 0x06dc, 1},
 		{0x06e1, 0x06e4, 1},
 		{0x06e7, 0x06e8, 1},
-		{0x06ed, 0x06ed, 1},
-		{0x0711, 0x0711, 1},
+		{0x06ed, 0x0711, 36},
 		{0x0730, 0x073f, 1},
 		{0x07a6, 0x07b0, 1},
 		{0x0816, 0x0817, 1},
@@ -5838,15 +5727,14 @@ var _Other_Alphabetic = &RangeTable{
 		{0x09be, 0x09c4, 1},
 		{0x09c7, 0x09c8, 1},
 		{0x09cb, 0x09cc, 1},
-		{0x09d7, 0x09d7, 1},
-		{0x09e2, 0x09e3, 1},
-		{0x0a01, 0x0a03, 1},
+		{0x09d7, 0x09e2, 11},
+		{0x09e3, 0x0a01, 30},
+		{0x0a02, 0x0a03, 1},
 		{0x0a3e, 0x0a42, 1},
 		{0x0a47, 0x0a48, 1},
 		{0x0a4b, 0x0a4c, 1},
-		{0x0a51, 0x0a51, 1},
-		{0x0a70, 0x0a71, 1},
-		{0x0a75, 0x0a75, 1},
+		{0x0a51, 0x0a70, 31},
+		{0x0a71, 0x0a75, 4},
 		{0x0a81, 0x0a83, 1},
 		{0x0abe, 0x0ac5, 1},
 		{0x0ac7, 0x0ac9, 1},
@@ -5859,12 +5747,12 @@ var _Other_Alphabetic = &RangeTable{
 		{0x0b4b, 0x0b4c, 1},
 		{0x0b56, 0x0b57, 1},
 		{0x0b62, 0x0b63, 1},
-		{0x0b82, 0x0b82, 1},
-		{0x0bbe, 0x0bc2, 1},
+		{0x0b82, 0x0bbe, 60},
+		{0x0bbf, 0x0bc2, 1},
 		{0x0bc6, 0x0bc8, 1},
 		{0x0bca, 0x0bcc, 1},
-		{0x0bd7, 0x0bd7, 1},
-		{0x0c00, 0x0c03, 1},
+		{0x0bd7, 0x0c00, 41},
+		{0x0c01, 0x0c03, 1},
 		{0x0c3e, 0x0c44, 1},
 		{0x0c46, 0x0c48, 1},
 		{0x0c4a, 0x0c4c, 1},
@@ -5880,42 +5768,41 @@ var _Other_Alphabetic = &RangeTable{
 		{0x0d3e, 0x0d44, 1},
 		{0x0d46, 0x0d48, 1},
 		{0x0d4a, 0x0d4c, 1},
-		{0x0d57, 0x0d57, 1},
-		{0x0d62, 0x0d63, 1},
-		{0x0d82, 0x0d83, 1},
-		{0x0dcf, 0x0dd4, 1},
-		{0x0dd6, 0x0dd6, 1},
-		{0x0dd8, 0x0ddf, 1},
+		{0x0d57, 0x0d62, 11},
+		{0x0d63, 0x0d82, 31},
+		{0x0d83, 0x0dcf, 76},
+		{0x0dd0, 0x0dd4, 1},
+		{0x0dd6, 0x0dd8, 2},
+		{0x0dd9, 0x0ddf, 1},
 		{0x0df2, 0x0df3, 1},
-		{0x0e31, 0x0e31, 1},
-		{0x0e34, 0x0e3a, 1},
-		{0x0e4d, 0x0e4d, 1},
-		{0x0eb1, 0x0eb1, 1},
+		{0x0e31, 0x0e34, 3},
+		{0x0e35, 0x0e3a, 1},
+		{0x0e4d, 0x0eb1, 100},
 		{0x0eb4, 0x0eb9, 1},
 		{0x0ebb, 0x0ebc, 1},
-		{0x0ecd, 0x0ecd, 1},
-		{0x0f71, 0x0f81, 1},
+		{0x0ecd, 0x0f71, 164},
+		{0x0f72, 0x0f81, 1},
 		{0x0f8d, 0x0f97, 1},
 		{0x0f99, 0x0fbc, 1},
 		{0x102b, 0x1036, 1},
-		{0x1038, 0x1038, 1},
-		{0x103b, 0x103e, 1},
+		{0x1038, 0x103b, 3},
+		{0x103c, 0x103e, 1},
 		{0x1056, 0x1059, 1},
 		{0x105e, 0x1060, 1},
-		{0x1062, 0x1062, 1},
-		{0x1067, 0x1068, 1},
-		{0x1071, 0x1074, 1},
+		{0x1062, 0x1067, 5},
+		{0x1068, 0x1071, 9},
+		{0x1072, 0x1074, 1},
 		{0x1082, 0x1086, 1},
 		{0x109c, 0x109d, 1},
-		{0x135f, 0x135f, 1},
-		{0x1712, 0x1713, 1},
-		{0x1732, 0x1733, 1},
-		{0x1752, 0x1753, 1},
-		{0x1772, 0x1773, 1},
-		{0x17b6, 0x17c8, 1},
+		{0x135f, 0x1712, 947},
+		{0x1713, 0x1732, 31},
+		{0x1733, 0x1752, 31},
+		{0x1753, 0x1772, 31},
+		{0x1773, 0x17b6, 67},
+		{0x17b7, 0x17c8, 1},
 		{0x1885, 0x1886, 1},
-		{0x18a9, 0x18a9, 1},
-		{0x1920, 0x192b, 1},
+		{0x18a9, 0x1920, 119},
+		{0x1921, 0x192b, 1},
 		{0x1930, 0x1938, 1},
 		{0x1a17, 0x1a1b, 1},
 		{0x1a55, 0x1a5e, 1},
@@ -5936,21 +5823,20 @@ var _Other_Alphabetic = &RangeTable{
 		{0xa823, 0xa827, 1},
 		{0xa880, 0xa881, 1},
 		{0xa8b4, 0xa8c3, 1},
-		{0xa8c5, 0xa8c5, 1},
-		{0xa926, 0xa92a, 1},
+		{0xa8c5, 0xa926, 97},
+		{0xa927, 0xa92a, 1},
 		{0xa947, 0xa952, 1},
 		{0xa980, 0xa983, 1},
 		{0xa9b4, 0xa9bf, 1},
 		{0xaa29, 0xaa36, 1},
-		{0xaa43, 0xaa43, 1},
-		{0xaa4c, 0xaa4d, 1},
-		{0xaab0, 0xaab0, 1},
+		{0xaa43, 0xaa4c, 9},
+		{0xaa4d, 0xaab0, 99},
 		{0xaab2, 0xaab4, 1},
 		{0xaab7, 0xaab8, 1},
-		{0xaabe, 0xaabe, 1},
-		{0xaaeb, 0xaaef, 1},
-		{0xaaf5, 0xaaf5, 1},
-		{0xabe3, 0xabea, 1},
+		{0xaabe, 0xaaeb, 45},
+		{0xaaec, 0xaaef, 1},
+		{0xaaf5, 0xabe3, 238},
+		{0xabe4, 0xabea, 1},
 		{0xfb1e, 0xfb1e, 1},
 	},
 	R32: []Range32{
@@ -5960,31 +5846,30 @@ var _Other_Alphabetic = &RangeTable{
 		{0x10a0c, 0x10a0f, 1},
 		{0x11000, 0x11002, 1},
 		{0x11038, 0x11045, 1},
-		{0x11082, 0x11082, 1},
-		{0x110b0, 0x110b8, 1},
+		{0x11082, 0x110b0, 46},
+		{0x110b1, 0x110b8, 1},
 		{0x11100, 0x11102, 1},
 		{0x11127, 0x11132, 1},
 		{0x11180, 0x11182, 1},
 		{0x111b3, 0x111bf, 1},
 		{0x1122c, 0x11234, 1},
-		{0x11237, 0x11237, 1},
-		{0x1123e, 0x1123e, 1},
+		{0x11237, 0x1123e, 7},
 		{0x112df, 0x112e8, 1},
 		{0x11300, 0x11303, 1},
 		{0x1133e, 0x11344, 1},
 		{0x11347, 0x11348, 1},
 		{0x1134b, 0x1134c, 1},
-		{0x11357, 0x11357, 1},
-		{0x11362, 0x11363, 1},
-		{0x11435, 0x11441, 1},
+		{0x11357, 0x11362, 11},
+		{0x11363, 0x11435, 210},
+		{0x11436, 0x11441, 1},
 		{0x11443, 0x11445, 1},
 		{0x114b0, 0x114c1, 1},
 		{0x115af, 0x115b5, 1},
 		{0x115b8, 0x115be, 1},
 		{0x115dc, 0x115dd, 1},
 		{0x11630, 0x1163e, 1},
-		{0x11640, 0x11640, 1},
-		{0x116ab, 0x116b5, 1},
+		{0x11640, 0x116ab, 107},
+		{0x116ac, 0x116b5, 1},
 		{0x1171d, 0x1172a, 1},
 		{0x11a01, 0x11a0a, 1},
 		{0x11a35, 0x11a39, 1},
@@ -5996,21 +5881,20 @@ var _Other_Alphabetic = &RangeTable{
 		{0x11c92, 0x11ca7, 1},
 		{0x11ca9, 0x11cb6, 1},
 		{0x11d31, 0x11d36, 1},
-		{0x11d3a, 0x11d3a, 1},
-		{0x11d3c, 0x11d3d, 1},
-		{0x11d3f, 0x11d41, 1},
-		{0x11d43, 0x11d43, 1},
-		{0x11d47, 0x11d47, 1},
+		{0x11d3a, 0x11d3c, 2},
+		{0x11d3d, 0x11d3f, 2},
+		{0x11d40, 0x11d41, 1},
+		{0x11d43, 0x11d47, 4},
 		{0x16b30, 0x16b36, 1},
 		{0x16f51, 0x16f7e, 1},
-		{0x1bc9e, 0x1bc9e, 1},
-		{0x1e000, 0x1e006, 1},
+		{0x1bc9e, 0x1e000, 9058},
+		{0x1e001, 0x1e006, 1},
 		{0x1e008, 0x1e018, 1},
 		{0x1e01b, 0x1e021, 1},
 		{0x1e023, 0x1e024, 1},
 		{0x1e026, 0x1e02a, 1},
-		{0x1e947, 0x1e947, 1},
-		{0x1f130, 0x1f149, 1},
+		{0x1e947, 0x1f130, 2025},
+		{0x1f131, 0x1f149, 1},
 		{0x1f150, 0x1f169, 1},
 		{0x1f170, 0x1f189, 1},
 	},
@@ -6018,17 +5902,15 @@ var _Other_Alphabetic = &RangeTable{
 
 var _Other_Default_Ignorable_Code_Point = &RangeTable{
 	R16: []Range16{
-		{0x034f, 0x034f, 1},
-		{0x115f, 0x1160, 1},
-		{0x17b4, 0x17b5, 1},
-		{0x2065, 0x2065, 1},
-		{0x3164, 0x3164, 1},
-		{0xffa0, 0xffa0, 1},
+		{0x034f, 0x115f, 3600},
+		{0x1160, 0x17b4, 1620},
+		{0x17b5, 0x2065, 2224},
+		{0x3164, 0xffa0, 52796},
 		{0xfff0, 0xfff8, 1},
 	},
 	R32: []Range32{
-		{0xe0000, 0xe0000, 1},
-		{0xe0002, 0xe001f, 1},
+		{0xe0000, 0xe0002, 2},
+		{0xe0003, 0xe001f, 1},
 		{0xe0080, 0xe00ff, 1},
 		{0xe01f0, 0xe0fff, 1},
 	},
@@ -6036,29 +5918,20 @@ var _Other_Default_Ignorable_Code_Point = &RangeTable{
 
 var _Other_Grapheme_Extend = &RangeTable{
 	R16: []Range16{
-		{0x09be, 0x09be, 1},
-		{0x09d7, 0x09d7, 1},
-		{0x0b3e, 0x0b3e, 1},
-		{0x0b57, 0x0b57, 1},
-		{0x0bbe, 0x0bbe, 1},
-		{0x0bd7, 0x0bd7, 1},
-		{0x0cc2, 0x0cc2, 1},
-		{0x0cd5, 0x0cd6, 1},
-		{0x0d3e, 0x0d3e, 1},
-		{0x0d57, 0x0d57, 1},
-		{0x0dcf, 0x0dcf, 1},
-		{0x0ddf, 0x0ddf, 1},
-		{0x200c, 0x200c, 1},
+		{0x09be, 0x09d7, 25},
+		{0x0b3e, 0x0b57, 25},
+		{0x0bbe, 0x0bd7, 25},
+		{0x0cc2, 0x0cd5, 19},
+		{0x0cd6, 0x0d3e, 104},
+		{0x0d57, 0x0dcf, 120},
+		{0x0ddf, 0x200c, 4653},
 		{0x302e, 0x302f, 1},
 		{0xff9e, 0xff9f, 1},
 	},
 	R32: []Range32{
-		{0x1133e, 0x1133e, 1},
-		{0x11357, 0x11357, 1},
-		{0x114b0, 0x114b0, 1},
-		{0x114bd, 0x114bd, 1},
-		{0x115af, 0x115af, 1},
-		{0x1d165, 0x1d165, 1},
+		{0x1133e, 0x11357, 25},
+		{0x114b0, 0x114bd, 13},
+		{0x115af, 0x1d165, 48054},
 		{0x1d16e, 0x1d172, 1},
 		{0xe0020, 0xe007f, 1},
 	},
@@ -6066,75 +5939,67 @@ var _Other_Grapheme_Extend = &RangeTable{
 
 var _Other_ID_Continue = &RangeTable{
 	R16: []Range16{
-		{0x00b7, 0x00b7, 1},
-		{0x0387, 0x0387, 1},
+		{0x00b7, 0x0387, 720},
 		{0x1369, 0x1371, 1},
 		{0x19da, 0x19da, 1},
 	},
-	LatinOffset: 1,
 }
 
 var _Other_ID_Start = &RangeTable{
 	R16: []Range16{
 		{0x1885, 0x1886, 1},
-		{0x2118, 0x2118, 1},
-		{0x212e, 0x212e, 1},
+		{0x2118, 0x212e, 22},
 		{0x309b, 0x309c, 1},
 	},
 }
 
 var _Other_Lowercase = &RangeTable{
 	R16: []Range16{
-		{0x00aa, 0x00aa, 1},
-		{0x00ba, 0x00ba, 1},
+		{0x00aa, 0x00ba, 16},
 		{0x02b0, 0x02b8, 1},
 		{0x02c0, 0x02c1, 1},
 		{0x02e0, 0x02e4, 1},
-		{0x0345, 0x0345, 1},
-		{0x037a, 0x037a, 1},
+		{0x0345, 0x037a, 53},
 		{0x1d2c, 0x1d6a, 1},
-		{0x1d78, 0x1d78, 1},
-		{0x1d9b, 0x1dbf, 1},
-		{0x2071, 0x2071, 1},
-		{0x207f, 0x207f, 1},
+		{0x1d78, 0x1d9b, 35},
+		{0x1d9c, 0x1dbf, 1},
+		{0x2071, 0x207f, 14},
 		{0x2090, 0x209c, 1},
 		{0x2170, 0x217f, 1},
 		{0x24d0, 0x24e9, 1},
 		{0x2c7c, 0x2c7d, 1},
 		{0xa69c, 0xa69d, 1},
-		{0xa770, 0xa770, 1},
-		{0xa7f8, 0xa7f9, 1},
-		{0xab5c, 0xab5f, 1},
+		{0xa770, 0xa7f8, 136},
+		{0xa7f9, 0xab5c, 867},
+		{0xab5d, 0xab5f, 1},
 	},
-	LatinOffset: 2,
+	LatinOffset: 1,
 }
 
 var _Other_Math = &RangeTable{
 	R16: []Range16{
-		{0x005e, 0x005e, 1},
-		{0x03d0, 0x03d2, 1},
-		{0x03d5, 0x03d5, 1},
-		{0x03f0, 0x03f1, 1},
-		{0x03f4, 0x03f5, 1},
-		{0x2016, 0x2016, 1},
+		{0x005e, 0x03d0, 882},
+		{0x03d1, 0x03d2, 1},
+		{0x03d5, 0x03f0, 27},
+		{0x03f1, 0x03f4, 3},
+		{0x03f5, 0x2016, 7201},
 		{0x2032, 0x2034, 1},
-		{0x2040, 0x2040, 1},
-		{0x2061, 0x2064, 1},
+		{0x2040, 0x2061, 33},
+		{0x2062, 0x2064, 1},
 		{0x207d, 0x207e, 1},
 		{0x208d, 0x208e, 1},
 		{0x20d0, 0x20dc, 1},
-		{0x20e1, 0x20e1, 1},
-		{0x20e5, 0x20e6, 1},
-		{0x20eb, 0x20ef, 1},
-		{0x2102, 0x2102, 1},
-		{0x2107, 0x2107, 1},
+		{0x20e1, 0x20e5, 4},
+		{0x20e6, 0x20eb, 5},
+		{0x20ec, 0x20ef, 1},
+		{0x2102, 0x2107, 5},
 		{0x210a, 0x2113, 1},
-		{0x2115, 0x2115, 1},
-		{0x2119, 0x211d, 1},
-		{0x2124, 0x2124, 1},
-		{0x2128, 0x2129, 1},
-		{0x212c, 0x212d, 1},
-		{0x212f, 0x2131, 1},
+		{0x2115, 0x2119, 4},
+		{0x211a, 0x211d, 1},
+		{0x2124, 0x2128, 4},
+		{0x2129, 0x212c, 3},
+		{0x212d, 0x212f, 2},
+		{0x2130, 0x2131, 1},
 		{0x2133, 0x2138, 1},
 		{0x213c, 0x213f, 1},
 		{0x2145, 0x2149, 1},
@@ -6142,33 +6007,30 @@ var _Other_Math = &RangeTable{
 		{0x219c, 0x219f, 1},
 		{0x21a1, 0x21a2, 1},
 		{0x21a4, 0x21a5, 1},
-		{0x21a7, 0x21a7, 1},
-		{0x21a9, 0x21ad, 1},
+		{0x21a7, 0x21a9, 2},
+		{0x21aa, 0x21ad, 1},
 		{0x21b0, 0x21b1, 1},
 		{0x21b6, 0x21b7, 1},
 		{0x21bc, 0x21cd, 1},
 		{0x21d0, 0x21d1, 1},
-		{0x21d3, 0x21d3, 1},
-		{0x21d5, 0x21db, 1},
-		{0x21dd, 0x21dd, 1},
-		{0x21e4, 0x21e5, 1},
-		{0x2308, 0x230b, 1},
+		{0x21d3, 0x21d5, 2},
+		{0x21d6, 0x21db, 1},
+		{0x21dd, 0x21e4, 7},
+		{0x21e5, 0x2308, 291},
+		{0x2309, 0x230b, 1},
 		{0x23b4, 0x23b5, 1},
-		{0x23b7, 0x23b7, 1},
-		{0x23d0, 0x23d0, 1},
-		{0x23e2, 0x23e2, 1},
-		{0x25a0, 0x25a1, 1},
-		{0x25ae, 0x25b6, 1},
+		{0x23b7, 0x23d0, 25},
+		{0x23e2, 0x25a0, 446},
+		{0x25a1, 0x25ae, 13},
+		{0x25af, 0x25b6, 1},
 		{0x25bc, 0x25c0, 1},
 		{0x25c6, 0x25c7, 1},
 		{0x25ca, 0x25cb, 1},
 		{0x25cf, 0x25d3, 1},
-		{0x25e2, 0x25e2, 1},
-		{0x25e4, 0x25e4, 1},
+		{0x25e2, 0x25e4, 2},
 		{0x25e7, 0x25ec, 1},
 		{0x2605, 0x2606, 1},
-		{0x2640, 0x2640, 1},
-		{0x2642, 0x2642, 1},
+		{0x2640, 0x2642, 2},
 		{0x2660, 0x2663, 1},
 		{0x266d, 0x266e, 1},
 		{0x27c5, 0x27c6, 1},
@@ -6176,22 +6038,20 @@ var _Other_Math = &RangeTable{
 		{0x2983, 0x2998, 1},
 		{0x29d8, 0x29db, 1},
 		{0x29fc, 0x29fd, 1},
-		{0xfe61, 0xfe61, 1},
-		{0xfe63, 0xfe63, 1},
-		{0xfe68, 0xfe68, 1},
-		{0xff3c, 0xff3c, 1},
+		{0xfe61, 0xfe63, 2},
+		{0xfe68, 0xff3c, 212},
 		{0xff3e, 0xff3e, 1},
 	},
 	R32: []Range32{
 		{0x1d400, 0x1d454, 1},
 		{0x1d456, 0x1d49c, 1},
 		{0x1d49e, 0x1d49f, 1},
-		{0x1d4a2, 0x1d4a2, 1},
-		{0x1d4a5, 0x1d4a6, 1},
-		{0x1d4a9, 0x1d4ac, 1},
+		{0x1d4a2, 0x1d4a5, 3},
+		{0x1d4a6, 0x1d4a9, 3},
+		{0x1d4aa, 0x1d4ac, 1},
 		{0x1d4ae, 0x1d4b9, 1},
-		{0x1d4bb, 0x1d4bb, 1},
-		{0x1d4bd, 0x1d4c3, 1},
+		{0x1d4bb, 0x1d4bd, 2},
+		{0x1d4be, 0x1d4c3, 1},
 		{0x1d4c5, 0x1d505, 1},
 		{0x1d507, 0x1d50a, 1},
 		{0x1d50d, 0x1d514, 1},
@@ -6199,8 +6059,8 @@ var _Other_Math = &RangeTable{
 		{0x1d51e, 0x1d539, 1},
 		{0x1d53b, 0x1d53e, 1},
 		{0x1d540, 0x1d544, 1},
-		{0x1d546, 0x1d546, 1},
-		{0x1d54a, 0x1d550, 1},
+		{0x1d546, 0x1d54a, 4},
+		{0x1d54b, 0x1d550, 1},
 		{0x1d552, 0x1d6a5, 1},
 		{0x1d6a8, 0x1d6c0, 1},
 		{0x1d6c2, 0x1d6da, 1},
@@ -6217,38 +6077,28 @@ var _Other_Math = &RangeTable{
 		{0x1ee00, 0x1ee03, 1},
 		{0x1ee05, 0x1ee1f, 1},
 		{0x1ee21, 0x1ee22, 1},
-		{0x1ee24, 0x1ee24, 1},
-		{0x1ee27, 0x1ee27, 1},
+		{0x1ee24, 0x1ee27, 3},
 		{0x1ee29, 0x1ee32, 1},
 		{0x1ee34, 0x1ee37, 1},
-		{0x1ee39, 0x1ee39, 1},
-		{0x1ee3b, 0x1ee3b, 1},
-		{0x1ee42, 0x1ee42, 1},
-		{0x1ee47, 0x1ee47, 1},
-		{0x1ee49, 0x1ee49, 1},
-		{0x1ee4b, 0x1ee4b, 1},
-		{0x1ee4d, 0x1ee4f, 1},
+		{0x1ee39, 0x1ee3b, 2},
+		{0x1ee42, 0x1ee47, 5},
+		{0x1ee49, 0x1ee4d, 2},
+		{0x1ee4e, 0x1ee4f, 1},
 		{0x1ee51, 0x1ee52, 1},
-		{0x1ee54, 0x1ee54, 1},
-		{0x1ee57, 0x1ee57, 1},
-		{0x1ee59, 0x1ee59, 1},
-		{0x1ee5b, 0x1ee5b, 1},
-		{0x1ee5d, 0x1ee5d, 1},
-		{0x1ee5f, 0x1ee5f, 1},
-		{0x1ee61, 0x1ee62, 1},
-		{0x1ee64, 0x1ee64, 1},
+		{0x1ee54, 0x1ee57, 3},
+		{0x1ee59, 0x1ee61, 2},
+		{0x1ee62, 0x1ee64, 2},
 		{0x1ee67, 0x1ee6a, 1},
 		{0x1ee6c, 0x1ee72, 1},
 		{0x1ee74, 0x1ee77, 1},
 		{0x1ee79, 0x1ee7c, 1},
-		{0x1ee7e, 0x1ee7e, 1},
-		{0x1ee80, 0x1ee89, 1},
+		{0x1ee7e, 0x1ee80, 2},
+		{0x1ee81, 0x1ee89, 1},
 		{0x1ee8b, 0x1ee9b, 1},
 		{0x1eea1, 0x1eea3, 1},
 		{0x1eea5, 0x1eea9, 1},
 		{0x1eeab, 0x1eebb, 1},
 	},
-	LatinOffset: 1,
 }
 
 var _Other_Uppercase = &RangeTable{
@@ -6268,19 +6118,15 @@ var _Pattern_Syntax = &RangeTable{
 		{0x0021, 0x002f, 1},
 		{0x003a, 0x0040, 1},
 		{0x005b, 0x005e, 1},
-		{0x0060, 0x0060, 1},
-		{0x007b, 0x007e, 1},
+		{0x0060, 0x007b, 27},
+		{0x007c, 0x007e, 1},
 		{0x00a1, 0x00a7, 1},
-		{0x00a9, 0x00a9, 1},
-		{0x00ab, 0x00ac, 1},
-		{0x00ae, 0x00ae, 1},
-		{0x00b0, 0x00b1, 1},
-		{0x00b6, 0x00b6, 1},
-		{0x00bb, 0x00bb, 1},
-		{0x00bf, 0x00bf, 1},
-		{0x00d7, 0x00d7, 1},
-		{0x00f7, 0x00f7, 1},
-		{0x2010, 0x2027, 1},
+		{0x00a9, 0x00ab, 2},
+		{0x00ac, 0x00b0, 2},
+		{0x00b1, 0x00bb, 5},
+		{0x00bf, 0x00d7, 24},
+		{0x00f7, 0x2010, 7961},
+		{0x2011, 0x2027, 1},
 		{0x2030, 0x203e, 1},
 		{0x2041, 0x2053, 1},
 		{0x2055, 0x205e, 1},
@@ -6290,29 +6136,27 @@ var _Pattern_Syntax = &RangeTable{
 		{0x2e00, 0x2e7f, 1},
 		{0x3001, 0x3003, 1},
 		{0x3008, 0x3020, 1},
-		{0x3030, 0x3030, 1},
-		{0xfd3e, 0xfd3f, 1},
-		{0xfe45, 0xfe46, 1},
+		{0x3030, 0xfd3e, 52494},
+		{0xfd3f, 0xfe45, 262},
+		{0xfe46, 0xfe46, 1},
 	},
-	LatinOffset: 15,
+	LatinOffset: 10,
 }
 
 var _Pattern_White_Space = &RangeTable{
 	R16: []Range16{
 		{0x0009, 0x000d, 1},
-		{0x0020, 0x0020, 1},
-		{0x0085, 0x0085, 1},
+		{0x0020, 0x0085, 101},
 		{0x200e, 0x200f, 1},
 		{0x2028, 0x2029, 1},
 	},
-	LatinOffset: 3,
+	LatinOffset: 2,
 }
 
 var _Prepended_Concatenation_Mark = &RangeTable{
 	R16: []Range16{
 		{0x0600, 0x0605, 1},
-		{0x06dd, 0x06dd, 1},
-		{0x070f, 0x070f, 1},
+		{0x06dd, 0x070f, 50},
 		{0x08e2, 0x08e2, 1},
 	},
 	R32: []Range32{
@@ -6322,21 +6166,18 @@ var _Prepended_Concatenation_Mark = &RangeTable{
 
 var _Quotation_Mark = &RangeTable{
 	R16: []Range16{
-		{0x0022, 0x0022, 1},
-		{0x0027, 0x0027, 1},
-		{0x00ab, 0x00ab, 1},
-		{0x00bb, 0x00bb, 1},
+		{0x0022, 0x0027, 5},
+		{0x00ab, 0x00bb, 16},
 		{0x2018, 0x201f, 1},
 		{0x2039, 0x203a, 1},
-		{0x2e42, 0x2e42, 1},
-		{0x300c, 0x300f, 1},
+		{0x2e42, 0x300c, 458},
+		{0x300d, 0x300f, 1},
 		{0x301d, 0x301f, 1},
 		{0xfe41, 0xfe44, 1},
-		{0xff02, 0xff02, 1},
-		{0xff07, 0xff07, 1},
+		{0xff02, 0xff07, 5},
 		{0xff62, 0xff63, 1},
 	},
-	LatinOffset: 4,
+	LatinOffset: 2,
 }
 
 var _Radical = &RangeTable{
@@ -6356,50 +6197,39 @@ var _Regional_Indicator = &RangeTable{
 
 var _Sentence_Terminal = &RangeTable{
 	R16: []Range16{
-		{0x0021, 0x0021, 1},
-		{0x002e, 0x002e, 1},
-		{0x003f, 0x003f, 1},
-		{0x0589, 0x0589, 1},
-		{0x061f, 0x061f, 1},
-		{0x06d4, 0x06d4, 1},
+		{0x0021, 0x002e, 13},
+		{0x003f, 0x0589, 1354},
+		{0x061f, 0x06d4, 181},
 		{0x0700, 0x0702, 1},
-		{0x07f9, 0x07f9, 1},
-		{0x0964, 0x0965, 1},
-		{0x104a, 0x104b, 1},
-		{0x1362, 0x1362, 1},
+		{0x07f9, 0x0964, 363},
+		{0x0965, 0x104a, 1765},
+		{0x104b, 0x1362, 791},
 		{0x1367, 0x1368, 1},
-		{0x166e, 0x166e, 1},
-		{0x1735, 0x1736, 1},
-		{0x1803, 0x1803, 1},
-		{0x1809, 0x1809, 1},
-		{0x1944, 0x1945, 1},
-		{0x1aa8, 0x1aab, 1},
+		{0x166e, 0x1735, 199},
+		{0x1736, 0x1803, 205},
+		{0x1809, 0x1944, 315},
+		{0x1945, 0x1aa8, 355},
+		{0x1aa9, 0x1aab, 1},
 		{0x1b5a, 0x1b5b, 1},
 		{0x1b5e, 0x1b5f, 1},
 		{0x1c3b, 0x1c3c, 1},
 		{0x1c7e, 0x1c7f, 1},
 		{0x203c, 0x203d, 1},
 		{0x2047, 0x2049, 1},
-		{0x2e2e, 0x2e2e, 1},
-		{0x2e3c, 0x2e3c, 1},
-		{0x3002, 0x3002, 1},
-		{0xa4ff, 0xa4ff, 1},
+		{0x2e2e, 0x2e3c, 14},
+		{0x3002, 0xa4ff, 29949},
 		{0xa60e, 0xa60f, 1},
-		{0xa6f3, 0xa6f3, 1},
-		{0xa6f7, 0xa6f7, 1},
+		{0xa6f3, 0xa6f7, 4},
 		{0xa876, 0xa877, 1},
 		{0xa8ce, 0xa8cf, 1},
-		{0xa92f, 0xa92f, 1},
-		{0xa9c8, 0xa9c9, 1},
-		{0xaa5d, 0xaa5f, 1},
+		{0xa92f, 0xa9c8, 153},
+		{0xa9c9, 0xaa5d, 148},
+		{0xaa5e, 0xaa5f, 1},
 		{0xaaf0, 0xaaf1, 1},
-		{0xabeb, 0xabeb, 1},
-		{0xfe52, 0xfe52, 1},
+		{0xabeb, 0xfe52, 21095},
 		{0xfe56, 0xfe57, 1},
-		{0xff01, 0xff01, 1},
-		{0xff0e, 0xff0e, 1},
-		{0xff1f, 0xff1f, 1},
-		{0xff61, 0xff61, 1},
+		{0xff01, 0xff0e, 13},
+		{0xff1f, 0xff61, 66},
 	},
 	R32: []Range32{
 		{0x10a56, 0x10a57, 1},
@@ -6407,11 +6237,10 @@ var _Sentence_Terminal = &RangeTable{
 		{0x110be, 0x110c1, 1},
 		{0x11141, 0x11143, 1},
 		{0x111c5, 0x111c6, 1},
-		{0x111cd, 0x111cd, 1},
-		{0x111de, 0x111df, 1},
-		{0x11238, 0x11239, 1},
-		{0x1123b, 0x1123c, 1},
-		{0x112a9, 0x112a9, 1},
+		{0x111cd, 0x111de, 17},
+		{0x111df, 0x11238, 89},
+		{0x11239, 0x1123b, 2},
+		{0x1123c, 0x112a9, 109},
 		{0x1144b, 0x1144c, 1},
 		{0x115c2, 0x115c3, 1},
 		{0x115c9, 0x115d7, 1},
@@ -6421,35 +6250,25 @@ var _Sentence_Terminal = &RangeTable{
 		{0x11a9b, 0x11a9c, 1},
 		{0x11c41, 0x11c42, 1},
 		{0x16a6e, 0x16a6f, 1},
-		{0x16af5, 0x16af5, 1},
-		{0x16b37, 0x16b38, 1},
-		{0x16b44, 0x16b44, 1},
-		{0x1bc9f, 0x1bc9f, 1},
-		{0x1da88, 0x1da88, 1},
+		{0x16af5, 0x16b37, 66},
+		{0x16b38, 0x16b44, 12},
+		{0x1bc9f, 0x1da88, 7657},
 	},
-	LatinOffset: 3,
+	LatinOffset: 1,
 }
 
 var _Soft_Dotted = &RangeTable{
 	R16: []Range16{
 		{0x0069, 0x006a, 1},
-		{0x012f, 0x012f, 1},
-		{0x0249, 0x0249, 1},
-		{0x0268, 0x0268, 1},
-		{0x029d, 0x029d, 1},
-		{0x02b2, 0x02b2, 1},
-		{0x03f3, 0x03f3, 1},
-		{0x0456, 0x0456, 1},
-		{0x0458, 0x0458, 1},
-		{0x1d62, 0x1d62, 1},
-		{0x1d96, 0x1d96, 1},
-		{0x1da4, 0x1da4, 1},
-		{0x1da8, 0x1da8, 1},
-		{0x1e2d, 0x1e2d, 1},
-		{0x1ecb, 0x1ecb, 1},
-		{0x2071, 0x2071, 1},
-		{0x2148, 0x2149, 1},
-		{0x2c7c, 0x2c7c, 1},
+		{0x012f, 0x0249, 282},
+		{0x0268, 0x029d, 53},
+		{0x02b2, 0x03f3, 321},
+		{0x0456, 0x0458, 2},
+		{0x1d62, 0x1d96, 52},
+		{0x1da4, 0x1da8, 4},
+		{0x1e2d, 0x1ecb, 158},
+		{0x2071, 0x2148, 215},
+		{0x2149, 0x2c7c, 2867},
 	},
 	R32: []Range32{
 		{0x1d422, 0x1d423, 1},
@@ -6471,27 +6290,20 @@ var _Soft_Dotted = &RangeTable{
 
 var _Terminal_Punctuation = &RangeTable{
 	R16: []Range16{
-		{0x0021, 0x0021, 1},
-		{0x002c, 0x002c, 1},
-		{0x002e, 0x002e, 1},
-		{0x003a, 0x003b, 1},
-		{0x003f, 0x003f, 1},
-		{0x037e, 0x037e, 1},
-		{0x0387, 0x0387, 1},
-		{0x0589, 0x0589, 1},
-		{0x05c3, 0x05c3, 1},
-		{0x060c, 0x060c, 1},
-		{0x061b, 0x061b, 1},
-		{0x061f, 0x061f, 1},
-		{0x06d4, 0x06d4, 1},
+		{0x0021, 0x002c, 11},
+		{0x002e, 0x003a, 12},
+		{0x003b, 0x003f, 4},
+		{0x037e, 0x0387, 9},
+		{0x0589, 0x05c3, 58},
+		{0x060c, 0x061b, 15},
+		{0x061f, 0x06d4, 181},
 		{0x0700, 0x070a, 1},
-		{0x070c, 0x070c, 1},
-		{0x07f8, 0x07f9, 1},
-		{0x0830, 0x083e, 1},
-		{0x085e, 0x085e, 1},
-		{0x0964, 0x0965, 1},
-		{0x0e5a, 0x0e5b, 1},
-		{0x0f08, 0x0f08, 1},
+		{0x070c, 0x07f8, 236},
+		{0x07f9, 0x0830, 55},
+		{0x0831, 0x083e, 1},
+		{0x085e, 0x0964, 262},
+		{0x0965, 0x0e5a, 1269},
+		{0x0e5b, 0x0f08, 173},
 		{0x0f0d, 0x0f12, 1},
 		{0x104a, 0x104b, 1},
 		{0x1361, 0x1368, 1},
@@ -6499,8 +6311,8 @@ var _Terminal_Punctuation = &RangeTable{
 		{0x16eb, 0x16ed, 1},
 		{0x1735, 0x1736, 1},
 		{0x17d4, 0x17d6, 1},
-		{0x17da, 0x17da, 1},
-		{0x1802, 0x1805, 1},
+		{0x17da, 0x1802, 40},
+		{0x1803, 0x1805, 1},
 		{0x1808, 0x1809, 1},
 		{0x1944, 0x1945, 1},
 		{0x1aa8, 0x1aab, 1},
@@ -6510,36 +6322,29 @@ var _Terminal_Punctuation = &RangeTable{
 		{0x1c7e, 0x1c7f, 1},
 		{0x203c, 0x203d, 1},
 		{0x2047, 0x2049, 1},
-		{0x2e2e, 0x2e2e, 1},
-		{0x2e3c, 0x2e3c, 1},
-		{0x2e41, 0x2e41, 1},
-		{0x3001, 0x3002, 1},
-		{0xa4fe, 0xa4ff, 1},
-		{0xa60d, 0xa60f, 1},
+		{0x2e2e, 0x2e3c, 14},
+		{0x2e41, 0x3001, 448},
+		{0x3002, 0xa4fe, 29948},
+		{0xa4ff, 0xa60d, 270},
+		{0xa60e, 0xa60f, 1},
 		{0xa6f3, 0xa6f7, 1},
 		{0xa876, 0xa877, 1},
 		{0xa8ce, 0xa8cf, 1},
-		{0xa92f, 0xa92f, 1},
-		{0xa9c7, 0xa9c9, 1},
+		{0xa92f, 0xa9c7, 152},
+		{0xa9c8, 0xa9c9, 1},
 		{0xaa5d, 0xaa5f, 1},
-		{0xaadf, 0xaadf, 1},
-		{0xaaf0, 0xaaf1, 1},
-		{0xabeb, 0xabeb, 1},
+		{0xaadf, 0xaaf0, 17},
+		{0xaaf1, 0xabeb, 250},
 		{0xfe50, 0xfe52, 1},
 		{0xfe54, 0xfe57, 1},
-		{0xff01, 0xff01, 1},
-		{0xff0c, 0xff0c, 1},
-		{0xff0e, 0xff0e, 1},
-		{0xff1a, 0xff1b, 1},
-		{0xff1f, 0xff1f, 1},
-		{0xff61, 0xff61, 1},
-		{0xff64, 0xff64, 1},
+		{0xff01, 0xff0c, 11},
+		{0xff0e, 0xff1a, 12},
+		{0xff1b, 0xff1f, 4},
+		{0xff61, 0xff64, 3},
 	},
 	R32: []Range32{
-		{0x1039f, 0x1039f, 1},
-		{0x103d0, 0x103d0, 1},
-		{0x10857, 0x10857, 1},
-		{0x1091f, 0x1091f, 1},
+		{0x1039f, 0x103d0, 49},
+		{0x10857, 0x1091f, 200},
 		{0x10a56, 0x10a57, 1},
 		{0x10af0, 0x10af5, 1},
 		{0x10b3a, 0x10b3f, 1},
@@ -6548,13 +6353,13 @@ var _Terminal_Punctuation = &RangeTable{
 		{0x110be, 0x110c1, 1},
 		{0x11141, 0x11143, 1},
 		{0x111c5, 0x111c6, 1},
-		{0x111cd, 0x111cd, 1},
-		{0x111de, 0x111df, 1},
-		{0x11238, 0x1123c, 1},
-		{0x112a9, 0x112a9, 1},
-		{0x1144b, 0x1144d, 1},
-		{0x1145b, 0x1145b, 1},
-		{0x115c2, 0x115c5, 1},
+		{0x111cd, 0x111de, 17},
+		{0x111df, 0x11238, 89},
+		{0x11239, 0x1123c, 1},
+		{0x112a9, 0x1144b, 418},
+		{0x1144c, 0x1144d, 1},
+		{0x1145b, 0x115c2, 359},
+		{0x115c3, 0x115c5, 1},
 		{0x115c9, 0x115d7, 1},
 		{0x11641, 0x11642, 1},
 		{0x1173c, 0x1173e, 1},
@@ -6562,16 +6367,15 @@ var _Terminal_Punctuation = &RangeTable{
 		{0x11a9b, 0x11a9c, 1},
 		{0x11aa1, 0x11aa2, 1},
 		{0x11c41, 0x11c43, 1},
-		{0x11c71, 0x11c71, 1},
-		{0x12470, 0x12474, 1},
+		{0x11c71, 0x12470, 2047},
+		{0x12471, 0x12474, 1},
 		{0x16a6e, 0x16a6f, 1},
-		{0x16af5, 0x16af5, 1},
-		{0x16b37, 0x16b39, 1},
-		{0x16b44, 0x16b44, 1},
-		{0x1bc9f, 0x1bc9f, 1},
+		{0x16af5, 0x16b37, 66},
+		{0x16b38, 0x16b39, 1},
+		{0x16b44, 0x1bc9f, 20827},
 		{0x1da87, 0x1da8a, 1},
 	},
-	LatinOffset: 5,
+	LatinOffset: 3,
 }
 
 var _Unified_Ideograph = &RangeTable{
@@ -6579,12 +6383,11 @@ var _Unified_Ideograph = &RangeTable{
 		{0x3400, 0x4db5, 1},
 		{0x4e00, 0x9fea, 1},
 		{0xfa0e, 0xfa0f, 1},
-		{0xfa11, 0xfa11, 1},
-		{0xfa13, 0xfa14, 1},
-		{0xfa1f, 0xfa1f, 1},
-		{0xfa21, 0xfa21, 1},
-		{0xfa23, 0xfa24, 1},
-		{0xfa27, 0xfa29, 1},
+		{0xfa11, 0xfa13, 2},
+		{0xfa14, 0xfa1f, 11},
+		{0xfa21, 0xfa23, 2},
+		{0xfa24, 0xfa27, 3},
+		{0xfa28, 0xfa29, 1},
 	},
 	R32: []Range32{
 		{0x20000, 0x2a6d6, 1},
@@ -6608,17 +6411,14 @@ var _Variation_Selector = &RangeTable{
 var _White_Space = &RangeTable{
 	R16: []Range16{
 		{0x0009, 0x000d, 1},
-		{0x0020, 0x0020, 1},
-		{0x0085, 0x0085, 1},
-		{0x00a0, 0x00a0, 1},
-		{0x1680, 0x1680, 1},
+		{0x0020, 0x0085, 101},
+		{0x00a0, 0x1680, 5600},
 		{0x2000, 0x200a, 1},
 		{0x2028, 0x2029, 1},
-		{0x202f, 0x202f, 1},
-		{0x205f, 0x205f, 1},
+		{0x202f, 0x205f, 48},
 		{0x3000, 0x3000, 1},
 	},
-	LatinOffset: 4,
+	LatinOffset: 2,
 }
 
 // These variables have type *RangeTable.
@@ -6660,10 +6460,6 @@ var (
 	White_Space                        = _White_Space                        // White_Space is the set of Unicode characters with property White_Space.
 )
 
-// Generated by running
-//	maketables --data=http://www.unicode.org/Public/10.0.0/ucd/UnicodeData.txt --casefolding=http://www.unicode.org/Public/10.0.0/ucd/CaseFolding.txt
-// DO NOT EDIT
-
 // CaseRanges is the table describing case mappings for all letters with
 // non-self mappings.
 var CaseRanges = _CaseRanges
@@ -7760,7 +7556,7 @@ var foldInherited = &RangeTable{
 	},
 }
 
-// Range entries: 3587 16-bit, 1554 32-bit, 5141 total.
-// Range bytes: 21522 16-bit, 18648 32-bit, 40170 total.
+// Range entries: 3461 16-bit, 1511 32-bit, 4972 total.
+// Range bytes: 20766 16-bit, 18132 32-bit, 38898 total.
 
 // Fold orbit bytes: 88 pairs, 352 bytes