cli/vendor/github.com/mattn/go-runewidth/runewidth.go

package runewidth

import (
	"os"
	"sort"
	"strings"
	"sync"
	"sync/atomic"
	"unicode/utf8"

	"github.com/clipperhouse/uax29/v2/graphemes"
)

//go:generate go run script/generate.go

var (
	// EastAsianWidth will be set true if the current locale is CJK
	EastAsianWidth bool

	// StrictEmojiNeutral should be set false if handle broken fonts
	StrictEmojiNeutral bool = true

	// ZeroWidthJoiner is flag to set to use UTR#51 ZWJ.
	//
	// Deprecated: ZWJ sequences are always handled through Unicode
	// grapheme cluster segmentation now, so this flag has no effect.
	// It is kept only for compatibility with code written against
	// v0.0.9 and earlier.
	ZeroWidthJoiner bool

	// DefaultCondition is a condition in current locale
	DefaultCondition = &Condition{
		EastAsianWidth:     false,
		StrictEmojiNeutral: true,
	}
)

var (
	zerowidth      table // combining + nonprint merged for faster zero-width lookup
	widewidth      table // ambiguous + doublewidth merged for EA path
	eastAsianWidth widthTable
	tablesOnce     sync.Once

	// strictWidthLUT is mostly built lazily on the first width lookup so
	// that importing the package costs neither the build time nor the 2 MB
	// of resident memory; see issue #104. Only the entries below
	// strictWidthLUTLimit are valid: init fills the first 0x300 entries of
	// both planes, and the lazy build fills the rest — never rewriting the
	// low region, so readers of it cannot race with the build. The limit
	// is loaded with acquire semantics, which makes the non-atomic reads
	// of the high region safe once it reports 0x110000. Keeping the whole
	// check down to one compare-and-branch matters: RuneWidth is only a
	// dozen instructions long.
	strictWidthLUT      [2][0x110000]byte
	strictWidthLUTLimit atomic.Int32
	strictWidthLUTOnce  sync.Once

	// joinerBits is the joiner table as a bitmap over
	// [joinerBase, 0x10000), the range where the per-rune test has to be
	// cheap for the fast paths in StringWidth and Wrap to pay off. It is
	// 7.6 KB and init fills it in a few microseconds. Runes above it stay
	// on the interval search: they are rare in the text these fast paths
	// are for, and the emoji that are common there leave the fast path at
	// their first joiner anyway.
	joinerBits [(0x10000 - joinerBase) / 8]byte
)

// joinerBase is the lowest rune in the joiner table. CR is the only rune
// below it that can form a multi-rune cluster, by pairing with LF.
const joinerBase = 0x300

func init() {
	initStrictWidthLUTLow()
	fillJoinerBits()
	strictWidthLUTLimit.Store(0x300)
	handleEnv()
}

// initStrictWidthLUTLow paints the first 0x300 entries of strictWidthLUT
// from the static interval tables. The result must stay identical to
// runeWidthNoLUT for runes below 0x300, which TestStrictWidthLUT verifies.
func initStrictWidthLUTLow() {
	for i := 0; i < 0x300; i++ {
		r := rune(i)
		w := byte(1)
		if r < 0x20 || (r >= 0x7F && r <= 0x9F) || r == 0xAD { // nonprint
			w = 0
		}
		strictWidthLUT[0][i] = w
	}

	ea := strictWidthLUT[1][:0x300]
	fillBytes(ea, 1)
	paint := func(t table, w byte) {
		for _, iv := range t {
			if iv.first >= 0x300 {
				break
			}
			last := iv.last
			if last > 0x2FF {
				last = 0x2FF
			}
			fillBytes(ea[iv.first:last+1], w)
		}
	}
	paint(ambiguous, 2)
	paint(doublewidth, 2)
	// zero-width wins over wide on overlap, so paint it last.
	paint(combining, 0)
	paint(nonprint, 0)
}

// initTables builds the merged lookup tables. It runs lazily through
// tablesOnce so that merely importing the package stays cheap; see issue
// #104.
func initTables() {
	zerowidth = mergeIntervals(combining, nonprint)
	widewidth = mergeIntervals(ambiguous, doublewidth)
	eastAsianWidth = makeWidthTable(zerowidth, widewidth)
}

