1 files changed, 0 insertions, 187 deletions
diff --git a/vendor/golang.org/x/text/runes/cond.go b/vendor/golang.org/x/text/runes/cond.go
deleted file mode 100644
index df7aa02d..00000000
--- a/vendor/golang.org/x/text/runes/cond.go
+++ /dev/null
@@ -1,187 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package runes
-
-import (
-	"unicode/utf8"
-
-	"golang.org/x/text/transform"
-)
-
-// Note: below we pass invalid UTF-8 to the tIn and tNotIn transformers as is.
-// This is done for various reasons:
-// - To retain the semantics of the Nop transformer: if input is passed to a Nop
-//   one would expect it to be unchanged.
-// - It would be very expensive to pass a converted RuneError to a transformer:
-//   a transformer might need more source bytes after RuneError, meaning that
-//   the only way to pass it safely is to create a new buffer and manage the
-//   intermingling of RuneErrors and normal input.
-// - Many transformers leave ill-formed UTF-8 as is, so this is not
-//   inconsistent. Generally ill-formed UTF-8 is only replaced if it is a
-//   logical consequence of the operation (as for Map) or if it otherwise would
-//   pose security concerns (as for Remove).
-// - An alternative would be to return an error on ill-formed UTF-8, but this
-//   would be inconsistent with other operations.
-
-// If returns a transformer that applies tIn to consecutive runes for which
-// s.Contains(r) and tNotIn to consecutive runes for which !s.Contains(r). Reset
-// is called on tIn and tNotIn at the start of each run. A Nop transformer will
-// substitute a nil value passed to tIn or tNotIn. Invalid UTF-8 is translated
-// to RuneError to determine which transformer to apply, but is passed as is to
-// the respective transformer.
-func If(s Set, tIn, tNotIn transform.Transformer) Transformer {
-	if tIn == nil && tNotIn == nil {
-		return Transformer{transform.Nop}
-	}
-	if tIn == nil {
-		tIn = transform.Nop
-	}
-	if tNotIn == nil {
-		tNotIn = transform.Nop
-	}
-	sIn, ok := tIn.(transform.SpanningTransformer)
-	if !ok {
-		sIn = dummySpan{tIn}
-	}
-	sNotIn, ok := tNotIn.(transform.SpanningTransformer)
-	if !ok {
-		sNotIn = dummySpan{tNotIn}
-	}
-
-	a := &cond{
-		tIn:    sIn,
-		tNotIn: sNotIn,
-		f:      s.Contains,
-	}
-	a.Reset()
-	return Transformer{a}
-}
-
-type dummySpan struct{ transform.Transformer }
-
-func (d dummySpan) Span(src []byte, atEOF bool) (n int, err error) {
-	return 0, transform.ErrEndOfSpan
-}
-
-type cond struct {
-	tIn, tNotIn transform.SpanningTransformer
-	f           func(rune) bool
-	check       func(rune) bool               // current check to perform
-	t           transform.SpanningTransformer // current transformer to use
-}
-
-// Reset implements transform.Transformer.
-func (t *cond) Reset() {
-	t.check = t.is
-	t.t = t.tIn
-	t.t.Reset() // notIn will be reset on first usage.
-}
-
-func (t *cond) is(r rune) bool {
-	if t.f(r) {
-		return true
-	}
-	t.check = t.isNot
-	t.t = t.tNotIn
-	t.tNotIn.Reset()
-	return false
-}
-
-func (t *cond) isNot(r rune) bool {
-	if !t.f(r) {
-		return true
-	}
-	t.check = t.is
-	t.t = t.tIn
-	t.tIn.Reset()
-	return false
-}
-
-// This implementation of Span doesn't help all too much, but it needs to be
-// there to satisfy this package's Transformer interface.
-// TODO: there are certainly room for improvements, though. For example, if
-// t.t == transform.Nop (which will a common occurrence) it will save a bundle
-// to special-case that loop.
-func (t *cond) Span(src []byte, atEOF bool) (n int, err error) {
-	p := 0
-	for n < len(src) && err == nil {
-		// Don't process too much at a time as the Spanner that will be
-		// called on this block may terminate early.
-		const maxChunk = 4096
-		max := len(src)
-		if v := n + maxChunk; v < max {
-			max = v
-		}
-		atEnd := false
-		size := 0
-		current := t.t
-		for ; p < max; p += size {
-			r := rune(src[p])
-			if r < utf8.RuneSelf {
-				size = 1
-			} else if r, size = utf8.DecodeRune(src[p:]); size == 1 {
-				if !atEOF && !utf8.FullRune(src[p:]) {
-					err = transform.ErrShortSrc
-					break
-				}
-			}
-			if !t.check(r) {
-				// The next rune will be the start of a new run.
-				atEnd = true
-				break
-			}
-		}
-		n2, err2 := current.Span(src[n:p], atEnd || (atEOF && p == len(src)))
-		n += n2
-		if err2 != nil {
-			return n, err2
-		}
-		// At this point either err != nil or t.check will pass for the rune at p.
-		p = n + size
-	}
-	return n, err
-}
-
-func (t *cond) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
-	p := 0
-	for nSrc < len(src) && err == nil {
-		// Don't process too much at a time, as the work might be wasted if the
-		// destination buffer isn't large enough to hold the result or a
-		// transform returns an error early.
-		const maxChunk = 4096
-		max := len(src)
-		if n := nSrc + maxChunk; n < len(src) {
-			max = n
-		}
-		atEnd := false
-		size := 0
-		current := t.t
-		for ; p < max; p += size {
-			r := rune(src[p])
-			if r < utf8.RuneSelf {
-				size = 1
-			} else if r, size = utf8.DecodeRune(src[p:]); size == 1 {
-				if !atEOF && !utf8.FullRune(src[p:]) {
-					err = transform.ErrShortSrc
-					break
-				}
-			}
-			if !t.check(r) {
-				// The next rune will be the start of a new run.
-				atEnd = true
-				break
-			}
-		}
-		nDst2, nSrc2, err2 := current.Transform(dst[nDst:], src[nSrc:p], atEnd || (atEOF && p == len(src)))
-		nDst += nDst2
-		nSrc += nSrc2
-		if err2 != nil {
-			return nDst, nSrc, err2
-		}
-		// At this point either err != nil or t.check will pass for the rune at p.
-		p = nSrc + size
-	}
-	return nDst, nSrc, err
-}