+
Github
+GitHub
@@ -113,10 +113,7 @@
-
CryptoLive
CmdRunner
Git
- Github
+ GitHub
Google Calendar
IPInfo
Jira
diff --git a/docs/posts/modules/ipinfo/index.html b/docs/posts/modules/ipinfo/index.html
index 2ade4a3a..f3cd4865 100644
--- a/docs/posts/modules/ipinfo/index.html
+++ b/docs/posts/modules/ipinfo/index.html
@@ -69,7 +69,7 @@
CryptoLive
CmdRunner
Git
- Github
+ GitHub
Google Calendar
IPInfo
Jira
@@ -115,6 +115,8 @@
+ refreshInterval: 150Displays information about git repositories hosted on Github: open -review requests, and open pull requests.
- -
Displays information about your git repositories hosted on Github:
Open Review Requests
@@ -126,6 +123,8 @@ review requests, and open pull requests.All open pull requests created by you.
+
Source Code
wtf/github/Required ENV Variables
diff --git a/docs/posts/modules/index.html b/docs/posts/modules/index.html index 525d0d9c..fad43ff2 100644 --- a/docs/posts/modules/index.html +++ b/docs/posts/modules/index.html @@ -69,7 +69,7 @@Displays your current IP address information, from ipinfo.io.
+Note: IPInfo.io has a free-plan rate limit of 1000 requests per day.
+
+
+A: You're likely trying to generate and display colors that can't be represented by RGB,
+and thus monitors. When you're trying to convert, say, `HCL(190.0, 1.0, 1.0).RGB255()`,
+you're asking for RGB values of `(-2105.254 300.680 286.185)`, which clearly don't exist,
+and the `RGB255` function just casts these numbers to `uint8`, creating wrap-around and
+what looks like a completely broken gradient. What you want to do, is either use more
+reasonable values of colors which actually exist in RGB, or just `Clamp()` the resulting
+color to its nearest existing one, living with the consequences:
+`HCL(190.0, 1.0, 1.0).Clamp().RGB255()`. It will look something like this:
+
+
+
+[Here's an issue going in-depth about this](https://github.com/lucasb-eyer/go-colorful/issues/14),
+as well as [my answer](https://github.com/lucasb-eyer/go-colorful/issues/14#issuecomment-324205385),
+both with code and pretty pictures. Also note that this was somewhat covered above in the
+["Blending colors" section](https://github.com/lucasb-eyer/go-colorful#blending-colors).
+
+### Q: In a tight loop, conversion to Lab/Luv/HCl/... are slooooow!
+A: Yes, they are.
+This library aims for correctness, readability, and modularity; it wasn't written with speed in mind.
+A large part of the slowness comes from these conversions going through `LinearRgb` which uses powers.
+I implemented a fast approximation to `LinearRgb` called `FastLinearRgb` by using Taylor approximations.
+The approximation is roughly 5x faster and precise up to roughly 0.5%,
+the major caveat being that if the input values are outside the range 0-1, accuracy drops dramatically.
+You can use these in your conversions as follows:
+
+```go
+col := // Get your color somehow
+l, a, b := XyzToLab(LinearRgbToXyz(col.LinearRgb()))
+```
+
+If you need faster versions of `Distance*` and `Blend*` that make use of this fast approximation,
+feel free to implement them and open a pull-request, I'll happily accept.
+
+The derivation of these functions can be followed in [this Jupyter notebook](doc/LinearRGB Approximations.ipynb).
+Here's the main figure showing the approximation quality:
+
+
+
+More speed could be gained by using SIMD instructions in many places.
+You can also get more speed for specific conversions by approximating the full conversion function,
+but that is outside the scope of this library.
+Thanks to [@ZirconiumX](https://github.com/ZirconiumX) for starting this investigation,
+see [issue #18](https://github.com/lucasb-eyer/go-colorful/issues/18) for details.
+
+### Q: Why would `MakeColor` ever fail!?
+A: `MakeColor` fails when the alpha channel is zero. In that case, the
+conversion is undefined. See [issue 21](https://github.com/lucasb-eyer/go-colorful/issues/21)
+as well as the short caveat note in the ["The `color.Color` interface"](README.md#the-colorcolor-interface)
+section above.
+
+Who?
+====
+
+This library has been developed by Lucas Beyer with contributions from
+Bastien Dejean (@baskerville), Phil Kulak (@pkulak) and Christian Muehlhaeuser (@muesli).
+
+Release Notes
+=============
+
+### Version 1.0
+- API Breaking change in `MakeColor`: instead of `panic`ing when alpha is zero, it now returns a secondary, boolean return value indicating success. See [the color.Color interface](https://github.com/lucasb-eyer/go-colorful#the-colorcolor-interface) section and [this FAQ entry](https://github.com/lucasb-eyer/go-colorful#q-why-would-makecolor-ever-fail) for details.
+
+### Version 0.9
+- Initial version number after having ignored versioning for a long time :)
+
+License: MIT
+============
+Copyright (c) 2013 Lucas Beyer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
diff --git a/vendor/github.com/lucasb-eyer/go-colorful/colorgens.go b/vendor/github.com/lucasb-eyer/go-colorful/colorgens.go
new file mode 100644
index 00000000..2e2e49e1
--- /dev/null
+++ b/vendor/github.com/lucasb-eyer/go-colorful/colorgens.go
@@ -0,0 +1,55 @@
+// Various ways to generate single random colors
+
+package colorful
+
+import (
+ "math/rand"
+)
+
+// Creates a random dark, "warm" color through a restricted HSV space.
+func FastWarmColor() Color {
+ return Hsv(
+ rand.Float64()*360.0,
+ 0.5+rand.Float64()*0.3,
+ 0.3+rand.Float64()*0.3)
+}
+
+// Creates a random dark, "warm" color through restricted HCL space.
+// This is slower than FastWarmColor but will likely give you colors which have
+// the same "warmness" if you run it many times.
+func WarmColor() (c Color) {
+ for c = randomWarm(); !c.IsValid(); c = randomWarm() {
+ }
+ return
+}
+
+func randomWarm() Color {
+ return Hcl(
+ rand.Float64()*360.0,
+ 0.1+rand.Float64()*0.3,
+ 0.2+rand.Float64()*0.3)
+}
+
+// Creates a random bright, "pimpy" color through a restricted HSV space.
+func FastHappyColor() Color {
+ return Hsv(
+ rand.Float64()*360.0,
+ 0.7+rand.Float64()*0.3,
+ 0.6+rand.Float64()*0.3)
+}
+
+// Creates a random bright, "pimpy" color through restricted HCL space.
+// This is slower than FastHappyColor but will likely give you colors which
+// have the same "brightness" if you run it many times.
+func HappyColor() (c Color) {
+ for c = randomPimp(); !c.IsValid(); c = randomPimp() {
+ }
+ return
+}
+
+func randomPimp() Color {
+ return Hcl(
+ rand.Float64()*360.0,
+ 0.5+rand.Float64()*0.3,
+ 0.5+rand.Float64()*0.3)
+}
diff --git a/vendor/github.com/lucasb-eyer/go-colorful/colors.go b/vendor/github.com/lucasb-eyer/go-colorful/colors.go
new file mode 100644
index 00000000..febf94c7
--- /dev/null
+++ b/vendor/github.com/lucasb-eyer/go-colorful/colors.go
@@ -0,0 +1,819 @@
+// The colorful package provides all kinds of functions for working with colors.
+package colorful
+
+import (
+ "fmt"
+ "image/color"
+ "math"
+)
+
+// A color is stored internally using sRGB (standard RGB) values in the range 0-1
+type Color struct {
+ R, G, B float64
+}
+
+// Implement the Go color.Color interface.
+func (col Color) RGBA() (r, g, b, a uint32) {
+ r = uint32(col.R*65535.0 + 0.5)
+ g = uint32(col.G*65535.0 + 0.5)
+ b = uint32(col.B*65535.0 + 0.5)
+ a = 0xFFFF
+ return
+}
+
+// Constructs a colorful.Color from something implementing color.Color
+func MakeColor(col color.Color) (Color, bool) {
+ r, g, b, a := col.RGBA()
+ if a == 0 {
+ return Color{0, 0, 0}, false
+ }
+
+ // Since color.Color is alpha pre-multiplied, we need to divide the
+ // RGB values by alpha again in order to get back the original RGB.
+ r *= 0xffff
+ r /= a
+ g *= 0xffff
+ g /= a
+ b *= 0xffff
+ b /= a
+
+ return Color{float64(r) / 65535.0, float64(g) / 65535.0, float64(b) / 65535.0}, true
+}
+
+// Might come in handy sometimes to reduce boilerplate code.
+func (col Color) RGB255() (r, g, b uint8) {
+ r = uint8(col.R*255.0 + 0.5)
+ g = uint8(col.G*255.0 + 0.5)
+ b = uint8(col.B*255.0 + 0.5)
+ return
+}
+
+// This is the tolerance used when comparing colors using AlmostEqualRgb.
+const Delta = 1.0 / 255.0
+
+// This is the default reference white point.
+var D65 = [3]float64{0.95047, 1.00000, 1.08883}
+
+// And another one.
+var D50 = [3]float64{0.96422, 1.00000, 0.82521}
+
+// Checks whether the color exists in RGB space, i.e. all values are in [0..1]
+func (c Color) IsValid() bool {
+ return 0.0 <= c.R && c.R <= 1.0 &&
+ 0.0 <= c.G && c.G <= 1.0 &&
+ 0.0 <= c.B && c.B <= 1.0
+}
+
+func clamp01(v float64) float64 {
+ return math.Max(0.0, math.Min(v, 1.0))
+}
+
+// Returns Clamps the color into valid range, clamping each value to [0..1]
+// If the color is valid already, this is a no-op.
+func (c Color) Clamped() Color {
+ return Color{clamp01(c.R), clamp01(c.G), clamp01(c.B)}
+}
+
+func sq(v float64) float64 {
+ return v * v
+}
+
+func cub(v float64) float64 {
+ return v * v * v
+}
+
+// DistanceRgb computes the distance between two colors in RGB space.
+// This is not a good measure! Rather do it in Lab space.
+func (c1 Color) DistanceRgb(c2 Color) float64 {
+ return math.Sqrt(sq(c1.R-c2.R) + sq(c1.G-c2.G) + sq(c1.B-c2.B))
+}
+
+// Check for equality between colors within the tolerance Delta (1/255).
+func (c1 Color) AlmostEqualRgb(c2 Color) bool {
+ return math.Abs(c1.R-c2.R)+
+ math.Abs(c1.G-c2.G)+
+ math.Abs(c1.B-c2.B) < 3.0*Delta
+}
+
+// You don't really want to use this, do you? Go for BlendLab, BlendLuv or BlendHcl.
+func (c1 Color) BlendRgb(c2 Color, t float64) Color {
+ return Color{c1.R + t*(c2.R-c1.R),
+ c1.G + t*(c2.G-c1.G),
+ c1.B + t*(c2.B-c1.B)}
+}
+
+// Utility used by Hxx color-spaces for interpolating between two angles in [0,360].
+func interp_angle(a0, a1, t float64) float64 {
+ // Based on the answer here: http://stackoverflow.com/a/14498790/2366315
+ // With potential proof that it works here: http://math.stackexchange.com/a/2144499
+ delta := math.Mod(math.Mod(a1-a0, 360.0)+540, 360.0) - 180.0
+ return math.Mod(a0+t*delta+360.0, 360.0)
+}
+
+/// HSV ///
+///////////
+// From http://en.wikipedia.org/wiki/HSL_and_HSV
+// Note that h is in [0..360] and s,v in [0..1]
+
+// Hsv returns the Hue [0..360], Saturation and Value [0..1] of the color.
+func (col Color) Hsv() (h, s, v float64) {
+ min := math.Min(math.Min(col.R, col.G), col.B)
+ v = math.Max(math.Max(col.R, col.G), col.B)
+ C := v - min
+
+ s = 0.0
+ if v != 0.0 {
+ s = C / v
+ }
+
+ h = 0.0 // We use 0 instead of undefined as in wp.
+ if min != v {
+ if v == col.R {
+ h = math.Mod((col.G-col.B)/C, 6.0)
+ }
+ if v == col.G {
+ h = (col.B-col.R)/C + 2.0
+ }
+ if v == col.B {
+ h = (col.R-col.G)/C + 4.0
+ }
+ h *= 60.0
+ if h < 0.0 {
+ h += 360.0
+ }
+ }
+ return
+}
+
+// Hsv creates a new Color given a Hue in [0..360], a Saturation and a Value in [0..1]
+func Hsv(H, S, V float64) Color {
+ Hp := H / 60.0
+ C := V * S
+ X := C * (1.0 - math.Abs(math.Mod(Hp, 2.0)-1.0))
+
+ m := V - C
+ r, g, b := 0.0, 0.0, 0.0
+
+ switch {
+ case 0.0 <= Hp && Hp < 1.0:
+ r = C
+ g = X
+ case 1.0 <= Hp && Hp < 2.0:
+ r = X
+ g = C
+ case 2.0 <= Hp && Hp < 3.0:
+ g = C
+ b = X
+ case 3.0 <= Hp && Hp < 4.0:
+ g = X
+ b = C
+ case 4.0 <= Hp && Hp < 5.0:
+ r = X
+ b = C
+ case 5.0 <= Hp && Hp < 6.0:
+ r = C
+ b = X
+ }
+
+ return Color{m + r, m + g, m + b}
+}
+
+// You don't really want to use this, do you? Go for BlendLab, BlendLuv or BlendHcl.
+func (c1 Color) BlendHsv(c2 Color, t float64) Color {
+ h1, s1, v1 := c1.Hsv()
+ h2, s2, v2 := c2.Hsv()
+
+ // We know that h are both in [0..360]
+ return Hsv(interp_angle(h1, h2, t), s1+t*(s2-s1), v1+t*(v2-v1))
+}
+
+/// HSL ///
+///////////
+
+// Hsl returns the Hue [0..360], Saturation [0..1], and Luminance (lightness) [0..1] of the color.
+func (col Color) Hsl() (h, s, l float64) {
+ min := math.Min(math.Min(col.R, col.G), col.B)
+ max := math.Max(math.Max(col.R, col.G), col.B)
+
+ l = (max + min) / 2
+
+ if min == max {
+ s = 0
+ h = 0
+ } else {
+ if l < 0.5 {
+ s = (max - min) / (max + min)
+ } else {
+ s = (max - min) / (2.0 - max - min)
+ }
+
+ if max == col.R {
+ h = (col.G - col.B) / (max - min)
+ } else if max == col.G {
+ h = 2.0 + (col.B-col.R)/(max-min)
+ } else {
+ h = 4.0 + (col.R-col.G)/(max-min)
+ }
+
+ h *= 60
+
+ if h < 0 {
+ h += 360
+ }
+ }
+
+ return
+}
+
+// Hsl creates a new Color given a Hue in [0..360], a Saturation [0..1], and a Luminance (lightness) in [0..1]
+func Hsl(h, s, l float64) Color {
+ if s == 0 {
+ return Color{l, l, l}
+ }
+
+ var r, g, b float64
+ var t1 float64
+ var t2 float64
+ var tr float64
+ var tg float64
+ var tb float64
+
+ if l < 0.5 {
+ t1 = l * (1.0 + s)
+ } else {
+ t1 = l + s - l*s
+ }
+
+ t2 = 2*l - t1
+ h = h / 360
+ tr = h + 1.0/3.0
+ tg = h
+ tb = h - 1.0/3.0
+
+ if tr < 0 {
+ tr++
+ }
+ if tr > 1 {
+ tr--
+ }
+ if tg < 0 {
+ tg++
+ }
+ if tg > 1 {
+ tg--
+ }
+ if tb < 0 {
+ tb++
+ }
+ if tb > 1 {
+ tb--
+ }
+
+ // Red
+ if 6*tr < 1 {
+ r = t2 + (t1-t2)*6*tr
+ } else if 2*tr < 1 {
+ r = t1
+ } else if 3*tr < 2 {
+ r = t2 + (t1-t2)*(2.0/3.0-tr)*6
+ } else {
+ r = t2
+ }
+
+ // Green
+ if 6*tg < 1 {
+ g = t2 + (t1-t2)*6*tg
+ } else if 2*tg < 1 {
+ g = t1
+ } else if 3*tg < 2 {
+ g = t2 + (t1-t2)*(2.0/3.0-tg)*6
+ } else {
+ g = t2
+ }
+
+ // Blue
+ if 6*tb < 1 {
+ b = t2 + (t1-t2)*6*tb
+ } else if 2*tb < 1 {
+ b = t1
+ } else if 3*tb < 2 {
+ b = t2 + (t1-t2)*(2.0/3.0-tb)*6
+ } else {
+ b = t2
+ }
+
+ return Color{r, g, b}
+}
+
+/// Hex ///
+///////////
+
+// Hex returns the hex "html" representation of the color, as in #ff0080.
+func (col Color) Hex() string {
+ // Add 0.5 for rounding
+ return fmt.Sprintf("#%02x%02x%02x", uint8(col.R*255.0+0.5), uint8(col.G*255.0+0.5), uint8(col.B*255.0+0.5))
+}
+
+// Hex parses a "html" hex color-string, either in the 3 "#f0c" or 6 "#ff1034" digits form.
+func Hex(scol string) (Color, error) {
+ format := "#%02x%02x%02x"
+ factor := 1.0 / 255.0
+ if len(scol) == 4 {
+ format = "#%1x%1x%1x"
+ factor = 1.0 / 15.0
+ }
+
+ var r, g, b uint8
+ n, err := fmt.Sscanf(scol, format, &r, &g, &b)
+ if err != nil {
+ return Color{}, err
+ }
+ if n != 3 {
+ return Color{}, fmt.Errorf("color: %v is not a hex-color", scol)
+ }
+
+ return Color{float64(r) * factor, float64(g) * factor, float64(b) * factor}, nil
+}
+
+/// Linear ///
+//////////////
+// http://www.sjbrown.co.uk/2004/05/14/gamma-correct-rendering/
+// http://www.brucelindbloom.com/Eqn_RGB_to_XYZ.html
+
+func linearize(v float64) float64 {
+ if v <= 0.04045 {
+ return v / 12.92
+ }
+ return math.Pow((v+0.055)/1.055, 2.4)
+}
+
+// LinearRgb converts the color into the linear RGB space (see http://www.sjbrown.co.uk/2004/05/14/gamma-correct-rendering/).
+func (col Color) LinearRgb() (r, g, b float64) {
+ r = linearize(col.R)
+ g = linearize(col.G)
+ b = linearize(col.B)
+ return
+}
+
+// A much faster and still quite precise linearization using a 6th-order Taylor approximation.
+// See the accompanying Jupyter notebook for derivation of the constants.
+func linearize_fast(v float64) float64 {
+ v1 := v - 0.5
+ v2 := v1 * v1
+ v3 := v2 * v1
+ v4 := v2 * v2
+ //v5 := v3*v2
+ return -0.248750514614486 + 0.925583310193438*v + 1.16740237321695*v2 + 0.280457026598666*v3 - 0.0757991963780179*v4 //+ 0.0437040411548932*v5
+}
+
+// FastLinearRgb is much faster than and almost as accurate as LinearRgb.
+// BUT it is important to NOTE that they only produce good results for valid colors r,g,b in [0,1].
+func (col Color) FastLinearRgb() (r, g, b float64) {
+ r = linearize_fast(col.R)
+ g = linearize_fast(col.G)
+ b = linearize_fast(col.B)
+ return
+}
+
+func delinearize(v float64) float64 {
+ if v <= 0.0031308 {
+ return 12.92 * v
+ }
+ return 1.055*math.Pow(v, 1.0/2.4) - 0.055
+}
+
+// LinearRgb creates an sRGB color out of the given linear RGB color (see http://www.sjbrown.co.uk/2004/05/14/gamma-correct-rendering/).
+func LinearRgb(r, g, b float64) Color {
+ return Color{delinearize(r), delinearize(g), delinearize(b)}
+}
+
+func delinearize_fast(v float64) float64 {
+ // This function (fractional root) is much harder to linearize, so we need to split.
+ if v > 0.2 {
+ v1 := v - 0.6
+ v2 := v1 * v1
+ v3 := v2 * v1
+ v4 := v2 * v2
+ v5 := v3 * v2
+ return 0.442430344268235 + 0.592178981271708*v - 0.287864782562636*v2 + 0.253214392068985*v3 - 0.272557158129811*v4 + 0.325554383321718*v5
+ } else if v > 0.03 {
+ v1 := v - 0.115
+ v2 := v1 * v1
+ v3 := v2 * v1
+ v4 := v2 * v2
+ v5 := v3 * v2
+ return 0.194915592891669 + 1.55227076330229*v - 3.93691860257828*v2 + 18.0679839248761*v3 - 101.468750302746*v4 + 632.341487393927*v5
+ } else {
+ v1 := v - 0.015
+ v2 := v1 * v1
+ v3 := v2 * v1
+ v4 := v2 * v2
+ v5 := v3 * v2
+ // You can clearly see from the involved constants that the low-end is highly nonlinear.
+ return 0.0519565234928877 + 5.09316778537561*v - 99.0338180489702*v2 + 3484.52322764895*v3 - 150028.083412663*v4 + 7168008.42971613*v5
+ }
+}
+
+// FastLinearRgb is much faster than and almost as accurate as LinearRgb.
+// BUT it is important to NOTE that they only produce good results for valid inputs r,g,b in [0,1].
+func FastLinearRgb(r, g, b float64) Color {
+ return Color{delinearize_fast(r), delinearize_fast(g), delinearize_fast(b)}
+}
+
+// XyzToLinearRgb converts from CIE XYZ-space to Linear RGB space.
+func XyzToLinearRgb(x, y, z float64) (r, g, b float64) {
+ r = 3.2404542*x - 1.5371385*y - 0.4985314*z
+ g = -0.9692660*x + 1.8760108*y + 0.0415560*z
+ b = 0.0556434*x - 0.2040259*y + 1.0572252*z
+ return
+}
+
+func LinearRgbToXyz(r, g, b float64) (x, y, z float64) {
+ x = 0.4124564*r + 0.3575761*g + 0.1804375*b
+ y = 0.2126729*r + 0.7151522*g + 0.0721750*b
+ z = 0.0193339*r + 0.1191920*g + 0.9503041*b
+ return
+}
+
+/// XYZ ///
+///////////
+// http://www.sjbrown.co.uk/2004/05/14/gamma-correct-rendering/
+
+func (col Color) Xyz() (x, y, z float64) {
+ return LinearRgbToXyz(col.LinearRgb())
+}
+
+func Xyz(x, y, z float64) Color {
+ return LinearRgb(XyzToLinearRgb(x, y, z))
+}
+
+/// xyY ///
+///////////
+// http://www.brucelindbloom.com/Eqn_XYZ_to_xyY.html
+
+// Well, the name is bad, since it's xyY but Golang needs me to start with a
+// capital letter to make the method public.
+func XyzToXyy(X, Y, Z float64) (x, y, Yout float64) {
+ return XyzToXyyWhiteRef(X, Y, Z, D65)
+}
+
+func XyzToXyyWhiteRef(X, Y, Z float64, wref [3]float64) (x, y, Yout float64) {
+ Yout = Y
+ N := X + Y + Z
+ if math.Abs(N) < 1e-14 {
+ // When we have black, Bruce Lindbloom recommends to use
+ // the reference white's chromacity for x and y.
+ x = wref[0] / (wref[0] + wref[1] + wref[2])
+ y = wref[1] / (wref[0] + wref[1] + wref[2])
+ } else {
+ x = X / N
+ y = Y / N
+ }
+ return
+}
+
+func XyyToXyz(x, y, Y float64) (X, Yout, Z float64) {
+ Yout = Y
+
+ if -1e-14 < y && y < 1e-14 {
+ X = 0.0
+ Z = 0.0
+ } else {
+ X = Y / y * x
+ Z = Y / y * (1.0 - x - y)
+ }
+
+ return
+}
+
+// Converts the given color to CIE xyY space using D65 as reference white.
+// (Note that the reference white is only used for black input.)
+// x, y and Y are in [0..1]
+func (col Color) Xyy() (x, y, Y float64) {
+ return XyzToXyy(col.Xyz())
+}
+
+// Converts the given color to CIE xyY space, taking into account
+// a given reference white. (i.e. the monitor's white)
+// (Note that the reference white is only used for black input.)
+// x, y and Y are in [0..1]
+func (col Color) XyyWhiteRef(wref [3]float64) (x, y, Y float64) {
+ X, Y2, Z := col.Xyz()
+ return XyzToXyyWhiteRef(X, Y2, Z, wref)
+}
+
+// Generates a color by using data given in CIE xyY space.
+// x, y and Y are in [0..1]
+func Xyy(x, y, Y float64) Color {
+ return Xyz(XyyToXyz(x, y, Y))
+}
+
+/// L*a*b* ///
+//////////////
+// http://en.wikipedia.org/wiki/Lab_color_space#CIELAB-CIEXYZ_conversions
+// For L*a*b*, we need to L*a*b*<->XYZ->RGB and the first one is device dependent.
+
+func lab_f(t float64) float64 {
+ if t > 6.0/29.0*6.0/29.0*6.0/29.0 {
+ return math.Cbrt(t)
+ }
+ return t/3.0*29.0/6.0*29.0/6.0 + 4.0/29.0
+}
+
+func XyzToLab(x, y, z float64) (l, a, b float64) {
+ // Use D65 white as reference point by default.
+ // http://www.fredmiranda.com/forum/topic/1035332
+ // http://en.wikipedia.org/wiki/Standard_illuminant
+ return XyzToLabWhiteRef(x, y, z, D65)
+}
+
+func XyzToLabWhiteRef(x, y, z float64, wref [3]float64) (l, a, b float64) {
+ fy := lab_f(y / wref[1])
+ l = 1.16*fy - 0.16
+ a = 5.0 * (lab_f(x/wref[0]) - fy)
+ b = 2.0 * (fy - lab_f(z/wref[2]))
+ return
+}
+
+func lab_finv(t float64) float64 {
+ if t > 6.0/29.0 {
+ return t * t * t
+ }
+ return 3.0 * 6.0 / 29.0 * 6.0 / 29.0 * (t - 4.0/29.0)
+}
+
+func LabToXyz(l, a, b float64) (x, y, z float64) {
+ // D65 white (see above).
+ return LabToXyzWhiteRef(l, a, b, D65)
+}
+
+func LabToXyzWhiteRef(l, a, b float64, wref [3]float64) (x, y, z float64) {
+ l2 := (l + 0.16) / 1.16
+ x = wref[0] * lab_finv(l2+a/5.0)
+ y = wref[1] * lab_finv(l2)
+ z = wref[2] * lab_finv(l2-b/2.0)
+ return
+}
+
+// Converts the given color to CIE L*a*b* space using D65 as reference white.
+func (col Color) Lab() (l, a, b float64) {
+ return XyzToLab(col.Xyz())
+}
+
+// Converts the given color to CIE L*a*b* space, taking into account
+// a given reference white. (i.e. the monitor's white)
+func (col Color) LabWhiteRef(wref [3]float64) (l, a, b float64) {
+ x, y, z := col.Xyz()
+ return XyzToLabWhiteRef(x, y, z, wref)
+}
+
+// Generates a color by using data given in CIE L*a*b* space using D65 as reference white.
+// WARNING: many combinations of `l`, `a`, and `b` values do not have corresponding
+// valid RGB values, check the FAQ in the README if you're unsure.
+func Lab(l, a, b float64) Color {
+ return Xyz(LabToXyz(l, a, b))
+}
+
+// Generates a color by using data given in CIE L*a*b* space, taking
+// into account a given reference white. (i.e. the monitor's white)
+func LabWhiteRef(l, a, b float64, wref [3]float64) Color {
+ return Xyz(LabToXyzWhiteRef(l, a, b, wref))
+}
+
+// DistanceLab is a good measure of visual similarity between two colors!
+// A result of 0 would mean identical colors, while a result of 1 or higher
+// means the colors differ a lot.
+func (c1 Color) DistanceLab(c2 Color) float64 {
+ l1, a1, b1 := c1.Lab()
+ l2, a2, b2 := c2.Lab()
+ return math.Sqrt(sq(l1-l2) + sq(a1-a2) + sq(b1-b2))
+}
+
+// That's actually the same, but I don't want to break code.
+func (c1 Color) DistanceCIE76(c2 Color) float64 {
+ return c1.DistanceLab(c2)
+}
+
+// Uses the CIE94 formula to calculate color distance. More accurate than
+// DistanceLab, but also more work.
+func (cl Color) DistanceCIE94(cr Color) float64 {
+ l1, a1, b1 := cl.Lab()
+ l2, a2, b2 := cr.Lab()
+
+ // NOTE: Since all those formulas expect L,a,b values 100x larger than we
+ // have them in this library, we either need to adjust all constants
+ // in the formula, or convert the ranges of L,a,b before, and then
+ // scale the distances down again. The latter is less error-prone.
+ l1, a1, b1 = l1*100.0, a1*100.0, b1*100.0
+ l2, a2, b2 = l2*100.0, a2*100.0, b2*100.0
+
+ kl := 1.0 // 2.0 for textiles
+ kc := 1.0
+ kh := 1.0
+ k1 := 0.045 // 0.048 for textiles
+ k2 := 0.015 // 0.014 for textiles.
+
+ deltaL := l1 - l2
+ c1 := math.Sqrt(sq(a1) + sq(b1))
+ c2 := math.Sqrt(sq(a2) + sq(b2))
+ deltaCab := c1 - c2
+
+ // Not taking Sqrt here for stability, and it's unnecessary.
+ deltaHab2 := sq(a1-a2) + sq(b1-b2) - sq(deltaCab)
+ sl := 1.0
+ sc := 1.0 + k1*c1
+ sh := 1.0 + k2*c1
+
+ vL2 := sq(deltaL / (kl * sl))
+ vC2 := sq(deltaCab / (kc * sc))
+ vH2 := deltaHab2 / sq(kh*sh)
+
+ return math.Sqrt(vL2+vC2+vH2) * 0.01 // See above.
+}
+
+// BlendLab blends two colors in the L*a*b* color-space, which should result in a smoother blend.
+// t == 0 results in c1, t == 1 results in c2
+func (c1 Color) BlendLab(c2 Color, t float64) Color {
+ l1, a1, b1 := c1.Lab()
+ l2, a2, b2 := c2.Lab()
+ return Lab(l1+t*(l2-l1),
+ a1+t*(a2-a1),
+ b1+t*(b2-b1))
+}
+
+/// L*u*v* ///
+//////////////
+// http://en.wikipedia.org/wiki/CIELUV#XYZ_.E2.86.92_CIELUV_and_CIELUV_.E2.86.92_XYZ_conversions
+// For L*u*v*, we need to L*u*v*<->XYZ<->RGB and the first one is device dependent.
+
+func XyzToLuv(x, y, z float64) (l, a, b float64) {
+ // Use D65 white as reference point by default.
+ // http://www.fredmiranda.com/forum/topic/1035332
+ // http://en.wikipedia.org/wiki/Standard_illuminant
+ return XyzToLuvWhiteRef(x, y, z, D65)
+}
+
+func XyzToLuvWhiteRef(x, y, z float64, wref [3]float64) (l, u, v float64) {
+ if y/wref[1] <= 6.0/29.0*6.0/29.0*6.0/29.0 {
+ l = y / wref[1] * 29.0 / 3.0 * 29.0 / 3.0 * 29.0 / 3.0
+ } else {
+ l = 1.16*math.Cbrt(y/wref[1]) - 0.16
+ }
+ ubis, vbis := xyz_to_uv(x, y, z)
+ un, vn := xyz_to_uv(wref[0], wref[1], wref[2])
+ u = 13.0 * l * (ubis - un)
+ v = 13.0 * l * (vbis - vn)
+ return
+}
+
+// For this part, we do as R's graphics.hcl does, not as wikipedia does.
+// Or is it the same?
+func xyz_to_uv(x, y, z float64) (u, v float64) {
+ denom := x + 15.0*y + 3.0*z
+ if denom == 0.0 {
+ u, v = 0.0, 0.0
+ } else {
+ u = 4.0 * x / denom
+ v = 9.0 * y / denom
+ }
+ return
+}
+
+func LuvToXyz(l, u, v float64) (x, y, z float64) {
+ // D65 white (see above).
+ return LuvToXyzWhiteRef(l, u, v, D65)
+}
+
+func LuvToXyzWhiteRef(l, u, v float64, wref [3]float64) (x, y, z float64) {
+ //y = wref[1] * lab_finv((l + 0.16) / 1.16)
+ if l <= 0.08 {
+ y = wref[1] * l * 100.0 * 3.0 / 29.0 * 3.0 / 29.0 * 3.0 / 29.0
+ } else {
+ y = wref[1] * cub((l+0.16)/1.16)
+ }
+ un, vn := xyz_to_uv(wref[0], wref[1], wref[2])
+ if l != 0.0 {
+ ubis := u/(13.0*l) + un
+ vbis := v/(13.0*l) + vn
+ x = y * 9.0 * ubis / (4.0 * vbis)
+ z = y * (12.0 - 3.0*ubis - 20.0*vbis) / (4.0 * vbis)
+ } else {
+ x, y = 0.0, 0.0
+ }
+ return
+}
+
+// Converts the given color to CIE L*u*v* space using D65 as reference white.
+// L* is in [0..1] and both u* and v* are in about [-1..1]
+func (col Color) Luv() (l, u, v float64) {
+ return XyzToLuv(col.Xyz())
+}
+
+// Converts the given color to CIE L*u*v* space, taking into account
+// a given reference white. (i.e. the monitor's white)
+// L* is in [0..1] and both u* and v* are in about [-1..1]
+func (col Color) LuvWhiteRef(wref [3]float64) (l, u, v float64) {
+ x, y, z := col.Xyz()
+ return XyzToLuvWhiteRef(x, y, z, wref)
+}
+
+// Generates a color by using data given in CIE L*u*v* space using D65 as reference white.
+// L* is in [0..1] and both u* and v* are in about [-1..1]
+// WARNING: many combinations of `l`, `a`, and `b` values do not have corresponding
+// valid RGB values, check the FAQ in the README if you're unsure.
+func Luv(l, u, v float64) Color {
+ return Xyz(LuvToXyz(l, u, v))
+}
+
+// Generates a color by using data given in CIE L*u*v* space, taking
+// into account a given reference white. (i.e. the monitor's white)
+// L* is in [0..1] and both u* and v* are in about [-1..1]
+func LuvWhiteRef(l, u, v float64, wref [3]float64) Color {
+ return Xyz(LuvToXyzWhiteRef(l, u, v, wref))
+}
+
+// DistanceLuv is a good measure of visual similarity between two colors!
+// A result of 0 would mean identical colors, while a result of 1 or higher
+// means the colors differ a lot.
+func (c1 Color) DistanceLuv(c2 Color) float64 {
+ l1, u1, v1 := c1.Luv()
+ l2, u2, v2 := c2.Luv()
+ return math.Sqrt(sq(l1-l2) + sq(u1-u2) + sq(v1-v2))
+}
+
+// BlendLuv blends two colors in the CIE-L*u*v* color-space, which should result in a smoother blend.
+// t == 0 results in c1, t == 1 results in c2
+func (c1 Color) BlendLuv(c2 Color, t float64) Color {
+ l1, u1, v1 := c1.Luv()
+ l2, u2, v2 := c2.Luv()
+ return Luv(l1+t*(l2-l1),
+ u1+t*(u2-u1),
+ v1+t*(v2-v1))
+}
+
+/// HCL ///
+///////////
+// HCL is nothing else than L*a*b* in cylindrical coordinates!
+// (this was wrong on English wikipedia, I fixed it, let's hope the fix stays.)
+// But it is widely popular since it is a "correct HSV"
+// http://www.hunterlab.com/appnotes/an09_96a.pdf
+
+// Converts the given color to HCL space using D65 as reference white.
+// H values are in [0..360], C and L values are in [0..1] although C can overshoot 1.0
+func (col Color) Hcl() (h, c, l float64) {
+ return col.HclWhiteRef(D65)
+}
+
+func LabToHcl(L, a, b float64) (h, c, l float64) {
+ // Oops, floating point workaround necessary if a ~= b and both are very small (i.e. almost zero).
+ if math.Abs(b-a) > 1e-4 && math.Abs(a) > 1e-4 {
+ h = math.Mod(57.29577951308232087721*math.Atan2(b, a)+360.0, 360.0) // Rad2Deg
+ } else {
+ h = 0.0
+ }
+ c = math.Sqrt(sq(a) + sq(b))
+ l = L
+ return
+}
+
+// Converts the given color to HCL space, taking into account
+// a given reference white. (i.e. the monitor's white)
+// H values are in [0..360], C and L values are in [0..1]
+func (col Color) HclWhiteRef(wref [3]float64) (h, c, l float64) {
+ L, a, b := col.LabWhiteRef(wref)
+ return LabToHcl(L, a, b)
+}
+
+// Generates a color by using data given in HCL space using D65 as reference white.
+// H values are in [0..360], C and L values are in [0..1]
+// WARNING: many combinations of `l`, `a`, and `b` values do not have corresponding
+// valid RGB values, check the FAQ in the README if you're unsure.
+func Hcl(h, c, l float64) Color {
+ return HclWhiteRef(h, c, l, D65)
+}
+
+func HclToLab(h, c, l float64) (L, a, b float64) {
+ H := 0.01745329251994329576 * h // Deg2Rad
+ a = c * math.Cos(H)
+ b = c * math.Sin(H)
+ L = l
+ return
+}
+
+// Generates a color by using data given in HCL space, taking
+// into account a given reference white. (i.e. the monitor's white)
+// H values are in [0..360], C and L values are in [0..1]
+func HclWhiteRef(h, c, l float64, wref [3]float64) Color {
+ L, a, b := HclToLab(h, c, l)
+ return LabWhiteRef(L, a, b, wref)
+}
+
+// BlendHcl blends two colors in the CIE-L*C*h° color-space, which should result in a smoother blend.
+// t == 0 results in c1, t == 1 results in c2
+func (col1 Color) BlendHcl(col2 Color, t float64) Color {
+ h1, c1, l1 := col1.Hcl()
+ h2, c2, l2 := col2.Hcl()
+
+ // We know that h are both in [0..360]
+ return Hcl(interp_angle(h1, h2, t), c1+t*(c2-c1), l1+t*(l2-l1))
+}
diff --git a/vendor/github.com/lucasb-eyer/go-colorful/happy_palettegen.go b/vendor/github.com/lucasb-eyer/go-colorful/happy_palettegen.go
new file mode 100644
index 00000000..bb66dfa4
--- /dev/null
+++ b/vendor/github.com/lucasb-eyer/go-colorful/happy_palettegen.go
@@ -0,0 +1,25 @@
+package colorful
+
+import (
+ "math/rand"
+)
+
+// Uses the HSV color space to generate colors with similar S,V but distributed
+// evenly along their Hue. This is fast but not always pretty.
+// If you've got time to spare, use Lab (the non-fast below).
+func FastHappyPalette(colorsCount int) (colors []Color) {
+ colors = make([]Color, colorsCount)
+
+ for i := 0; i < colorsCount; i++ {
+ colors[i] = Hsv(float64(i)*(360.0/float64(colorsCount)), 0.8+rand.Float64()*0.2, 0.65+rand.Float64()*0.2)
+ }
+ return
+}
+
+func HappyPalette(colorsCount int) ([]Color, error) {
+ pimpy := func(l, a, b float64) bool {
+ _, c, _ := LabToHcl(l, a, b)
+ return 0.3 <= c && 0.4 <= l && l <= 0.8
+ }
+ return SoftPaletteEx(colorsCount, SoftPaletteSettings{pimpy, 50, true})
+}
diff --git a/vendor/github.com/lucasb-eyer/go-colorful/hexcolor.go b/vendor/github.com/lucasb-eyer/go-colorful/hexcolor.go
new file mode 100644
index 00000000..86a5ed98
--- /dev/null
+++ b/vendor/github.com/lucasb-eyer/go-colorful/hexcolor.go
@@ -0,0 +1,37 @@
+package colorful
+
+import (
+ "database/sql/driver"
+ "fmt"
+ "reflect"
+)
+
+// A HexColor is a Color stored as a hex string "#rrggbb". It implements the
+// database/sql.Scanner and database/sql/driver.Value interfaces.
+type HexColor Color
+
+type errUnsupportedType struct {
+ got interface{}
+ want reflect.Type
+}
+
+func (hc *HexColor) Scan(value interface{}) error {
+ s, ok := value.(string)
+ if !ok {
+ return errUnsupportedType{got: reflect.TypeOf(value), want: reflect.TypeOf("")}
+ }
+ c, err := Hex(s)
+ if err != nil {
+ return err
+ }
+ *hc = HexColor(c)
+ return nil
+}
+
+func (hc *HexColor) Value() (driver.Value, error) {
+ return Color(*hc).Hex(), nil
+}
+
+func (e errUnsupportedType) Error() string {
+ return fmt.Sprintf("unsupported type: got %v, want a %s", e.got, e.want)
+}
diff --git a/vendor/github.com/lucasb-eyer/go-colorful/soft_palettegen.go b/vendor/github.com/lucasb-eyer/go-colorful/soft_palettegen.go
new file mode 100644
index 00000000..0154ac9b
--- /dev/null
+++ b/vendor/github.com/lucasb-eyer/go-colorful/soft_palettegen.go
@@ -0,0 +1,185 @@
+// Largely inspired by the descriptions in http://lab.medialab.sciences-po.fr/iwanthue/
+// but written from scratch.
+
+package colorful
+
+import (
+ "fmt"
+ "math"
+ "math/rand"
+)
+
+// The algorithm works in L*a*b* color space and converts to RGB in the end.
+// L* in [0..1], a* and b* in [-1..1]
+type lab_t struct {
+ L, A, B float64
+}
+
+type SoftPaletteSettings struct {
+ // A function which can be used to restrict the allowed color-space.
+ CheckColor func(l, a, b float64) bool
+
+ // The higher, the better quality but the slower. Usually two figures.
+ Iterations int
+
+ // Use up to 160000 or 8000 samples of the L*a*b* space (and thus calls to CheckColor).
+ // Set this to true only if your CheckColor shapes the Lab space weirdly.
+ ManySamples bool
+}
+
+// Yeah, windows-stype Foo, FooEx, screw you golang...
+// Uses K-means to cluster the color-space and return the means of the clusters
+// as a new palette of distinctive colors. Falls back to K-medoid if the mean
+// happens to fall outside of the color-space, which can only happen if you
+// specify a CheckColor function.
+func SoftPaletteEx(colorsCount int, settings SoftPaletteSettings) ([]Color, error) {
+
+ // Checks whether it's a valid RGB and also fulfills the potentially provided constraint.
+ check := func(col lab_t) bool {
+ c := Lab(col.L, col.A, col.B)
+ return c.IsValid() && (settings.CheckColor == nil || settings.CheckColor(col.L, col.A, col.B))
+ }
+
+ // Sample the color space. These will be the points k-means is run on.
+ dl := 0.05
+ dab := 0.1
+ if settings.ManySamples {
+ dl = 0.01
+ dab = 0.05
+ }
+
+ samples := make([]lab_t, 0, int(1.0/dl*2.0/dab*2.0/dab))
+ for l := 0.0; l <= 1.0; l += dl {
+ for a := -1.0; a <= 1.0; a += dab {
+ for b := -1.0; b <= 1.0; b += dab {
+ if check(lab_t{l, a, b}) {
+ samples = append(samples, lab_t{l, a, b})
+ }
+ }
+ }
+ }
+
+ // That would cause some infinite loops down there...
+ if len(samples) < colorsCount {
+ return nil, fmt.Errorf("palettegen: more colors requested (%v) than samples available (%v). Your requested color count may be wrong, you might want to use many samples or your constraint function makes the valid color space too small.", colorsCount, len(samples))
+ } else if len(samples) == colorsCount {
+ return labs2cols(samples), nil // Oops?
+ }
+
+ // We take the initial means out of the samples, so they are in fact medoids.
+ // This helps us avoid infinite loops or arbitrary cutoffs with too restrictive constraints.
+ means := make([]lab_t, colorsCount)
+ for i := 0; i < colorsCount; i++ {
+ for means[i] = samples[rand.Intn(len(samples))]; in(means, i, means[i]); means[i] = samples[rand.Intn(len(samples))] {
+ }
+ }
+
+ clusters := make([]int, len(samples))
+ samples_used := make([]bool, len(samples))
+
+ // The actual k-means/medoid iterations
+ for i := 0; i < settings.Iterations; i++ {
+ // Reassing the samples to clusters, i.e. to their closest mean.
+ // By the way, also check if any sample is used as a medoid and if so, mark that.
+ for isample, sample := range samples {
+ samples_used[isample] = false
+ mindist := math.Inf(+1)
+ for imean, mean := range means {
+ dist := lab_dist(sample, mean)
+ if dist < mindist {
+ mindist = dist
+ clusters[isample] = imean
+ }
+
+ // Mark samples which are used as a medoid.
+ if lab_eq(sample, mean) {
+ samples_used[isample] = true
+ }
+ }
+ }
+
+ // Compute new means according to the samples.
+ for imean := range means {
+ // The new mean is the average of all samples belonging to it..
+ nsamples := 0
+ newmean := lab_t{0.0, 0.0, 0.0}
+ for isample, sample := range samples {
+ if clusters[isample] == imean {
+ nsamples++
+ newmean.L += sample.L
+ newmean.A += sample.A
+ newmean.B += sample.B
+ }
+ }
+ if nsamples > 0 {
+ newmean.L /= float64(nsamples)
+ newmean.A /= float64(nsamples)
+ newmean.B /= float64(nsamples)
+ } else {
+ // That mean doesn't have any samples? Get a new mean from the sample list!
+ var inewmean int
+ for inewmean = rand.Intn(len(samples_used)); samples_used[inewmean]; inewmean = rand.Intn(len(samples_used)) {
+ }
+ newmean = samples[inewmean]
+ samples_used[inewmean] = true
+ }
+
+ // But now we still need to check whether the new mean is an allowed color.
+ if nsamples > 0 && check(newmean) {
+ // It does, life's good (TM)
+ means[imean] = newmean
+ } else {
+ // New mean isn't an allowed color or doesn't have any samples!
+ // Switch to medoid mode and pick the closest (unused) sample.
+ // This should always find something thanks to len(samples) >= colorsCount
+ mindist := math.Inf(+1)
+ for isample, sample := range samples {
+ if !samples_used[isample] {
+ dist := lab_dist(sample, newmean)
+ if dist < mindist {
+ mindist = dist
+ newmean = sample
+ }
+ }
+ }
+ }
+ }
+ }
+ return labs2cols(means), nil
+}
+
+// A wrapper which uses common parameters.
+func SoftPalette(colorsCount int) ([]Color, error) {
+ return SoftPaletteEx(colorsCount, SoftPaletteSettings{nil, 50, false})
+}
+
+func in(haystack []lab_t, upto int, needle lab_t) bool {
+ for i := 0; i < upto && i < len(haystack); i++ {
+ if haystack[i] == needle {
+ return true
+ }
+ }
+ return false
+}
+
+const LAB_DELTA = 1e-6
+
+func lab_eq(lab1, lab2 lab_t) bool {
+ return math.Abs(lab1.L-lab2.L) < LAB_DELTA &&
+ math.Abs(lab1.A-lab2.A) < LAB_DELTA &&
+ math.Abs(lab1.B-lab2.B) < LAB_DELTA
+}
+
+// That's faster than using colorful's DistanceLab since we would have to
+// convert back and forth for that. Here is no conversion.
+func lab_dist(lab1, lab2 lab_t) float64 {
+ return math.Sqrt(sq(lab1.L-lab2.L) + sq(lab1.A-lab2.A) + sq(lab1.B-lab2.B))
+}
+
+func labs2cols(labs []lab_t) (cols []Color) {
+ cols = make([]Color, len(labs))
+ for k, v := range labs {
+ cols[k] = Lab(v.L, v.A, v.B)
+ }
+ return cols
+}
diff --git a/vendor/github.com/lucasb-eyer/go-colorful/warm_palettegen.go b/vendor/github.com/lucasb-eyer/go-colorful/warm_palettegen.go
new file mode 100644
index 00000000..00f42a5c
--- /dev/null
+++ b/vendor/github.com/lucasb-eyer/go-colorful/warm_palettegen.go
@@ -0,0 +1,25 @@
+package colorful
+
+import (
+ "math/rand"
+)
+
+// Uses the HSV color space to generate colors with similar S,V but distributed
+// evenly along their Hue. This is fast but not always pretty.
+// If you've got time to spare, use Lab (the non-fast below).
+func FastWarmPalette(colorsCount int) (colors []Color) {
+ colors = make([]Color, colorsCount)
+
+ for i := 0; i < colorsCount; i++ {
+ colors[i] = Hsv(float64(i)*(360.0/float64(colorsCount)), 0.55+rand.Float64()*0.2, 0.35+rand.Float64()*0.2)
+ }
+ return
+}
+
+func WarmPalette(colorsCount int) ([]Color, error) {
+ warmy := func(l, a, b float64) bool {
+ _, c, _ := LabToHcl(l, a, b)
+ return 0.1 <= c && c <= 0.4 && 0.2 <= l && l <= 0.5
+ }
+ return SoftPaletteEx(colorsCount, SoftPaletteSettings{warmy, 50, true})
+}
diff --git a/vendor/github.com/mattn/go-runewidth/.travis.yml b/vendor/github.com/mattn/go-runewidth/.travis.yml
new file mode 100644
index 00000000..5c9c2a30
--- /dev/null
+++ b/vendor/github.com/mattn/go-runewidth/.travis.yml
@@ -0,0 +1,8 @@
+language: go
+go:
+ - tip
+before_install:
+ - go get github.com/mattn/goveralls
+ - go get golang.org/x/tools/cmd/cover
+script:
+ - $HOME/gopath/bin/goveralls -repotoken lAKAWPzcGsD3A8yBX3BGGtRUdJ6CaGERL
diff --git a/vendor/github.com/mattn/go-runewidth/LICENSE b/vendor/github.com/mattn/go-runewidth/LICENSE
new file mode 100644
index 00000000..91b5cef3
--- /dev/null
+++ b/vendor/github.com/mattn/go-runewidth/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Yasuhiro Matsumoto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/vendor/github.com/mattn/go-runewidth/README.mkd b/vendor/github.com/mattn/go-runewidth/README.mkd
new file mode 100644
index 00000000..66663a94
--- /dev/null
+++ b/vendor/github.com/mattn/go-runewidth/README.mkd
@@ -0,0 +1,27 @@
+go-runewidth
+============
+
+[](https://travis-ci.org/mattn/go-runewidth)
+[](https://coveralls.io/r/mattn/go-runewidth?branch=HEAD)
+[](http://godoc.org/github.com/mattn/go-runewidth)
+[](https://goreportcard.com/report/github.com/mattn/go-runewidth)
+
+Provides functions to get fixed width of the character or string.
+
+Usage
+-----
+
+```go
+runewidth.StringWidth("つのだ☆HIRO") == 12
+```
+
+
+Author
+------
+
+Yasuhiro Matsumoto
+
+License
+-------
+
+under the MIT License: http://mattn.mit-license.org/2013
diff --git a/vendor/github.com/mattn/go-runewidth/runewidth.go b/vendor/github.com/mattn/go-runewidth/runewidth.go
new file mode 100644
index 00000000..2164497a
--- /dev/null
+++ b/vendor/github.com/mattn/go-runewidth/runewidth.go
@@ -0,0 +1,1223 @@
+package runewidth
+
+var (
+ // EastAsianWidth will be set true if the current locale is CJK
+ EastAsianWidth = IsEastAsian()
+
+ // DefaultCondition is a condition in current locale
+ DefaultCondition = &Condition{EastAsianWidth}
+)
+
+type interval struct {
+ first rune
+ last rune
+}
+
+type table []interval
+
+func inTables(r rune, ts ...table) bool {
+ for _, t := range ts {
+ if inTable(r, t) {
+ return true
+ }
+ }
+ return false
+}
+
+func inTable(r rune, t table) bool {
+ // func (t table) IncludesRune(r rune) bool {
+ if r < t[0].first {
+ return false
+ }
+
+ bot := 0
+ top := len(t) - 1
+ for top >= bot {
+ mid := (bot + top) / 2
+
+ switch {
+ case t[mid].last < r:
+ bot = mid + 1
+ case t[mid].first > r:
+ top = mid - 1
+ default:
+ return true
+ }
+ }
+
+ return false
+}
+
+var private = table{
+ {0x00E000, 0x00F8FF}, {0x0F0000, 0x0FFFFD}, {0x100000, 0x10FFFD},
+}
+
+var nonprint = table{
+ {0x0000, 0x001F}, {0x007F, 0x009F}, {0x00AD, 0x00AD},
+ {0x070F, 0x070F}, {0x180B, 0x180E}, {0x200B, 0x200F},
+ {0x202A, 0x202E}, {0x206A, 0x206F}, {0xD800, 0xDFFF},
+ {0xFEFF, 0xFEFF}, {0xFFF9, 0xFFFB}, {0xFFFE, 0xFFFF},
+}
+
+var combining = table{
+ {0x0300, 0x036F}, {0x0483, 0x0489}, {0x0591, 0x05BD},
+ {0x05BF, 0x05BF}, {0x05C1, 0x05C2}, {0x05C4, 0x05C5},
+ {0x05C7, 0x05C7}, {0x0610, 0x061A}, {0x064B, 0x065F},
+ {0x0670, 0x0670}, {0x06D6, 0x06DC}, {0x06DF, 0x06E4},
+ {0x06E7, 0x06E8}, {0x06EA, 0x06ED}, {0x0711, 0x0711},
+ {0x0730, 0x074A}, {0x07A6, 0x07B0}, {0x07EB, 0x07F3},
+ {0x0816, 0x0819}, {0x081B, 0x0823}, {0x0825, 0x0827},
+ {0x0829, 0x082D}, {0x0859, 0x085B}, {0x08D4, 0x08E1},
+ {0x08E3, 0x0903}, {0x093A, 0x093C}, {0x093E, 0x094F},
+ {0x0951, 0x0957}, {0x0962, 0x0963}, {0x0981, 0x0983},
+ {0x09BC, 0x09BC}, {0x09BE, 0x09C4}, {0x09C7, 0x09C8},
+ {0x09CB, 0x09CD}, {0x09D7, 0x09D7}, {0x09E2, 0x09E3},
+ {0x0A01, 0x0A03}, {0x0A3C, 0x0A3C}, {0x0A3E, 0x0A42},
+ {0x0A47, 0x0A48}, {0x0A4B, 0x0A4D}, {0x0A51, 0x0A51},
+ {0x0A70, 0x0A71}, {0x0A75, 0x0A75}, {0x0A81, 0x0A83},
+ {0x0ABC, 0x0ABC}, {0x0ABE, 0x0AC5}, {0x0AC7, 0x0AC9},
+ {0x0ACB, 0x0ACD}, {0x0AE2, 0x0AE3}, {0x0B01, 0x0B03},
+ {0x0B3C, 0x0B3C}, {0x0B3E, 0x0B44}, {0x0B47, 0x0B48},
+ {0x0B4B, 0x0B4D}, {0x0B56, 0x0B57}, {0x0B62, 0x0B63},
+ {0x0B82, 0x0B82}, {0x0BBE, 0x0BC2}, {0x0BC6, 0x0BC8},
+ {0x0BCA, 0x0BCD}, {0x0BD7, 0x0BD7}, {0x0C00, 0x0C03},
+ {0x0C3E, 0x0C44}, {0x0C46, 0x0C48}, {0x0C4A, 0x0C4D},
+ {0x0C55, 0x0C56}, {0x0C62, 0x0C63}, {0x0C81, 0x0C83},
+ {0x0CBC, 0x0CBC}, {0x0CBE, 0x0CC4}, {0x0CC6, 0x0CC8},
+ {0x0CCA, 0x0CCD}, {0x0CD5, 0x0CD6}, {0x0CE2, 0x0CE3},
+ {0x0D01, 0x0D03}, {0x0D3E, 0x0D44}, {0x0D46, 0x0D48},
+ {0x0D4A, 0x0D4D}, {0x0D57, 0x0D57}, {0x0D62, 0x0D63},
+ {0x0D82, 0x0D83}, {0x0DCA, 0x0DCA}, {0x0DCF, 0x0DD4},
+ {0x0DD6, 0x0DD6}, {0x0DD8, 0x0DDF}, {0x0DF2, 0x0DF3},
+ {0x0E31, 0x0E31}, {0x0E34, 0x0E3A}, {0x0E47, 0x0E4E},
+ {0x0EB1, 0x0EB1}, {0x0EB4, 0x0EB9}, {0x0EBB, 0x0EBC},
+ {0x0EC8, 0x0ECD}, {0x0F18, 0x0F19}, {0x0F35, 0x0F35},
+ {0x0F37, 0x0F37}, {0x0F39, 0x0F39}, {0x0F3E, 0x0F3F},
+ {0x0F71, 0x0F84}, {0x0F86, 0x0F87}, {0x0F8D, 0x0F97},
+ {0x0F99, 0x0FBC}, {0x0FC6, 0x0FC6}, {0x102B, 0x103E},
+ {0x1056, 0x1059}, {0x105E, 0x1060}, {0x1062, 0x1064},
+ {0x1067, 0x106D}, {0x1071, 0x1074}, {0x1082, 0x108D},
+ {0x108F, 0x108F}, {0x109A, 0x109D}, {0x135D, 0x135F},
+ {0x1712, 0x1714}, {0x1732, 0x1734}, {0x1752, 0x1753},
+ {0x1772, 0x1773}, {0x17B4, 0x17D3}, {0x17DD, 0x17DD},
+ {0x180B, 0x180D}, {0x1885, 0x1886}, {0x18A9, 0x18A9},
+ {0x1920, 0x192B}, {0x1930, 0x193B}, {0x1A17, 0x1A1B},
+ {0x1A55, 0x1A5E}, {0x1A60, 0x1A7C}, {0x1A7F, 0x1A7F},
+ {0x1AB0, 0x1ABE}, {0x1B00, 0x1B04}, {0x1B34, 0x1B44},
+ {0x1B6B, 0x1B73}, {0x1B80, 0x1B82}, {0x1BA1, 0x1BAD},
+ {0x1BE6, 0x1BF3}, {0x1C24, 0x1C37}, {0x1CD0, 0x1CD2},
+ {0x1CD4, 0x1CE8}, {0x1CED, 0x1CED}, {0x1CF2, 0x1CF4},
+ {0x1CF8, 0x1CF9}, {0x1DC0, 0x1DF5}, {0x1DFB, 0x1DFF},
+ {0x20D0, 0x20F0}, {0x2CEF, 0x2CF1}, {0x2D7F, 0x2D7F},
+ {0x2DE0, 0x2DFF}, {0x302A, 0x302F}, {0x3099, 0x309A},
+ {0xA66F, 0xA672}, {0xA674, 0xA67D}, {0xA69E, 0xA69F},
+ {0xA6F0, 0xA6F1}, {0xA802, 0xA802}, {0xA806, 0xA806},
+ {0xA80B, 0xA80B}, {0xA823, 0xA827}, {0xA880, 0xA881},
+ {0xA8B4, 0xA8C5}, {0xA8E0, 0xA8F1}, {0xA926, 0xA92D},
+ {0xA947, 0xA953}, {0xA980, 0xA983}, {0xA9B3, 0xA9C0},
+ {0xA9E5, 0xA9E5}, {0xAA29, 0xAA36}, {0xAA43, 0xAA43},
+ {0xAA4C, 0xAA4D}, {0xAA7B, 0xAA7D}, {0xAAB0, 0xAAB0},
+ {0xAAB2, 0xAAB4}, {0xAAB7, 0xAAB8}, {0xAABE, 0xAABF},
+ {0xAAC1, 0xAAC1}, {0xAAEB, 0xAAEF}, {0xAAF5, 0xAAF6},
+ {0xABE3, 0xABEA}, {0xABEC, 0xABED}, {0xFB1E, 0xFB1E},
+ {0xFE00, 0xFE0F}, {0xFE20, 0xFE2F}, {0x101FD, 0x101FD},
+ {0x102E0, 0x102E0}, {0x10376, 0x1037A}, {0x10A01, 0x10A03},
+ {0x10A05, 0x10A06}, {0x10A0C, 0x10A0F}, {0x10A38, 0x10A3A},
+ {0x10A3F, 0x10A3F}, {0x10AE5, 0x10AE6}, {0x11000, 0x11002},
+ {0x11038, 0x11046}, {0x1107F, 0x11082}, {0x110B0, 0x110BA},
+ {0x11100, 0x11102}, {0x11127, 0x11134}, {0x11173, 0x11173},
+ {0x11180, 0x11182}, {0x111B3, 0x111C0}, {0x111CA, 0x111CC},
+ {0x1122C, 0x11237}, {0x1123E, 0x1123E}, {0x112DF, 0x112EA},
+ {0x11300, 0x11303}, {0x1133C, 0x1133C}, {0x1133E, 0x11344},
+ {0x11347, 0x11348}, {0x1134B, 0x1134D}, {0x11357, 0x11357},
+ {0x11362, 0x11363}, {0x11366, 0x1136C}, {0x11370, 0x11374},
+ {0x11435, 0x11446}, {0x114B0, 0x114C3}, {0x115AF, 0x115B5},
+ {0x115B8, 0x115C0}, {0x115DC, 0x115DD}, {0x11630, 0x11640},
+ {0x116AB, 0x116B7}, {0x1171D, 0x1172B}, {0x11C2F, 0x11C36},
+ {0x11C38, 0x11C3F}, {0x11C92, 0x11CA7}, {0x11CA9, 0x11CB6},
+ {0x16AF0, 0x16AF4}, {0x16B30, 0x16B36}, {0x16F51, 0x16F7E},
+ {0x16F8F, 0x16F92}, {0x1BC9D, 0x1BC9E}, {0x1D165, 0x1D169},
+ {0x1D16D, 0x1D172}, {0x1D17B, 0x1D182}, {0x1D185, 0x1D18B},
+ {0x1D1AA, 0x1D1AD}, {0x1D242, 0x1D244}, {0x1DA00, 0x1DA36},
+ {0x1DA3B, 0x1DA6C}, {0x1DA75, 0x1DA75}, {0x1DA84, 0x1DA84},
+ {0x1DA9B, 0x1DA9F}, {0x1DAA1, 0x1DAAF}, {0x1E000, 0x1E006},
+ {0x1E008, 0x1E018}, {0x1E01B, 0x1E021}, {0x1E023, 0x1E024},
+ {0x1E026, 0x1E02A}, {0x1E8D0, 0x1E8D6}, {0x1E944, 0x1E94A},
+ {0xE0100, 0xE01EF},
+}
+
+var doublewidth = table{
+ {0x1100, 0x115F}, {0x231A, 0x231B}, {0x2329, 0x232A},
+ {0x23E9, 0x23EC}, {0x23F0, 0x23F0}, {0x23F3, 0x23F3},
+ {0x25FD, 0x25FE}, {0x2614, 0x2615}, {0x2648, 0x2653},
+ {0x267F, 0x267F}, {0x2693, 0x2693}, {0x26A1, 0x26A1},
+ {0x26AA, 0x26AB}, {0x26BD, 0x26BE}, {0x26C4, 0x26C5},
+ {0x26CE, 0x26CE}, {0x26D4, 0x26D4}, {0x26EA, 0x26EA},
+ {0x26F2, 0x26F3}, {0x26F5, 0x26F5}, {0x26FA, 0x26FA},
+ {0x26FD, 0x26FD}, {0x2705, 0x2705}, {0x270A, 0x270B},
+ {0x2728, 0x2728}, {0x274C, 0x274C}, {0x274E, 0x274E},
+ {0x2753, 0x2755}, {0x2757, 0x2757}, {0x2795, 0x2797},
+ {0x27B0, 0x27B0}, {0x27BF, 0x27BF}, {0x2B1B, 0x2B1C},
+ {0x2B50, 0x2B50}, {0x2B55, 0x2B55}, {0x2E80, 0x2E99},
+ {0x2E9B, 0x2EF3}, {0x2F00, 0x2FD5}, {0x2FF0, 0x2FFB},
+ {0x3000, 0x303E}, {0x3041, 0x3096}, {0x3099, 0x30FF},
+ {0x3105, 0x312D}, {0x3131, 0x318E}, {0x3190, 0x31BA},
+ {0x31C0, 0x31E3}, {0x31F0, 0x321E}, {0x3220, 0x3247},
+ {0x3250, 0x32FE}, {0x3300, 0x4DBF}, {0x4E00, 0xA48C},
+ {0xA490, 0xA4C6}, {0xA960, 0xA97C}, {0xAC00, 0xD7A3},
+ {0xF900, 0xFAFF}, {0xFE10, 0xFE19}, {0xFE30, 0xFE52},
+ {0xFE54, 0xFE66}, {0xFE68, 0xFE6B}, {0xFF01, 0xFF60},
+ {0xFFE0, 0xFFE6}, {0x16FE0, 0x16FE0}, {0x17000, 0x187EC},
+ {0x18800, 0x18AF2}, {0x1B000, 0x1B001}, {0x1F004, 0x1F004},
+ {0x1F0CF, 0x1F0CF}, {0x1F18E, 0x1F18E}, {0x1F191, 0x1F19A},
+ {0x1F200, 0x1F202}, {0x1F210, 0x1F23B}, {0x1F240, 0x1F248},
+ {0x1F250, 0x1F251}, {0x1F300, 0x1F320}, {0x1F32D, 0x1F335},
+ {0x1F337, 0x1F37C}, {0x1F37E, 0x1F393}, {0x1F3A0, 0x1F3CA},
+ {0x1F3CF, 0x1F3D3}, {0x1F3E0, 0x1F3F0}, {0x1F3F4, 0x1F3F4},
+ {0x1F3F8, 0x1F43E}, {0x1F440, 0x1F440}, {0x1F442, 0x1F4FC},
+ {0x1F4FF, 0x1F53D}, {0x1F54B, 0x1F54E}, {0x1F550, 0x1F567},
+ {0x1F57A, 0x1F57A}, {0x1F595, 0x1F596}, {0x1F5A4, 0x1F5A4},
+ {0x1F5FB, 0x1F64F}, {0x1F680, 0x1F6C5}, {0x1F6CC, 0x1F6CC},
+ {0x1F6D0, 0x1F6D2}, {0x1F6EB, 0x1F6EC}, {0x1F6F4, 0x1F6F6},
+ {0x1F910, 0x1F91E}, {0x1F920, 0x1F927}, {0x1F930, 0x1F930},
+ {0x1F933, 0x1F93E}, {0x1F940, 0x1F94B}, {0x1F950, 0x1F95E},
+ {0x1F980, 0x1F991}, {0x1F9C0, 0x1F9C0}, {0x20000, 0x2FFFD},
+ {0x30000, 0x3FFFD},
+}
+
+var ambiguous = table{
+ {0x00A1, 0x00A1}, {0x00A4, 0x00A4}, {0x00A7, 0x00A8},
+ {0x00AA, 0x00AA}, {0x00AD, 0x00AE}, {0x00B0, 0x00B4},
+ {0x00B6, 0x00BA}, {0x00BC, 0x00BF}, {0x00C6, 0x00C6},
+ {0x00D0, 0x00D0}, {0x00D7, 0x00D8}, {0x00DE, 0x00E1},
+ {0x00E6, 0x00E6}, {0x00E8, 0x00EA}, {0x00EC, 0x00ED},
+ {0x00F0, 0x00F0}, {0x00F2, 0x00F3}, {0x00F7, 0x00FA},
+ {0x00FC, 0x00FC}, {0x00FE, 0x00FE}, {0x0101, 0x0101},
+ {0x0111, 0x0111}, {0x0113, 0x0113}, {0x011B, 0x011B},
+ {0x0126, 0x0127}, {0x012B, 0x012B}, {0x0131, 0x0133},
+ {0x0138, 0x0138}, {0x013F, 0x0142}, {0x0144, 0x0144},
+ {0x0148, 0x014B}, {0x014D, 0x014D}, {0x0152, 0x0153},
+ {0x0166, 0x0167}, {0x016B, 0x016B}, {0x01CE, 0x01CE},
+ {0x01D0, 0x01D0}, {0x01D2, 0x01D2}, {0x01D4, 0x01D4},
+ {0x01D6, 0x01D6}, {0x01D8, 0x01D8}, {0x01DA, 0x01DA},
+ {0x01DC, 0x01DC}, {0x0251, 0x0251}, {0x0261, 0x0261},
+ {0x02C4, 0x02C4}, {0x02C7, 0x02C7}, {0x02C9, 0x02CB},
+ {0x02CD, 0x02CD}, {0x02D0, 0x02D0}, {0x02D8, 0x02DB},
+ {0x02DD, 0x02DD}, {0x02DF, 0x02DF}, {0x0300, 0x036F},
+ {0x0391, 0x03A1}, {0x03A3, 0x03A9}, {0x03B1, 0x03C1},
+ {0x03C3, 0x03C9}, {0x0401, 0x0401}, {0x0410, 0x044F},
+ {0x0451, 0x0451}, {0x2010, 0x2010}, {0x2013, 0x2016},
+ {0x2018, 0x2019}, {0x201C, 0x201D}, {0x2020, 0x2022},
+ {0x2024, 0x2027}, {0x2030, 0x2030}, {0x2032, 0x2033},
+ {0x2035, 0x2035}, {0x203B, 0x203B}, {0x203E, 0x203E},
+ {0x2074, 0x2074}, {0x207F, 0x207F}, {0x2081, 0x2084},
+ {0x20AC, 0x20AC}, {0x2103, 0x2103}, {0x2105, 0x2105},
+ {0x2109, 0x2109}, {0x2113, 0x2113}, {0x2116, 0x2116},
+ {0x2121, 0x2122}, {0x2126, 0x2126}, {0x212B, 0x212B},
+ {0x2153, 0x2154}, {0x215B, 0x215E}, {0x2160, 0x216B},
+ {0x2170, 0x2179}, {0x2189, 0x2189}, {0x2190, 0x2199},
+ {0x21B8, 0x21B9}, {0x21D2, 0x21D2}, {0x21D4, 0x21D4},
+ {0x21E7, 0x21E7}, {0x2200, 0x2200}, {0x2202, 0x2203},
+ {0x2207, 0x2208}, {0x220B, 0x220B}, {0x220F, 0x220F},
+ {0x2211, 0x2211}, {0x2215, 0x2215}, {0x221A, 0x221A},
+ {0x221D, 0x2220}, {0x2223, 0x2223}, {0x2225, 0x2225},
+ {0x2227, 0x222C}, {0x222E, 0x222E}, {0x2234, 0x2237},
+ {0x223C, 0x223D}, {0x2248, 0x2248}, {0x224C, 0x224C},
+ {0x2252, 0x2252}, {0x2260, 0x2261}, {0x2264, 0x2267},
+ {0x226A, 0x226B}, {0x226E, 0x226F}, {0x2282, 0x2283},
+ {0x2286, 0x2287}, {0x2295, 0x2295}, {0x2299, 0x2299},
+ {0x22A5, 0x22A5}, {0x22BF, 0x22BF}, {0x2312, 0x2312},
+ {0x2460, 0x24E9}, {0x24EB, 0x254B}, {0x2550, 0x2573},
+ {0x2580, 0x258F}, {0x2592, 0x2595}, {0x25A0, 0x25A1},
+ {0x25A3, 0x25A9}, {0x25B2, 0x25B3}, {0x25B6, 0x25B7},
+ {0x25BC, 0x25BD}, {0x25C0, 0x25C1}, {0x25C6, 0x25C8},
+ {0x25CB, 0x25CB}, {0x25CE, 0x25D1}, {0x25E2, 0x25E5},
+ {0x25EF, 0x25EF}, {0x2605, 0x2606}, {0x2609, 0x2609},
+ {0x260E, 0x260F}, {0x261C, 0x261C}, {0x261E, 0x261E},
+ {0x2640, 0x2640}, {0x2642, 0x2642}, {0x2660, 0x2661},
+ {0x2663, 0x2665}, {0x2667, 0x266A}, {0x266C, 0x266D},
+ {0x266F, 0x266F}, {0x269E, 0x269F}, {0x26BF, 0x26BF},
+ {0x26C6, 0x26CD}, {0x26CF, 0x26D3}, {0x26D5, 0x26E1},
+ {0x26E3, 0x26E3}, {0x26E8, 0x26E9}, {0x26EB, 0x26F1},
+ {0x26F4, 0x26F4}, {0x26F6, 0x26F9}, {0x26FB, 0x26FC},
+ {0x26FE, 0x26FF}, {0x273D, 0x273D}, {0x2776, 0x277F},
+ {0x2B56, 0x2B59}, {0x3248, 0x324F}, {0xE000, 0xF8FF},
+ {0xFE00, 0xFE0F}, {0xFFFD, 0xFFFD}, {0x1F100, 0x1F10A},
+ {0x1F110, 0x1F12D}, {0x1F130, 0x1F169}, {0x1F170, 0x1F18D},
+ {0x1F18F, 0x1F190}, {0x1F19B, 0x1F1AC}, {0xE0100, 0xE01EF},
+ {0xF0000, 0xFFFFD}, {0x100000, 0x10FFFD},
+}
+
+var emoji = table{
+ {0x1F1E6, 0x1F1FF}, {0x1F321, 0x1F321}, {0x1F324, 0x1F32C},
+ {0x1F336, 0x1F336}, {0x1F37D, 0x1F37D}, {0x1F396, 0x1F397},
+ {0x1F399, 0x1F39B}, {0x1F39E, 0x1F39F}, {0x1F3CB, 0x1F3CE},
+ {0x1F3D4, 0x1F3DF}, {0x1F3F3, 0x1F3F5}, {0x1F3F7, 0x1F3F7},
+ {0x1F43F, 0x1F43F}, {0x1F441, 0x1F441}, {0x1F4FD, 0x1F4FD},
+ {0x1F549, 0x1F54A}, {0x1F56F, 0x1F570}, {0x1F573, 0x1F579},
+ {0x1F587, 0x1F587}, {0x1F58A, 0x1F58D}, {0x1F590, 0x1F590},
+ {0x1F5A5, 0x1F5A5}, {0x1F5A8, 0x1F5A8}, {0x1F5B1, 0x1F5B2},
+ {0x1F5BC, 0x1F5BC}, {0x1F5C2, 0x1F5C4}, {0x1F5D1, 0x1F5D3},
+ {0x1F5DC, 0x1F5DE}, {0x1F5E1, 0x1F5E1}, {0x1F5E3, 0x1F5E3},
+ {0x1F5E8, 0x1F5E8}, {0x1F5EF, 0x1F5EF}, {0x1F5F3, 0x1F5F3},
+ {0x1F5FA, 0x1F5FA}, {0x1F6CB, 0x1F6CF}, {0x1F6E0, 0x1F6E5},
+ {0x1F6E9, 0x1F6E9}, {0x1F6F0, 0x1F6F0}, {0x1F6F3, 0x1F6F3},
+}
+
+var notassigned = table{
+ {0x0378, 0x0379}, {0x0380, 0x0383}, {0x038B, 0x038B},
+ {0x038D, 0x038D}, {0x03A2, 0x03A2}, {0x0530, 0x0530},
+ {0x0557, 0x0558}, {0x0560, 0x0560}, {0x0588, 0x0588},
+ {0x058B, 0x058C}, {0x0590, 0x0590}, {0x05C8, 0x05CF},
+ {0x05EB, 0x05EF}, {0x05F5, 0x05FF}, {0x061D, 0x061D},
+ {0x070E, 0x070E}, {0x074B, 0x074C}, {0x07B2, 0x07BF},
+ {0x07FB, 0x07FF}, {0x082E, 0x082F}, {0x083F, 0x083F},
+ {0x085C, 0x085D}, {0x085F, 0x089F}, {0x08B5, 0x08B5},
+ {0x08BE, 0x08D3}, {0x0984, 0x0984}, {0x098D, 0x098E},
+ {0x0991, 0x0992}, {0x09A9, 0x09A9}, {0x09B1, 0x09B1},
+ {0x09B3, 0x09B5}, {0x09BA, 0x09BB}, {0x09C5, 0x09C6},
+ {0x09C9, 0x09CA}, {0x09CF, 0x09D6}, {0x09D8, 0x09DB},
+ {0x09DE, 0x09DE}, {0x09E4, 0x09E5}, {0x09FC, 0x0A00},
+ {0x0A04, 0x0A04}, {0x0A0B, 0x0A0E}, {0x0A11, 0x0A12},
+ {0x0A29, 0x0A29}, {0x0A31, 0x0A31}, {0x0A34, 0x0A34},
+ {0x0A37, 0x0A37}, {0x0A3A, 0x0A3B}, {0x0A3D, 0x0A3D},
+ {0x0A43, 0x0A46}, {0x0A49, 0x0A4A}, {0x0A4E, 0x0A50},
+ {0x0A52, 0x0A58}, {0x0A5D, 0x0A5D}, {0x0A5F, 0x0A65},
+ {0x0A76, 0x0A80}, {0x0A84, 0x0A84}, {0x0A8E, 0x0A8E},
+ {0x0A92, 0x0A92}, {0x0AA9, 0x0AA9}, {0x0AB1, 0x0AB1},
+ {0x0AB4, 0x0AB4}, {0x0ABA, 0x0ABB}, {0x0AC6, 0x0AC6},
+ {0x0ACA, 0x0ACA}, {0x0ACE, 0x0ACF}, {0x0AD1, 0x0ADF},
+ {0x0AE4, 0x0AE5}, {0x0AF2, 0x0AF8}, {0x0AFA, 0x0B00},
+ {0x0B04, 0x0B04}, {0x0B0D, 0x0B0E}, {0x0B11, 0x0B12},
+ {0x0B29, 0x0B29}, {0x0B31, 0x0B31}, {0x0B34, 0x0B34},
+ {0x0B3A, 0x0B3B}, {0x0B45, 0x0B46}, {0x0B49, 0x0B4A},
+ {0x0B4E, 0x0B55}, {0x0B58, 0x0B5B}, {0x0B5E, 0x0B5E},
+ {0x0B64, 0x0B65}, {0x0B78, 0x0B81}, {0x0B84, 0x0B84},
+ {0x0B8B, 0x0B8D}, {0x0B91, 0x0B91}, {0x0B96, 0x0B98},
+ {0x0B9B, 0x0B9B}, {0x0B9D, 0x0B9D}, {0x0BA0, 0x0BA2},
+ {0x0BA5, 0x0BA7}, {0x0BAB, 0x0BAD}, {0x0BBA, 0x0BBD},
+ {0x0BC3, 0x0BC5}, {0x0BC9, 0x0BC9}, {0x0BCE, 0x0BCF},
+ {0x0BD1, 0x0BD6}, {0x0BD8, 0x0BE5}, {0x0BFB, 0x0BFF},
+ {0x0C04, 0x0C04}, {0x0C0D, 0x0C0D}, {0x0C11, 0x0C11},
+ {0x0C29, 0x0C29}, {0x0C3A, 0x0C3C}, {0x0C45, 0x0C45},
+ {0x0C49, 0x0C49}, {0x0C4E, 0x0C54}, {0x0C57, 0x0C57},
+ {0x0C5B, 0x0C5F}, {0x0C64, 0x0C65}, {0x0C70, 0x0C77},
+ {0x0C84, 0x0C84}, {0x0C8D, 0x0C8D}, {0x0C91, 0x0C91},
+ {0x0CA9, 0x0CA9}, {0x0CB4, 0x0CB4}, {0x0CBA, 0x0CBB},
+ {0x0CC5, 0x0CC5}, {0x0CC9, 0x0CC9}, {0x0CCE, 0x0CD4},
+ {0x0CD7, 0x0CDD}, {0x0CDF, 0x0CDF}, {0x0CE4, 0x0CE5},
+ {0x0CF0, 0x0CF0}, {0x0CF3, 0x0D00}, {0x0D04, 0x0D04},
+ {0x0D0D, 0x0D0D}, {0x0D11, 0x0D11}, {0x0D3B, 0x0D3C},
+ {0x0D45, 0x0D45}, {0x0D49, 0x0D49}, {0x0D50, 0x0D53},
+ {0x0D64, 0x0D65}, {0x0D80, 0x0D81}, {0x0D84, 0x0D84},
+ {0x0D97, 0x0D99}, {0x0DB2, 0x0DB2}, {0x0DBC, 0x0DBC},
+ {0x0DBE, 0x0DBF}, {0x0DC7, 0x0DC9}, {0x0DCB, 0x0DCE},
+ {0x0DD5, 0x0DD5}, {0x0DD7, 0x0DD7}, {0x0DE0, 0x0DE5},
+ {0x0DF0, 0x0DF1}, {0x0DF5, 0x0E00}, {0x0E3B, 0x0E3E},
+ {0x0E5C, 0x0E80}, {0x0E83, 0x0E83}, {0x0E85, 0x0E86},
+ {0x0E89, 0x0E89}, {0x0E8B, 0x0E8C}, {0x0E8E, 0x0E93},
+ {0x0E98, 0x0E98}, {0x0EA0, 0x0EA0}, {0x0EA4, 0x0EA4},
+ {0x0EA6, 0x0EA6}, {0x0EA8, 0x0EA9}, {0x0EAC, 0x0EAC},
+ {0x0EBA, 0x0EBA}, {0x0EBE, 0x0EBF}, {0x0EC5, 0x0EC5},
+ {0x0EC7, 0x0EC7}, {0x0ECE, 0x0ECF}, {0x0EDA, 0x0EDB},
+ {0x0EE0, 0x0EFF}, {0x0F48, 0x0F48}, {0x0F6D, 0x0F70},
+ {0x0F98, 0x0F98}, {0x0FBD, 0x0FBD}, {0x0FCD, 0x0FCD},
+ {0x0FDB, 0x0FFF}, {0x10C6, 0x10C6}, {0x10C8, 0x10CC},
+ {0x10CE, 0x10CF}, {0x1249, 0x1249}, {0x124E, 0x124F},
+ {0x1257, 0x1257}, {0x1259, 0x1259}, {0x125E, 0x125F},
+ {0x1289, 0x1289}, {0x128E, 0x128F}, {0x12B1, 0x12B1},
+ {0x12B6, 0x12B7}, {0x12BF, 0x12BF}, {0x12C1, 0x12C1},
+ {0x12C6, 0x12C7}, {0x12D7, 0x12D7}, {0x1311, 0x1311},
+ {0x1316, 0x1317}, {0x135B, 0x135C}, {0x137D, 0x137F},
+ {0x139A, 0x139F}, {0x13F6, 0x13F7}, {0x13FE, 0x13FF},
+ {0x169D, 0x169F}, {0x16F9, 0x16FF}, {0x170D, 0x170D},
+ {0x1715, 0x171F}, {0x1737, 0x173F}, {0x1754, 0x175F},
+ {0x176D, 0x176D}, {0x1771, 0x1771}, {0x1774, 0x177F},
+ {0x17DE, 0x17DF}, {0x17EA, 0x17EF}, {0x17FA, 0x17FF},
+ {0x180F, 0x180F}, {0x181A, 0x181F}, {0x1878, 0x187F},
+ {0x18AB, 0x18AF}, {0x18F6, 0x18FF}, {0x191F, 0x191F},
+ {0x192C, 0x192F}, {0x193C, 0x193F}, {0x1941, 0x1943},
+ {0x196E, 0x196F}, {0x1975, 0x197F}, {0x19AC, 0x19AF},
+ {0x19CA, 0x19CF}, {0x19DB, 0x19DD}, {0x1A1C, 0x1A1D},
+ {0x1A5F, 0x1A5F}, {0x1A7D, 0x1A7E}, {0x1A8A, 0x1A8F},
+ {0x1A9A, 0x1A9F}, {0x1AAE, 0x1AAF}, {0x1ABF, 0x1AFF},
+ {0x1B4C, 0x1B4F}, {0x1B7D, 0x1B7F}, {0x1BF4, 0x1BFB},
+ {0x1C38, 0x1C3A}, {0x1C4A, 0x1C4C}, {0x1C89, 0x1CBF},
+ {0x1CC8, 0x1CCF}, {0x1CF7, 0x1CF7}, {0x1CFA, 0x1CFF},
+ {0x1DF6, 0x1DFA}, {0x1F16, 0x1F17}, {0x1F1E, 0x1F1F},
+ {0x1F46, 0x1F47}, {0x1F4E, 0x1F4F}, {0x1F58, 0x1F58},
+ {0x1F5A, 0x1F5A}, {0x1F5C, 0x1F5C}, {0x1F5E, 0x1F5E},
+ {0x1F7E, 0x1F7F}, {0x1FB5, 0x1FB5}, {0x1FC5, 0x1FC5},
+ {0x1FD4, 0x1FD5}, {0x1FDC, 0x1FDC}, {0x1FF0, 0x1FF1},
+ {0x1FF5, 0x1FF5}, {0x1FFF, 0x1FFF}, {0x2065, 0x2065},
+ {0x2072, 0x2073}, {0x208F, 0x208F}, {0x209D, 0x209F},
+ {0x20BF, 0x20CF}, {0x20F1, 0x20FF}, {0x218C, 0x218F},
+ {0x23FF, 0x23FF}, {0x2427, 0x243F}, {0x244B, 0x245F},
+ {0x2B74, 0x2B75}, {0x2B96, 0x2B97}, {0x2BBA, 0x2BBC},
+ {0x2BC9, 0x2BC9}, {0x2BD2, 0x2BEB}, {0x2BF0, 0x2BFF},
+ {0x2C2F, 0x2C2F}, {0x2C5F, 0x2C5F}, {0x2CF4, 0x2CF8},
+ {0x2D26, 0x2D26}, {0x2D28, 0x2D2C}, {0x2D2E, 0x2D2F},
+ {0x2D68, 0x2D6E}, {0x2D71, 0x2D7E}, {0x2D97, 0x2D9F},
+ {0x2DA7, 0x2DA7}, {0x2DAF, 0x2DAF}, {0x2DB7, 0x2DB7},
+ {0x2DBF, 0x2DBF}, {0x2DC7, 0x2DC7}, {0x2DCF, 0x2DCF},
+ {0x2DD7, 0x2DD7}, {0x2DDF, 0x2DDF}, {0x2E45, 0x2E7F},
+ {0x2E9A, 0x2E9A}, {0x2EF4, 0x2EFF}, {0x2FD6, 0x2FEF},
+ {0x2FFC, 0x2FFF}, {0x3040, 0x3040}, {0x3097, 0x3098},
+ {0x3100, 0x3104}, {0x312E, 0x3130}, {0x318F, 0x318F},
+ {0x31BB, 0x31BF}, {0x31E4, 0x31EF}, {0x321F, 0x321F},
+ {0x32FF, 0x32FF}, {0x4DB6, 0x4DBF}, {0x9FD6, 0x9FFF},
+ {0xA48D, 0xA48F}, {0xA4C7, 0xA4CF}, {0xA62C, 0xA63F},
+ {0xA6F8, 0xA6FF}, {0xA7AF, 0xA7AF}, {0xA7B8, 0xA7F6},
+ {0xA82C, 0xA82F}, {0xA83A, 0xA83F}, {0xA878, 0xA87F},
+ {0xA8C6, 0xA8CD}, {0xA8DA, 0xA8DF}, {0xA8FE, 0xA8FF},
+ {0xA954, 0xA95E}, {0xA97D, 0xA97F}, {0xA9CE, 0xA9CE},
+ {0xA9DA, 0xA9DD}, {0xA9FF, 0xA9FF}, {0xAA37, 0xAA3F},
+ {0xAA4E, 0xAA4F}, {0xAA5A, 0xAA5B}, {0xAAC3, 0xAADA},
+ {0xAAF7, 0xAB00}, {0xAB07, 0xAB08}, {0xAB0F, 0xAB10},
+ {0xAB17, 0xAB1F}, {0xAB27, 0xAB27}, {0xAB2F, 0xAB2F},
+ {0xAB66, 0xAB6F}, {0xABEE, 0xABEF}, {0xABFA, 0xABFF},
+ {0xD7A4, 0xD7AF}, {0xD7C7, 0xD7CA}, {0xD7FC, 0xD7FF},
+ {0xFA6E, 0xFA6F}, {0xFADA, 0xFAFF}, {0xFB07, 0xFB12},
+ {0xFB18, 0xFB1C}, {0xFB37, 0xFB37}, {0xFB3D, 0xFB3D},
+ {0xFB3F, 0xFB3F}, {0xFB42, 0xFB42}, {0xFB45, 0xFB45},
+ {0xFBC2, 0xFBD2}, {0xFD40, 0xFD4F}, {0xFD90, 0xFD91},
+ {0xFDC8, 0xFDEF}, {0xFDFE, 0xFDFF}, {0xFE1A, 0xFE1F},
+ {0xFE53, 0xFE53}, {0xFE67, 0xFE67}, {0xFE6C, 0xFE6F},
+ {0xFE75, 0xFE75}, {0xFEFD, 0xFEFE}, {0xFF00, 0xFF00},
+ {0xFFBF, 0xFFC1}, {0xFFC8, 0xFFC9}, {0xFFD0, 0xFFD1},
+ {0xFFD8, 0xFFD9}, {0xFFDD, 0xFFDF}, {0xFFE7, 0xFFE7},
+ {0xFFEF, 0xFFF8}, {0xFFFE, 0xFFFF}, {0x1000C, 0x1000C},
+ {0x10027, 0x10027}, {0x1003B, 0x1003B}, {0x1003E, 0x1003E},
+ {0x1004E, 0x1004F}, {0x1005E, 0x1007F}, {0x100FB, 0x100FF},
+ {0x10103, 0x10106}, {0x10134, 0x10136}, {0x1018F, 0x1018F},
+ {0x1019C, 0x1019F}, {0x101A1, 0x101CF}, {0x101FE, 0x1027F},
+ {0x1029D, 0x1029F}, {0x102D1, 0x102DF}, {0x102FC, 0x102FF},
+ {0x10324, 0x1032F}, {0x1034B, 0x1034F}, {0x1037B, 0x1037F},
+ {0x1039E, 0x1039E}, {0x103C4, 0x103C7}, {0x103D6, 0x103FF},
+ {0x1049E, 0x1049F}, {0x104AA, 0x104AF}, {0x104D4, 0x104D7},
+ {0x104FC, 0x104FF}, {0x10528, 0x1052F}, {0x10564, 0x1056E},
+ {0x10570, 0x105FF}, {0x10737, 0x1073F}, {0x10756, 0x1075F},
+ {0x10768, 0x107FF}, {0x10806, 0x10807}, {0x10809, 0x10809},
+ {0x10836, 0x10836}, {0x10839, 0x1083B}, {0x1083D, 0x1083E},
+ {0x10856, 0x10856}, {0x1089F, 0x108A6}, {0x108B0, 0x108DF},
+ {0x108F3, 0x108F3}, {0x108F6, 0x108FA}, {0x1091C, 0x1091E},
+ {0x1093A, 0x1093E}, {0x10940, 0x1097F}, {0x109B8, 0x109BB},
+ {0x109D0, 0x109D1}, {0x10A04, 0x10A04}, {0x10A07, 0x10A0B},
+ {0x10A14, 0x10A14}, {0x10A18, 0x10A18}, {0x10A34, 0x10A37},
+ {0x10A3B, 0x10A3E}, {0x10A48, 0x10A4F}, {0x10A59, 0x10A5F},
+ {0x10AA0, 0x10ABF}, {0x10AE7, 0x10AEA}, {0x10AF7, 0x10AFF},
+ {0x10B36, 0x10B38}, {0x10B56, 0x10B57}, {0x10B73, 0x10B77},
+ {0x10B92, 0x10B98}, {0x10B9D, 0x10BA8}, {0x10BB0, 0x10BFF},
+ {0x10C49, 0x10C7F}, {0x10CB3, 0x10CBF}, {0x10CF3, 0x10CF9},
+ {0x10D00, 0x10E5F}, {0x10E7F, 0x10FFF}, {0x1104E, 0x11051},
+ {0x11070, 0x1107E}, {0x110C2, 0x110CF}, {0x110E9, 0x110EF},
+ {0x110FA, 0x110FF}, {0x11135, 0x11135}, {0x11144, 0x1114F},
+ {0x11177, 0x1117F}, {0x111CE, 0x111CF}, {0x111E0, 0x111E0},
+ {0x111F5, 0x111FF}, {0x11212, 0x11212}, {0x1123F, 0x1127F},
+ {0x11287, 0x11287}, {0x11289, 0x11289}, {0x1128E, 0x1128E},
+ {0x1129E, 0x1129E}, {0x112AA, 0x112AF}, {0x112EB, 0x112EF},
+ {0x112FA, 0x112FF}, {0x11304, 0x11304}, {0x1130D, 0x1130E},
+ {0x11311, 0x11312}, {0x11329, 0x11329}, {0x11331, 0x11331},
+ {0x11334, 0x11334}, {0x1133A, 0x1133B}, {0x11345, 0x11346},
+ {0x11349, 0x1134A}, {0x1134E, 0x1134F}, {0x11351, 0x11356},
+ {0x11358, 0x1135C}, {0x11364, 0x11365}, {0x1136D, 0x1136F},
+ {0x11375, 0x113FF}, {0x1145A, 0x1145A}, {0x1145C, 0x1145C},
+ {0x1145E, 0x1147F}, {0x114C8, 0x114CF}, {0x114DA, 0x1157F},
+ {0x115B6, 0x115B7}, {0x115DE, 0x115FF}, {0x11645, 0x1164F},
+ {0x1165A, 0x1165F}, {0x1166D, 0x1167F}, {0x116B8, 0x116BF},
+ {0x116CA, 0x116FF}, {0x1171A, 0x1171C}, {0x1172C, 0x1172F},
+ {0x11740, 0x1189F}, {0x118F3, 0x118FE}, {0x11900, 0x11ABF},
+ {0x11AF9, 0x11BFF}, {0x11C09, 0x11C09}, {0x11C37, 0x11C37},
+ {0x11C46, 0x11C4F}, {0x11C6D, 0x11C6F}, {0x11C90, 0x11C91},
+ {0x11CA8, 0x11CA8}, {0x11CB7, 0x11FFF}, {0x1239A, 0x123FF},
+ {0x1246F, 0x1246F}, {0x12475, 0x1247F}, {0x12544, 0x12FFF},
+ {0x1342F, 0x143FF}, {0x14647, 0x167FF}, {0x16A39, 0x16A3F},
+ {0x16A5F, 0x16A5F}, {0x16A6A, 0x16A6D}, {0x16A70, 0x16ACF},
+ {0x16AEE, 0x16AEF}, {0x16AF6, 0x16AFF}, {0x16B46, 0x16B4F},
+ {0x16B5A, 0x16B5A}, {0x16B62, 0x16B62}, {0x16B78, 0x16B7C},
+ {0x16B90, 0x16EFF}, {0x16F45, 0x16F4F}, {0x16F7F, 0x16F8E},
+ {0x16FA0, 0x16FDF}, {0x16FE1, 0x16FFF}, {0x187ED, 0x187FF},
+ {0x18AF3, 0x1AFFF}, {0x1B002, 0x1BBFF}, {0x1BC6B, 0x1BC6F},
+ {0x1BC7D, 0x1BC7F}, {0x1BC89, 0x1BC8F}, {0x1BC9A, 0x1BC9B},
+ {0x1BCA4, 0x1CFFF}, {0x1D0F6, 0x1D0FF}, {0x1D127, 0x1D128},
+ {0x1D1E9, 0x1D1FF}, {0x1D246, 0x1D2FF}, {0x1D357, 0x1D35F},
+ {0x1D372, 0x1D3FF}, {0x1D455, 0x1D455}, {0x1D49D, 0x1D49D},
+ {0x1D4A0, 0x1D4A1}, {0x1D4A3, 0x1D4A4}, {0x1D4A7, 0x1D4A8},
+ {0x1D4AD, 0x1D4AD}, {0x1D4BA, 0x1D4BA}, {0x1D4BC, 0x1D4BC},
+ {0x1D4C4, 0x1D4C4}, {0x1D506, 0x1D506}, {0x1D50B, 0x1D50C},
+ {0x1D515, 0x1D515}, {0x1D51D, 0x1D51D}, {0x1D53A, 0x1D53A},
+ {0x1D53F, 0x1D53F}, {0x1D545, 0x1D545}, {0x1D547, 0x1D549},
+ {0x1D551, 0x1D551}, {0x1D6A6, 0x1D6A7}, {0x1D7CC, 0x1D7CD},
+ {0x1DA8C, 0x1DA9A}, {0x1DAA0, 0x1DAA0}, {0x1DAB0, 0x1DFFF},
+ {0x1E007, 0x1E007}, {0x1E019, 0x1E01A}, {0x1E022, 0x1E022},
+ {0x1E025, 0x1E025}, {0x1E02B, 0x1E7FF}, {0x1E8C5, 0x1E8C6},
+ {0x1E8D7, 0x1E8FF}, {0x1E94B, 0x1E94F}, {0x1E95A, 0x1E95D},
+ {0x1E960, 0x1EDFF}, {0x1EE04, 0x1EE04}, {0x1EE20, 0x1EE20},
+ {0x1EE23, 0x1EE23}, {0x1EE25, 0x1EE26}, {0x1EE28, 0x1EE28},
+ {0x1EE33, 0x1EE33}, {0x1EE38, 0x1EE38}, {0x1EE3A, 0x1EE3A},
+ {0x1EE3C, 0x1EE41}, {0x1EE43, 0x1EE46}, {0x1EE48, 0x1EE48},
+ {0x1EE4A, 0x1EE4A}, {0x1EE4C, 0x1EE4C}, {0x1EE50, 0x1EE50},
+ {0x1EE53, 0x1EE53}, {0x1EE55, 0x1EE56}, {0x1EE58, 0x1EE58},
+ {0x1EE5A, 0x1EE5A}, {0x1EE5C, 0x1EE5C}, {0x1EE5E, 0x1EE5E},
+ {0x1EE60, 0x1EE60}, {0x1EE63, 0x1EE63}, {0x1EE65, 0x1EE66},
+ {0x1EE6B, 0x1EE6B}, {0x1EE73, 0x1EE73}, {0x1EE78, 0x1EE78},
+ {0x1EE7D, 0x1EE7D}, {0x1EE7F, 0x1EE7F}, {0x1EE8A, 0x1EE8A},
+ {0x1EE9C, 0x1EEA0}, {0x1EEA4, 0x1EEA4}, {0x1EEAA, 0x1EEAA},
+ {0x1EEBC, 0x1EEEF}, {0x1EEF2, 0x1EFFF}, {0x1F02C, 0x1F02F},
+ {0x1F094, 0x1F09F}, {0x1F0AF, 0x1F0B0}, {0x1F0C0, 0x1F0C0},
+ {0x1F0D0, 0x1F0D0}, {0x1F0F6, 0x1F0FF}, {0x1F10D, 0x1F10F},
+ {0x1F12F, 0x1F12F}, {0x1F16C, 0x1F16F}, {0x1F1AD, 0x1F1E5},
+ {0x1F203, 0x1F20F}, {0x1F23C, 0x1F23F}, {0x1F249, 0x1F24F},
+ {0x1F252, 0x1F2FF}, {0x1F6D3, 0x1F6DF}, {0x1F6ED, 0x1F6EF},
+ {0x1F6F7, 0x1F6FF}, {0x1F774, 0x1F77F}, {0x1F7D5, 0x1F7FF},
+ {0x1F80C, 0x1F80F}, {0x1F848, 0x1F84F}, {0x1F85A, 0x1F85F},
+ {0x1F888, 0x1F88F}, {0x1F8AE, 0x1F90F}, {0x1F91F, 0x1F91F},
+ {0x1F928, 0x1F92F}, {0x1F931, 0x1F932}, {0x1F93F, 0x1F93F},
+ {0x1F94C, 0x1F94F}, {0x1F95F, 0x1F97F}, {0x1F992, 0x1F9BF},
+ {0x1F9C1, 0x1FFFF}, {0x2A6D7, 0x2A6FF}, {0x2B735, 0x2B73F},
+ {0x2B81E, 0x2B81F}, {0x2CEA2, 0x2F7FF}, {0x2FA1E, 0xE0000},
+ {0xE0002, 0xE001F}, {0xE0080, 0xE00FF}, {0xE01F0, 0xEFFFF},
+ {0xFFFFE, 0xFFFFF},
+}
+
+var neutral = table{
+ {0x0000, 0x001F}, {0x007F, 0x007F}, {0x0080, 0x009F},
+ {0x00A0, 0x00A0}, {0x00A9, 0x00A9}, {0x00AB, 0x00AB},
+ {0x00B5, 0x00B5}, {0x00BB, 0x00BB}, {0x00C0, 0x00C5},
+ {0x00C7, 0x00CF}, {0x00D1, 0x00D6}, {0x00D9, 0x00DD},
+ {0x00E2, 0x00E5}, {0x00E7, 0x00E7}, {0x00EB, 0x00EB},
+ {0x00EE, 0x00EF}, {0x00F1, 0x00F1}, {0x00F4, 0x00F6},
+ {0x00FB, 0x00FB}, {0x00FD, 0x00FD}, {0x00FF, 0x00FF},
+ {0x0100, 0x0100}, {0x0102, 0x0110}, {0x0112, 0x0112},
+ {0x0114, 0x011A}, {0x011C, 0x0125}, {0x0128, 0x012A},
+ {0x012C, 0x0130}, {0x0134, 0x0137}, {0x0139, 0x013E},
+ {0x0143, 0x0143}, {0x0145, 0x0147}, {0x014C, 0x014C},
+ {0x014E, 0x0151}, {0x0154, 0x0165}, {0x0168, 0x016A},
+ {0x016C, 0x017F}, {0x0180, 0x01BA}, {0x01BB, 0x01BB},
+ {0x01BC, 0x01BF}, {0x01C0, 0x01C3}, {0x01C4, 0x01CD},
+ {0x01CF, 0x01CF}, {0x01D1, 0x01D1}, {0x01D3, 0x01D3},
+ {0x01D5, 0x01D5}, {0x01D7, 0x01D7}, {0x01D9, 0x01D9},
+ {0x01DB, 0x01DB}, {0x01DD, 0x024F}, {0x0250, 0x0250},
+ {0x0252, 0x0260}, {0x0262, 0x0293}, {0x0294, 0x0294},
+ {0x0295, 0x02AF}, {0x02B0, 0x02C1}, {0x02C2, 0x02C3},
+ {0x02C5, 0x02C5}, {0x02C6, 0x02C6}, {0x02C8, 0x02C8},
+ {0x02CC, 0x02CC}, {0x02CE, 0x02CF}, {0x02D1, 0x02D1},
+ {0x02D2, 0x02D7}, {0x02DC, 0x02DC}, {0x02DE, 0x02DE},
+ {0x02E0, 0x02E4}, {0x02E5, 0x02EB}, {0x02EC, 0x02EC},
+ {0x02ED, 0x02ED}, {0x02EE, 0x02EE}, {0x02EF, 0x02FF},
+ {0x0370, 0x0373}, {0x0374, 0x0374}, {0x0375, 0x0375},
+ {0x0376, 0x0377}, {0x037A, 0x037A}, {0x037B, 0x037D},
+ {0x037E, 0x037E}, {0x037F, 0x037F}, {0x0384, 0x0385},
+ {0x0386, 0x0386}, {0x0387, 0x0387}, {0x0388, 0x038A},
+ {0x038C, 0x038C}, {0x038E, 0x0390}, {0x03AA, 0x03B0},
+ {0x03C2, 0x03C2}, {0x03CA, 0x03F5}, {0x03F6, 0x03F6},
+ {0x03F7, 0x03FF}, {0x0400, 0x0400}, {0x0402, 0x040F},
+ {0x0450, 0x0450}, {0x0452, 0x0481}, {0x0482, 0x0482},
+ {0x0483, 0x0487}, {0x0488, 0x0489}, {0x048A, 0x04FF},
+ {0x0500, 0x052F}, {0x0531, 0x0556}, {0x0559, 0x0559},
+ {0x055A, 0x055F}, {0x0561, 0x0587}, {0x0589, 0x0589},
+ {0x058A, 0x058A}, {0x058D, 0x058E}, {0x058F, 0x058F},
+ {0x0591, 0x05BD}, {0x05BE, 0x05BE}, {0x05BF, 0x05BF},
+ {0x05C0, 0x05C0}, {0x05C1, 0x05C2}, {0x05C3, 0x05C3},
+ {0x05C4, 0x05C5}, {0x05C6, 0x05C6}, {0x05C7, 0x05C7},
+ {0x05D0, 0x05EA}, {0x05F0, 0x05F2}, {0x05F3, 0x05F4},
+ {0x0600, 0x0605}, {0x0606, 0x0608}, {0x0609, 0x060A},
+ {0x060B, 0x060B}, {0x060C, 0x060D}, {0x060E, 0x060F},
+ {0x0610, 0x061A}, {0x061B, 0x061B}, {0x061C, 0x061C},
+ {0x061E, 0x061F}, {0x0620, 0x063F}, {0x0640, 0x0640},
+ {0x0641, 0x064A}, {0x064B, 0x065F}, {0x0660, 0x0669},
+ {0x066A, 0x066D}, {0x066E, 0x066F}, {0x0670, 0x0670},
+ {0x0671, 0x06D3}, {0x06D4, 0x06D4}, {0x06D5, 0x06D5},
+ {0x06D6, 0x06DC}, {0x06DD, 0x06DD}, {0x06DE, 0x06DE},
+ {0x06DF, 0x06E4}, {0x06E5, 0x06E6}, {0x06E7, 0x06E8},
+ {0x06E9, 0x06E9}, {0x06EA, 0x06ED}, {0x06EE, 0x06EF},
+ {0x06F0, 0x06F9}, {0x06FA, 0x06FC}, {0x06FD, 0x06FE},
+ {0x06FF, 0x06FF}, {0x0700, 0x070D}, {0x070F, 0x070F},
+ {0x0710, 0x0710}, {0x0711, 0x0711}, {0x0712, 0x072F},
+ {0x0730, 0x074A}, {0x074D, 0x074F}, {0x0750, 0x077F},
+ {0x0780, 0x07A5}, {0x07A6, 0x07B0}, {0x07B1, 0x07B1},
+ {0x07C0, 0x07C9}, {0x07CA, 0x07EA}, {0x07EB, 0x07F3},
+ {0x07F4, 0x07F5}, {0x07F6, 0x07F6}, {0x07F7, 0x07F9},
+ {0x07FA, 0x07FA}, {0x0800, 0x0815}, {0x0816, 0x0819},
+ {0x081A, 0x081A}, {0x081B, 0x0823}, {0x0824, 0x0824},
+ {0x0825, 0x0827}, {0x0828, 0x0828}, {0x0829, 0x082D},
+ {0x0830, 0x083E}, {0x0840, 0x0858}, {0x0859, 0x085B},
+ {0x085E, 0x085E}, {0x08A0, 0x08B4}, {0x08B6, 0x08BD},
+ {0x08D4, 0x08E1}, {0x08E2, 0x08E2}, {0x08E3, 0x08FF},
+ {0x0900, 0x0902}, {0x0903, 0x0903}, {0x0904, 0x0939},
+ {0x093A, 0x093A}, {0x093B, 0x093B}, {0x093C, 0x093C},
+ {0x093D, 0x093D}, {0x093E, 0x0940}, {0x0941, 0x0948},
+ {0x0949, 0x094C}, {0x094D, 0x094D}, {0x094E, 0x094F},
+ {0x0950, 0x0950}, {0x0951, 0x0957}, {0x0958, 0x0961},
+ {0x0962, 0x0963}, {0x0964, 0x0965}, {0x0966, 0x096F},
+ {0x0970, 0x0970}, {0x0971, 0x0971}, {0x0972, 0x097F},
+ {0x0980, 0x0980}, {0x0981, 0x0981}, {0x0982, 0x0983},
+ {0x0985, 0x098C}, {0x098F, 0x0990}, {0x0993, 0x09A8},
+ {0x09AA, 0x09B0}, {0x09B2, 0x09B2}, {0x09B6, 0x09B9},
+ {0x09BC, 0x09BC}, {0x09BD, 0x09BD}, {0x09BE, 0x09C0},
+ {0x09C1, 0x09C4}, {0x09C7, 0x09C8}, {0x09CB, 0x09CC},
+ {0x09CD, 0x09CD}, {0x09CE, 0x09CE}, {0x09D7, 0x09D7},
+ {0x09DC, 0x09DD}, {0x09DF, 0x09E1}, {0x09E2, 0x09E3},
+ {0x09E6, 0x09EF}, {0x09F0, 0x09F1}, {0x09F2, 0x09F3},
+ {0x09F4, 0x09F9}, {0x09FA, 0x09FA}, {0x09FB, 0x09FB},
+ {0x0A01, 0x0A02}, {0x0A03, 0x0A03}, {0x0A05, 0x0A0A},
+ {0x0A0F, 0x0A10}, {0x0A13, 0x0A28}, {0x0A2A, 0x0A30},
+ {0x0A32, 0x0A33}, {0x0A35, 0x0A36}, {0x0A38, 0x0A39},
+ {0x0A3C, 0x0A3C}, {0x0A3E, 0x0A40}, {0x0A41, 0x0A42},
+ {0x0A47, 0x0A48}, {0x0A4B, 0x0A4D}, {0x0A51, 0x0A51},
+ {0x0A59, 0x0A5C}, {0x0A5E, 0x0A5E}, {0x0A66, 0x0A6F},
+ {0x0A70, 0x0A71}, {0x0A72, 0x0A74}, {0x0A75, 0x0A75},
+ {0x0A81, 0x0A82}, {0x0A83, 0x0A83}, {0x0A85, 0x0A8D},
+ {0x0A8F, 0x0A91}, {0x0A93, 0x0AA8}, {0x0AAA, 0x0AB0},
+ {0x0AB2, 0x0AB3}, {0x0AB5, 0x0AB9}, {0x0ABC, 0x0ABC},
+ {0x0ABD, 0x0ABD}, {0x0ABE, 0x0AC0}, {0x0AC1, 0x0AC5},
+ {0x0AC7, 0x0AC8}, {0x0AC9, 0x0AC9}, {0x0ACB, 0x0ACC},
+ {0x0ACD, 0x0ACD}, {0x0AD0, 0x0AD0}, {0x0AE0, 0x0AE1},
+ {0x0AE2, 0x0AE3}, {0x0AE6, 0x0AEF}, {0x0AF0, 0x0AF0},
+ {0x0AF1, 0x0AF1}, {0x0AF9, 0x0AF9}, {0x0B01, 0x0B01},
+ {0x0B02, 0x0B03}, {0x0B05, 0x0B0C}, {0x0B0F, 0x0B10},
+ {0x0B13, 0x0B28}, {0x0B2A, 0x0B30}, {0x0B32, 0x0B33},
+ {0x0B35, 0x0B39}, {0x0B3C, 0x0B3C}, {0x0B3D, 0x0B3D},
+ {0x0B3E, 0x0B3E}, {0x0B3F, 0x0B3F}, {0x0B40, 0x0B40},
+ {0x0B41, 0x0B44}, {0x0B47, 0x0B48}, {0x0B4B, 0x0B4C},
+ {0x0B4D, 0x0B4D}, {0x0B56, 0x0B56}, {0x0B57, 0x0B57},
+ {0x0B5C, 0x0B5D}, {0x0B5F, 0x0B61}, {0x0B62, 0x0B63},
+ {0x0B66, 0x0B6F}, {0x0B70, 0x0B70}, {0x0B71, 0x0B71},
+ {0x0B72, 0x0B77}, {0x0B82, 0x0B82}, {0x0B83, 0x0B83},
+ {0x0B85, 0x0B8A}, {0x0B8E, 0x0B90}, {0x0B92, 0x0B95},
+ {0x0B99, 0x0B9A}, {0x0B9C, 0x0B9C}, {0x0B9E, 0x0B9F},
+ {0x0BA3, 0x0BA4}, {0x0BA8, 0x0BAA}, {0x0BAE, 0x0BB9},
+ {0x0BBE, 0x0BBF}, {0x0BC0, 0x0BC0}, {0x0BC1, 0x0BC2},
+ {0x0BC6, 0x0BC8}, {0x0BCA, 0x0BCC}, {0x0BCD, 0x0BCD},
+ {0x0BD0, 0x0BD0}, {0x0BD7, 0x0BD7}, {0x0BE6, 0x0BEF},
+ {0x0BF0, 0x0BF2}, {0x0BF3, 0x0BF8}, {0x0BF9, 0x0BF9},
+ {0x0BFA, 0x0BFA}, {0x0C00, 0x0C00}, {0x0C01, 0x0C03},
+ {0x0C05, 0x0C0C}, {0x0C0E, 0x0C10}, {0x0C12, 0x0C28},
+ {0x0C2A, 0x0C39}, {0x0C3D, 0x0C3D}, {0x0C3E, 0x0C40},
+ {0x0C41, 0x0C44}, {0x0C46, 0x0C48}, {0x0C4A, 0x0C4D},
+ {0x0C55, 0x0C56}, {0x0C58, 0x0C5A}, {0x0C60, 0x0C61},
+ {0x0C62, 0x0C63}, {0x0C66, 0x0C6F}, {0x0C78, 0x0C7E},
+ {0x0C7F, 0x0C7F}, {0x0C80, 0x0C80}, {0x0C81, 0x0C81},
+ {0x0C82, 0x0C83}, {0x0C85, 0x0C8C}, {0x0C8E, 0x0C90},
+ {0x0C92, 0x0CA8}, {0x0CAA, 0x0CB3}, {0x0CB5, 0x0CB9},
+ {0x0CBC, 0x0CBC}, {0x0CBD, 0x0CBD}, {0x0CBE, 0x0CBE},
+ {0x0CBF, 0x0CBF}, {0x0CC0, 0x0CC4}, {0x0CC6, 0x0CC6},
+ {0x0CC7, 0x0CC8}, {0x0CCA, 0x0CCB}, {0x0CCC, 0x0CCD},
+ {0x0CD5, 0x0CD6}, {0x0CDE, 0x0CDE}, {0x0CE0, 0x0CE1},
+ {0x0CE2, 0x0CE3}, {0x0CE6, 0x0CEF}, {0x0CF1, 0x0CF2},
+ {0x0D01, 0x0D01}, {0x0D02, 0x0D03}, {0x0D05, 0x0D0C},
+ {0x0D0E, 0x0D10}, {0x0D12, 0x0D3A}, {0x0D3D, 0x0D3D},
+ {0x0D3E, 0x0D40}, {0x0D41, 0x0D44}, {0x0D46, 0x0D48},
+ {0x0D4A, 0x0D4C}, {0x0D4D, 0x0D4D}, {0x0D4E, 0x0D4E},
+ {0x0D4F, 0x0D4F}, {0x0D54, 0x0D56}, {0x0D57, 0x0D57},
+ {0x0D58, 0x0D5E}, {0x0D5F, 0x0D61}, {0x0D62, 0x0D63},
+ {0x0D66, 0x0D6F}, {0x0D70, 0x0D78}, {0x0D79, 0x0D79},
+ {0x0D7A, 0x0D7F}, {0x0D82, 0x0D83}, {0x0D85, 0x0D96},
+ {0x0D9A, 0x0DB1}, {0x0DB3, 0x0DBB}, {0x0DBD, 0x0DBD},
+ {0x0DC0, 0x0DC6}, {0x0DCA, 0x0DCA}, {0x0DCF, 0x0DD1},
+ {0x0DD2, 0x0DD4}, {0x0DD6, 0x0DD6}, {0x0DD8, 0x0DDF},
+ {0x0DE6, 0x0DEF}, {0x0DF2, 0x0DF3}, {0x0DF4, 0x0DF4},
+ {0x0E01, 0x0E30}, {0x0E31, 0x0E31}, {0x0E32, 0x0E33},
+ {0x0E34, 0x0E3A}, {0x0E3F, 0x0E3F}, {0x0E40, 0x0E45},
+ {0x0E46, 0x0E46}, {0x0E47, 0x0E4E}, {0x0E4F, 0x0E4F},
+ {0x0E50, 0x0E59}, {0x0E5A, 0x0E5B}, {0x0E81, 0x0E82},
+ {0x0E84, 0x0E84}, {0x0E87, 0x0E88}, {0x0E8A, 0x0E8A},
+ {0x0E8D, 0x0E8D}, {0x0E94, 0x0E97}, {0x0E99, 0x0E9F},
+ {0x0EA1, 0x0EA3}, {0x0EA5, 0x0EA5}, {0x0EA7, 0x0EA7},
+ {0x0EAA, 0x0EAB}, {0x0EAD, 0x0EB0}, {0x0EB1, 0x0EB1},
+ {0x0EB2, 0x0EB3}, {0x0EB4, 0x0EB9}, {0x0EBB, 0x0EBC},
+ {0x0EBD, 0x0EBD}, {0x0EC0, 0x0EC4}, {0x0EC6, 0x0EC6},
+ {0x0EC8, 0x0ECD}, {0x0ED0, 0x0ED9}, {0x0EDC, 0x0EDF},
+ {0x0F00, 0x0F00}, {0x0F01, 0x0F03}, {0x0F04, 0x0F12},
+ {0x0F13, 0x0F13}, {0x0F14, 0x0F14}, {0x0F15, 0x0F17},
+ {0x0F18, 0x0F19}, {0x0F1A, 0x0F1F}, {0x0F20, 0x0F29},
+ {0x0F2A, 0x0F33}, {0x0F34, 0x0F34}, {0x0F35, 0x0F35},
+ {0x0F36, 0x0F36}, {0x0F37, 0x0F37}, {0x0F38, 0x0F38},
+ {0x0F39, 0x0F39}, {0x0F3A, 0x0F3A}, {0x0F3B, 0x0F3B},
+ {0x0F3C, 0x0F3C}, {0x0F3D, 0x0F3D}, {0x0F3E, 0x0F3F},
+ {0x0F40, 0x0F47}, {0x0F49, 0x0F6C}, {0x0F71, 0x0F7E},
+ {0x0F7F, 0x0F7F}, {0x0F80, 0x0F84}, {0x0F85, 0x0F85},
+ {0x0F86, 0x0F87}, {0x0F88, 0x0F8C}, {0x0F8D, 0x0F97},
+ {0x0F99, 0x0FBC}, {0x0FBE, 0x0FC5}, {0x0FC6, 0x0FC6},
+ {0x0FC7, 0x0FCC}, {0x0FCE, 0x0FCF}, {0x0FD0, 0x0FD4},
+ {0x0FD5, 0x0FD8}, {0x0FD9, 0x0FDA}, {0x1000, 0x102A},
+ {0x102B, 0x102C}, {0x102D, 0x1030}, {0x1031, 0x1031},
+ {0x1032, 0x1037}, {0x1038, 0x1038}, {0x1039, 0x103A},
+ {0x103B, 0x103C}, {0x103D, 0x103E}, {0x103F, 0x103F},
+ {0x1040, 0x1049}, {0x104A, 0x104F}, {0x1050, 0x1055},
+ {0x1056, 0x1057}, {0x1058, 0x1059}, {0x105A, 0x105D},
+ {0x105E, 0x1060}, {0x1061, 0x1061}, {0x1062, 0x1064},
+ {0x1065, 0x1066}, {0x1067, 0x106D}, {0x106E, 0x1070},
+ {0x1071, 0x1074}, {0x1075, 0x1081}, {0x1082, 0x1082},
+ {0x1083, 0x1084}, {0x1085, 0x1086}, {0x1087, 0x108C},
+ {0x108D, 0x108D}, {0x108E, 0x108E}, {0x108F, 0x108F},
+ {0x1090, 0x1099}, {0x109A, 0x109C}, {0x109D, 0x109D},
+ {0x109E, 0x109F}, {0x10A0, 0x10C5}, {0x10C7, 0x10C7},
+ {0x10CD, 0x10CD}, {0x10D0, 0x10FA}, {0x10FB, 0x10FB},
+ {0x10FC, 0x10FC}, {0x10FD, 0x10FF}, {0x1160, 0x11FF},
+ {0x1200, 0x1248}, {0x124A, 0x124D}, {0x1250, 0x1256},
+ {0x1258, 0x1258}, {0x125A, 0x125D}, {0x1260, 0x1288},
+ {0x128A, 0x128D}, {0x1290, 0x12B0}, {0x12B2, 0x12B5},
+ {0x12B8, 0x12BE}, {0x12C0, 0x12C0}, {0x12C2, 0x12C5},
+ {0x12C8, 0x12D6}, {0x12D8, 0x1310}, {0x1312, 0x1315},
+ {0x1318, 0x135A}, {0x135D, 0x135F}, {0x1360, 0x1368},
+ {0x1369, 0x137C}, {0x1380, 0x138F}, {0x1390, 0x1399},
+ {0x13A0, 0x13F5}, {0x13F8, 0x13FD}, {0x1400, 0x1400},
+ {0x1401, 0x166C}, {0x166D, 0x166E}, {0x166F, 0x167F},
+ {0x1680, 0x1680}, {0x1681, 0x169A}, {0x169B, 0x169B},
+ {0x169C, 0x169C}, {0x16A0, 0x16EA}, {0x16EB, 0x16ED},
+ {0x16EE, 0x16F0}, {0x16F1, 0x16F8}, {0x1700, 0x170C},
+ {0x170E, 0x1711}, {0x1712, 0x1714}, {0x1720, 0x1731},
+ {0x1732, 0x1734}, {0x1735, 0x1736}, {0x1740, 0x1751},
+ {0x1752, 0x1753}, {0x1760, 0x176C}, {0x176E, 0x1770},
+ {0x1772, 0x1773}, {0x1780, 0x17B3}, {0x17B4, 0x17B5},
+ {0x17B6, 0x17B6}, {0x17B7, 0x17BD}, {0x17BE, 0x17C5},
+ {0x17C6, 0x17C6}, {0x17C7, 0x17C8}, {0x17C9, 0x17D3},
+ {0x17D4, 0x17D6}, {0x17D7, 0x17D7}, {0x17D8, 0x17DA},
+ {0x17DB, 0x17DB}, {0x17DC, 0x17DC}, {0x17DD, 0x17DD},
+ {0x17E0, 0x17E9}, {0x17F0, 0x17F9}, {0x1800, 0x1805},
+ {0x1806, 0x1806}, {0x1807, 0x180A}, {0x180B, 0x180D},
+ {0x180E, 0x180E}, {0x1810, 0x1819}, {0x1820, 0x1842},
+ {0x1843, 0x1843}, {0x1844, 0x1877}, {0x1880, 0x1884},
+ {0x1885, 0x1886}, {0x1887, 0x18A8}, {0x18A9, 0x18A9},
+ {0x18AA, 0x18AA}, {0x18B0, 0x18F5}, {0x1900, 0x191E},
+ {0x1920, 0x1922}, {0x1923, 0x1926}, {0x1927, 0x1928},
+ {0x1929, 0x192B}, {0x1930, 0x1931}, {0x1932, 0x1932},
+ {0x1933, 0x1938}, {0x1939, 0x193B}, {0x1940, 0x1940},
+ {0x1944, 0x1945}, {0x1946, 0x194F}, {0x1950, 0x196D},
+ {0x1970, 0x1974}, {0x1980, 0x19AB}, {0x19B0, 0x19C9},
+ {0x19D0, 0x19D9}, {0x19DA, 0x19DA}, {0x19DE, 0x19DF},
+ {0x19E0, 0x19FF}, {0x1A00, 0x1A16}, {0x1A17, 0x1A18},
+ {0x1A19, 0x1A1A}, {0x1A1B, 0x1A1B}, {0x1A1E, 0x1A1F},
+ {0x1A20, 0x1A54}, {0x1A55, 0x1A55}, {0x1A56, 0x1A56},
+ {0x1A57, 0x1A57}, {0x1A58, 0x1A5E}, {0x1A60, 0x1A60},
+ {0x1A61, 0x1A61}, {0x1A62, 0x1A62}, {0x1A63, 0x1A64},
+ {0x1A65, 0x1A6C}, {0x1A6D, 0x1A72}, {0x1A73, 0x1A7C},
+ {0x1A7F, 0x1A7F}, {0x1A80, 0x1A89}, {0x1A90, 0x1A99},
+ {0x1AA0, 0x1AA6}, {0x1AA7, 0x1AA7}, {0x1AA8, 0x1AAD},
+ {0x1AB0, 0x1ABD}, {0x1ABE, 0x1ABE}, {0x1B00, 0x1B03},
+ {0x1B04, 0x1B04}, {0x1B05, 0x1B33}, {0x1B34, 0x1B34},
+ {0x1B35, 0x1B35}, {0x1B36, 0x1B3A}, {0x1B3B, 0x1B3B},
+ {0x1B3C, 0x1B3C}, {0x1B3D, 0x1B41}, {0x1B42, 0x1B42},
+ {0x1B43, 0x1B44}, {0x1B45, 0x1B4B}, {0x1B50, 0x1B59},
+ {0x1B5A, 0x1B60}, {0x1B61, 0x1B6A}, {0x1B6B, 0x1B73},
+ {0x1B74, 0x1B7C}, {0x1B80, 0x1B81}, {0x1B82, 0x1B82},
+ {0x1B83, 0x1BA0}, {0x1BA1, 0x1BA1}, {0x1BA2, 0x1BA5},
+ {0x1BA6, 0x1BA7}, {0x1BA8, 0x1BA9}, {0x1BAA, 0x1BAA},
+ {0x1BAB, 0x1BAD}, {0x1BAE, 0x1BAF}, {0x1BB0, 0x1BB9},
+ {0x1BBA, 0x1BBF}, {0x1BC0, 0x1BE5}, {0x1BE6, 0x1BE6},
+ {0x1BE7, 0x1BE7}, {0x1BE8, 0x1BE9}, {0x1BEA, 0x1BEC},
+ {0x1BED, 0x1BED}, {0x1BEE, 0x1BEE}, {0x1BEF, 0x1BF1},
+ {0x1BF2, 0x1BF3}, {0x1BFC, 0x1BFF}, {0x1C00, 0x1C23},
+ {0x1C24, 0x1C2B}, {0x1C2C, 0x1C33}, {0x1C34, 0x1C35},
+ {0x1C36, 0x1C37}, {0x1C3B, 0x1C3F}, {0x1C40, 0x1C49},
+ {0x1C4D, 0x1C4F}, {0x1C50, 0x1C59}, {0x1C5A, 0x1C77},
+ {0x1C78, 0x1C7D}, {0x1C7E, 0x1C7F}, {0x1C80, 0x1C88},
+ {0x1CC0, 0x1CC7}, {0x1CD0, 0x1CD2}, {0x1CD3, 0x1CD3},
+ {0x1CD4, 0x1CE0}, {0x1CE1, 0x1CE1}, {0x1CE2, 0x1CE8},
+ {0x1CE9, 0x1CEC}, {0x1CED, 0x1CED}, {0x1CEE, 0x1CF1},
+ {0x1CF2, 0x1CF3}, {0x1CF4, 0x1CF4}, {0x1CF5, 0x1CF6},
+ {0x1CF8, 0x1CF9}, {0x1D00, 0x1D2B}, {0x1D2C, 0x1D6A},
+ {0x1D6B, 0x1D77}, {0x1D78, 0x1D78}, {0x1D79, 0x1D7F},
+ {0x1D80, 0x1D9A}, {0x1D9B, 0x1DBF}, {0x1DC0, 0x1DF5},
+ {0x1DFB, 0x1DFF}, {0x1E00, 0x1EFF}, {0x1F00, 0x1F15},
+ {0x1F18, 0x1F1D}, {0x1F20, 0x1F45}, {0x1F48, 0x1F4D},
+ {0x1F50, 0x1F57}, {0x1F59, 0x1F59}, {0x1F5B, 0x1F5B},
+ {0x1F5D, 0x1F5D}, {0x1F5F, 0x1F7D}, {0x1F80, 0x1FB4},
+ {0x1FB6, 0x1FBC}, {0x1FBD, 0x1FBD}, {0x1FBE, 0x1FBE},
+ {0x1FBF, 0x1FC1}, {0x1FC2, 0x1FC4}, {0x1FC6, 0x1FCC},
+ {0x1FCD, 0x1FCF}, {0x1FD0, 0x1FD3}, {0x1FD6, 0x1FDB},
+ {0x1FDD, 0x1FDF}, {0x1FE0, 0x1FEC}, {0x1FED, 0x1FEF},
+ {0x1FF2, 0x1FF4}, {0x1FF6, 0x1FFC}, {0x1FFD, 0x1FFE},
+ {0x2000, 0x200A}, {0x200B, 0x200F}, {0x2011, 0x2012},
+ {0x2017, 0x2017}, {0x201A, 0x201A}, {0x201B, 0x201B},
+ {0x201E, 0x201E}, {0x201F, 0x201F}, {0x2023, 0x2023},
+ {0x2028, 0x2028}, {0x2029, 0x2029}, {0x202A, 0x202E},
+ {0x202F, 0x202F}, {0x2031, 0x2031}, {0x2034, 0x2034},
+ {0x2036, 0x2038}, {0x2039, 0x2039}, {0x203A, 0x203A},
+ {0x203C, 0x203D}, {0x203F, 0x2040}, {0x2041, 0x2043},
+ {0x2044, 0x2044}, {0x2045, 0x2045}, {0x2046, 0x2046},
+ {0x2047, 0x2051}, {0x2052, 0x2052}, {0x2053, 0x2053},
+ {0x2054, 0x2054}, {0x2055, 0x205E}, {0x205F, 0x205F},
+ {0x2060, 0x2064}, {0x2066, 0x206F}, {0x2070, 0x2070},
+ {0x2071, 0x2071}, {0x2075, 0x2079}, {0x207A, 0x207C},
+ {0x207D, 0x207D}, {0x207E, 0x207E}, {0x2080, 0x2080},
+ {0x2085, 0x2089}, {0x208A, 0x208C}, {0x208D, 0x208D},
+ {0x208E, 0x208E}, {0x2090, 0x209C}, {0x20A0, 0x20A8},
+ {0x20AA, 0x20AB}, {0x20AD, 0x20BE}, {0x20D0, 0x20DC},
+ {0x20DD, 0x20E0}, {0x20E1, 0x20E1}, {0x20E2, 0x20E4},
+ {0x20E5, 0x20F0}, {0x2100, 0x2101}, {0x2102, 0x2102},
+ {0x2104, 0x2104}, {0x2106, 0x2106}, {0x2107, 0x2107},
+ {0x2108, 0x2108}, {0x210A, 0x2112}, {0x2114, 0x2114},
+ {0x2115, 0x2115}, {0x2117, 0x2117}, {0x2118, 0x2118},
+ {0x2119, 0x211D}, {0x211E, 0x2120}, {0x2123, 0x2123},
+ {0x2124, 0x2124}, {0x2125, 0x2125}, {0x2127, 0x2127},
+ {0x2128, 0x2128}, {0x2129, 0x2129}, {0x212A, 0x212A},
+ {0x212C, 0x212D}, {0x212E, 0x212E}, {0x212F, 0x2134},
+ {0x2135, 0x2138}, {0x2139, 0x2139}, {0x213A, 0x213B},
+ {0x213C, 0x213F}, {0x2140, 0x2144}, {0x2145, 0x2149},
+ {0x214A, 0x214A}, {0x214B, 0x214B}, {0x214C, 0x214D},
+ {0x214E, 0x214E}, {0x214F, 0x214F}, {0x2150, 0x2152},
+ {0x2155, 0x215A}, {0x215F, 0x215F}, {0x216C, 0x216F},
+ {0x217A, 0x2182}, {0x2183, 0x2184}, {0x2185, 0x2188},
+ {0x218A, 0x218B}, {0x219A, 0x219B}, {0x219C, 0x219F},
+ {0x21A0, 0x21A0}, {0x21A1, 0x21A2}, {0x21A3, 0x21A3},
+ {0x21A4, 0x21A5}, {0x21A6, 0x21A6}, {0x21A7, 0x21AD},
+ {0x21AE, 0x21AE}, {0x21AF, 0x21B7}, {0x21BA, 0x21CD},
+ {0x21CE, 0x21CF}, {0x21D0, 0x21D1}, {0x21D3, 0x21D3},
+ {0x21D5, 0x21E6}, {0x21E8, 0x21F3}, {0x21F4, 0x21FF},
+ {0x2201, 0x2201}, {0x2204, 0x2206}, {0x2209, 0x220A},
+ {0x220C, 0x220E}, {0x2210, 0x2210}, {0x2212, 0x2214},
+ {0x2216, 0x2219}, {0x221B, 0x221C}, {0x2221, 0x2222},
+ {0x2224, 0x2224}, {0x2226, 0x2226}, {0x222D, 0x222D},
+ {0x222F, 0x2233}, {0x2238, 0x223B}, {0x223E, 0x2247},
+ {0x2249, 0x224B}, {0x224D, 0x2251}, {0x2253, 0x225F},
+ {0x2262, 0x2263}, {0x2268, 0x2269}, {0x226C, 0x226D},
+ {0x2270, 0x2281}, {0x2284, 0x2285}, {0x2288, 0x2294},
+ {0x2296, 0x2298}, {0x229A, 0x22A4}, {0x22A6, 0x22BE},
+ {0x22C0, 0x22FF}, {0x2300, 0x2307}, {0x2308, 0x2308},
+ {0x2309, 0x2309}, {0x230A, 0x230A}, {0x230B, 0x230B},
+ {0x230C, 0x2311}, {0x2313, 0x2319}, {0x231C, 0x231F},
+ {0x2320, 0x2321}, {0x2322, 0x2328}, {0x232B, 0x237B},
+ {0x237C, 0x237C}, {0x237D, 0x239A}, {0x239B, 0x23B3},
+ {0x23B4, 0x23DB}, {0x23DC, 0x23E1}, {0x23E2, 0x23E8},
+ {0x23ED, 0x23EF}, {0x23F1, 0x23F2}, {0x23F4, 0x23FE},
+ {0x2400, 0x2426}, {0x2440, 0x244A}, {0x24EA, 0x24EA},
+ {0x254C, 0x254F}, {0x2574, 0x257F}, {0x2590, 0x2591},
+ {0x2596, 0x259F}, {0x25A2, 0x25A2}, {0x25AA, 0x25B1},
+ {0x25B4, 0x25B5}, {0x25B8, 0x25BB}, {0x25BE, 0x25BF},
+ {0x25C2, 0x25C5}, {0x25C9, 0x25CA}, {0x25CC, 0x25CD},
+ {0x25D2, 0x25E1}, {0x25E6, 0x25EE}, {0x25F0, 0x25F7},
+ {0x25F8, 0x25FC}, {0x25FF, 0x25FF}, {0x2600, 0x2604},
+ {0x2607, 0x2608}, {0x260A, 0x260D}, {0x2610, 0x2613},
+ {0x2616, 0x261B}, {0x261D, 0x261D}, {0x261F, 0x263F},
+ {0x2641, 0x2641}, {0x2643, 0x2647}, {0x2654, 0x265F},
+ {0x2662, 0x2662}, {0x2666, 0x2666}, {0x266B, 0x266B},
+ {0x266E, 0x266E}, {0x2670, 0x267E}, {0x2680, 0x2692},
+ {0x2694, 0x269D}, {0x26A0, 0x26A0}, {0x26A2, 0x26A9},
+ {0x26AC, 0x26BC}, {0x26C0, 0x26C3}, {0x26E2, 0x26E2},
+ {0x26E4, 0x26E7}, {0x2700, 0x2704}, {0x2706, 0x2709},
+ {0x270C, 0x2727}, {0x2729, 0x273C}, {0x273E, 0x274B},
+ {0x274D, 0x274D}, {0x274F, 0x2752}, {0x2756, 0x2756},
+ {0x2758, 0x2767}, {0x2768, 0x2768}, {0x2769, 0x2769},
+ {0x276A, 0x276A}, {0x276B, 0x276B}, {0x276C, 0x276C},
+ {0x276D, 0x276D}, {0x276E, 0x276E}, {0x276F, 0x276F},
+ {0x2770, 0x2770}, {0x2771, 0x2771}, {0x2772, 0x2772},
+ {0x2773, 0x2773}, {0x2774, 0x2774}, {0x2775, 0x2775},
+ {0x2780, 0x2793}, {0x2794, 0x2794}, {0x2798, 0x27AF},
+ {0x27B1, 0x27BE}, {0x27C0, 0x27C4}, {0x27C5, 0x27C5},
+ {0x27C6, 0x27C6}, {0x27C7, 0x27E5}, {0x27EE, 0x27EE},
+ {0x27EF, 0x27EF}, {0x27F0, 0x27FF}, {0x2800, 0x28FF},
+ {0x2900, 0x297F}, {0x2980, 0x2982}, {0x2983, 0x2983},
+ {0x2984, 0x2984}, {0x2987, 0x2987}, {0x2988, 0x2988},
+ {0x2989, 0x2989}, {0x298A, 0x298A}, {0x298B, 0x298B},
+ {0x298C, 0x298C}, {0x298D, 0x298D}, {0x298E, 0x298E},
+ {0x298F, 0x298F}, {0x2990, 0x2990}, {0x2991, 0x2991},
+ {0x2992, 0x2992}, {0x2993, 0x2993}, {0x2994, 0x2994},
+ {0x2995, 0x2995}, {0x2996, 0x2996}, {0x2997, 0x2997},
+ {0x2998, 0x2998}, {0x2999, 0x29D7}, {0x29D8, 0x29D8},
+ {0x29D9, 0x29D9}, {0x29DA, 0x29DA}, {0x29DB, 0x29DB},
+ {0x29DC, 0x29FB}, {0x29FC, 0x29FC}, {0x29FD, 0x29FD},
+ {0x29FE, 0x29FF}, {0x2A00, 0x2AFF}, {0x2B00, 0x2B1A},
+ {0x2B1D, 0x2B2F}, {0x2B30, 0x2B44}, {0x2B45, 0x2B46},
+ {0x2B47, 0x2B4C}, {0x2B4D, 0x2B4F}, {0x2B51, 0x2B54},
+ {0x2B5A, 0x2B73}, {0x2B76, 0x2B95}, {0x2B98, 0x2BB9},
+ {0x2BBD, 0x2BC8}, {0x2BCA, 0x2BD1}, {0x2BEC, 0x2BEF},
+ {0x2C00, 0x2C2E}, {0x2C30, 0x2C5E}, {0x2C60, 0x2C7B},
+ {0x2C7C, 0x2C7D}, {0x2C7E, 0x2C7F}, {0x2C80, 0x2CE4},
+ {0x2CE5, 0x2CEA}, {0x2CEB, 0x2CEE}, {0x2CEF, 0x2CF1},
+ {0x2CF2, 0x2CF3}, {0x2CF9, 0x2CFC}, {0x2CFD, 0x2CFD},
+ {0x2CFE, 0x2CFF}, {0x2D00, 0x2D25}, {0x2D27, 0x2D27},
+ {0x2D2D, 0x2D2D}, {0x2D30, 0x2D67}, {0x2D6F, 0x2D6F},
+ {0x2D70, 0x2D70}, {0x2D7F, 0x2D7F}, {0x2D80, 0x2D96},
+ {0x2DA0, 0x2DA6}, {0x2DA8, 0x2DAE}, {0x2DB0, 0x2DB6},
+ {0x2DB8, 0x2DBE}, {0x2DC0, 0x2DC6}, {0x2DC8, 0x2DCE},
+ {0x2DD0, 0x2DD6}, {0x2DD8, 0x2DDE}, {0x2DE0, 0x2DFF},
+ {0x2E00, 0x2E01}, {0x2E02, 0x2E02}, {0x2E03, 0x2E03},
+ {0x2E04, 0x2E04}, {0x2E05, 0x2E05}, {0x2E06, 0x2E08},
+ {0x2E09, 0x2E09}, {0x2E0A, 0x2E0A}, {0x2E0B, 0x2E0B},
+ {0x2E0C, 0x2E0C}, {0x2E0D, 0x2E0D}, {0x2E0E, 0x2E16},
+ {0x2E17, 0x2E17}, {0x2E18, 0x2E19}, {0x2E1A, 0x2E1A},
+ {0x2E1B, 0x2E1B}, {0x2E1C, 0x2E1C}, {0x2E1D, 0x2E1D},
+ {0x2E1E, 0x2E1F}, {0x2E20, 0x2E20}, {0x2E21, 0x2E21},
+ {0x2E22, 0x2E22}, {0x2E23, 0x2E23}, {0x2E24, 0x2E24},
+ {0x2E25, 0x2E25}, {0x2E26, 0x2E26}, {0x2E27, 0x2E27},
+ {0x2E28, 0x2E28}, {0x2E29, 0x2E29}, {0x2E2A, 0x2E2E},
+ {0x2E2F, 0x2E2F}, {0x2E30, 0x2E39}, {0x2E3A, 0x2E3B},
+ {0x2E3C, 0x2E3F}, {0x2E40, 0x2E40}, {0x2E41, 0x2E41},
+ {0x2E42, 0x2E42}, {0x2E43, 0x2E44}, {0x303F, 0x303F},
+ {0x4DC0, 0x4DFF}, {0xA4D0, 0xA4F7}, {0xA4F8, 0xA4FD},
+ {0xA4FE, 0xA4FF}, {0xA500, 0xA60B}, {0xA60C, 0xA60C},
+ {0xA60D, 0xA60F}, {0xA610, 0xA61F}, {0xA620, 0xA629},
+ {0xA62A, 0xA62B}, {0xA640, 0xA66D}, {0xA66E, 0xA66E},
+ {0xA66F, 0xA66F}, {0xA670, 0xA672}, {0xA673, 0xA673},
+ {0xA674, 0xA67D}, {0xA67E, 0xA67E}, {0xA67F, 0xA67F},
+ {0xA680, 0xA69B}, {0xA69C, 0xA69D}, {0xA69E, 0xA69F},
+ {0xA6A0, 0xA6E5}, {0xA6E6, 0xA6EF}, {0xA6F0, 0xA6F1},
+ {0xA6F2, 0xA6F7}, {0xA700, 0xA716}, {0xA717, 0xA71F},
+ {0xA720, 0xA721}, {0xA722, 0xA76F}, {0xA770, 0xA770},
+ {0xA771, 0xA787}, {0xA788, 0xA788}, {0xA789, 0xA78A},
+ {0xA78B, 0xA78E}, {0xA78F, 0xA78F}, {0xA790, 0xA7AE},
+ {0xA7B0, 0xA7B7}, {0xA7F7, 0xA7F7}, {0xA7F8, 0xA7F9},
+ {0xA7FA, 0xA7FA}, {0xA7FB, 0xA7FF}, {0xA800, 0xA801},
+ {0xA802, 0xA802}, {0xA803, 0xA805}, {0xA806, 0xA806},
+ {0xA807, 0xA80A}, {0xA80B, 0xA80B}, {0xA80C, 0xA822},
+ {0xA823, 0xA824}, {0xA825, 0xA826}, {0xA827, 0xA827},
+ {0xA828, 0xA82B}, {0xA830, 0xA835}, {0xA836, 0xA837},
+ {0xA838, 0xA838}, {0xA839, 0xA839}, {0xA840, 0xA873},
+ {0xA874, 0xA877}, {0xA880, 0xA881}, {0xA882, 0xA8B3},
+ {0xA8B4, 0xA8C3}, {0xA8C4, 0xA8C5}, {0xA8CE, 0xA8CF},
+ {0xA8D0, 0xA8D9}, {0xA8E0, 0xA8F1}, {0xA8F2, 0xA8F7},
+ {0xA8F8, 0xA8FA}, {0xA8FB, 0xA8FB}, {0xA8FC, 0xA8FC},
+ {0xA8FD, 0xA8FD}, {0xA900, 0xA909}, {0xA90A, 0xA925},
+ {0xA926, 0xA92D}, {0xA92E, 0xA92F}, {0xA930, 0xA946},
+ {0xA947, 0xA951}, {0xA952, 0xA953}, {0xA95F, 0xA95F},
+ {0xA980, 0xA982}, {0xA983, 0xA983}, {0xA984, 0xA9B2},
+ {0xA9B3, 0xA9B3}, {0xA9B4, 0xA9B5}, {0xA9B6, 0xA9B9},
+ {0xA9BA, 0xA9BB}, {0xA9BC, 0xA9BC}, {0xA9BD, 0xA9C0},
+ {0xA9C1, 0xA9CD}, {0xA9CF, 0xA9CF}, {0xA9D0, 0xA9D9},
+ {0xA9DE, 0xA9DF}, {0xA9E0, 0xA9E4}, {0xA9E5, 0xA9E5},
+ {0xA9E6, 0xA9E6}, {0xA9E7, 0xA9EF}, {0xA9F0, 0xA9F9},
+ {0xA9FA, 0xA9FE}, {0xAA00, 0xAA28}, {0xAA29, 0xAA2E},
+ {0xAA2F, 0xAA30}, {0xAA31, 0xAA32}, {0xAA33, 0xAA34},
+ {0xAA35, 0xAA36}, {0xAA40, 0xAA42}, {0xAA43, 0xAA43},
+ {0xAA44, 0xAA4B}, {0xAA4C, 0xAA4C}, {0xAA4D, 0xAA4D},
+ {0xAA50, 0xAA59}, {0xAA5C, 0xAA5F}, {0xAA60, 0xAA6F},
+ {0xAA70, 0xAA70}, {0xAA71, 0xAA76}, {0xAA77, 0xAA79},
+ {0xAA7A, 0xAA7A}, {0xAA7B, 0xAA7B}, {0xAA7C, 0xAA7C},
+ {0xAA7D, 0xAA7D}, {0xAA7E, 0xAA7F}, {0xAA80, 0xAAAF},
+ {0xAAB0, 0xAAB0}, {0xAAB1, 0xAAB1}, {0xAAB2, 0xAAB4},
+ {0xAAB5, 0xAAB6}, {0xAAB7, 0xAAB8}, {0xAAB9, 0xAABD},
+ {0xAABE, 0xAABF}, {0xAAC0, 0xAAC0}, {0xAAC1, 0xAAC1},
+ {0xAAC2, 0xAAC2}, {0xAADB, 0xAADC}, {0xAADD, 0xAADD},
+ {0xAADE, 0xAADF}, {0xAAE0, 0xAAEA}, {0xAAEB, 0xAAEB},
+ {0xAAEC, 0xAAED}, {0xAAEE, 0xAAEF}, {0xAAF0, 0xAAF1},
+ {0xAAF2, 0xAAF2}, {0xAAF3, 0xAAF4}, {0xAAF5, 0xAAF5},
+ {0xAAF6, 0xAAF6}, {0xAB01, 0xAB06}, {0xAB09, 0xAB0E},
+ {0xAB11, 0xAB16}, {0xAB20, 0xAB26}, {0xAB28, 0xAB2E},
+ {0xAB30, 0xAB5A}, {0xAB5B, 0xAB5B}, {0xAB5C, 0xAB5F},
+ {0xAB60, 0xAB65}, {0xAB70, 0xABBF}, {0xABC0, 0xABE2},
+ {0xABE3, 0xABE4}, {0xABE5, 0xABE5}, {0xABE6, 0xABE7},
+ {0xABE8, 0xABE8}, {0xABE9, 0xABEA}, {0xABEB, 0xABEB},
+ {0xABEC, 0xABEC}, {0xABED, 0xABED}, {0xABF0, 0xABF9},
+ {0xD7B0, 0xD7C6}, {0xD7CB, 0xD7FB}, {0xD800, 0xDB7F},
+ {0xDB80, 0xDBFF}, {0xDC00, 0xDFFF}, {0xFB00, 0xFB06},
+ {0xFB13, 0xFB17}, {0xFB1D, 0xFB1D}, {0xFB1E, 0xFB1E},
+ {0xFB1F, 0xFB28}, {0xFB29, 0xFB29}, {0xFB2A, 0xFB36},
+ {0xFB38, 0xFB3C}, {0xFB3E, 0xFB3E}, {0xFB40, 0xFB41},
+ {0xFB43, 0xFB44}, {0xFB46, 0xFB4F}, {0xFB50, 0xFBB1},
+ {0xFBB2, 0xFBC1}, {0xFBD3, 0xFD3D}, {0xFD3E, 0xFD3E},
+ {0xFD3F, 0xFD3F}, {0xFD50, 0xFD8F}, {0xFD92, 0xFDC7},
+ {0xFDF0, 0xFDFB}, {0xFDFC, 0xFDFC}, {0xFDFD, 0xFDFD},
+ {0xFE20, 0xFE2F}, {0xFE70, 0xFE74}, {0xFE76, 0xFEFC},
+ {0xFEFF, 0xFEFF}, {0xFFF9, 0xFFFB}, {0xFFFC, 0xFFFC},
+ {0x10000, 0x1000B}, {0x1000D, 0x10026}, {0x10028, 0x1003A},
+ {0x1003C, 0x1003D}, {0x1003F, 0x1004D}, {0x10050, 0x1005D},
+ {0x10080, 0x100FA}, {0x10100, 0x10102}, {0x10107, 0x10133},
+ {0x10137, 0x1013F}, {0x10140, 0x10174}, {0x10175, 0x10178},
+ {0x10179, 0x10189}, {0x1018A, 0x1018B}, {0x1018C, 0x1018E},
+ {0x10190, 0x1019B}, {0x101A0, 0x101A0}, {0x101D0, 0x101FC},
+ {0x101FD, 0x101FD}, {0x10280, 0x1029C}, {0x102A0, 0x102D0},
+ {0x102E0, 0x102E0}, {0x102E1, 0x102FB}, {0x10300, 0x1031F},
+ {0x10320, 0x10323}, {0x10330, 0x10340}, {0x10341, 0x10341},
+ {0x10342, 0x10349}, {0x1034A, 0x1034A}, {0x10350, 0x10375},
+ {0x10376, 0x1037A}, {0x10380, 0x1039D}, {0x1039F, 0x1039F},
+ {0x103A0, 0x103C3}, {0x103C8, 0x103CF}, {0x103D0, 0x103D0},
+ {0x103D1, 0x103D5}, {0x10400, 0x1044F}, {0x10450, 0x1047F},
+ {0x10480, 0x1049D}, {0x104A0, 0x104A9}, {0x104B0, 0x104D3},
+ {0x104D8, 0x104FB}, {0x10500, 0x10527}, {0x10530, 0x10563},
+ {0x1056F, 0x1056F}, {0x10600, 0x10736}, {0x10740, 0x10755},
+ {0x10760, 0x10767}, {0x10800, 0x10805}, {0x10808, 0x10808},
+ {0x1080A, 0x10835}, {0x10837, 0x10838}, {0x1083C, 0x1083C},
+ {0x1083F, 0x1083F}, {0x10840, 0x10855}, {0x10857, 0x10857},
+ {0x10858, 0x1085F}, {0x10860, 0x10876}, {0x10877, 0x10878},
+ {0x10879, 0x1087F}, {0x10880, 0x1089E}, {0x108A7, 0x108AF},
+ {0x108E0, 0x108F2}, {0x108F4, 0x108F5}, {0x108FB, 0x108FF},
+ {0x10900, 0x10915}, {0x10916, 0x1091B}, {0x1091F, 0x1091F},
+ {0x10920, 0x10939}, {0x1093F, 0x1093F}, {0x10980, 0x1099F},
+ {0x109A0, 0x109B7}, {0x109BC, 0x109BD}, {0x109BE, 0x109BF},
+ {0x109C0, 0x109CF}, {0x109D2, 0x109FF}, {0x10A00, 0x10A00},
+ {0x10A01, 0x10A03}, {0x10A05, 0x10A06}, {0x10A0C, 0x10A0F},
+ {0x10A10, 0x10A13}, {0x10A15, 0x10A17}, {0x10A19, 0x10A33},
+ {0x10A38, 0x10A3A}, {0x10A3F, 0x10A3F}, {0x10A40, 0x10A47},
+ {0x10A50, 0x10A58}, {0x10A60, 0x10A7C}, {0x10A7D, 0x10A7E},
+ {0x10A7F, 0x10A7F}, {0x10A80, 0x10A9C}, {0x10A9D, 0x10A9F},
+ {0x10AC0, 0x10AC7}, {0x10AC8, 0x10AC8}, {0x10AC9, 0x10AE4},
+ {0x10AE5, 0x10AE6}, {0x10AEB, 0x10AEF}, {0x10AF0, 0x10AF6},
+ {0x10B00, 0x10B35}, {0x10B39, 0x10B3F}, {0x10B40, 0x10B55},
+ {0x10B58, 0x10B5F}, {0x10B60, 0x10B72}, {0x10B78, 0x10B7F},
+ {0x10B80, 0x10B91}, {0x10B99, 0x10B9C}, {0x10BA9, 0x10BAF},
+ {0x10C00, 0x10C48}, {0x10C80, 0x10CB2}, {0x10CC0, 0x10CF2},
+ {0x10CFA, 0x10CFF}, {0x10E60, 0x10E7E}, {0x11000, 0x11000},
+ {0x11001, 0x11001}, {0x11002, 0x11002}, {0x11003, 0x11037},
+ {0x11038, 0x11046}, {0x11047, 0x1104D}, {0x11052, 0x11065},
+ {0x11066, 0x1106F}, {0x1107F, 0x1107F}, {0x11080, 0x11081},
+ {0x11082, 0x11082}, {0x11083, 0x110AF}, {0x110B0, 0x110B2},
+ {0x110B3, 0x110B6}, {0x110B7, 0x110B8}, {0x110B9, 0x110BA},
+ {0x110BB, 0x110BC}, {0x110BD, 0x110BD}, {0x110BE, 0x110C1},
+ {0x110D0, 0x110E8}, {0x110F0, 0x110F9}, {0x11100, 0x11102},
+ {0x11103, 0x11126}, {0x11127, 0x1112B}, {0x1112C, 0x1112C},
+ {0x1112D, 0x11134}, {0x11136, 0x1113F}, {0x11140, 0x11143},
+ {0x11150, 0x11172}, {0x11173, 0x11173}, {0x11174, 0x11175},
+ {0x11176, 0x11176}, {0x11180, 0x11181}, {0x11182, 0x11182},
+ {0x11183, 0x111B2}, {0x111B3, 0x111B5}, {0x111B6, 0x111BE},
+ {0x111BF, 0x111C0}, {0x111C1, 0x111C4}, {0x111C5, 0x111C9},
+ {0x111CA, 0x111CC}, {0x111CD, 0x111CD}, {0x111D0, 0x111D9},
+ {0x111DA, 0x111DA}, {0x111DB, 0x111DB}, {0x111DC, 0x111DC},
+ {0x111DD, 0x111DF}, {0x111E1, 0x111F4}, {0x11200, 0x11211},
+ {0x11213, 0x1122B}, {0x1122C, 0x1122E}, {0x1122F, 0x11231},
+ {0x11232, 0x11233}, {0x11234, 0x11234}, {0x11235, 0x11235},
+ {0x11236, 0x11237}, {0x11238, 0x1123D}, {0x1123E, 0x1123E},
+ {0x11280, 0x11286}, {0x11288, 0x11288}, {0x1128A, 0x1128D},
+ {0x1128F, 0x1129D}, {0x1129F, 0x112A8}, {0x112A9, 0x112A9},
+ {0x112B0, 0x112DE}, {0x112DF, 0x112DF}, {0x112E0, 0x112E2},
+ {0x112E3, 0x112EA}, {0x112F0, 0x112F9}, {0x11300, 0x11301},
+ {0x11302, 0x11303}, {0x11305, 0x1130C}, {0x1130F, 0x11310},
+ {0x11313, 0x11328}, {0x1132A, 0x11330}, {0x11332, 0x11333},
+ {0x11335, 0x11339}, {0x1133C, 0x1133C}, {0x1133D, 0x1133D},
+ {0x1133E, 0x1133F}, {0x11340, 0x11340}, {0x11341, 0x11344},
+ {0x11347, 0x11348}, {0x1134B, 0x1134D}, {0x11350, 0x11350},
+ {0x11357, 0x11357}, {0x1135D, 0x11361}, {0x11362, 0x11363},
+ {0x11366, 0x1136C}, {0x11370, 0x11374}, {0x11400, 0x11434},
+ {0x11435, 0x11437}, {0x11438, 0x1143F}, {0x11440, 0x11441},
+ {0x11442, 0x11444}, {0x11445, 0x11445}, {0x11446, 0x11446},
+ {0x11447, 0x1144A}, {0x1144B, 0x1144F}, {0x11450, 0x11459},
+ {0x1145B, 0x1145B}, {0x1145D, 0x1145D}, {0x11480, 0x114AF},
+ {0x114B0, 0x114B2}, {0x114B3, 0x114B8}, {0x114B9, 0x114B9},
+ {0x114BA, 0x114BA}, {0x114BB, 0x114BE}, {0x114BF, 0x114C0},
+ {0x114C1, 0x114C1}, {0x114C2, 0x114C3}, {0x114C4, 0x114C5},
+ {0x114C6, 0x114C6}, {0x114C7, 0x114C7}, {0x114D0, 0x114D9},
+ {0x11580, 0x115AE}, {0x115AF, 0x115B1}, {0x115B2, 0x115B5},
+ {0x115B8, 0x115BB}, {0x115BC, 0x115BD}, {0x115BE, 0x115BE},
+ {0x115BF, 0x115C0}, {0x115C1, 0x115D7}, {0x115D8, 0x115DB},
+ {0x115DC, 0x115DD}, {0x11600, 0x1162F}, {0x11630, 0x11632},
+ {0x11633, 0x1163A}, {0x1163B, 0x1163C}, {0x1163D, 0x1163D},
+ {0x1163E, 0x1163E}, {0x1163F, 0x11640}, {0x11641, 0x11643},
+ {0x11644, 0x11644}, {0x11650, 0x11659}, {0x11660, 0x1166C},
+ {0x11680, 0x116AA}, {0x116AB, 0x116AB}, {0x116AC, 0x116AC},
+ {0x116AD, 0x116AD}, {0x116AE, 0x116AF}, {0x116B0, 0x116B5},
+ {0x116B6, 0x116B6}, {0x116B7, 0x116B7}, {0x116C0, 0x116C9},
+ {0x11700, 0x11719}, {0x1171D, 0x1171F}, {0x11720, 0x11721},
+ {0x11722, 0x11725}, {0x11726, 0x11726}, {0x11727, 0x1172B},
+ {0x11730, 0x11739}, {0x1173A, 0x1173B}, {0x1173C, 0x1173E},
+ {0x1173F, 0x1173F}, {0x118A0, 0x118DF}, {0x118E0, 0x118E9},
+ {0x118EA, 0x118F2}, {0x118FF, 0x118FF}, {0x11AC0, 0x11AF8},
+ {0x11C00, 0x11C08}, {0x11C0A, 0x11C2E}, {0x11C2F, 0x11C2F},
+ {0x11C30, 0x11C36}, {0x11C38, 0x11C3D}, {0x11C3E, 0x11C3E},
+ {0x11C3F, 0x11C3F}, {0x11C40, 0x11C40}, {0x11C41, 0x11C45},
+ {0x11C50, 0x11C59}, {0x11C5A, 0x11C6C}, {0x11C70, 0x11C71},
+ {0x11C72, 0x11C8F}, {0x11C92, 0x11CA7}, {0x11CA9, 0x11CA9},
+ {0x11CAA, 0x11CB0}, {0x11CB1, 0x11CB1}, {0x11CB2, 0x11CB3},
+ {0x11CB4, 0x11CB4}, {0x11CB5, 0x11CB6}, {0x12000, 0x12399},
+ {0x12400, 0x1246E}, {0x12470, 0x12474}, {0x12480, 0x12543},
+ {0x13000, 0x1342E}, {0x14400, 0x14646}, {0x16800, 0x16A38},
+ {0x16A40, 0x16A5E}, {0x16A60, 0x16A69}, {0x16A6E, 0x16A6F},
+ {0x16AD0, 0x16AED}, {0x16AF0, 0x16AF4}, {0x16AF5, 0x16AF5},
+ {0x16B00, 0x16B2F}, {0x16B30, 0x16B36}, {0x16B37, 0x16B3B},
+ {0x16B3C, 0x16B3F}, {0x16B40, 0x16B43}, {0x16B44, 0x16B44},
+ {0x16B45, 0x16B45}, {0x16B50, 0x16B59}, {0x16B5B, 0x16B61},
+ {0x16B63, 0x16B77}, {0x16B7D, 0x16B8F}, {0x16F00, 0x16F44},
+ {0x16F50, 0x16F50}, {0x16F51, 0x16F7E}, {0x16F8F, 0x16F92},
+ {0x16F93, 0x16F9F}, {0x1BC00, 0x1BC6A}, {0x1BC70, 0x1BC7C},
+ {0x1BC80, 0x1BC88}, {0x1BC90, 0x1BC99}, {0x1BC9C, 0x1BC9C},
+ {0x1BC9D, 0x1BC9E}, {0x1BC9F, 0x1BC9F}, {0x1BCA0, 0x1BCA3},
+ {0x1D000, 0x1D0F5}, {0x1D100, 0x1D126}, {0x1D129, 0x1D164},
+ {0x1D165, 0x1D166}, {0x1D167, 0x1D169}, {0x1D16A, 0x1D16C},
+ {0x1D16D, 0x1D172}, {0x1D173, 0x1D17A}, {0x1D17B, 0x1D182},
+ {0x1D183, 0x1D184}, {0x1D185, 0x1D18B}, {0x1D18C, 0x1D1A9},
+ {0x1D1AA, 0x1D1AD}, {0x1D1AE, 0x1D1E8}, {0x1D200, 0x1D241},
+ {0x1D242, 0x1D244}, {0x1D245, 0x1D245}, {0x1D300, 0x1D356},
+ {0x1D360, 0x1D371}, {0x1D400, 0x1D454}, {0x1D456, 0x1D49C},
+ {0x1D49E, 0x1D49F}, {0x1D4A2, 0x1D4A2}, {0x1D4A5, 0x1D4A6},
+ {0x1D4A9, 0x1D4AC}, {0x1D4AE, 0x1D4B9}, {0x1D4BB, 0x1D4BB},
+ {0x1D4BD, 0x1D4C3}, {0x1D4C5, 0x1D505}, {0x1D507, 0x1D50A},
+ {0x1D50D, 0x1D514}, {0x1D516, 0x1D51C}, {0x1D51E, 0x1D539},
+ {0x1D53B, 0x1D53E}, {0x1D540, 0x1D544}, {0x1D546, 0x1D546},
+ {0x1D54A, 0x1D550}, {0x1D552, 0x1D6A5}, {0x1D6A8, 0x1D6C0},
+ {0x1D6C1, 0x1D6C1}, {0x1D6C2, 0x1D6DA}, {0x1D6DB, 0x1D6DB},
+ {0x1D6DC, 0x1D6FA}, {0x1D6FB, 0x1D6FB}, {0x1D6FC, 0x1D714},
+ {0x1D715, 0x1D715}, {0x1D716, 0x1D734}, {0x1D735, 0x1D735},
+ {0x1D736, 0x1D74E}, {0x1D74F, 0x1D74F}, {0x1D750, 0x1D76E},
+ {0x1D76F, 0x1D76F}, {0x1D770, 0x1D788}, {0x1D789, 0x1D789},
+ {0x1D78A, 0x1D7A8}, {0x1D7A9, 0x1D7A9}, {0x1D7AA, 0x1D7C2},
+ {0x1D7C3, 0x1D7C3}, {0x1D7C4, 0x1D7CB}, {0x1D7CE, 0x1D7FF},
+ {0x1D800, 0x1D9FF}, {0x1DA00, 0x1DA36}, {0x1DA37, 0x1DA3A},
+ {0x1DA3B, 0x1DA6C}, {0x1DA6D, 0x1DA74}, {0x1DA75, 0x1DA75},
+ {0x1DA76, 0x1DA83}, {0x1DA84, 0x1DA84}, {0x1DA85, 0x1DA86},
+ {0x1DA87, 0x1DA8B}, {0x1DA9B, 0x1DA9F}, {0x1DAA1, 0x1DAAF},
+ {0x1E000, 0x1E006}, {0x1E008, 0x1E018}, {0x1E01B, 0x1E021},
+ {0x1E023, 0x1E024}, {0x1E026, 0x1E02A}, {0x1E800, 0x1E8C4},
+ {0x1E8C7, 0x1E8CF}, {0x1E8D0, 0x1E8D6}, {0x1E900, 0x1E943},
+ {0x1E944, 0x1E94A}, {0x1E950, 0x1E959}, {0x1E95E, 0x1E95F},
+ {0x1EE00, 0x1EE03}, {0x1EE05, 0x1EE1F}, {0x1EE21, 0x1EE22},
+ {0x1EE24, 0x1EE24}, {0x1EE27, 0x1EE27}, {0x1EE29, 0x1EE32},
+ {0x1EE34, 0x1EE37}, {0x1EE39, 0x1EE39}, {0x1EE3B, 0x1EE3B},
+ {0x1EE42, 0x1EE42}, {0x1EE47, 0x1EE47}, {0x1EE49, 0x1EE49},
+ {0x1EE4B, 0x1EE4B}, {0x1EE4D, 0x1EE4F}, {0x1EE51, 0x1EE52},
+ {0x1EE54, 0x1EE54}, {0x1EE57, 0x1EE57}, {0x1EE59, 0x1EE59},
+ {0x1EE5B, 0x1EE5B}, {0x1EE5D, 0x1EE5D}, {0x1EE5F, 0x1EE5F},
+ {0x1EE61, 0x1EE62}, {0x1EE64, 0x1EE64}, {0x1EE67, 0x1EE6A},
+ {0x1EE6C, 0x1EE72}, {0x1EE74, 0x1EE77}, {0x1EE79, 0x1EE7C},
+ {0x1EE7E, 0x1EE7E}, {0x1EE80, 0x1EE89}, {0x1EE8B, 0x1EE9B},
+ {0x1EEA1, 0x1EEA3}, {0x1EEA5, 0x1EEA9}, {0x1EEAB, 0x1EEBB},
+ {0x1EEF0, 0x1EEF1}, {0x1F000, 0x1F003}, {0x1F005, 0x1F02B},
+ {0x1F030, 0x1F093}, {0x1F0A0, 0x1F0AE}, {0x1F0B1, 0x1F0BF},
+ {0x1F0C1, 0x1F0CE}, {0x1F0D1, 0x1F0F5}, {0x1F10B, 0x1F10C},
+ {0x1F12E, 0x1F12E}, {0x1F16A, 0x1F16B}, {0x1F1E6, 0x1F1FF},
+ {0x1F321, 0x1F32C}, {0x1F336, 0x1F336}, {0x1F37D, 0x1F37D},
+ {0x1F394, 0x1F39F}, {0x1F3CB, 0x1F3CE}, {0x1F3D4, 0x1F3DF},
+ {0x1F3F1, 0x1F3F3}, {0x1F3F5, 0x1F3F7}, {0x1F43F, 0x1F43F},
+ {0x1F441, 0x1F441}, {0x1F4FD, 0x1F4FE}, {0x1F53E, 0x1F54A},
+ {0x1F54F, 0x1F54F}, {0x1F568, 0x1F579}, {0x1F57B, 0x1F594},
+ {0x1F597, 0x1F5A3}, {0x1F5A5, 0x1F5FA}, {0x1F650, 0x1F67F},
+ {0x1F6C6, 0x1F6CB}, {0x1F6CD, 0x1F6CF}, {0x1F6E0, 0x1F6EA},
+ {0x1F6F0, 0x1F6F3}, {0x1F700, 0x1F773}, {0x1F780, 0x1F7D4},
+ {0x1F800, 0x1F80B}, {0x1F810, 0x1F847}, {0x1F850, 0x1F859},
+ {0x1F860, 0x1F887}, {0x1F890, 0x1F8AD}, {0xE0001, 0xE0001},
+ {0xE0020, 0xE007F},
+}
+
+// Condition have flag EastAsianWidth whether the current locale is CJK or not.
+type Condition struct {
+ EastAsianWidth bool
+}
+
+// NewCondition return new instance of Condition which is current locale.
+func NewCondition() *Condition {
+ return &Condition{EastAsianWidth}
+}
+
+// RuneWidth returns the number of cells in r.
+// See http://www.unicode.org/reports/tr11/
+func (c *Condition) RuneWidth(r rune) int {
+ switch {
+ case r < 0 || r > 0x10FFFF ||
+ inTables(r, nonprint, combining, notassigned):
+ return 0
+ case (c.EastAsianWidth && IsAmbiguousWidth(r)) ||
+ inTables(r, doublewidth, emoji):
+ return 2
+ default:
+ return 1
+ }
+}
+
+// StringWidth return width as you can see
+func (c *Condition) StringWidth(s string) (width int) {
+ for _, r := range []rune(s) {
+ width += c.RuneWidth(r)
+ }
+ return width
+}
+
+// Truncate return string truncated with w cells
+func (c *Condition) Truncate(s string, w int, tail string) string {
+ if c.StringWidth(s) <= w {
+ return s
+ }
+ r := []rune(s)
+ tw := c.StringWidth(tail)
+ w -= tw
+ width := 0
+ i := 0
+ for ; i < len(r); i++ {
+ cw := c.RuneWidth(r[i])
+ if width+cw > w {
+ break
+ }
+ width += cw
+ }
+ return string(r[0:i]) + tail
+}
+
+// Wrap return string wrapped with w cells
+func (c *Condition) Wrap(s string, w int) string {
+ width := 0
+ out := ""
+ for _, r := range []rune(s) {
+ cw := RuneWidth(r)
+ if r == '\n' {
+ out += string(r)
+ width = 0
+ continue
+ } else if width+cw > w {
+ out += "\n"
+ width = 0
+ out += string(r)
+ width += cw
+ continue
+ }
+ out += string(r)
+ width += cw
+ }
+ return out
+}
+
+// FillLeft return string filled in left by spaces in w cells
+func (c *Condition) FillLeft(s string, w int) string {
+ width := c.StringWidth(s)
+ count := w - width
+ if count > 0 {
+ b := make([]byte, count)
+ for i := range b {
+ b[i] = ' '
+ }
+ return string(b) + s
+ }
+ return s
+}
+
+// FillRight return string filled in left by spaces in w cells
+func (c *Condition) FillRight(s string, w int) string {
+ width := c.StringWidth(s)
+ count := w - width
+ if count > 0 {
+ b := make([]byte, count)
+ for i := range b {
+ b[i] = ' '
+ }
+ return s + string(b)
+ }
+ return s
+}
+
+// RuneWidth returns the number of cells in r.
+// See http://www.unicode.org/reports/tr11/
+func RuneWidth(r rune) int {
+ return DefaultCondition.RuneWidth(r)
+}
+
+// IsAmbiguousWidth returns whether is ambiguous width or not.
+func IsAmbiguousWidth(r rune) bool {
+ return inTables(r, private, ambiguous)
+}
+
+// IsNeutralWidth returns whether is neutral width or not.
+func IsNeutralWidth(r rune) bool {
+ return inTable(r, neutral)
+}
+
+// StringWidth return width as you can see
+func StringWidth(s string) (width int) {
+ return DefaultCondition.StringWidth(s)
+}
+
+// Truncate return string truncated with w cells
+func Truncate(s string, w int, tail string) string {
+ return DefaultCondition.Truncate(s, w, tail)
+}
+
+// Wrap return string wrapped with w cells
+func Wrap(s string, w int) string {
+ return DefaultCondition.Wrap(s, w)
+}
+
+// FillLeft return string filled in left by spaces in w cells
+func FillLeft(s string, w int) string {
+ return DefaultCondition.FillLeft(s, w)
+}
+
+// FillRight return string filled in left by spaces in w cells
+func FillRight(s string, w int) string {
+ return DefaultCondition.FillRight(s, w)
+}
diff --git a/vendor/github.com/mattn/go-runewidth/runewidth_js.go b/vendor/github.com/mattn/go-runewidth/runewidth_js.go
new file mode 100644
index 00000000..0ce32c5e
--- /dev/null
+++ b/vendor/github.com/mattn/go-runewidth/runewidth_js.go
@@ -0,0 +1,8 @@
+// +build js
+
+package runewidth
+
+func IsEastAsian() bool {
+ // TODO: Implement this for the web. Detect east asian in a compatible way, and return true.
+ return false
+}
diff --git a/vendor/github.com/mattn/go-runewidth/runewidth_posix.go b/vendor/github.com/mattn/go-runewidth/runewidth_posix.go
new file mode 100644
index 00000000..c579e9a3
--- /dev/null
+++ b/vendor/github.com/mattn/go-runewidth/runewidth_posix.go
@@ -0,0 +1,77 @@
+// +build !windows,!js
+
+package runewidth
+
+import (
+ "os"
+ "regexp"
+ "strings"
+)
+
+var reLoc = regexp.MustCompile(`^[a-z][a-z][a-z]?(?:_[A-Z][A-Z])?\.(.+)`)
+
+var mblenTable = map[string]int{
+ "utf-8": 6,
+ "utf8": 6,
+ "jis": 8,
+ "eucjp": 3,
+ "euckr": 2,
+ "euccn": 2,
+ "sjis": 2,
+ "cp932": 2,
+ "cp51932": 2,
+ "cp936": 2,
+ "cp949": 2,
+ "cp950": 2,
+ "big5": 2,
+ "gbk": 2,
+ "gb2312": 2,
+}
+
+func isEastAsian(locale string) bool {
+ charset := strings.ToLower(locale)
+ r := reLoc.FindStringSubmatch(locale)
+ if len(r) == 2 {
+ charset = strings.ToLower(r[1])
+ }
+
+ if strings.HasSuffix(charset, "@cjk_narrow") {
+ return false
+ }
+
+ for pos, b := range []byte(charset) {
+ if b == '@' {
+ charset = charset[:pos]
+ break
+ }
+ }
+ max := 1
+ if m, ok := mblenTable[charset]; ok {
+ max = m
+ }
+ if max > 1 && (charset[0] != 'u' ||
+ strings.HasPrefix(locale, "ja") ||
+ strings.HasPrefix(locale, "ko") ||
+ strings.HasPrefix(locale, "zh")) {
+ return true
+ }
+ return false
+}
+
+// IsEastAsian return true if the current locale is CJK
+func IsEastAsian() bool {
+ locale := os.Getenv("LC_CTYPE")
+ if locale == "" {
+ locale = os.Getenv("LANG")
+ }
+
+ // ignore C locale
+ if locale == "POSIX" || locale == "C" {
+ return false
+ }
+ if len(locale) > 1 && locale[0] == 'C' && (locale[1] == '.' || locale[1] == '-') {
+ return false
+ }
+
+ return isEastAsian(locale)
+}
diff --git a/vendor/github.com/mattn/go-runewidth/runewidth_windows.go b/vendor/github.com/mattn/go-runewidth/runewidth_windows.go
new file mode 100644
index 00000000..0258876b
--- /dev/null
+++ b/vendor/github.com/mattn/go-runewidth/runewidth_windows.go
@@ -0,0 +1,25 @@
+package runewidth
+
+import (
+ "syscall"
+)
+
+var (
+ kernel32 = syscall.NewLazyDLL("kernel32")
+ procGetConsoleOutputCP = kernel32.NewProc("GetConsoleOutputCP")
+)
+
+// IsEastAsian return true if the current locale is CJK
+func IsEastAsian() bool {
+ r1, _, _ := procGetConsoleOutputCP.Call()
+ if r1 == 0 {
+ return false
+ }
+
+ switch int(r1) {
+ case 932, 51932, 936, 949, 950:
+ return true
+ }
+
+ return false
+}
diff --git a/vendor/github.com/olebedev/config/.gitignore b/vendor/github.com/olebedev/config/.gitignore
new file mode 100644
index 00000000..00268614
--- /dev/null
+++ b/vendor/github.com/olebedev/config/.gitignore
@@ -0,0 +1,22 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
diff --git a/vendor/github.com/olebedev/config/LICENSE b/vendor/github.com/olebedev/config/LICENSE
new file mode 100644
index 00000000..c09d13e5
--- /dev/null
+++ b/vendor/github.com/olebedev/config/LICENSE
@@ -0,0 +1,20 @@
+JSON or YAML configuration wrapper with convenient access methods
+Copyright (C) 2014 Oleg Lebedev
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
+OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/vendor/github.com/olebedev/config/README.md b/vendor/github.com/olebedev/config/README.md
new file mode 100644
index 00000000..7f554252
--- /dev/null
+++ b/vendor/github.com/olebedev/config/README.md
@@ -0,0 +1,19 @@
+# Config [](https://app.wercker.com/project/bykey/b4e8561d9a711afcb016bf0018e83897) [](https://godoc.org/github.com/olebedev/config)
+
+Package config provides convenient access methods to configuration
+stored as JSON or YAML.
+
+This is a fork of the [original version](https://github.com/moraes/config).
+This version extends the functionality of the original without losing compatibility.
+Major features added:
+
+- [`Set(path string, value interface{}) error`](http://godoc.org/github.com/olebedev/config#Config.Set) method
+- [`Env() *config.Config`](http://godoc.org/github.com/olebedev/config#Config.Env) method, for OS environment variables parsing
+- [`Flag() *config.Config`](http://godoc.org/github.com/olebedev/config#Config.Flag) method, for command line arguments parsing usign pkg/flag singleton
+- [`Args(args ...string) *config.Config`](http://godoc.org/github.com/olebedev/config#Config.Args) method, for command line arguments parsing
+- [`U*`](https://godoc.org/github.com/olebedev/config#Config.UBool) methods
+- [`Copy(...path) (*config.config, error)`](https://godoc.org/github.com/olebedev/config#Config.Copy) method
+- [`Extend(*config.Config) (*config.Config, error)`](https://godoc.org/github.com/olebedev/config#Config.Extend) method
+- [`Error() error`](https://godoc.org/github.com/olebedev/config#Config.Error) method to show last parsing error, works only with `.Args()` method
+
+Example and more information you can find [here](http://godoc.org/github.com/olebedev/config).
diff --git a/vendor/github.com/olebedev/config/config.go b/vendor/github.com/olebedev/config/config.go
new file mode 100644
index 00000000..b007f9db
--- /dev/null
+++ b/vendor/github.com/olebedev/config/config.go
@@ -0,0 +1,642 @@
+// Copyright 2012 The Gorilla Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package config
+
+import (
+ "bytes"
+ "encoding/json"
+ "flag"
+ "fmt"
+ "io/ioutil"
+ "strconv"
+ "strings"
+ "syscall"
+
+ yaml "gopkg.in/yaml.v2"
+)
+
+// Config ---------------------------------------------------------------------
+
+// Config represents a configuration with convenient access methods.
+type Config struct {
+ Root interface{}
+ lastErr error
+}
+
+// Error return last error
+func (c *Config) Error() error {
+ return c.lastErr
+}
+
+// Get returns a nested config according to a dotted path.
+func (cfg *Config) Get(path string) (*Config, error) {
+ n, err := Get(cfg.Root, path)
+ if err != nil {
+ return nil, err
+ }
+ return &Config{Root: n}, nil
+}
+
+// Set a nested config according to a dotted path.
+func (cfg *Config) Set(path string, val interface{}) error {
+ return Set(cfg.Root, path, val)
+}
+
+// Fetch data from system env, based on existing config keys.
+func (cfg *Config) Env() *Config {
+ return cfg.EnvPrefix("")
+}
+
+// Fetch data from system env using prefix, based on existing config keys.
+func (cfg *Config) EnvPrefix(prefix string) *Config {
+ if prefix != "" {
+ prefix = strings.ToUpper(prefix) + "_"
+ }
+
+ keys := getKeys(cfg.Root)
+ for _, key := range keys {
+ k := strings.ToUpper(strings.Join(key, "_"))
+ if val, exist := syscall.Getenv(prefix + k); exist {
+ cfg.Set(strings.Join(key, "."), val)
+ }
+ }
+ return cfg
+}
+
+// Parse command line arguments, based on existing config keys.
+func (cfg *Config) Flag() *Config {
+ keys := getKeys(cfg.Root)
+ hash := map[string]*string{}
+ for _, key := range keys {
+ k := strings.Join(key, "-")
+ hash[k] = new(string)
+ val, _ := cfg.String(k)
+ flag.StringVar(hash[k], k, val, "")
+ }
+
+ flag.Parse()
+
+ flag.Visit(func(f *flag.Flag) {
+ name := strings.Replace(f.Name, "-", ".", -1)
+ cfg.Set(name, f.Value.String())
+ })
+
+ return cfg
+}
+
+// Args command line arguments, based on existing config keys.
+func (cfg *Config) Args(args ...string) *Config {
+ if len(args) <= 1 {
+ return cfg
+ }
+
+ keys := getKeys(cfg.Root)
+ hash := map[string]*string{}
+ _flag := flag.NewFlagSet(args[0], flag.ContinueOnError)
+ var _err bytes.Buffer
+ _flag.SetOutput(&_err)
+ for _, key := range keys {
+ k := strings.Join(key, "-")
+ hash[k] = new(string)
+ val, _ := cfg.String(k)
+ _flag.StringVar(hash[k], k, val, "")
+ }
+
+ cfg.lastErr = _flag.Parse(args[1:])
+
+ _flag.Visit(func(f *flag.Flag) {
+ name := strings.Replace(f.Name, "-", ".", -1)
+ cfg.Set(name, f.Value.String())
+ })
+
+ return cfg
+}
+
+// Get all keys for given interface
+func getKeys(source interface{}, base ...string) [][]string {
+ acc := [][]string{}
+
+ // Copy "base" so that underlying slice array is not
+ // modified in recursive calls
+ nextBase := make([]string, len(base))
+ copy(nextBase, base)
+
+ switch c := source.(type) {
+ case map[string]interface{}:
+ for k, v := range c {
+ keys := getKeys(v, append(nextBase, k)...)
+ acc = append(acc, keys...)
+ }
+ case []interface{}:
+ for i, v := range c {
+ k := strconv.Itoa(i)
+ keys := getKeys(v, append(nextBase, k)...)
+ acc = append(acc, keys...)
+ }
+ default:
+ acc = append(acc, nextBase)
+ return acc
+ }
+ return acc
+}
+
+// Bool returns a bool according to a dotted path.
+func (cfg *Config) Bool(path string) (bool, error) {
+ n, err := Get(cfg.Root, path)
+ if err != nil {
+ return false, err
+ }
+ switch n := n.(type) {
+ case bool:
+ return n, nil
+ case string:
+ return strconv.ParseBool(n)
+ }
+ return false, typeMismatch("bool or string", n)
+}
+
+// UBool returns a bool according to a dotted path or default value or false.
+func (c *Config) UBool(path string, defaults ...bool) bool {
+ value, err := c.Bool(path)
+
+ if err == nil {
+ return value
+ }
+
+ for _, def := range defaults {
+ return def
+ }
+ return false
+}
+
+// Float64 returns a float64 according to a dotted path.
+func (cfg *Config) Float64(path string) (float64, error) {
+ n, err := Get(cfg.Root, path)
+ if err != nil {
+ return 0, err
+ }
+ switch n := n.(type) {
+ case float64:
+ return n, nil
+ case int:
+ return float64(n), nil
+ case string:
+ return strconv.ParseFloat(n, 64)
+ }
+ return 0, typeMismatch("float64, int or string", n)
+}
+
+// UFloat64 returns a float64 according to a dotted path or default value or 0.
+func (c *Config) UFloat64(path string, defaults ...float64) float64 {
+ value, err := c.Float64(path)
+
+ if err == nil {
+ return value
+ }
+
+ for _, def := range defaults {
+ return def
+ }
+ return float64(0)
+}
+
+// Int returns an int according to a dotted path.
+func (cfg *Config) Int(path string) (int, error) {
+ n, err := Get(cfg.Root, path)
+ if err != nil {
+ return 0, err
+ }
+ switch n := n.(type) {
+ case float64:
+ // encoding/json unmarshals numbers into floats, so we compare
+ // the string representation to see if we can return an int.
+ if i := int(n); fmt.Sprint(i) == fmt.Sprint(n) {
+ return i, nil
+ } else {
+ return 0, fmt.Errorf("Value can't be converted to int: %v", n)
+ }
+ case int:
+ return n, nil
+ case string:
+ if v, err := strconv.ParseInt(n, 10, 0); err == nil {
+ return int(v), nil
+ } else {
+ return 0, err
+ }
+ }
+ return 0, typeMismatch("float64, int or string", n)
+}
+
+// UInt returns an int according to a dotted path or default value or 0.
+func (c *Config) UInt(path string, defaults ...int) int {
+ value, err := c.Int(path)
+
+ if err == nil {
+ return value
+ }
+
+ for _, def := range defaults {
+ return def
+ }
+ return 0
+}
+
+// List returns a []interface{} according to a dotted path.
+func (cfg *Config) List(path string) ([]interface{}, error) {
+ n, err := Get(cfg.Root, path)
+ if err != nil {
+ return nil, err
+ }
+ if value, ok := n.([]interface{}); ok {
+ return value, nil
+ }
+ return nil, typeMismatch("[]interface{}", n)
+}
+
+// UList returns a []interface{} according to a dotted path or defaults or []interface{}.
+func (c *Config) UList(path string, defaults ...[]interface{}) []interface{} {
+ value, err := c.List(path)
+
+ if err == nil {
+ return value
+ }
+
+ for _, def := range defaults {
+ return def
+ }
+ return make([]interface{}, 0)
+}
+
+// Map returns a map[string]interface{} according to a dotted path.
+func (cfg *Config) Map(path string) (map[string]interface{}, error) {
+ n, err := Get(cfg.Root, path)
+ if err != nil {
+ return nil, err
+ }
+ if value, ok := n.(map[string]interface{}); ok {
+ return value, nil
+ }
+ return nil, typeMismatch("map[string]interface{}", n)
+}
+
+// UMap returns a map[string]interface{} according to a dotted path or default or map[string]interface{}.
+func (c *Config) UMap(path string, defaults ...map[string]interface{}) map[string]interface{} {
+ value, err := c.Map(path)
+
+ if err == nil {
+ return value
+ }
+
+ for _, def := range defaults {
+ return def
+ }
+ return map[string]interface{}{}
+}
+
+// String returns a string according to a dotted path.
+func (cfg *Config) String(path string) (string, error) {
+ n, err := Get(cfg.Root, path)
+ if err != nil {
+ return "", err
+ }
+ switch n := n.(type) {
+ case bool, float64, int:
+ return fmt.Sprint(n), nil
+ case string:
+ return n, nil
+ }
+ return "", typeMismatch("bool, float64, int or string", n)
+}
+
+// UString returns a string according to a dotted path or default or "".
+func (c *Config) UString(path string, defaults ...string) string {
+ value, err := c.String(path)
+
+ if err == nil {
+ return value
+ }
+
+ for _, def := range defaults {
+ return def
+ }
+ return ""
+}
+
+// Copy returns a deep copy with given path or without.
+func (c *Config) Copy(dottedPath ...string) (*Config, error) {
+ toJoin := []string{}
+ for _, part := range dottedPath {
+ if len(part) != 0 {
+ toJoin = append(toJoin, part)
+ }
+ }
+
+ var err error
+ var path = strings.Join(toJoin, ".")
+ var cfg = c
+ var root = ""
+
+ if len(path) > 0 {
+ if cfg, err = c.Get(path); err != nil {
+ return nil, err
+ }
+ }
+
+ if root, err = RenderYaml(cfg.Root); err != nil {
+ return nil, err
+ }
+ return ParseYaml(root)
+}
+
+// Extend returns extended copy of current config with applied
+// values from the given config instance. Note that if you extend
+// with different structure you will get an error. See: `.Set()` method
+// for details.
+func (c *Config) Extend(cfg *Config) (*Config, error) {
+ n, err := c.Copy()
+ if err != nil {
+ return nil, err
+ }
+
+ keys := getKeys(cfg.Root)
+ for _, key := range keys {
+ k := strings.Join(key, ".")
+ i, err := Get(cfg.Root, k)
+ if err != nil {
+ return nil, err
+ }
+ if err := n.Set(k, i); err != nil {
+ return nil, err
+ }
+ }
+ return n, nil
+}
+
+// typeMismatch returns an error for an expected type.
+func typeMismatch(expected string, got interface{}) error {
+ return fmt.Errorf("Type mismatch: expected %s; got %T", expected, got)
+}
+
+// Fetching -------------------------------------------------------------------
+
+// Get returns a child of the given value according to a dotted path.
+func Get(cfg interface{}, path string) (interface{}, error) {
+ parts := strings.Split(path, ".")
+ // Normalize path.
+ for k, v := range parts {
+ if v == "" {
+ if k == 0 {
+ parts = parts[1:]
+ } else {
+ return nil, fmt.Errorf("Invalid path %q", path)
+ }
+ }
+ }
+ // Get the value.
+ for pos, part := range parts {
+ switch c := cfg.(type) {
+ case []interface{}:
+ if i, error := strconv.ParseInt(part, 10, 0); error == nil {
+ if int(i) < len(c) {
+ cfg = c[i]
+ } else {
+ return nil, fmt.Errorf(
+ "Index out of range at %q: list has only %v items",
+ strings.Join(parts[:pos+1], "."), len(c))
+ }
+ } else {
+ return nil, fmt.Errorf("Invalid list index at %q",
+ strings.Join(parts[:pos+1], "."))
+ }
+ case map[string]interface{}:
+ if value, ok := c[part]; ok {
+ cfg = value
+ } else {
+ return nil, fmt.Errorf("Nonexistent map key at %q",
+ strings.Join(parts[:pos+1], "."))
+ }
+ default:
+ return nil, fmt.Errorf(
+ "Invalid type at %q: expected []interface{} or map[string]interface{}; got %T",
+ strings.Join(parts[:pos+1], "."), cfg)
+ }
+ }
+
+ return cfg, nil
+}
+
+// Set returns an error, in case when it is not possible to
+// establish the value obtained in accordance with given dotted path.
+func Set(cfg interface{}, path string, value interface{}) error {
+ parts := strings.Split(path, ".")
+ // Normalize path.
+ for k, v := range parts {
+ if v == "" {
+ if k == 0 {
+ parts = parts[1:]
+ } else {
+ return fmt.Errorf("Invalid path %q", path)
+ }
+ }
+ }
+
+ point := &cfg
+ for pos, part := range parts {
+ switch c := (*point).(type) {
+ case []interface{}:
+ if i, error := strconv.ParseInt(part, 10, 0); error == nil {
+ // 1. normalize slice capacity
+ if int(i) >= cap(c) {
+ c = append(c, make([]interface{}, int(i)-cap(c)+1, int(i)-cap(c)+1)...)
+ }
+
+ // 2. set value or go further
+ if pos+1 == len(parts) {
+ c[i] = value
+ } else {
+
+ // if exists just pick the pointer
+ if va := c[i]; va != nil {
+ point = &va
+ } else {
+ // is next part slice or map?
+ if i, err := strconv.ParseInt(parts[pos+1], 10, 0); err == nil {
+ va = make([]interface{}, int(i)+1, int(i)+1)
+ } else {
+ va = make(map[string]interface{})
+ }
+ c[i] = va
+ point = &va
+ }
+
+ }
+
+ } else {
+ return fmt.Errorf("Invalid list index at %q",
+ strings.Join(parts[:pos+1], "."))
+ }
+ case map[string]interface{}:
+ if pos+1 == len(parts) {
+ c[part] = value
+ } else {
+ // if exists just pick the pointer
+ if va, ok := c[part]; ok {
+ point = &va
+ } else {
+ // is next part slice or map?
+ if i, err := strconv.ParseInt(parts[pos+1], 10, 0); err == nil {
+ va = make([]interface{}, int(i)+1, int(i)+1)
+ } else {
+ va = make(map[string]interface{})
+ }
+ c[part] = va
+ point = &va
+ }
+ }
+ default:
+ return fmt.Errorf(
+ "Invalid type at %q: expected []interface{} or map[string]interface{}; got %T",
+ strings.Join(parts[:pos+1], "."), cfg)
+ }
+ }
+
+ return nil
+}
+
+// Parsing --------------------------------------------------------------------
+
+// Must is a wrapper for parsing functions to be used during initialization.
+// It panics on failure.
+func Must(cfg *Config, err error) *Config {
+ if err != nil {
+ panic(err)
+ }
+ return cfg
+}
+
+// normalizeValue normalizes a unmarshalled value. This is needed because
+// encoding/json doesn't support marshalling map[interface{}]interface{}.
+func normalizeValue(value interface{}) (interface{}, error) {
+ switch value := value.(type) {
+ case map[interface{}]interface{}:
+ node := make(map[string]interface{}, len(value))
+ for k, v := range value {
+ key, ok := k.(string)
+ if !ok {
+ return nil, fmt.Errorf("Unsupported map key: %#v", k)
+ }
+ item, err := normalizeValue(v)
+ if err != nil {
+ return nil, fmt.Errorf("Unsupported map value: %#v", v)
+ }
+ node[key] = item
+ }
+ return node, nil
+ case map[string]interface{}:
+ node := make(map[string]interface{}, len(value))
+ for key, v := range value {
+ item, err := normalizeValue(v)
+ if err != nil {
+ return nil, fmt.Errorf("Unsupported map value: %#v", v)
+ }
+ node[key] = item
+ }
+ return node, nil
+ case []interface{}:
+ node := make([]interface{}, len(value))
+ for key, v := range value {
+ item, err := normalizeValue(v)
+ if err != nil {
+ return nil, fmt.Errorf("Unsupported list item: %#v", v)
+ }
+ node[key] = item
+ }
+ return node, nil
+ case bool, float64, int, string, nil:
+ return value, nil
+ }
+ return nil, fmt.Errorf("Unsupported type: %T", value)
+}
+
+// JSON -----------------------------------------------------------------------
+
+// ParseJson reads a JSON configuration from the given string.
+func ParseJson(cfg string) (*Config, error) {
+ return parseJson([]byte(cfg))
+}
+
+// ParseJsonFile reads a JSON configuration from the given filename.
+func ParseJsonFile(filename string) (*Config, error) {
+ cfg, err := ioutil.ReadFile(filename)
+ if err != nil {
+ return nil, err
+ }
+ return parseJson(cfg)
+}
+
+// parseJson performs the real JSON parsing.
+func parseJson(cfg []byte) (*Config, error) {
+ var out interface{}
+ var err error
+ if err = json.Unmarshal(cfg, &out); err != nil {
+ return nil, err
+ }
+ if out, err = normalizeValue(out); err != nil {
+ return nil, err
+ }
+ return &Config{Root: out}, nil
+}
+
+// RenderJson renders a JSON configuration.
+func RenderJson(cfg interface{}) (string, error) {
+ b, err := json.Marshal(cfg)
+ if err != nil {
+ return "", err
+ }
+ return string(b), nil
+}
+
+// YAML -----------------------------------------------------------------------
+
+// ParseYamlBytes reads a YAML configuration from the given []byte.
+func ParseYamlBytes(cfg []byte) (*Config, error) {
+ return parseYaml(cfg)
+}
+
+// ParseYaml reads a YAML configuration from the given string.
+func ParseYaml(cfg string) (*Config, error) {
+ return parseYaml([]byte(cfg))
+}
+
+// ParseYamlFile reads a YAML configuration from the given filename.
+func ParseYamlFile(filename string) (*Config, error) {
+ cfg, err := ioutil.ReadFile(filename)
+ if err != nil {
+ return nil, err
+ }
+ return parseYaml(cfg)
+}
+
+// parseYaml performs the real YAML parsing.
+func parseYaml(cfg []byte) (*Config, error) {
+ var out interface{}
+ var err error
+ if err = yaml.Unmarshal(cfg, &out); err != nil {
+ return nil, err
+ }
+ if out, err = normalizeValue(out); err != nil {
+ return nil, err
+ }
+ return &Config{Root: out}, nil
+}
+
+// RenderYaml renders a YAML configuration.
+func RenderYaml(cfg interface{}) (string, error) {
+ b, err := yaml.Marshal(cfg)
+ if err != nil {
+ return "", err
+ }
+ return string(b), nil
+}
diff --git a/vendor/github.com/olebedev/config/doc.go b/vendor/github.com/olebedev/config/doc.go
new file mode 100644
index 00000000..a71e76c8
--- /dev/null
+++ b/vendor/github.com/olebedev/config/doc.go
@@ -0,0 +1,141 @@
+// Copyright 2012 The Gorilla Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/*
+Package config provides convenient access methods to configuration stored as
+JSON or YAML.
+
+Let's start with a simple YAML example:
+
+ development:
+ database:
+ host: localhost
+ users:
+ - name: calvin
+ password: yukon
+ - name: hobbes
+ password: tuna
+ production:
+ database:
+ host: 192.168.1.1
+
+We can parse it using ParseYaml(), which will return a *Config instance on
+success:
+
+ cfg, err := config.ParseYaml(yamlString)
+
+An equivalent JSON configuration could be built using ParseJson():
+
+ cfg, err := config.ParseJson(jsonString)
+
+From now, we can retrieve configuration values using a path in dotted notation:
+
+ // "localhost"
+ host, err := cfg.String("development.database.host")
+
+ // or...
+
+ // "192.168.1.1"
+ host, err := cfg.String("production.database.host")
+
+Besides String(), other types can be fetched directly: Bool(), Float64(),
+Int(), Map() and List(). All these methods will return an error if the path
+doesn't exist, or the value doesn't match or can't be converted to the
+requested type.
+
+A nested configuration can be fetched using Get(). Here we get a new *Config
+instance with a subset of the configuration:
+
+ cfg, err := cfg.Get("development")
+
+Then the inner values are fetched relatively to the subset:
+
+ // "localhost"
+ host, err := cfg.String("database.host")
+
+For lists, the dotted path must use an index to refer to a specific value.
+To retrieve the information from a user stored in the configuration above:
+
+ // map[string]interface{}{ ... }
+ user1, err := cfg.Map("development.users.0")
+ // map[string]interface{}{ ... }
+ user2, err := cfg.Map("development.users.1")
+
+ // or...
+
+ // "calvin"
+ name1, err := cfg.String("development.users.0.name")
+ // "hobbes"
+ name2, err := cfg.String("development.users.1.name")
+
+JSON or YAML strings can be created calling the appropriate Render*()
+functions. Here's how we render a configuration like the one used in these
+examples:
+
+ cfg := map[string]interface{}{
+ "development": map[string]interface{}{
+ "database": map[string]interface{}{
+ "host": "localhost",
+ },
+ "users": []interface{}{
+ map[string]interface{}{
+ "name": "calvin",
+ "password": "yukon",
+ },
+ map[string]interface{}{
+ "name": "hobbes",
+ "password": "tuna",
+ },
+ },
+ },
+ "production": map[string]interface{}{
+ "database": map[string]interface{}{
+ "host": "192.168.1.1",
+ },
+ },
+ }
+
+ json, err := config.RenderJson(cfg)
+
+ // or...
+
+ yaml, err := config.RenderYaml(cfg)
+
+This results in a configuration string to be stored in a file or database.
+
+For more more convenience it can parse OS environment variables and command line arguments.
+
+ cfg, err := config.ParseYaml(yamlString)
+ cfg.Env()
+
+ // or
+
+ cfg.Flag()
+
+We can also specify the order of parsing:
+
+ cfg.Env().Flag()
+
+ // or
+
+ cfg.Flag().Env()
+
+In case of OS environment all existing at the moment of parsing keys will be scanned in OS environment,
+but in uppercase and the separator will be `_` instead of a `.`. If EnvPrefix() is used the given prefix
+will be used to lookup the environment variable, e.g PREFIX_FOO_BAR will set foo.bar.
+In case of flags separator will be `-`.
+In case of command line arguments possible to use regular dot notation syntax for all keys.
+For see existing keys we can run application with `-h`.
+
+We can use unsafe method to get value:
+
+ // ""
+ cfg.UString("undefined.key")
+
+ // or with default value
+ unsafeValue := cfg.UString("undefined.key", "default value")
+
+There is unsafe methods, like regular, but wuth prefix `U`.
+*/
+package config
diff --git a/vendor/github.com/olebedev/config/wercker.yml b/vendor/github.com/olebedev/config/wercker.yml
new file mode 100644
index 00000000..4a47bb17
--- /dev/null
+++ b/vendor/github.com/olebedev/config/wercker.yml
@@ -0,0 +1 @@
+box: wercker/golang@1.1.1
diff --git a/vendor/github.com/radovskyb/watcher/.travis.yml b/vendor/github.com/radovskyb/watcher/.travis.yml
new file mode 100644
index 00000000..3f478f10
--- /dev/null
+++ b/vendor/github.com/radovskyb/watcher/.travis.yml
@@ -0,0 +1,4 @@
+language: go
+go:
+ - 1.7
+ - tip
\ No newline at end of file
diff --git a/vendor/github.com/radovskyb/watcher/LICENSE b/vendor/github.com/radovskyb/watcher/LICENSE
new file mode 100644
index 00000000..92ef0e91
--- /dev/null
+++ b/vendor/github.com/radovskyb/watcher/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2016, Benjamin Radovsky.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+3. Neither the name of watcher nor the names of its contributors may be used to
+ endorse or promote products derived from this software without specific prior
+ written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/github.com/radovskyb/watcher/README.md b/vendor/github.com/radovskyb/watcher/README.md
new file mode 100644
index 00000000..c0ef08bc
--- /dev/null
+++ b/vendor/github.com/radovskyb/watcher/README.md
@@ -0,0 +1,172 @@
+# watcher
+
+[](https://travis-ci.org/radovskyb/watcher)
+
+`watcher` is a Go package for watching for files or directory changes (recursively or non recursively) without using filesystem events, which allows it to work cross platform consistently.
+
+`watcher` watches for changes and notifies over channels either anytime an event or an error has occurred.
+
+Events contain the `os.FileInfo` of the file or directory that the event is based on and the type of event and file or directory path.
+
+[Installation](#installation)
+[Features](#features)
+[Example](#example)
+[Contributing](#contributing)
+[Watcher Command](#command)
+
+# Update
+Event.Path for Rename and Move events is now returned in the format of `fromPath -> toPath`
+
+#### Chmod event is not supported under windows.
+
+# Installation
+
+```shell
+go get -u github.com/radovskyb/watcher/...
+```
+
+# Features
+
+- Customizable polling interval.
+- Filter Events.
+- Watch folders recursively or non-recursively.
+- Choose to ignore hidden files.
+- Choose to ignore specified files and folders.
+- Notifies the `os.FileInfo` of the file that the event is based on. e.g `Name`, `ModTime`, `IsDir`, etc.
+- Notifies the full path of the file that the event is based on or the old and new paths if the event was a `Rename` or `Move` event.
+- Limit amount of events that can be received per watching cycle.
+- List the files being watched.
+- Trigger custom events.
+
+# Todo
+
+- Write more tests.
+- Write benchmarks.
+
+# Example
+
+```go
+package main
+
+import (
+ "fmt"
+ "log"
+ "time"
+
+ "github.com/radovskyb/watcher"
+)
+
+func main() {
+ w := watcher.New()
+
+ // SetMaxEvents to 1 to allow at most 1 event's to be received
+ // on the Event channel per watching cycle.
+ //
+ // If SetMaxEvents is not set, the default is to send all events.
+ w.SetMaxEvents(1)
+
+ // Only notify rename and move events.
+ w.FilterOps(watcher.Rename, watcher.Move)
+
+ go func() {
+ for {
+ select {
+ case event := <-w.Event:
+ fmt.Println(event) // Print the event's info.
+ case err := <-w.Error:
+ log.Fatalln(err)
+ case <-w.Closed:
+ return
+ }
+ }
+ }()
+
+ // Watch this folder for changes.
+ if err := w.Add("."); err != nil {
+ log.Fatalln(err)
+ }
+
+ // Watch test_folder recursively for changes.
+ if err := w.AddRecursive("../test_folder"); err != nil {
+ log.Fatalln(err)
+ }
+
+ // Print a list of all of the files and folders currently
+ // being watched and their paths.
+ for path, f := range w.WatchedFiles() {
+ fmt.Printf("%s: %s\n", path, f.Name())
+ }
+
+ fmt.Println()
+
+ // Trigger 2 events after watcher started.
+ go func() {
+ w.Wait()
+ w.TriggerEvent(watcher.Create, nil)
+ w.TriggerEvent(watcher.Remove, nil)
+ }()
+
+ // Start the watching process - it'll check for changes every 100ms.
+ if err := w.Start(time.Millisecond * 100); err != nil {
+ log.Fatalln(err)
+ }
+}
+```
+
+# Contributing
+If you would ike to contribute, simply submit a pull request.
+
+# Command
+
+`watcher` comes with a simple command which is installed when using the `go get` command from above.
+
+# Usage
+
+```
+Usage of watcher:
+ -cmd string
+ command to run when an event occurs
+ -dotfiles
+ watch dot files (default true)
+ -interval string
+ watcher poll interval (default "100ms")
+ -keepalive
+ keep alive when a cmd returns code != 0
+ -list
+ list watched files on start
+ -pipe
+ pipe event's info to command's stdin
+ -recursive
+ watch folders recursively (default true)
+ -startcmd
+ run the command when watcher starts
+```
+
+All of the flags are optional and watcher can also be called by itself:
+```shell
+watcher
+```
+(watches the current directory recursively for changes and notifies any events that occur.)
+
+A more elaborate example using the `watcher` command:
+```shell
+watcher -dotfiles=false -recursive=false -cmd="./myscript" main.go ../
+```
+In this example, `watcher` will ignore dot files and folders and won't watch any of the specified folders recursively. It will also run the script `./myscript` anytime an event occurs while watching `main.go` or any files or folders in the previous directory (`../`).
+
+Using the `pipe` and `cmd` flags together will send the event's info to the command's stdin when changes are detected.
+
+First create a file called `script.py` with the following contents:
+```python
+import sys
+
+for line in sys.stdin:
+ print (line + " - python")
+```
+
+Next, start watcher with the `pipe` and `cmd` flags enabled:
+```shell
+watcher -cmd="python script.py" -pipe=true
+```
+
+Now when changes are detected, the event's info will be output from the running python script.
diff --git a/vendor/github.com/radovskyb/watcher/samefile.go b/vendor/github.com/radovskyb/watcher/samefile.go
new file mode 100644
index 00000000..8c9cb325
--- /dev/null
+++ b/vendor/github.com/radovskyb/watcher/samefile.go
@@ -0,0 +1,9 @@
+// +build !windows
+
+package watcher
+
+import "os"
+
+func SameFile(fi1, fi2 os.FileInfo) bool {
+ return os.SameFile(fi1, fi2)
+}
diff --git a/vendor/github.com/radovskyb/watcher/samefile_windows.go b/vendor/github.com/radovskyb/watcher/samefile_windows.go
new file mode 100644
index 00000000..1ea95120
--- /dev/null
+++ b/vendor/github.com/radovskyb/watcher/samefile_windows.go
@@ -0,0 +1,12 @@
+// +build windows
+
+package watcher
+
+import "os"
+
+func SameFile(fi1, fi2 os.FileInfo) bool {
+ return fi1.ModTime() == fi2.ModTime() &&
+ fi1.Size() == fi2.Size() &&
+ fi1.Mode() == fi2.Mode() &&
+ fi1.IsDir() == fi2.IsDir()
+}
diff --git a/vendor/github.com/radovskyb/watcher/watcher.go b/vendor/github.com/radovskyb/watcher/watcher.go
new file mode 100644
index 00000000..e486ea0a
--- /dev/null
+++ b/vendor/github.com/radovskyb/watcher/watcher.go
@@ -0,0 +1,621 @@
+package watcher
+
+import (
+ "errors"
+ "fmt"
+ "io/ioutil"
+ "os"
+ "path/filepath"
+ "strings"
+ "sync"
+ "time"
+)
+
+var (
+ // ErrDurationTooShort occurs when calling the watcher's Start
+ // method with a duration that's less than 1 nanosecond.
+ ErrDurationTooShort = errors.New("error: duration is less than 1ns")
+
+ // ErrWatcherRunning occurs when trying to call the watcher's
+ // Start method and the polling cycle is still already running
+ // from previously calling Start and not yet calling Close.
+ ErrWatcherRunning = errors.New("error: watcher is already running")
+
+ // ErrWatchedFileDeleted is an error that occurs when a file or folder that was
+ // being watched has been deleted.
+ ErrWatchedFileDeleted = errors.New("error: watched file or folder deleted")
+)
+
+// An Op is a type that is used to describe what type
+// of event has occurred during the watching process.
+type Op uint32
+
+// Ops
+const (
+ Create Op = iota
+ Write
+ Remove
+ Rename
+ Chmod
+ Move
+)
+
+var ops = map[Op]string{
+ Create: "CREATE",
+ Write: "WRITE",
+ Remove: "REMOVE",
+ Rename: "RENAME",
+ Chmod: "CHMOD",
+ Move: "MOVE",
+}
+
+// String prints the string version of the Op consts
+func (e Op) String() string {
+ if op, found := ops[e]; found {
+ return op
+ }
+ return "???"
+}
+
+// An Event describes an event that is received when files or directory
+// changes occur. It includes the os.FileInfo of the changed file or
+// directory and the type of event that's occurred and the full path of the file.
+type Event struct {
+ Op
+ Path string
+ os.FileInfo
+}
+
+// String returns a string depending on what type of event occurred and the
+// file name associated with the event.
+func (e Event) String() string {
+ if e.FileInfo != nil {
+ pathType := "FILE"
+ if e.IsDir() {
+ pathType = "DIRECTORY"
+ }
+ return fmt.Sprintf("%s %q %s [%s]", pathType, e.Name(), e.Op, e.Path)
+ }
+ return "???"
+}
+
+type Watcher struct {
+ Event chan Event
+ Error chan error
+ Closed chan struct{}
+ close chan struct{}
+ wg *sync.WaitGroup
+
+ // mu protects the following.
+ mu *sync.Mutex
+ running bool
+ names map[string]bool // bool for recursive or not.
+ files map[string]os.FileInfo // map of files.
+ ignored map[string]struct{} // ignored files or directories.
+ ops map[Op]struct{} // Op filtering.
+ ignoreHidden bool // ignore hidden files or not.
+ maxEvents int // max sent events per cycle
+}
+
+// New creates a new Watcher.
+func New() *Watcher {
+ // Set up the WaitGroup for w.Wait().
+ var wg sync.WaitGroup
+ wg.Add(1)
+
+ return &Watcher{
+ Event: make(chan Event),
+ Error: make(chan error),
+ Closed: make(chan struct{}),
+ close: make(chan struct{}),
+ mu: new(sync.Mutex),
+ wg: &wg,
+ files: make(map[string]os.FileInfo),
+ ignored: make(map[string]struct{}),
+ names: make(map[string]bool),
+ }
+}
+
+// SetMaxEvents controls the maximum amount of events that are sent on
+// the Event channel per watching cycle. If max events is less than 1, there is
+// no limit, which is the default.
+func (w *Watcher) SetMaxEvents(delta int) {
+ w.mu.Lock()
+ w.maxEvents = delta
+ w.mu.Unlock()
+}
+
+// IgnoreHiddenFiles sets the watcher to ignore any file or directory
+// that starts with a dot.
+func (w *Watcher) IgnoreHiddenFiles(ignore bool) {
+ w.mu.Lock()
+ w.ignoreHidden = ignore
+ w.mu.Unlock()
+}
+
+// FilterOps filters which event op types should be returned
+// when an event occurs.
+func (w *Watcher) FilterOps(ops ...Op) {
+ w.mu.Lock()
+ w.ops = make(map[Op]struct{})
+ for _, op := range ops {
+ w.ops[op] = struct{}{}
+ }
+ w.mu.Unlock()
+}
+
+// Add adds either a single file or directory to the file list.
+func (w *Watcher) Add(name string) (err error) {
+ w.mu.Lock()
+ defer w.mu.Unlock()
+
+ name, err = filepath.Abs(name)
+ if err != nil {
+ return err
+ }
+
+ // If name is on the ignored list or if hidden files are
+ // ignored and name is a hidden file or directory, simply return.
+ _, ignored := w.ignored[name]
+ if ignored || (w.ignoreHidden && strings.HasPrefix(name, ".")) {
+ return nil
+ }
+
+ // Add the directory's contents to the files list.
+ fileList, err := w.list(name)
+ if err != nil {
+ return err
+ }
+ for k, v := range fileList {
+ w.files[k] = v
+ }
+
+ // Add the name to the names list.
+ w.names[name] = false
+
+ return nil
+}
+
+func (w *Watcher) list(name string) (map[string]os.FileInfo, error) {
+ fileList := make(map[string]os.FileInfo)
+
+ // Make sure name exists.
+ stat, err := os.Stat(name)
+ if err != nil {
+ return nil, err
+ }
+
+ fileList[name] = stat
+
+ // If it's not a directory, just return.
+ if !stat.IsDir() {
+ return fileList, nil
+ }
+
+ // It's a directory.
+ fInfoList, err := ioutil.ReadDir(name)
+ if err != nil {
+ return nil, err
+ }
+ // Add all of the files in the directory to the file list as long
+ // as they aren't on the ignored list or are hidden files if ignoreHidden
+ // is set to true.
+ for _, fInfo := range fInfoList {
+ path := filepath.Join(name, fInfo.Name())
+ _, ignored := w.ignored[path]
+ if ignored || (w.ignoreHidden && strings.HasPrefix(fInfo.Name(), ".")) {
+ continue
+ }
+ fileList[path] = fInfo
+ }
+ return fileList, nil
+}
+
+// Add adds either a single file or directory recursively to the file list.
+func (w *Watcher) AddRecursive(name string) (err error) {
+ w.mu.Lock()
+ defer w.mu.Unlock()
+
+ name, err = filepath.Abs(name)
+ if err != nil {
+ return err
+ }
+
+ fileList, err := w.listRecursive(name)
+ if err != nil {
+ return err
+ }
+ for k, v := range fileList {
+ w.files[k] = v
+ }
+
+ // Add the name to the names list.
+ w.names[name] = true
+
+ return nil
+}
+
+func (w *Watcher) listRecursive(name string) (map[string]os.FileInfo, error) {
+ fileList := make(map[string]os.FileInfo)
+
+ return fileList, filepath.Walk(name, func(path string, info os.FileInfo, err error) error {
+ if err != nil {
+ return err
+ }
+ // If path is ignored and it's a directory, skip the directory. If it's
+ // ignored and it's a single file, skip the file.
+ _, ignored := w.ignored[path]
+ if ignored || (w.ignoreHidden && strings.HasPrefix(info.Name(), ".")) {
+ if info.IsDir() {
+ return filepath.SkipDir
+ }
+ return nil
+ }
+ // Add the path and it's info to the file list.
+ fileList[path] = info
+ return nil
+ })
+}
+
+// Remove removes either a single file or directory from the file's list.
+func (w *Watcher) Remove(name string) (err error) {
+ w.mu.Lock()
+ defer w.mu.Unlock()
+
+ name, err = filepath.Abs(name)
+ if err != nil {
+ return err
+ }
+
+ // Remove the name from w's names list.
+ delete(w.names, name)
+
+ // If name is a single file, remove it and return.
+ info, found := w.files[name]
+ if !found {
+ return nil // Doesn't exist, just return.
+ }
+ if !info.IsDir() {
+ delete(w.files, name)
+ return nil
+ }
+
+ // Delete the actual directory from w.files
+ delete(w.files, name)
+
+ // If it's a directory, delete all of it's contents from w.files.
+ for path := range w.files {
+ if filepath.Dir(path) == name {
+ delete(w.files, path)
+ }
+ }
+ return nil
+}
+
+// Remove removes either a single file or a directory recursively from
+// the file's list.
+func (w *Watcher) RemoveRecursive(name string) (err error) {
+ w.mu.Lock()
+ defer w.mu.Unlock()
+
+ name, err = filepath.Abs(name)
+ if err != nil {
+ return err
+ }
+
+ // Remove the name from w's names list.
+ delete(w.names, name)
+
+ // If name is a single file, remove it and return.
+ info, found := w.files[name]
+ if !found {
+ return nil // Doesn't exist, just return.
+ }
+ if !info.IsDir() {
+ delete(w.files, name)
+ return nil
+ }
+
+ // If it's a directory, delete all of it's contents recursively
+ // from w.files.
+ for path := range w.files {
+ if strings.HasPrefix(path, name) {
+ delete(w.files, path)
+ }
+ }
+ return nil
+}
+
+// Ignore adds paths that should be ignored.
+//
+// For files that are already added, Ignore removes them.
+func (w *Watcher) Ignore(paths ...string) (err error) {
+ for _, path := range paths {
+ path, err = filepath.Abs(path)
+ if err != nil {
+ return err
+ }
+ // Remove any of the paths that were already added.
+ if err := w.RemoveRecursive(path); err != nil {
+ return err
+ }
+ w.mu.Lock()
+ w.ignored[path] = struct{}{}
+ w.mu.Unlock()
+ }
+ return nil
+}
+
+func (w *Watcher) WatchedFiles() map[string]os.FileInfo {
+ w.mu.Lock()
+ defer w.mu.Unlock()
+
+ return w.files
+}
+
+// fileInfo is an implementation of os.FileInfo that can be used
+// as a mocked os.FileInfo when triggering an event when the specified
+// os.FileInfo is nil.
+type fileInfo struct {
+ name string
+ size int64
+ mode os.FileMode
+ modTime time.Time
+ sys interface{}
+ dir bool
+}
+
+func (fs *fileInfo) IsDir() bool {
+ return fs.dir
+}
+func (fs *fileInfo) ModTime() time.Time {
+ return fs.modTime
+}
+func (fs *fileInfo) Mode() os.FileMode {
+ return fs.mode
+}
+func (fs *fileInfo) Name() string {
+ return fs.name
+}
+func (fs *fileInfo) Size() int64 {
+ return fs.size
+}
+func (fs *fileInfo) Sys() interface{} {
+ return fs.sys
+}
+
+// TriggerEvent is a method that can be used to trigger an event, separate to
+// the file watching process.
+func (w *Watcher) TriggerEvent(eventType Op, file os.FileInfo) {
+ w.Wait()
+ if file == nil {
+ file = &fileInfo{name: "triggered event", modTime: time.Now()}
+ }
+ w.Event <- Event{Op: eventType, Path: "-", FileInfo: file}
+}
+
+func (w *Watcher) retrieveFileList() map[string]os.FileInfo {
+ w.mu.Lock()
+ defer w.mu.Unlock()
+
+ fileList := make(map[string]os.FileInfo)
+
+ var list map[string]os.FileInfo
+ var err error
+
+ for name, recursive := range w.names {
+ if recursive {
+ list, err = w.listRecursive(name)
+ if err != nil {
+ if os.IsNotExist(err) {
+ w.Error <- ErrWatchedFileDeleted
+ w.mu.Unlock()
+ w.RemoveRecursive(name)
+ w.mu.Lock()
+ } else {
+ w.Error <- err
+ }
+ }
+ } else {
+ list, err = w.list(name)
+ if err != nil {
+ if os.IsNotExist(err) {
+ w.Error <- ErrWatchedFileDeleted
+ w.mu.Unlock()
+ w.Remove(name)
+ w.mu.Lock()
+ } else {
+ w.Error <- err
+ }
+ }
+ }
+ // Add the file's to the file list.
+ for k, v := range list {
+ fileList[k] = v
+ }
+ }
+
+ return fileList
+}
+
+// Start begins the polling cycle which repeats every specified
+// duration until Close is called.
+func (w *Watcher) Start(d time.Duration) error {
+ // Return an error if d is less than 1 nanosecond.
+ if d < time.Nanosecond {
+ return ErrDurationTooShort
+ }
+
+ // Make sure the Watcher is not already running.
+ w.mu.Lock()
+ if w.running {
+ w.mu.Unlock()
+ return ErrWatcherRunning
+ }
+ w.running = true
+ w.mu.Unlock()
+
+ // Unblock w.Wait().
+ w.wg.Done()
+
+ for {
+ // done lets the inner polling cycle loop know when the
+ // current cycle's method has finished executing.
+ done := make(chan struct{})
+
+ // Any events that are found are first piped to evt before
+ // being sent to the main Event channel.
+ evt := make(chan Event)
+
+ // Retrieve the file list for all watched file's and dirs.
+ fileList := w.retrieveFileList()
+
+ // cancel can be used to cancel the current event polling function.
+ cancel := make(chan struct{})
+
+ // Look for events.
+ go func() {
+ w.pollEvents(fileList, evt, cancel)
+ done <- struct{}{}
+ }()
+
+ // numEvents holds the number of events for the current cycle.
+ numEvents := 0
+
+ inner:
+ for {
+ select {
+ case <-w.close:
+ close(cancel)
+ close(w.Closed)
+ return nil
+ case event := <-evt:
+ if len(w.ops) > 0 { // Filter Ops.
+ _, found := w.ops[event.Op]
+ if !found {
+ continue
+ }
+ }
+ numEvents++
+ if w.maxEvents > 0 && numEvents > w.maxEvents {
+ close(cancel)
+ break inner
+ }
+ w.Event <- event
+ case <-done: // Current cycle is finished.
+ break inner
+ }
+ }
+
+ // Update the file's list.
+ w.mu.Lock()
+ w.files = fileList
+ w.mu.Unlock()
+
+ // Sleep and then continue to the next loop iteration.
+ time.Sleep(d)
+ }
+}
+
+func (w *Watcher) pollEvents(files map[string]os.FileInfo, evt chan Event,
+ cancel chan struct{}) {
+ w.mu.Lock()
+ defer w.mu.Unlock()
+
+ // Store create and remove events for use to check for rename events.
+ creates := make(map[string]os.FileInfo)
+ removes := make(map[string]os.FileInfo)
+
+ // Check for removed files.
+ for path, info := range w.files {
+ if _, found := files[path]; !found {
+ removes[path] = info
+ }
+ }
+
+ // Check for created files, writes and chmods.
+ for path, info := range files {
+ oldInfo, found := w.files[path]
+ if !found {
+ // A file was created.
+ creates[path] = info
+ continue
+ }
+ if oldInfo.ModTime() != info.ModTime() {
+ select {
+ case <-cancel:
+ return
+ case evt <- Event{Write, path, info}:
+ }
+ }
+ if oldInfo.Mode() != info.Mode() {
+ select {
+ case <-cancel:
+ return
+ case evt <- Event{Chmod, path, info}:
+ }
+ }
+ }
+
+ // Check for renames and moves.
+ for path1, info1 := range removes {
+ for path2, info2 := range creates {
+ if SameFile(info1, info2) {
+ e := Event{
+ Op: Move,
+ Path: fmt.Sprintf("%s -> %s", path1, path2),
+ FileInfo: info1,
+ }
+ // If they are from the same directory, it's a rename
+ // instead of a move event.
+ if filepath.Dir(path1) == filepath.Dir(path2) {
+ e.Op = Rename
+ }
+
+ delete(removes, path1)
+ delete(creates, path2)
+
+ select {
+ case <-cancel:
+ return
+ case evt <- e:
+ }
+ }
+ }
+ }
+
+ // Send all the remaining create and remove events.
+ for path, info := range creates {
+ select {
+ case <-cancel:
+ return
+ case evt <- Event{Create, path, info}:
+ }
+ }
+ for path, info := range removes {
+ select {
+ case <-cancel:
+ return
+ case evt <- Event{Remove, path, info}:
+ }
+ }
+}
+
+// Wait blocks until the watcher is started.
+func (w *Watcher) Wait() {
+ w.wg.Wait()
+}
+
+func (w *Watcher) Close() {
+ w.mu.Lock()
+ if !w.running {
+ w.mu.Unlock()
+ return
+ }
+ w.running = false
+ w.files = make(map[string]os.FileInfo)
+ w.names = make(map[string]bool)
+ w.mu.Unlock()
+ // Send a close signal to the Start method.
+ w.close <- struct{}{}
+}
diff --git a/vendor/github.com/rivo/tview/CODE_OF_CONDUCT.md b/vendor/github.com/rivo/tview/CODE_OF_CONDUCT.md
new file mode 100644
index 00000000..601e63b8
--- /dev/null
+++ b/vendor/github.com/rivo/tview/CODE_OF_CONDUCT.md
@@ -0,0 +1,73 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+education, socio-economic status, nationality, personal appearance, race,
+religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+ advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+ address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+ professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at https://rentafounder.com/page/about-me/. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
diff --git a/vendor/github.com/rivo/tview/CONTRIBUTING.md b/vendor/github.com/rivo/tview/CONTRIBUTING.md
new file mode 100644
index 00000000..0d962926
--- /dev/null
+++ b/vendor/github.com/rivo/tview/CONTRIBUTING.md
@@ -0,0 +1,31 @@
+# Contributing to tview
+
+First of all, thank you for taking the time to contribute.
+
+The following provides you with some guidance on how to contribute to this project. Mainly, it is meant to save us all some time so please read it, it's not long.
+
+Please note that this document is work in progress so I might add to it in the future.
+
+## Issues
+
+- Please include enough information so everybody understands your request.
+- Screenshots or code that illustrates your point always helps.
+- It's fine to ask for help. But you should have checked out the [documentation](https://godoc.org/github.com/rivo/tview) first in any case.
+- If you request a new feature, state your motivation and share a use case that you faced where you needed that new feature. It should be something that others will also need.
+
+## Pull Requests
+
+If you have a feature request, open an issue first before sending me a pull request. It may save you from writing code that will get rejected. If your case is strong, there is a good chance that I will add the feature for you.
+
+I'm very picky about the code that goes into this repo. So if you violate any of the following guidelines, there is a good chance I won't merge your pull request.
+
+- There must be a strong case for your additions/changes, such as:
+ - Bug fixes
+ - Features that are needed (see "Issues" above; state your motivation)
+ - Improvements in stability or performance (if readability does not suffer)
+- Your code must follow the structure of the existing code. Don't just patch something on. Try to understand how `tview` is currently designed and follow that design. Your code needs to be consistent with existing code.
+- If you're adding code that increases the work required to maintain the project, you must be willing to take responsibility for that extra work. I will ask you to maintain your part of the code in the long run.
+- Function/type/variable/constant names must be as descriptive as they are right now. Follow the conventions of the package.
+- All functions/types/variables/constants, even private ones, must have comments in good English. These comments must be elaborate enough so that new users of the package understand them and can follow them. Provide examples if you have to.
+- Your changes must not decrease the project's [Go Report](https://goreportcard.com/report/github.com/rivo/tview) rating.
+- No breaking changes unless there is absolutely no other way.
diff --git a/vendor/github.com/rivo/tview/LICENSE.txt b/vendor/github.com/rivo/tview/LICENSE.txt
new file mode 100644
index 00000000..8aa26455
--- /dev/null
+++ b/vendor/github.com/rivo/tview/LICENSE.txt
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [year] [fullname]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/vendor/github.com/rivo/tview/README.md b/vendor/github.com/rivo/tview/README.md
new file mode 100644
index 00000000..1ebfc01b
--- /dev/null
+++ b/vendor/github.com/rivo/tview/README.md
@@ -0,0 +1,101 @@
+# Rich Interactive Widgets for Terminal UIs
+
+[](https://godoc.org/github.com/rivo/tview)
+[](https://goreportcard.com/report/github.com/rivo/tview)
+
+This Go package provides commonly needed components for terminal based user interfaces.
+
+
+
+Among these components are:
+
+- __Input forms__ (include __input/password fields__, __drop-down selections__, __checkboxes__, and __buttons__)
+- Navigable multi-color __text views__
+- Sophisticated navigable __table views__
+- Selectable __lists__
+- __Grid__, __Flexbox__ and __page layouts__
+- Modal __message windows__
+- An __application__ wrapper
+
+They come with lots of customization options and can be easily extended to fit your needs.
+
+## Installation
+
+```bash
+go get github.com/rivo/tview
+```
+
+## Hello World
+
+This basic example creates a box titled "Hello, World!" and displays it in your terminal:
+
+```go
+package main
+
+import (
+ "github.com/rivo/tview"
+)
+
+func main() {
+ box := tview.NewBox().SetBorder(true).SetTitle("Hello, world!")
+ if err := tview.NewApplication().SetRoot(box, true).Run(); err != nil {
+ panic(err)
+ }
+}
+```
+
+Check out the [GitHub Wiki](https://github.com/rivo/tview/wiki) for more examples along with screenshots. Or try the examples in the "demos" subdirectory.
+
+For a presentation highlighting this package, compile and run the program found in the "demos/presentation" subdirectory.
+
+## Documentation
+
+Refer to https://godoc.org/github.com/rivo/tview for the package's documentation.
+
+## Dependencies
+
+This package is based on [github.com/gdamore/tcell](https://github.com/gdamore/tcell) (and its dependencies).
+
+## Your Feedback
+
+Add your issue here on GitHub. Feel free to get in touch if you have any questions.
+
+## Version History
+
+(There are no corresponding tags in the project. I only keep such a history in this README.)
+
+- v0.15 (2018-05-02)
+ - `Flex` and `Grid` don't clear their background per default, thus allowing for custom modals. See the [Wiki](https://github.com/rivo/tview/wiki/Modal) for an example.
+- v0.14 (2018-04-13)
+ - Added an `Escape()` function which keep strings like color or region tags from being recognized as such.
+ - Added `ANSIIWriter()` and `TranslateANSII()` which convert ANSII escape sequences to `tview` color tags.
+- v0.13 (2018-04-01)
+ - Added background colors and text attributes to color tags.
+- v0.12 (2018-03-13)
+ - Added "suspended mode" to `Application`.
+- v0.11 (2018-03-02)
+ - Added a `RemoveItem()` function to `Grid` and `Flex`.
+- v0.10 (2018-02-22)
+ - Direct access to the `screen` object through callback in `Box` (i.e. for all primitives).
+- v0.9 (2018-02-20)
+ - Introduced `Grid` layout.
+ - Direct access to the `screen` object through callbacks in `Application`.
+- v0.8 (2018-01-17)
+ - Color tags can now be used almost everywhere.
+- v0.7 (2018-01-16)
+ - Forms can now also have a horizontal layout.
+- v0.6 (2018-01-14)
+ - All primitives can now intercept all key events when they have focus.
+ - Key events can also be intercepted globally (changed to a more general, consistent handling)
+- v0.5 (2018-01-13)
+ - `TextView` now has word wrapping and text alignment
+- v0.4 (2018-01-12)
+ - `TextView` now accepts color tags with any W3C color (including RGB hex values).
+ - Support for wide unicode characters.
+- v0.3 (2018-01-11)
+ - Added masking to `InputField` and password entry to `Form`.
+- v0.2 (2018-01-10)
+ - Added `Styles` variable with default colors for primitives.
+ - Completed some missing InputField functions.
+- v0.1 (2018-01-06)
+ - First Release.
diff --git a/vendor/github.com/rivo/tview/ansii.go b/vendor/github.com/rivo/tview/ansii.go
new file mode 100644
index 00000000..0ce3d4a7
--- /dev/null
+++ b/vendor/github.com/rivo/tview/ansii.go
@@ -0,0 +1,237 @@
+package tview
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "strconv"
+ "strings"
+)
+
+// The states of the ANSII escape code parser.
+const (
+ ansiiText = iota
+ ansiiEscape
+ ansiiSubstring
+ ansiiControlSequence
+)
+
+// ansii is a io.Writer which translates ANSII escape codes into tview color
+// tags.
+type ansii struct {
+ io.Writer
+
+ // Reusable buffers.
+ buffer *bytes.Buffer // The entire output text of one Write().
+ csiParameter, csiIntermediate *bytes.Buffer // Partial CSI strings.
+
+ // The current state of the parser. One of the ansii constants.
+ state int
+}
+
+// ANSIIWriter returns an io.Writer which translates any ANSII escape codes
+// written to it into tview color tags. Other escape codes don't have an effect
+// and are simply removed. The translated text is written to the provided
+// writer.
+func ANSIIWriter(writer io.Writer) io.Writer {
+ return &ansii{
+ Writer: writer,
+ buffer: new(bytes.Buffer),
+ csiParameter: new(bytes.Buffer),
+ csiIntermediate: new(bytes.Buffer),
+ state: ansiiText,
+ }
+}
+
+// Write parses the given text as a string of runes, translates ANSII escape
+// codes to color tags and writes them to the output writer.
+func (a *ansii) Write(text []byte) (int, error) {
+ defer func() {
+ a.buffer.Reset()
+ }()
+
+ for _, r := range string(text) {
+ switch a.state {
+
+ // We just entered an escape sequence.
+ case ansiiEscape:
+ switch r {
+ case '[': // Control Sequence Introducer.
+ a.csiParameter.Reset()
+ a.csiIntermediate.Reset()
+ a.state = ansiiControlSequence
+ case 'c': // Reset.
+ fmt.Fprint(a.buffer, "[-:-:-]")
+ a.state = ansiiText
+ case 'P', ']', 'X', '^', '_': // Substrings and commands.
+ a.state = ansiiSubstring
+ default: // Ignore.
+ a.state = ansiiText
+ }
+
+ // CSI Sequences.
+ case ansiiControlSequence:
+ switch {
+ case r >= 0x30 && r <= 0x3f: // Parameter bytes.
+ if _, err := a.csiParameter.WriteRune(r); err != nil {
+ return 0, err
+ }
+ case r >= 0x20 && r <= 0x2f: // Intermediate bytes.
+ if _, err := a.csiIntermediate.WriteRune(r); err != nil {
+ return 0, err
+ }
+ case r >= 0x40 && r <= 0x7e: // Final byte.
+ switch r {
+ case 'E': // Next line.
+ count, _ := strconv.Atoi(a.csiParameter.String())
+ if count == 0 {
+ count = 1
+ }
+ fmt.Fprint(a.buffer, strings.Repeat("\n", count))
+ case 'm': // Select Graphic Rendition.
+ var (
+ background, foreground, attributes string
+ clearAttributes bool
+ )
+ fields := strings.Split(a.csiParameter.String(), ";")
+ if len(fields) == 0 || len(fields) == 1 && fields[0] == "0" {
+ // Reset.
+ if _, err := a.buffer.WriteString("[-:-:-]"); err != nil {
+ return 0, err
+ }
+ break
+ }
+ lookupColor := func(colorNumber int, bright bool) string {
+ if colorNumber < 0 || colorNumber > 7 {
+ return "black"
+ }
+ if bright {
+ colorNumber += 8
+ }
+ return [...]string{
+ "black",
+ "red",
+ "green",
+ "yellow",
+ "blue",
+ "darkmagenta",
+ "darkcyan",
+ "white",
+ "#7f7f7f",
+ "#ff0000",
+ "#00ff00",
+ "#ffff00",
+ "#5c5cff",
+ "#ff00ff",
+ "#00ffff",
+ "#ffffff",
+ }[colorNumber]
+ }
+ for index, field := range fields {
+ switch field {
+ case "1", "01":
+ attributes += "b"
+ case "2", "02":
+ attributes += "d"
+ case "4", "04":
+ attributes += "u"
+ case "5", "05":
+ attributes += "l"
+ case "7", "07":
+ attributes += "7"
+ case "22", "24", "25", "27":
+ clearAttributes = true
+ case "30", "31", "32", "33", "34", "35", "36", "37":
+ colorNumber, _ := strconv.Atoi(field)
+ foreground = lookupColor(colorNumber-30, false)
+ case "40", "41", "42", "43", "44", "45", "46", "47":
+ colorNumber, _ := strconv.Atoi(field)
+ background = lookupColor(colorNumber-40, false)
+ case "90", "91", "92", "93", "94", "95", "96", "97":
+ colorNumber, _ := strconv.Atoi(field)
+ foreground = lookupColor(colorNumber-90, true)
+ case "100", "101", "102", "103", "104", "105", "106", "107":
+ colorNumber, _ := strconv.Atoi(field)
+ background = lookupColor(colorNumber-100, true)
+ case "38", "48":
+ var color string
+ if len(fields) > index+1 {
+ if fields[index+1] == "5" && len(fields) > index+2 { // 8-bit colors.
+ colorNumber, _ := strconv.Atoi(fields[index+2])
+ if colorNumber <= 7 {
+ color = lookupColor(colorNumber, false)
+ } else if colorNumber <= 15 {
+ color = lookupColor(colorNumber, true)
+ } else if colorNumber <= 231 {
+ red := (colorNumber - 16) / 36
+ green := ((colorNumber - 16) / 6) % 6
+ blue := (colorNumber - 16) % 6
+ color = fmt.Sprintf("%02x%02x%02x", 255*red/5, 255*green/5, 255*blue/5)
+ } else if colorNumber <= 255 {
+ grey := 255 * (colorNumber - 232) / 23
+ color = fmt.Sprintf("%02x%02x%02x", grey, grey, grey)
+ }
+ } else if fields[index+1] == "2" && len(fields) > index+4 { // 24-bit colors.
+ red, _ := strconv.Atoi(fields[index+2])
+ green, _ := strconv.Atoi(fields[index+3])
+ blue, _ := strconv.Atoi(fields[index+4])
+ color = fmt.Sprintf("%02x%02x%02x", red, green, blue)
+ }
+ }
+ if len(color) > 0 {
+ if field == "38" {
+ foreground = color
+ } else {
+ background = color
+ }
+ }
+ }
+ }
+ if len(attributes) > 0 || clearAttributes {
+ attributes = ":" + attributes
+ }
+ if len(foreground) > 0 || len(background) > 0 || len(attributes) > 0 {
+ fmt.Fprintf(a.buffer, "[%s:%s%s]", foreground, background, attributes)
+ }
+ }
+ a.state = ansiiText
+ default: // Undefined byte.
+ a.state = ansiiText // Abort CSI.
+ }
+
+ // We just entered a substring/command sequence.
+ case ansiiSubstring:
+ if r == 27 { // Most likely the end of the substring.
+ a.state = ansiiEscape
+ } // Ignore all other characters.
+
+ // "ansiiText" and all others.
+ default:
+ if r == 27 {
+ // This is the start of an escape sequence.
+ a.state = ansiiEscape
+ } else {
+ // Just a regular rune. Send to buffer.
+ if _, err := a.buffer.WriteRune(r); err != nil {
+ return 0, err
+ }
+ }
+ }
+ }
+
+ // Write buffer to target writer.
+ n, err := a.buffer.WriteTo(a.Writer)
+ if err != nil {
+ return int(n), err
+ }
+ return len(text), nil
+}
+
+// TranslateANSII replaces ANSII escape sequences found in the provided string
+// with tview's color tags and returns the resulting string.
+func TranslateANSII(text string) string {
+ var buffer bytes.Buffer
+ writer := ANSIIWriter(&buffer)
+ writer.Write([]byte(text))
+ return buffer.String()
+}
diff --git a/vendor/github.com/rivo/tview/application.go b/vendor/github.com/rivo/tview/application.go
new file mode 100644
index 00000000..31821d9d
--- /dev/null
+++ b/vendor/github.com/rivo/tview/application.go
@@ -0,0 +1,375 @@
+package tview
+
+import (
+ "fmt"
+ "os"
+ "sync"
+
+ "github.com/gdamore/tcell"
+)
+
+// Application represents the top node of an application.
+//
+// It is not strictly required to use this class as none of the other classes
+// depend on it. However, it provides useful tools to set up an application and
+// plays nicely with all widgets.
+type Application struct {
+ sync.RWMutex
+
+ // The application's screen.
+ screen tcell.Screen
+
+ // The primitive which currently has the keyboard focus.
+ focus Primitive
+
+ // The root primitive to be seen on the screen.
+ root Primitive
+
+ // Whether or not the application resizes the root primitive.
+ rootFullscreen bool
+
+ // An optional capture function which receives a key event and returns the
+ // event to be forwarded to the default input handler (nil if nothing should
+ // be forwarded).
+ inputCapture func(event *tcell.EventKey) *tcell.EventKey
+
+ // An optional callback function which is invoked just before the root
+ // primitive is drawn.
+ beforeDraw func(screen tcell.Screen) bool
+
+ // An optional callback function which is invoked after the root primitive
+ // was drawn.
+ afterDraw func(screen tcell.Screen)
+
+ // If this value is true, the application has entered suspended mode.
+ suspended bool
+}
+
+// NewApplication creates and returns a new application.
+func NewApplication() *Application {
+ return &Application{}
+}
+
+// SetInputCapture sets a function which captures all key events before they are
+// forwarded to the key event handler of the primitive which currently has
+// focus. This function can then choose to forward that key event (or a
+// different one) by returning it or stop the key event processing by returning
+// nil.
+//
+// Note that this also affects the default event handling of the application
+// itself: Such a handler can intercept the Ctrl-C event which closes the
+// applicatoon.
+func (a *Application) SetInputCapture(capture func(event *tcell.EventKey) *tcell.EventKey) *Application {
+ a.inputCapture = capture
+ return a
+}
+
+// GetInputCapture returns the function installed with SetInputCapture() or nil
+// if no such function has been installed.
+func (a *Application) GetInputCapture() func(event *tcell.EventKey) *tcell.EventKey {
+ return a.inputCapture
+}
+
+// Run starts the application and thus the event loop. This function returns
+// when Stop() was called.
+func (a *Application) Run() error {
+ var err error
+ a.Lock()
+
+ // Make a screen.
+ a.screen, err = tcell.NewScreen()
+ if err != nil {
+ a.Unlock()
+ return err
+ }
+ if err = a.screen.Init(); err != nil {
+ a.Unlock()
+ return err
+ }
+
+ // We catch panics to clean up because they mess up the terminal.
+ defer func() {
+ if p := recover(); p != nil {
+ if a.screen != nil {
+ a.screen.Fini()
+ }
+ panic(p)
+ }
+ }()
+
+ // Draw the screen for the first time.
+ a.Unlock()
+ a.Draw()
+
+ // Start event loop.
+ for {
+ a.Lock()
+ screen := a.screen
+ if a.suspended {
+ a.suspended = false // Clear previous suspended flag.
+ }
+ a.Unlock()
+ if screen == nil {
+ break
+ }
+
+ // Wait for next event.
+ event := a.screen.PollEvent()
+ if event == nil {
+ a.Lock()
+ if a.suspended {
+ // This screen was renewed due to suspended mode.
+ a.suspended = false
+ a.Unlock()
+ continue // Resume.
+ }
+ a.Unlock()
+
+ // The screen was finalized. Exit the loop.
+ break
+ }
+
+ switch event := event.(type) {
+ case *tcell.EventKey:
+ a.RLock()
+ p := a.focus
+ a.RUnlock()
+
+ // Intercept keys.
+ if a.inputCapture != nil {
+ event = a.inputCapture(event)
+ if event == nil {
+ break // Don't forward event.
+ }
+ }
+
+ // Ctrl-C closes the application.
+ if event.Key() == tcell.KeyCtrlC {
+ a.Stop()
+ }
+
+ // Pass other key events to the currently focused primitive.
+ if p != nil {
+ if handler := p.InputHandler(); handler != nil {
+ handler(event, func(p Primitive) {
+ a.SetFocus(p)
+ })
+ a.Draw()
+ }
+ }
+ case *tcell.EventResize:
+ a.Lock()
+ screen := a.screen
+ a.Unlock()
+ screen.Clear()
+ a.Draw()
+ }
+ }
+
+ return nil
+}
+
+// Stop stops the application, causing Run() to return.
+func (a *Application) Stop() {
+ a.RLock()
+ defer a.RUnlock()
+ if a.screen == nil {
+ return
+ }
+ a.screen.Fini()
+ a.screen = nil
+}
+
+// Suspend temporarily suspends the application by exiting terminal UI mode and
+// invoking the provided function "f". When "f" returns, terminal UI mode is
+// entered again and the application resumes.
+//
+// A return value of true indicates that the application was suspended and "f"
+// was called. If false is returned, the application was already suspended,
+// terminal UI mode was not exited, and "f" was not called.
+func (a *Application) Suspend(f func()) bool {
+ a.Lock()
+
+ if a.suspended || a.screen == nil {
+ // Application is already suspended.
+ a.Unlock()
+ return false
+ }
+
+ // Enter suspended mode.
+ a.suspended = true
+ a.Unlock()
+ a.Stop()
+
+ // Deal with panics during suspended mode. Exit the program.
+ defer func() {
+ if p := recover(); p != nil {
+ fmt.Println(p)
+ os.Exit(1)
+ }
+ }()
+
+ // Wait for "f" to return.
+ f()
+
+ // Make a new screen and redraw.
+ a.Lock()
+ var err error
+ a.screen, err = tcell.NewScreen()
+ if err != nil {
+ a.Unlock()
+ panic(err)
+ }
+ if err = a.screen.Init(); err != nil {
+ a.Unlock()
+ panic(err)
+ }
+ a.Unlock()
+ a.Draw()
+
+ // Continue application loop.
+ return true
+}
+
+// Draw refreshes the screen. It calls the Draw() function of the application's
+// root primitive and then syncs the screen buffer.
+func (a *Application) Draw() *Application {
+ a.RLock()
+ screen := a.screen
+ root := a.root
+ fullscreen := a.rootFullscreen
+ before := a.beforeDraw
+ after := a.afterDraw
+ a.RUnlock()
+
+ // Maybe we're not ready yet or not anymore.
+ if screen == nil || root == nil {
+ return a
+ }
+
+ // Resize if requested.
+ if fullscreen && root != nil {
+ width, height := screen.Size()
+ root.SetRect(0, 0, width, height)
+ }
+
+ // Call before handler if there is one.
+ if before != nil {
+ if before(screen) {
+ screen.Show()
+ return a
+ }
+ }
+
+ // Draw all primitives.
+ root.Draw(screen)
+
+ // Call after handler if there is one.
+ if after != nil {
+ after(screen)
+ }
+
+ // Sync screen.
+ screen.Show()
+
+ return a
+}
+
+// SetBeforeDrawFunc installs a callback function which is invoked just before
+// the root primitive is drawn during screen updates. If the function returns
+// true, drawing will not continue, i.e. the root primitive will not be drawn
+// (and an after-draw-handler will not be called).
+//
+// Note that the screen is not cleared by the application. To clear the screen,
+// you may call screen.Clear().
+//
+// Provide nil to uninstall the callback function.
+func (a *Application) SetBeforeDrawFunc(handler func(screen tcell.Screen) bool) *Application {
+ a.beforeDraw = handler
+ return a
+}
+
+// GetBeforeDrawFunc returns the callback function installed with
+// SetBeforeDrawFunc() or nil if none has been installed.
+func (a *Application) GetBeforeDrawFunc() func(screen tcell.Screen) bool {
+ return a.beforeDraw
+}
+
+// SetAfterDrawFunc installs a callback function which is invoked after the root
+// primitive was drawn during screen updates.
+//
+// Provide nil to uninstall the callback function.
+func (a *Application) SetAfterDrawFunc(handler func(screen tcell.Screen)) *Application {
+ a.afterDraw = handler
+ return a
+}
+
+// GetAfterDrawFunc returns the callback function installed with
+// SetAfterDrawFunc() or nil if none has been installed.
+func (a *Application) GetAfterDrawFunc() func(screen tcell.Screen) {
+ return a.afterDraw
+}
+
+// SetRoot sets the root primitive for this application. If "fullscreen" is set
+// to true, the root primitive's position will be changed to fill the screen.
+//
+// This function must be called at least once or nothing will be displayed when
+// the application starts.
+//
+// It also calls SetFocus() on the primitive.
+func (a *Application) SetRoot(root Primitive, fullscreen bool) *Application {
+ a.Lock()
+ a.root = root
+ a.rootFullscreen = fullscreen
+ if a.screen != nil {
+ a.screen.Clear()
+ }
+ a.Unlock()
+
+ a.SetFocus(root)
+
+ return a
+}
+
+// ResizeToFullScreen resizes the given primitive such that it fills the entire
+// screen.
+func (a *Application) ResizeToFullScreen(p Primitive) *Application {
+ a.RLock()
+ width, height := a.screen.Size()
+ a.RUnlock()
+ p.SetRect(0, 0, width, height)
+ return a
+}
+
+// SetFocus sets the focus on a new primitive. All key events will be redirected
+// to that primitive. Callers must ensure that the primitive will handle key
+// events.
+//
+// Blur() will be called on the previously focused primitive. Focus() will be
+// called on the new primitive.
+func (a *Application) SetFocus(p Primitive) *Application {
+ a.Lock()
+ if a.focus != nil {
+ a.focus.Blur()
+ }
+ a.focus = p
+ if a.screen != nil {
+ a.screen.HideCursor()
+ }
+ a.Unlock()
+ if p != nil {
+ p.Focus(func(p Primitive) {
+ a.SetFocus(p)
+ })
+ }
+
+ return a
+}
+
+// GetFocus returns the primitive which has the current focus. If none has it,
+// nil is returned.
+func (a *Application) GetFocus() Primitive {
+ a.RLock()
+ defer a.RUnlock()
+ return a.focus
+}
diff --git a/vendor/github.com/rivo/tview/box.go b/vendor/github.com/rivo/tview/box.go
new file mode 100644
index 00000000..086ff5a6
--- /dev/null
+++ b/vendor/github.com/rivo/tview/box.go
@@ -0,0 +1,324 @@
+package tview
+
+import (
+ "github.com/gdamore/tcell"
+)
+
+// Box implements Primitive with a background and optional elements such as a
+// border and a title. Most subclasses keep their content contained in the box
+// but don't necessarily have to.
+//
+// Note that all classes which subclass from Box will also have access to its
+// functions.
+//
+// See https://github.com/rivo/tview/wiki/Box for an example.
+type Box struct {
+ // The position of the rect.
+ x, y, width, height int
+
+ // The inner rect reserved for the box's content.
+ innerX, innerY, innerWidth, innerHeight int
+
+ // Border padding.
+ paddingTop, paddingBottom, paddingLeft, paddingRight int
+
+ // The box's background color.
+ backgroundColor tcell.Color
+
+ // Whether or not a border is drawn, reducing the box's space for content by
+ // two in width and height.
+ border bool
+
+ // The color of the border.
+ borderColor tcell.Color
+
+ // The title. Only visible if there is a border, too.
+ title string
+
+ // The color of the title.
+ titleColor tcell.Color
+
+ // The alignment of the title.
+ titleAlign int
+
+ // Provides a way to find out if this box has focus. We always go through
+ // this interface because it may be overridden by implementing classes.
+ focus Focusable
+
+ // Whether or not this box has focus.
+ hasFocus bool
+
+ // If set to true, the inner rect of this box will be within the screen at the
+ // last time the box was drawn.
+ clampToScreen bool
+
+ // An optional capture function which receives a key event and returns the
+ // event to be forwarded to the primitive's default input handler (nil if
+ // nothing should be forwarded).
+ inputCapture func(event *tcell.EventKey) *tcell.EventKey
+
+ // An optional function which is called before the box is drawn.
+ draw func(screen tcell.Screen, x, y, width, height int) (int, int, int, int)
+}
+
+// NewBox returns a Box without a border.
+func NewBox() *Box {
+ b := &Box{
+ width: 15,
+ height: 10,
+ innerX: -1, // Mark as uninitialized.
+ backgroundColor: Styles.PrimitiveBackgroundColor,
+ borderColor: Styles.BorderColor,
+ titleColor: Styles.TitleColor,
+ titleAlign: AlignCenter,
+ clampToScreen: true,
+ }
+ b.focus = b
+ return b
+}
+
+// SetBorderPadding sets the size of the borders around the box content.
+func (b *Box) SetBorderPadding(top, bottom, left, right int) *Box {
+ b.paddingTop, b.paddingBottom, b.paddingLeft, b.paddingRight = top, bottom, left, right
+ return b
+}
+
+// GetRect returns the current position of the rectangle, x, y, width, and
+// height.
+func (b *Box) GetRect() (int, int, int, int) {
+ return b.x, b.y, b.width, b.height
+}
+
+// GetInnerRect returns the position of the inner rectangle (x, y, width,
+// height), without the border and without any padding.
+func (b *Box) GetInnerRect() (int, int, int, int) {
+ if b.innerX >= 0 {
+ return b.innerX, b.innerY, b.innerWidth, b.innerHeight
+ }
+ x, y, width, height := b.GetRect()
+ if b.border {
+ x++
+ y++
+ width -= 2
+ height -= 2
+ }
+ return x + b.paddingLeft,
+ y + b.paddingTop,
+ width - b.paddingLeft - b.paddingRight,
+ height - b.paddingTop - b.paddingBottom
+}
+
+// SetRect sets a new position of the primitive.
+func (b *Box) SetRect(x, y, width, height int) {
+ b.x = x
+ b.y = y
+ b.width = width
+ b.height = height
+}
+
+// SetDrawFunc sets a callback function which is invoked after the box primitive
+// has been drawn. This allows you to add a more individual style to the box
+// (and all primitives which extend it).
+//
+// The function is provided with the box's dimensions (set via SetRect()). It
+// must return the box's inner dimensions (x, y, width, height) which will be
+// returned by GetInnerRect(), used by descendent primitives to draw their own
+// content.
+func (b *Box) SetDrawFunc(handler func(screen tcell.Screen, x, y, width, height int) (int, int, int, int)) *Box {
+ b.draw = handler
+ return b
+}
+
+// GetDrawFunc returns the callback function which was installed with
+// SetDrawFunc() or nil if no such function has been installed.
+func (b *Box) GetDrawFunc() func(screen tcell.Screen, x, y, width, height int) (int, int, int, int) {
+ return b.draw
+}
+
+// WrapInputHandler wraps an input handler (see InputHandler()) with the
+// functionality to capture input (see SetInputCapture()) before passing it
+// on to the provided (default) input handler.
+//
+// This is only meant to be used by subclassing primitives.
+func (b *Box) WrapInputHandler(inputHandler func(*tcell.EventKey, func(p Primitive))) func(*tcell.EventKey, func(p Primitive)) {
+ return func(event *tcell.EventKey, setFocus func(p Primitive)) {
+ if b.inputCapture != nil {
+ event = b.inputCapture(event)
+ }
+ if event != nil && inputHandler != nil {
+ inputHandler(event, setFocus)
+ }
+ }
+}
+
+// InputHandler returns nil.
+func (b *Box) InputHandler() func(event *tcell.EventKey, setFocus func(p Primitive)) {
+ return b.WrapInputHandler(nil)
+}
+
+// SetInputCapture installs a function which captures key events before they are
+// forwarded to the primitive's default key event handler. This function can
+// then choose to forward that key event (or a different one) to the default
+// handler by returning it. If nil is returned, the default handler will not
+// be called.
+//
+// Providing a nil handler will remove a previously existing handler.
+func (b *Box) SetInputCapture(capture func(event *tcell.EventKey) *tcell.EventKey) *Box {
+ b.inputCapture = capture
+ return b
+}
+
+// GetInputCapture returns the function installed with SetInputCapture() or nil
+// if no such function has been installed.
+func (b *Box) GetInputCapture() func(event *tcell.EventKey) *tcell.EventKey {
+ return b.inputCapture
+}
+
+// SetBackgroundColor sets the box's background color.
+func (b *Box) SetBackgroundColor(color tcell.Color) *Box {
+ b.backgroundColor = color
+ return b
+}
+
+// SetBorder sets the flag indicating whether or not the box should have a
+// border.
+func (b *Box) SetBorder(show bool) *Box {
+ b.border = show
+ return b
+}
+
+// SetBorderColor sets the box's border color.
+func (b *Box) SetBorderColor(color tcell.Color) *Box {
+ b.borderColor = color
+ return b
+}
+
+// SetTitle sets the box's title.
+func (b *Box) SetTitle(title string) *Box {
+ b.title = title
+ return b
+}
+
+// SetTitleColor sets the box's title color.
+func (b *Box) SetTitleColor(color tcell.Color) *Box {
+ b.titleColor = color
+ return b
+}
+
+// SetTitleAlign sets the alignment of the title, one of AlignLeft, AlignCenter,
+// or AlignRight.
+func (b *Box) SetTitleAlign(align int) *Box {
+ b.titleAlign = align
+ return b
+}
+
+// Draw draws this primitive onto the screen.
+func (b *Box) Draw(screen tcell.Screen) {
+ // Don't draw anything if there is no space.
+ if b.width <= 0 || b.height <= 0 {
+ return
+ }
+
+ def := tcell.StyleDefault
+
+ // Fill background.
+ background := def.Background(b.backgroundColor)
+ if b.backgroundColor != tcell.ColorDefault {
+ for y := b.y; y < b.y+b.height; y++ {
+ for x := b.x; x < b.x+b.width; x++ {
+ screen.SetContent(x, y, ' ', nil, background)
+ }
+ }
+ }
+
+ // Draw border.
+ if b.border && b.width >= 2 && b.height >= 2 {
+ border := background.Foreground(b.borderColor)
+ var vertical, horizontal, topLeft, topRight, bottomLeft, bottomRight rune
+ if b.focus.HasFocus() {
+ vertical = GraphicsDbVertBar
+ horizontal = GraphicsDbHorBar
+ topLeft = GraphicsDbTopLeftCorner
+ topRight = GraphicsDbTopRightCorner
+ bottomLeft = GraphicsDbBottomLeftCorner
+ bottomRight = GraphicsDbBottomRightCorner
+ } else {
+ vertical = GraphicsHoriBar
+ horizontal = GraphicsVertBar
+ topLeft = GraphicsTopLeftCorner
+ topRight = GraphicsTopRightCorner
+ bottomLeft = GraphicsBottomLeftCorner
+ bottomRight = GraphicsBottomRightCorner
+ }
+ for x := b.x + 1; x < b.x+b.width-1; x++ {
+ screen.SetContent(x, b.y, vertical, nil, border)
+ screen.SetContent(x, b.y+b.height-1, vertical, nil, border)
+ }
+ for y := b.y + 1; y < b.y+b.height-1; y++ {
+ screen.SetContent(b.x, y, horizontal, nil, border)
+ screen.SetContent(b.x+b.width-1, y, horizontal, nil, border)
+ }
+ screen.SetContent(b.x, b.y, topLeft, nil, border)
+ screen.SetContent(b.x+b.width-1, b.y, topRight, nil, border)
+ screen.SetContent(b.x, b.y+b.height-1, bottomLeft, nil, border)
+ screen.SetContent(b.x+b.width-1, b.y+b.height-1, bottomRight, nil, border)
+
+ // Draw title.
+ if b.title != "" && b.width >= 4 {
+ _, printed := Print(screen, b.title, b.x+1, b.y, b.width-2, b.titleAlign, b.titleColor)
+ if StringWidth(b.title)-printed > 0 && printed > 0 {
+ _, _, style, _ := screen.GetContent(b.x+b.width-2, b.y)
+ fg, _, _ := style.Decompose()
+ Print(screen, string(GraphicsEllipsis), b.x+b.width-2, b.y, 1, AlignLeft, fg)
+ }
+ }
+ }
+
+ // Call custom draw function.
+ if b.draw != nil {
+ b.innerX, b.innerY, b.innerWidth, b.innerHeight = b.draw(screen, b.x, b.y, b.width, b.height)
+ } else {
+ // Remember the inner rect.
+ b.innerX = -1
+ b.innerX, b.innerY, b.innerWidth, b.innerHeight = b.GetInnerRect()
+ }
+
+ // Clamp inner rect to screen.
+ if b.clampToScreen {
+ width, height := screen.Size()
+ if b.innerX < 0 {
+ b.innerWidth += b.innerX
+ b.innerX = 0
+ }
+ if b.innerX+b.innerWidth >= width {
+ b.innerWidth = width - b.innerX
+ }
+ if b.innerY+b.innerHeight >= height {
+ b.innerHeight = height - b.innerY
+ }
+ if b.innerY < 0 {
+ b.innerHeight += b.innerY
+ b.innerY = 0
+ }
+ }
+}
+
+// Focus is called when this primitive receives focus.
+func (b *Box) Focus(delegate func(p Primitive)) {
+ b.hasFocus = true
+}
+
+// Blur is called when this primitive loses focus.
+func (b *Box) Blur() {
+ b.hasFocus = false
+}
+
+// HasFocus returns whether or not this primitive has focus.
+func (b *Box) HasFocus() bool {
+ return b.hasFocus
+}
+
+// GetFocusable returns the item's Focusable.
+func (b *Box) GetFocusable() Focusable {
+ return b.focus
+}
diff --git a/vendor/github.com/rivo/tview/button.go b/vendor/github.com/rivo/tview/button.go
new file mode 100644
index 00000000..5efc31ae
--- /dev/null
+++ b/vendor/github.com/rivo/tview/button.go
@@ -0,0 +1,137 @@
+package tview
+
+import (
+ "github.com/gdamore/tcell"
+)
+
+// Button is labeled box that triggers an action when selected.
+//
+// See https://github.com/rivo/tview/wiki/Button for an example.
+type Button struct {
+ *Box
+
+ // The text to be displayed before the input area.
+ label string
+
+ // The label color.
+ labelColor tcell.Color
+
+ // The label color when the button is in focus.
+ labelColorActivated tcell.Color
+
+ // The background color when the button is in focus.
+ backgroundColorActivated tcell.Color
+
+ // An optional function which is called when the button was selected.
+ selected func()
+
+ // An optional function which is called when the user leaves the button. A
+ // key is provided indicating which key was pressed to leave (tab or backtab).
+ blur func(tcell.Key)
+}
+
+// NewButton returns a new input field.
+func NewButton(label string) *Button {
+ box := NewBox().SetBackgroundColor(Styles.ContrastBackgroundColor)
+ box.SetRect(0, 0, StringWidth(label)+4, 1)
+ return &Button{
+ Box: box,
+ label: label,
+ labelColor: Styles.PrimaryTextColor,
+ labelColorActivated: Styles.InverseTextColor,
+ backgroundColorActivated: Styles.PrimaryTextColor,
+ }
+}
+
+// SetLabel sets the button text.
+func (b *Button) SetLabel(label string) *Button {
+ b.label = label
+ return b
+}
+
+// GetLabel returns the button text.
+func (b *Button) GetLabel() string {
+ return b.label
+}
+
+// SetLabelColor sets the color of the button text.
+func (b *Button) SetLabelColor(color tcell.Color) *Button {
+ b.labelColor = color
+ return b
+}
+
+// SetLabelColorActivated sets the color of the button text when the button is
+// in focus.
+func (b *Button) SetLabelColorActivated(color tcell.Color) *Button {
+ b.labelColorActivated = color
+ return b
+}
+
+// SetBackgroundColorActivated sets the background color of the button text when
+// the button is in focus.
+func (b *Button) SetBackgroundColorActivated(color tcell.Color) *Button {
+ b.backgroundColorActivated = color
+ return b
+}
+
+// SetSelectedFunc sets a handler which is called when the button was selected.
+func (b *Button) SetSelectedFunc(handler func()) *Button {
+ b.selected = handler
+ return b
+}
+
+// SetBlurFunc sets a handler which is called when the user leaves the button.
+// The callback function is provided with the key that was pressed, which is one
+// of the following:
+//
+// - KeyEscape: Leaving the button with no specific direction.
+// - KeyTab: Move to the next field.
+// - KeyBacktab: Move to the previous field.
+func (b *Button) SetBlurFunc(handler func(key tcell.Key)) *Button {
+ b.blur = handler
+ return b
+}
+
+// Draw draws this primitive onto the screen.
+func (b *Button) Draw(screen tcell.Screen) {
+ // Draw the box.
+ borderColor := b.borderColor
+ backgroundColor := b.backgroundColor
+ if b.focus.HasFocus() {
+ b.backgroundColor = b.backgroundColorActivated
+ b.borderColor = b.labelColorActivated
+ defer func() {
+ b.borderColor = borderColor
+ }()
+ }
+ b.Box.Draw(screen)
+ b.backgroundColor = backgroundColor
+
+ // Draw label.
+ x, y, width, height := b.GetInnerRect()
+ if width > 0 && height > 0 {
+ y = y + height/2
+ labelColor := b.labelColor
+ if b.focus.HasFocus() {
+ labelColor = b.labelColorActivated
+ }
+ Print(screen, b.label, x, y, width, AlignCenter, labelColor)
+ }
+}
+
+// InputHandler returns the handler for this primitive.
+func (b *Button) InputHandler() func(event *tcell.EventKey, setFocus func(p Primitive)) {
+ return b.WrapInputHandler(func(event *tcell.EventKey, setFocus func(p Primitive)) {
+ // Process key event.
+ switch key := event.Key(); key {
+ case tcell.KeyEnter: // Selected.
+ if b.selected != nil {
+ b.selected()
+ }
+ case tcell.KeyBacktab, tcell.KeyTab, tcell.KeyEscape: // Leave. No action.
+ if b.blur != nil {
+ b.blur(key)
+ }
+ }
+ })
+}
diff --git a/vendor/github.com/rivo/tview/checkbox.go b/vendor/github.com/rivo/tview/checkbox.go
new file mode 100644
index 00000000..768c112e
--- /dev/null
+++ b/vendor/github.com/rivo/tview/checkbox.go
@@ -0,0 +1,203 @@
+package tview
+
+import (
+ "github.com/gdamore/tcell"
+)
+
+// Checkbox implements a simple box for boolean values which can be checked and
+// unchecked.
+//
+// See https://github.com/rivo/tview/wiki/Checkbox for an example.
+type Checkbox struct {
+ *Box
+
+ // Whether or not this box is checked.
+ checked bool
+
+ // The text to be displayed before the input area.
+ label string
+
+ // The screen width of the label area. A value of 0 means use the width of
+ // the label text.
+ labelWidth int
+
+ // The label color.
+ labelColor tcell.Color
+
+ // The background color of the input area.
+ fieldBackgroundColor tcell.Color
+
+ // The text color of the input area.
+ fieldTextColor tcell.Color
+
+ // An optional function which is called when the user changes the checked
+ // state of this checkbox.
+ changed func(checked bool)
+
+ // An optional function which is called when the user indicated that they
+ // are done entering text. The key which was pressed is provided (tab,
+ // shift-tab, or escape).
+ done func(tcell.Key)
+
+ // A callback function set by the Form class and called when the user leaves
+ // this form item.
+ finished func(tcell.Key)
+}
+
+// NewCheckbox returns a new input field.
+func NewCheckbox() *Checkbox {
+ return &Checkbox{
+ Box: NewBox(),
+ labelColor: Styles.SecondaryTextColor,
+ fieldBackgroundColor: Styles.ContrastBackgroundColor,
+ fieldTextColor: Styles.PrimaryTextColor,
+ }
+}
+
+// SetChecked sets the state of the checkbox.
+func (c *Checkbox) SetChecked(checked bool) *Checkbox {
+ c.checked = checked
+ return c
+}
+
+// IsChecked returns whether or not the box is checked.
+func (c *Checkbox) IsChecked() bool {
+ return c.checked
+}
+
+// SetLabel sets the text to be displayed before the input area.
+func (c *Checkbox) SetLabel(label string) *Checkbox {
+ c.label = label
+ return c
+}
+
+// GetLabel returns the text to be displayed before the input area.
+func (c *Checkbox) GetLabel() string {
+ return c.label
+}
+
+// SetLabelWidth sets the screen width of the label. A value of 0 will cause the
+// primitive to use the width of the label string.
+func (c *Checkbox) SetLabelWidth(width int) *Checkbox {
+ c.labelWidth = width
+ return c
+}
+
+// SetLabelColor sets the color of the label.
+func (c *Checkbox) SetLabelColor(color tcell.Color) *Checkbox {
+ c.labelColor = color
+ return c
+}
+
+// SetFieldBackgroundColor sets the background color of the input area.
+func (c *Checkbox) SetFieldBackgroundColor(color tcell.Color) *Checkbox {
+ c.fieldBackgroundColor = color
+ return c
+}
+
+// SetFieldTextColor sets the text color of the input area.
+func (c *Checkbox) SetFieldTextColor(color tcell.Color) *Checkbox {
+ c.fieldTextColor = color
+ return c
+}
+
+// SetFormAttributes sets attributes shared by all form items.
+func (c *Checkbox) SetFormAttributes(labelWidth int, labelColor, bgColor, fieldTextColor, fieldBgColor tcell.Color) FormItem {
+ c.labelWidth = labelWidth
+ c.labelColor = labelColor
+ c.backgroundColor = bgColor
+ c.fieldTextColor = fieldTextColor
+ c.fieldBackgroundColor = fieldBgColor
+ return c
+}
+
+// GetFieldWidth returns this primitive's field width.
+func (c *Checkbox) GetFieldWidth() int {
+ return 1
+}
+
+// SetChangedFunc sets a handler which is called when the checked state of this
+// checkbox was changed by the user. The handler function receives the new
+// state.
+func (c *Checkbox) SetChangedFunc(handler func(checked bool)) *Checkbox {
+ c.changed = handler
+ return c
+}
+
+// SetDoneFunc sets a handler which is called when the user is done entering
+// text. The callback function is provided with the key that was pressed, which
+// is one of the following:
+//
+// - KeyEscape: Abort text input.
+// - KeyTab: Move to the next field.
+// - KeyBacktab: Move to the previous field.
+func (c *Checkbox) SetDoneFunc(handler func(key tcell.Key)) *Checkbox {
+ c.done = handler
+ return c
+}
+
+// SetFinishedFunc sets a callback invoked when the user leaves this form item.
+func (c *Checkbox) SetFinishedFunc(handler func(key tcell.Key)) FormItem {
+ c.finished = handler
+ return c
+}
+
+// Draw draws this primitive onto the screen.
+func (c *Checkbox) Draw(screen tcell.Screen) {
+ c.Box.Draw(screen)
+
+ // Prepare
+ x, y, width, height := c.GetInnerRect()
+ rightLimit := x + width
+ if height < 1 || rightLimit <= x {
+ return
+ }
+
+ // Draw label.
+ if c.labelWidth > 0 {
+ labelWidth := c.labelWidth
+ if labelWidth > rightLimit-x {
+ labelWidth = rightLimit - x
+ }
+ Print(screen, c.label, x, y, labelWidth, AlignLeft, c.labelColor)
+ x += labelWidth
+ } else {
+ _, drawnWidth := Print(screen, c.label, x, y, rightLimit-x, AlignLeft, c.labelColor)
+ x += drawnWidth
+ }
+
+ // Draw checkbox.
+ fieldStyle := tcell.StyleDefault.Background(c.fieldBackgroundColor).Foreground(c.fieldTextColor)
+ if c.focus.HasFocus() {
+ fieldStyle = fieldStyle.Background(c.fieldTextColor).Foreground(c.fieldBackgroundColor)
+ }
+ checkedRune := 'X'
+ if !c.checked {
+ checkedRune = ' '
+ }
+ screen.SetContent(x, y, checkedRune, nil, fieldStyle)
+}
+
+// InputHandler returns the handler for this primitive.
+func (c *Checkbox) InputHandler() func(event *tcell.EventKey, setFocus func(p Primitive)) {
+ return c.WrapInputHandler(func(event *tcell.EventKey, setFocus func(p Primitive)) {
+ // Process key event.
+ switch key := event.Key(); key {
+ case tcell.KeyRune, tcell.KeyEnter: // Check.
+ if key == tcell.KeyRune && event.Rune() != ' ' {
+ break
+ }
+ c.checked = !c.checked
+ if c.changed != nil {
+ c.changed(c.checked)
+ }
+ case tcell.KeyTab, tcell.KeyBacktab, tcell.KeyEscape: // We're done.
+ if c.done != nil {
+ c.done(key)
+ }
+ if c.finished != nil {
+ c.finished(key)
+ }
+ }
+ })
+}
diff --git a/vendor/github.com/rivo/tview/doc.go b/vendor/github.com/rivo/tview/doc.go
new file mode 100644
index 00000000..211185f3
--- /dev/null
+++ b/vendor/github.com/rivo/tview/doc.go
@@ -0,0 +1,151 @@
+/*
+Package tview implements rich widgets for terminal based user interfaces. The
+widgets provided with this package are useful for data exploration and data
+entry.
+
+Widgets
+
+The package implements the following widgets:
+
+ - TextView: Scrollable windows that display multi-colored text. Text may also
+ be highlighted.
+ - Table: Scrollable display of tabular data. Table cells, rows, or columns may
+ also be highlighted.
+ - List: A navigable text list with optional keyboard shortcuts.
+ - InputField: One-line input fields to enter text.
+ - DropDown: Drop-down selection fields.
+ - Checkbox: Selectable checkbox for boolean values.
+ - Button: Buttons which get activated when the user selects them.
+ - Form: Forms composed of input fields, drop down selections, checkboxes, and
+ buttons.
+ - Modal: A centered window with a text message and one or more buttons.
+ - Flex: A Flexbox based layout manager.
+ - Pages: A page based layout manager.
+
+The package also provides Application which is used to poll the event queue and
+draw widgets on screen.
+
+Hello World
+
+The following is a very basic example showing a box with the title "Hello,
+world!":
+
+ package main
+
+ import (
+ "github.com/rivo/tview"
+ )
+
+ func main() {
+ box := tview.NewBox().SetBorder(true).SetTitle("Hello, world!")
+ if err := tview.NewApplication().SetRoot(box, true).Run(); err != nil {
+ panic(err)
+ }
+ }
+
+First, we create a box primitive with a border and a title. Then we create an
+application, set the box as its root primitive, and run the event loop. The
+application exits when the application's Stop() function is called or when
+Ctrl-C is pressed.
+
+If we have a primitive which consumes key presses, we call the application's
+SetFocus() function to redirect all key presses to that primitive. Most
+primitives then offer ways to install handlers that allow you to react to any
+actions performed on them.
+
+More Demos
+
+You will find more demos in the "demos" subdirectory. It also contains a
+presentation (written using tview) which gives an overview of the different
+widgets and how they can be used.
+
+Colors
+
+Throughout this package, colors are specified using the tcell.Color type.
+Functions such as tcell.GetColor(), tcell.NewHexColor(), and tcell.NewRGBColor()
+can be used to create colors from W3C color names or RGB values.
+
+Almost all strings which are displayed can contain color tags. Color tags are
+W3C color names or six hexadecimal digits following a hash tag, wrapped in
+square brackets. Examples:
+
+ This is a [red]warning[white]!
+ The sky is [#8080ff]blue[#ffffff].
+
+A color tag changes the color of the characters following that color tag. This
+applies to almost everything from box titles, list text, form item labels, to
+table cells. In a TextView, this functionality has to be switched on explicitly.
+See the TextView documentation for more information.
+
+Color tags may contain not just the foreground (text) color but also the
+background color and additional flags. In fact, the full definition of a color
+tag is as follows:
+
+ [