func mergeIntervals(t1, t2 table) table {
	merged := make(table, 0, len(t1)+len(t2))
	i, j := 0, 0
	for i < len(t1) && j < len(t2) {
		if t1[i].first <= t2[j].first {
			merged = append(merged, t1[i])
			i++
		} else {
			merged = append(merged, t2[j])
			j++
		}
	}
	merged = append(merged, t1[i:]...)
	merged = append(merged, t2[j:]...)
	if len(merged) == 0 {
		return merged
	}
	result := merged[:1]
	for _, iv := range merged[1:] {
		last := &result[len(result)-1]
		if iv.first <= last.last+1 {
			if iv.last > last.last {
				last.last = iv.last
			}
		} else {
			result = append(result, iv)
		}
	}
	return result
}

func handleEnv() {
	env := os.Getenv("RUNEWIDTH_EASTASIAN")
	if env == "" {
		EastAsianWidth = IsEastAsian()
	} else {
		EastAsianWidth = env == "1"
	}
	// update DefaultCondition
	if DefaultCondition.EastAsianWidth != EastAsianWidth {
		DefaultCondition.EastAsianWidth = EastAsianWidth
		if len(DefaultCondition.combinedLut) > 0 {
			CreateLUT()
		}
	}
}

type interval struct {
	first rune
	last  rune
}

type table []interval

type widthInterval struct {
	first rune
	last  rune
	width byte
}

type widthTable []widthInterval

func inTable(r rune, t table) bool {
	if r < t[0].first {
		return false
	}
	if r > t[len(t)-1].last {
		return false
	}

	bot := 0
	top := len(t) - 1
	for top >= bot {
		mid := (bot + top) >> 1

		switch {
		case t[mid].last < r:
			bot = mid + 1
		case t[mid].first > r:
			top = mid - 1
		default:
			return true
		}
	}

	return false
}

func makeWidthTable(zero, two table) widthTable {
	wt := make(widthTable, 0, len(zero)+len(two))
	zi := 0
	for _, iv := range two {
		start := iv.first
		for zi < len(zero) && zero[zi].last < start {
			zi++
		}
		for i := zi; i < len(zero) && zero[i].first <= iv.last; i++ {
			if start < zero[i].first {
				wt = append(wt, widthInterval{start, zero[i].first - 1, 2})
			}
			if start <= zero[i].last {
				start = zero[i].last + 1
			}
			if start > iv.last {
				break
			}
		}
		if start <= iv.last {
			wt = append(wt, widthInterval{start, iv.last, 2})
		}
	}
	for _, iv := range zero {
		wt = append(wt, widthInterval{iv.first, iv.last, 0})
	}
	sort.Slice(wt, func(i, j int) bool {
		return wt[i].first < wt[j].first
	})
	return wt
}

func inWidthTable(r rune, t widthTable) (int, bool) {
	if r < t[0].first {
		return 0, false
	}
	if r > t[len(t)-1].last {
		return 0, false
	}

	bot := 0
	top := len(t) - 1
	for top >= bot {
		mid := (bot + top) >> 1

		switch {
		case t[mid].last < r:
			bot = mid + 1
		case t[mid].first > r:
			top = mid - 1
		default:
			return int(t[mid].width), true
		}
	}

	return 0, false
}

func runeWidthNoLUT(r rune, eastAsian, strictEmojiNeutral bool) int {
	tablesOnce.Do(initTables)
	if !eastAsian {
		if r < 0x20 {
			return 0
		}
		if (r >= 0x7F && r <= 0x9F) || r == 0xAD { // nonprint
			return 0
		}
		if r < 0x300 {
			return 1
		}
		switch {
		case inTable(r, zerowidth):
			return 0
		case inTable(r, doublewidth):
			return 2
		default:
			return 1
		}
	}

	if r < 0x300 {
		return int(strictWidthLUT[1][r])
	}
	if w, ok := inWidthTable(r, eastAsianWidth); ok {
		return w
	}
	if !strictEmojiNeutral && inTable(r, emoji) {
		return 2
	}
	return 1
}

// fillBytes sets every byte of b to v. It doubles the copied region on each
// iteration so large slices are filled at memcpy speed instead of one byte
// per loop iteration.
func fillBytes(b []byte, v byte) {
	if len(b) == 0 {
		return
	}
	b[0] = v
	for i := 1; i < len(b); i *= 2 {
		copy(b[i:], b[:i])
	}
}

// buildStrictWidthLUT builds the strict-width lookup table above 0x300
// exactly once. It paints whole intervals instead of computing every rune
// through the binary searches in runeWidthNoLUT. It must not write below
// 0x300: that region was filled by init and may be read concurrently. The
// result must stay identical to runeWidthNoLUT(r, eastAsian, true), which
// TestStrictWidthLUT verifies.
func buildStrictWidthLUT() {
	strictWidthLUTOnce.Do(func() {
		tablesOnce.Do(initTables)

		// paintHigh fills lut with w over each interval, clipped to 0x300+.
		paintHigh := func(lut []byte, first, last rune, w byte) {
			if first < 0x300 {
				if last < 0x300 {
					return
				}
				first = 0x300
			}
			fillBytes(lut[first:last+1], w)
		}

		// EastAsianWidth=false, StrictEmojiNeutral=true
		lut := strictWidthLUT[0][:]
		fillBytes(lut[0x300:], 1)
		for _, iv := range doublewidth {
			paintHigh(lut, iv.first, iv.last, 2)
		}
		// zerowidth is checked before doublewidth, so it wins on overlap.
		for _, iv := range zerowidth {
			paintHigh(lut, iv.first, iv.last, 0)
		}

		// EastAsianWidth=true, StrictEmojiNeutral=true
		lut = strictWidthLUT[1][:]
		fillBytes(lut[0x300:], 1)
		for _, iv := range eastAsianWidth {
			paintHigh(lut, iv.first, iv.last, iv.width)
		}

		strictWidthLUTLimit.Store(0x110000)
	})
}

var private = table{
	{0x00E000, 0x00F8FF}, {0x0F0000, 0x0FFFFD}, {0x100000, 0x10FFFD},
}

var nonprint = table{
	{0x0000, 0x001F}, {0x007F, 0x009F}, {0x00AD, 0x00AD},
	{0x061C, 0x061C}, {0x070F, 0x070F}, {0x180B, 0x180E},
	{0x200B, 0x200F}, {0x2028, 0x202E}, {0x2060, 0x2064},
	{0x2066, 0x206F}, {0xD800, 0xDFFF}, {0xFEFF, 0xFEFF},
	{0xFFF9, 0xFFFB}, {0xFFFE, 0xFFFF}, {0x13430, 0x1343F},
	{0x1BCA0, 0x1BCA3}, {0x1D173, 0x1D17A}, {0xE0001, 0xE0001},
}

// Condition have flag EastAsianWidth whether the current locale is CJK or not.
type Condition struct {
	combinedLut []byte
	// The flags combinedLut was built from, so that CreateLUT can tell a
	// table that is still current from one that has to be rebuilt.
	lutEastAsianWidth     bool
	lutStrictEmojiNeutral bool

	EastAsianWidth     bool
	StrictEmojiNeutral bool

	// Deprecated: ZWJ sequences are always handled through Unicode
	// grapheme cluster segmentation now, so this flag has no effect.
	// It is kept only for compatibility with code written against
	// v0.0.9 and earlier.
	ZeroWidthJoiner bool
}

// NewCondition return new instance of Condition which is current locale.
func NewCondition() *Condition {
	return &Condition{
		EastAsianWidth:     EastAsianWidth,
		StrictEmojiNeutral: StrictEmojiNeutral,
		ZeroWidthJoiner:    ZeroWidthJoiner,
	}
}

// RuneWidth returns the number of cells in r.
// See http://www.unicode.org/reports/tr11/
func (c *Condition) RuneWidth(r rune) int {
	// This one compare doubles as the range check and the lazy-LUT check:
	// out-of-range runes and runes above the built portion of
	// strictWidthLUT both take the slow path. Once the LUT is fully built
	// the limit is 0x110000 and only invalid runes go slow.
	if uint32(r) >= uint32(strictWidthLUTLimit.Load()) {
		return c.runeWidthSlow(r)
	}
	if len(c.combinedLut) > 0 {
		return int(c.combinedLut[r>>1]>>(uint(r&1)*4)) & 3
	}
	if c.StrictEmojiNeutral {
		if c.EastAsianWidth {
			return int(strictWidthLUT[1][r])
		}
		return int(strictWidthLUT[0][r])
	}
	return runeWidthNoLUT(r, c.EastAsianWidth, c.StrictEmojiNeutral)
}

func (c *Condition) runeWidthSlow(r rune) int {
	if r < 0 || r > 0x10FFFF {
		return 0
	}
	buildStrictWidthLUT()
	if len(c.combinedLut) > 0 {
		return int(c.combinedLut[r>>1]>>(uint(r&1)*4)) & 3
	}
	if c.StrictEmojiNeutral {
		if c.EastAsianWidth {
			return int(strictWidthLUT[1][r])
		}
		return int(strictWidthLUT[0][r])
	}
	return runeWidthNoLUT(r, c.EastAsianWidth, c.StrictEmojiNeutral)
}

// CreateLUT will create an in-memory lookup table of 557056 bytes for faster operation.
// This should not be called concurrently with other operations on c.
// If options in c is changed, CreateLUT should be called again.
func (c *Condition) CreateLUT() {
	const max = 0x110000
	lut := c.combinedLut
	if len(c.combinedLut) != 0 {
		if c.lutEastAsianWidth == c.EastAsianWidth && c.lutStrictEmojiNeutral == c.StrictEmojiNeutral {
			// The table still matches the flags, so rebuilding it
			// would produce the same bytes.
			return
		}
		// Remove so we don't use it.
		c.combinedLut = nil
	} else {
		lut = make([]byte, max/2)
	}
	for i := range lut {
		i32 := int32(i * 2)
		x0 := c.RuneWidth(i32)
		x1 := c.RuneWidth(i32 + 1)
		lut[i] = uint8(x0) | uint8(x1)<<4
	}
	c.combinedLut = lut
	c.lutEastAsianWidth = c.EastAsianWidth
	c.lutStrictEmojiNeutral = c.StrictEmojiNeutral
}

// isASCII reports whether s has no byte above 0x7F, in which case every
// grapheme cluster in s is a single byte apart from CRLF.
func isASCII(s string) bool {
	for i := 0; i < len(s); i++ {
		if s[i] >= 0x80 {
			return false
		}
	}
	return true
}

// fillJoinerBits paints joinerBits from the joiner table.
func fillJoinerBits() {
	for _, iv := range joiner {
		if iv.first >= 0x10000 {
			break // the table is sorted, the rest is astral
		}
		lo, hi := int(iv.first)-joinerBase, int(iv.last)-joinerBase
		if hi >= len(joinerBits)*8 {
			hi = len(joinerBits)*8 - 1
		}
		for lo <= hi {
			if lo&7 == 0 && lo+7 <= hi {
				joinerBits[lo>>3] = 0xFF
				lo += 8
				continue
			}
			joinerBits[lo>>3] |= 1 << uint(lo&7)
			lo++
		}
	}
	// A byte that is not valid UTF-8 decodes to U+FFFD, and the segmenter
	// can gather a run of such bytes into one cluster, which a rune loop
	// has no way to see. Marking U+FFFD keeps those strings on the
	// segmenter, and the only string it holds back needlessly is one that
	// really contains U+FFFD.
	i := int(utf8.RuneError) - joinerBase
	joinerBits[i>>3] |= 1 << uint(i&7)
}

// isJoiner reports whether r can join with a neighbour into a multi-rune
// grapheme cluster. A string of runes for which it reports false has one
// rune per cluster, so measuring it needs no grapheme segmentation.
func isJoiner(r rune) bool {
	if r < joinerBase {
		return r == '\r'
	}
	if r < 0x10000 {
		i := r - joinerBase
		return joinerBits[i>>3]&(1<<(uint(i)&7)) != 0
	}
	return inTable(r, joiner)
}

// clusterText returns s to segment in place of s. When s ends in a lead
// byte short of the bytes it promises, the segmenter gives up there and
// glues everything from it onto the cluster before, where the two-cell cap
// hides it, although the same bytes followed by anything else form
// clusters of their own. Such a string gets NULs after it, enough for any
// lead byte to be decoded; as controls they are clusters of their own, and
// the loops over the clusters stop at len(s) before reaching them.
func clusterText(s string) string {
	if endsShort(s) {
		return s + "\x00\x00\x00"
	}
	return s
}

// endsShort reports whether one of the last three bytes of s is a lead
// byte that needs more bytes than are left, which is where the segmenter
// stops decoding. It only looks at the length the lead byte announces, not
// at whether the bytes after it could continue it, as the segmenter does.
func endsShort(s string) bool {
	for i := max(len(s)-3, 0); i < len(s); i++ {
		b, left := s[i], len(s)-i
		if b >= 0xC2 && b < 0xE0 && left < 2 ||
			b >= 0xE0 && b < 0xF0 && left < 3 ||
			b >= 0xF0 && b < 0xF8 && left < 4 {
			return true
		}
	}
	return false
}

// graphemeWidth returns the width of a single grapheme cluster: the sum of
// the widths of its runes, with the part from the first rune that starts a
// single glyph (an emoji, a regional indicator, a Hangul jamo or syllable)
// capped at 2 cells. The cap keeps multi-rune sequences that render as one
// glyph (ZWJ emoji, skin tones, flags, Hangul jamo) from being counted
// wider than the two cells terminals give them. What comes before it, such
// as a Prepend rune, and a cluster with no such rune, like a letter with a
// skin tone modifier after it, are shown rune by rune and summed.
func (c *Condition) graphemeWidth(cluster string) int {
	if r, size := utf8.DecodeRuneInString(cluster); size == len(cluster) {
		return c.RuneWidth(r) // one rune, never over the cap
	}
	width, glyph := 0, -1
	for _, r := range cluster {
		w := c.RuneWidth(r)
		if glyph < 0 && r >= 0x1100 && startsGlyph(r) {
			glyph = 0
		}
		if glyph >= 0 {
			glyph += w
		} else {
			width += w
		}
	}
	return width + min(max(glyph, 0), 2)
}

// startsGlyph reports whether r begins a sequence that a terminal draws as
// a single glyph however many runes it has.
func startsGlyph(r rune) bool {
	switch {
	case 0x1100 <= r && r <= 0x11FF, // Hangul jamo
		0xA960 <= r && r <= 0xA97F,   // Hangul jamo extended-A
		0xAC00 <= r && r <= 0xD7FF,   // Hangul syllables, jamo extended-B
		0x1F1E6 <= r && r <= 0x1F1FF: // regional indicators
		return true
	case r < 0x203C, 0x3299 < r && r < 0x1F004:
		// Outside the emoji table: spares CJK text the search.
		return false
	}
	return inTable(r, emoji)
}

// StringWidth return width as you can see
func (c *Condition) StringWidth(s string) (width int) {
	if len(s) == 1 {
		b := s[0]
		if b < 0x20 || b == 0x7F {
			return 0
		}
		if b >= 0x80 {
			// Not UTF-8 on its own: measure it as the U+FFFD every other
			// path decodes it to, which is ambiguous width.
			return c.RuneWidth(utf8.RuneError)
		}
		return 1
	}
	if len(s) > 0 && len(s) <= utf8.UTFMax {
		r, size := utf8.DecodeRuneInString(s)
		if size == len(s) {
			return c.RuneWidth(r)
		}
	}
	// ASCII fast path: no grapheme clustering needed for pure ASCII
	for i := 0; i < len(s); i++ {
		b := s[i]
		if b >= 0x80 {
			goto graphemes
		}
		if b >= 0x20 && b != 0x7F {
			width++
		}
	}
	return

graphemes:
	// Runes first: until one of them can join a cluster, each cluster is a
	// single rune and segmenting the string would only find that out the
	// expensive way.
	if w, ok := c.runeWidthSum(s); ok {
		width = w
		return
	}
	width = 0
	g := graphemes.FromString(clusterText(s))
	for g.Next() && g.Start() < len(s) {
		width += c.graphemeWidth(g.Value())
	}
	return
}

// runeWidthSum adds up the widths of the runes in s, and reports false
// without a total once it meets a rune that can join a cluster, which is
// where per-rune widths stop being the whole story.
func (c *Condition) runeWidthSum(s string) (int, bool) {
	width := 0
	for _, r := range s {
		if isJoiner(r) {
			return 0, false
		}
		width += c.RuneWidth(r)
	}
	return width, true
}

// 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
	}
	w -= c.StringWidth(tail)
	if pos, ok := c.truncateRunes(s, w); ok {
		return s[:pos] + tail
	}
	var width int
	pos := len(s)
	g := graphemes.FromString(clusterText(s))
	for g.Next() && g.Start() < len(s) {
		chWidth := c.graphemeWidth(g.Value())
		if width+chWidth > w {
			pos = g.Start()
			break
		}
		width += chWidth
	}
	return s[:pos] + tail
}

// truncateRunes is the loop in Truncate with every rune taken for a whole
// cluster, which holds until a rune can join one. It reports false there
// and leaves the string to the segmenter.
func (c *Condition) truncateRunes(s string, w int) (int, bool) {
	width := 0
	for i, r := range s {
		if isJoiner(r) {
			return 0, false
		}
		cw := c.RuneWidth(r)
		if width+cw > w {
			return i, true
		}
		width += cw
	}
	return len(s), true
}

// endsCluster reports whether the byte at i, which follows a rune that
// cannot join a cluster, also starts one. Cutting there is only safe when
// the rune that follows does not reach back.
func endsCluster(s string, i int) bool {
	if i >= len(s) {
		return true
	}
	r, _ := utf8.DecodeRuneInString(s[i:])
	return !isJoiner(r)
}

// TruncateLeft cuts w cells from the beginning of the `s`.
func (c *Condition) TruncateLeft(s string, w int, prefix string) string {
	if c.StringWidth(s) <= w {
		return prefix
	}

	if pos, pad, ok := c.truncateLeftRunes(s, w); ok {
		return prefix + strings.Repeat(" ", pad) + s[pos:]
	}

	var width int
	pos := len(s)

	g := graphemes.FromString(clusterText(s))
	for g.Next() && g.Start() < len(s) {
		chWidth := c.graphemeWidth(g.Value())

		if width+chWidth > w {
			if width < w {
				pos = g.End()
				prefix += strings.Repeat(" ", width+chWidth-w)
			} else {
				pos = g.Start()
			}

			break
		}

		width += chWidth
	}

	return prefix + s[pos:]
}

// truncateLeftRunes is the loop in TruncateLeft with every rune taken for a
// whole cluster, returning the cut and the padding that replaces the cell
// the cut lands inside. It reports false at the first rune that can join a
// cluster.
func (c *Condition) truncateLeftRunes(s string, w int) (pos, pad int, ok bool) {
	width := 0
	for i, r := range s {
		if isJoiner(r) {
			return 0, 0, false
		}
		cw := c.RuneWidth(r)
		if width+cw > w {
			if width >= w {
				return i, 0, true
			}
			end := i + utf8.RuneLen(r)
			if !endsCluster(s, end) {
				return 0, 0, false
			}
			return end, width + cw - w, true
		}
		width += cw
	}
	return len(s), 0, true
}

// TruncatePrefix cuts the beginning of `s` so the result fits in w cells, with prefix prepended
func (c *Condition) TruncatePrefix(s string, w int, prefix string) string {
	if c.StringWidth(prefix) >= w {
		return prefix
	}

	sw := c.StringWidth(s)
	if sw <= w {
		return s
	}
	w -= c.StringWidth(prefix)
	if pos, ok := c.truncatePrefixRunes(s, sw, w); ok {
		return prefix + s[pos:]
	}
	var width int
	var pos int
	g := graphemes.FromString(clusterText(s))
	for g.Next() && g.Start() < len(s) {
		chWidth := c.graphemeWidth(g.Value())
		if sw-(width+chWidth) <= w {
			pos = g.End()
			break
		}
		width += chWidth
	}

	return prefix + s[pos:]
}

// truncatePrefixRunes is the loop in TruncatePrefix with every rune taken
// for a whole cluster, reporting false at the first rune that can join one.
func (c *Condition) truncatePrefixRunes(s string, sw, w int) (int, bool) {
	width := 0
	for i, r := range s {
		if isJoiner(r) {
			return 0, false
		}
		cw := c.RuneWidth(r)
		if sw-(width+cw) <= w {
			end := i + utf8.RuneLen(r)
			if !endsCluster(s, end) {
				return 0, false
			}
			return end, true
		}
		width += cw
	}
	return 0, true
}

// wrapRunes wraps s treating every rune as its own grapheme cluster, and
// reports false without a result once it meets a rune that can join one.
func (c *Condition) wrapRunes(s string, w int) (string, bool) {
	width := 0
	var out strings.Builder
	out.Grow(len(s) + len(s)/max(w, 1) + 1)
	for _, r := range s {
		if isJoiner(r) {
			return "", false
		}
		cw := c.RuneWidth(r)
		if r == '\n' {
			out.WriteRune(r)
			width = 0
			continue
		}
		if width+cw > w {
			out.WriteByte('\n')
			width = 0
		}
		out.WriteRune(r)
		width += cw
	}
	return out.String(), true
}

// Wrap return string wrapped with w cells
func (c *Condition) Wrap(s string, w int) string {
	// ASCII fast path: no grapheme clustering needed for pure ASCII
	if isASCII(s) {
		width := 0
		var out strings.Builder
		// max keeps the capacity hint from dividing by zero when w is 0;
		// a non-positive width breaks before every cluster, as it always
		// has.
		out.Grow(len(s) + len(s)/max(w, 1) + 1)
		for i := 0; i < len(s); i++ {
			b := s[i]
			if b == '\n' {
				out.WriteByte(b)
				width = 0
				continue
			}
			// CRLF is one cluster that ends the line, as on the
			// segmenter, so it is never broken before.
			if b == '\r' && i+1 < len(s) && s[i+1] == '\n' {
				out.WriteString("\r\n")
				width = 0
				i++
				continue
			}
			// Same rule as the StringWidth fast path: no ASCII byte is
			// wide or ambiguous, so the flags in c cannot change this.
			cw := 0
			if b >= 0x20 && b != 0x7F {
				cw = 1
			}
			if width+cw > w {
				out.WriteByte('\n')
				width = 0
			}
			out.WriteByte(b)
			width += cw
		}
		return out.String()
	}
	// Runes first, as in StringWidth. Reaching a rune that can join a
	// cluster throws the wrapped text away and starts over on the
	// segmenter, which is the uncommon case.
	if out, ok := c.wrapRunes(s, w); ok {
		return out
	}
	width := 0
	var out strings.Builder
	out.Grow(len(s) + len(s)/max(w, 1) + 1)
	g := graphemes.FromString(clusterText(s))
	for g.Next() && g.Start() < len(s) {
		cluster := g.Value()
		// LF and CRLF are each a single cluster
		if strings.HasSuffix(cluster, "\n") {
			out.WriteString(cluster)
			width = 0
			continue
		}
		cw := c.graphemeWidth(cluster)
		if width+cw > w {
			out.WriteByte('\n')
			width = 0
		}
		out.WriteString(cluster)
		width += cw
	}
	return out.String()
}

// 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 {
		return strings.Repeat(" ", count) + 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 {
		return s + strings.Repeat(" ", count)
	}
	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.
//
// NOTE: The Latin letters of U+0080..U+017F that Unicode gives ambiguous
// width (ü, é, ß, æ, ø and so on) are reported as ambiguous here, but
// RuneWidth measures them as one cell even with EastAsianWidth, since
// terminals draw them narrow in CJK locales too.
func IsAmbiguousWidth(r rune) bool {
	return inTable(r, private) || inTable(r, ambiguous) || inTable(r, ambiguousLatin)
}

// IsCombiningWidth returns whether is combining width or not.
func IsCombiningWidth(r rune) bool {
	return inTable(r, combining)
}

// 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)
}

// TruncateLeft cuts w cells from the beginning of the `s`.
func TruncateLeft(s string, w int, prefix string) string {
	return DefaultCondition.TruncateLeft(s, w, prefix)
}

// TruncatePrefix cuts the beginning of `s` so the result fits in w cells, with prefix prepended
func TruncatePrefix(s string, w int, prefix string) string {
	return DefaultCondition.TruncatePrefix(s, w, prefix)
}

// 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)
}

// CreateLUT will create an in-memory lookup table of 557055 bytes for faster operation.
// This should not be called concurrently with other operations.
// If flags in DefaultCondition are changed, CreateLUT should be called again;
// a call that finds the table already current is a no-op.
func CreateLUT() {
	DefaultCondition.CreateLUT()
}