package fzf

import (

"fmt"
"os"
"regexp"
"strconv"
"strings"
"unicode"

"github.com/junegunn/fzf/src/algo"
"github.com/junegunn/fzf/src/tui"

"github.com/mattn/go-runewidth"
"github.com/mattn/go-shellwords"

)

const usage = ‘usage: fzf [options]

Search
  -x, --extended        Extended-search mode
                        (enabled by default; +x or --no-extended to disable)
  -e, --exact           Enable Exact-match
  --algo=TYPE           Fuzzy matching algorithm: [v1|v2] (default: v2)
  -i                    Case-insensitive match (default: smart-case match)
  +i                    Case-sensitive match
  --literal             Do not normalize latin script letters before matching
  -n, --nth=N[,..]      Comma-separated list of field index expressions
                        for limiting search scope. Each can be a non-zero
                        integer or a range expression ([BEGIN]..[END]).
  --with-nth=N[,..]     Transform the presentation of each line using
                        field index expressions
  -d, --delimiter=STR   Field delimiter regex (default: AWK-style)
  +s, --no-sort         Do not sort the result
  --tac                 Reverse the order of the input
  --disabled            Do not perform search
  --tiebreak=CRI[,..]   Comma-separated list of sort criteria to apply
                        when the scores are tied [length|begin|end|index]
                        (default: length)

Interface
  -m, --multi[=MAX]     Enable multi-select with tab/shift-tab
  --no-mouse            Disable mouse
  --bind=KEYBINDS       Custom key bindings. Refer to the man page.
  --cycle               Enable cyclic scroll
  --keep-right          Keep the right end of the line visible on overflow
  --scroll-off=LINES    Number of screen lines to keep above or below when
                        scrolling to the top or to the bottom (default: 0)
  --no-hscroll          Disable horizontal scroll
  --hscroll-off=COLS    Number of screen columns to keep to the right of the
                        highlighted substring (default: 10)
  --filepath-word       Make word-wise movements respect path separators
  --jump-labels=CHARS   Label characters for jump and jump-accept

Layout
  --height=HEIGHT[%]    Display fzf window below the cursor with the given
                        height instead of using fullscreen
  --min-height=HEIGHT   Minimum height when --height is given in percent
                        (default: 10)
  --layout=LAYOUT       Choose layout: [default|reverse|reverse-list]
  --border[=STYLE]      Draw border around the finder
                        [rounded|sharp|horizontal|vertical|
                         top|bottom|left|right|none] (default: rounded)
  --margin=MARGIN       Screen margin (TRBL | TB,RL | T,RL,B | T,R,B,L)
  --padding=PADDING     Padding inside border (TRBL | TB,RL | T,RL,B | T,R,B,L)
  --info=STYLE          Finder info style [default|inline|hidden]
  --prompt=STR          Input prompt (default: '> ')
  --pointer=STR         Pointer to the current line (default: '>')
  --marker=STR          Multi-select marker (default: '>')
  --header=STR          String to print as header
  --header-lines=N      The first N lines of the input are treated as header
  --header-first        Print header before the prompt line

Display
  --ansi                Enable processing of ANSI color codes
  --tabstop=SPACES      Number of spaces for a tab character (default: 8)
  --color=COLSPEC       Base scheme (dark|light|16|bw) and/or custom colors
  --no-bold             Do not use bold text

History
  --history=FILE        History file
  --history-size=N      Maximum number of history entries (default: 1000)

Preview
  --preview=COMMAND     Command to preview highlighted line ({})
  --preview-window=OPT  Preview window layout (default: right:50%)
                        [up|down|left|right][,SIZE[%]]
                        [,[no]wrap][,[no]cycle][,[no]follow][,[no]hidden]
                        [,border-BORDER_OPT]
                        [,+SCROLL[OFFSETS][/DENOM]][,~HEADER_LINES]
                        [,default]

Scripting
  -q, --query=STR       Start the finder with the given query
  -1, --select-1        Automatically select the only match
  -0, --exit-0          Exit immediately when there's no match
  -f, --filter=STR      Filter mode. Do not start interactive finder.
  --print-query         Print query as the first line
  --expect=KEYS         Comma-separated list of keys to complete fzf
  --read0               Read input delimited by ASCII NUL characters
  --print0              Print output delimited by ASCII NUL characters
  --sync                Synchronous search for multi-staged filtering
  --version             Display version information and exit

Environment variables
  FZF_DEFAULT_COMMAND   Default command to use when input is tty
  FZF_DEFAULT_OPTS      Default options
                        (e.g. '--layout=reverse --inline-info')

// Case denotes case-sensitivity of search type Case int

// Case-sensitivities const (

CaseSmart Case = iota
CaseIgnore
CaseRespect

)

// Sort criteria type criterion int

const (

byScore criterion = iota
byLength
byBegin
byEnd

)

type sizeSpec struct {

size    float64
percent bool

}

func defaultMargin() [4]sizeSpec {

return [4]sizeSpec{}

}

type windowPosition int

const (

posUp windowPosition = iota
posDown
posLeft
posRight

)

type layoutType int

const (

layoutDefault layoutType = iota
layoutReverse
layoutReverseList

)

type infoStyle int

const (

infoDefault infoStyle = iota
infoInline
infoHidden

)

type previewOpts struct {

command     string
position    windowPosition
size        sizeSpec
scroll      string
hidden      bool
wrap        bool
cycle       bool
follow      bool
border      tui.BorderShape
headerLines int

}

// Options stores the values of command-line options type Options struct {

Fuzzy       bool
FuzzyAlgo   algo.Algo
Extended    bool
Phony       bool
Case        Case
Normalize   bool
Nth         []Range
WithNth     []Range
Delimiter   Delimiter
Sort        int
Tac         bool
Criteria    []criterion
Multi       int
Ansi        bool
Mouse       bool
Theme       *tui.ColorTheme
Black       bool
Bold        bool
Height      sizeSpec
MinHeight   int
Layout      layoutType
Cycle       bool
KeepRight   bool
Hscroll     bool
HscrollOff  int
ScrollOff   int
FileWord    bool
InfoStyle   infoStyle
JumpLabels  string
Prompt      string
Pointer     string
Marker      string
Query       string
Select1     bool
Exit0       bool
Filter      *string
ToggleSort  bool
Expect      map[tui.Event]string
Keymap      map[tui.Event][]action
Preview     previewOpts
PrintQuery  bool
ReadZero    bool
Printer     func(string)
PrintSep    string
Sync        bool
History     *History
Header      []string
HeaderLines int
HeaderFirst bool
Margin      [4]sizeSpec
Padding     [4]sizeSpec
BorderShape tui.BorderShape
Unicode     bool
Tabstop     int
ClearOnExit bool
Version     bool

}

func defaultPreviewOpts(command string) previewOpts {

return previewOpts{command, posRight, sizeSpec{50, true}, "", false, false, false, false, tui.BorderRounded, 0}

}

func defaultOptions() *Options {

return &Options{
        Fuzzy:       true,
        FuzzyAlgo:   algo.FuzzyMatchV2,
        Extended:    true,
        Phony:       false,
        Case:        CaseSmart,
        Normalize:   true,
        Nth:         make([]Range, 0),
        WithNth:     make([]Range, 0),
        Delimiter:   Delimiter{},
        Sort:        1000,
        Tac:         false,
        Criteria:    []criterion{byScore, byLength},
        Multi:       0,
        Ansi:        false,
        Mouse:       true,
        Theme:       tui.EmptyTheme(),
        Black:       false,
        Bold:        true,
        MinHeight:   10,
        Layout:      layoutDefault,
        Cycle:       false,
        KeepRight:   false,
        Hscroll:     true,
        HscrollOff:  10,
        ScrollOff:   0,
        FileWord:    false,
        InfoStyle:   infoDefault,
        JumpLabels:  defaultJumpLabels,
        Prompt:      "> ",
        Pointer:     ">",
        Marker:      ">",
        Query:       "",
        Select1:     false,
        Exit0:       false,
        Filter:      nil,
        ToggleSort:  false,
        Expect:      make(map[tui.Event]string),
        Keymap:      make(map[tui.Event][]action),
        Preview:     defaultPreviewOpts(""),
        PrintQuery:  false,
        ReadZero:    false,
        Printer:     func(str string) { fmt.Println(str) },
        PrintSep:    "\n",
        Sync:        false,
        History:     nil,
        Header:      make([]string, 0),
        HeaderLines: 0,
        HeaderFirst: false,
        Margin:      defaultMargin(),
        Padding:     defaultMargin(),
        Unicode:     true,
        Tabstop:     8,
        ClearOnExit: true,
        Version:     false}

}

func help(code int) {

os.Stdout.WriteString(usage)
os.Exit(code)

}

func errorExit(msg string) {

os.Stderr.WriteString(msg + "\n")
os.Exit(exitError)

}

func optString(arg string, prefixes …string) (bool, string) {

for _, prefix := range prefixes {
        if strings.HasPrefix(arg, prefix) {
                return true, arg[len(prefix):]
        }
}
return false, ""

}

func nextString(args []string, i *int, message string) string {

if len(args) > *i+1 {
        *i++
} else {
        errorExit(message)
}
return args[*i]

}

func optionalNextString(args []string, i *int) (bool, string) {

if len(args) > *i+1 && !strings.HasPrefix(args[*i+1], "-") && !strings.HasPrefix(args[*i+1], "+") {
        *i++
        return true, args[*i]
}
return false, ""

}

func atoi(str string) int {

num, err := strconv.Atoi(str)
if err != nil {
        errorExit("not a valid integer: " + str)
}
return num

}

func atof(str string) float64 {

num, err := strconv.ParseFloat(str, 64)
if err != nil {
        errorExit("not a valid number: " + str)
}
return num

}

func nextInt(args []string, i *int, message string) int {

if len(args) > *i+1 {
        *i++
} else {
        errorExit(message)
}
return atoi(args[*i])

}

func optionalNumeric(args []string, i *int, defaultValue int) int {

if len(args) > *i+1 {
        if strings.IndexAny(args[*i+1], "0123456789") == 0 {
                *i++
                return atoi(args[*i])
        }
}
return defaultValue

}

func splitNth(str string) []Range {

if match, _ := regexp.MatchString("^[0-9,-.]+$", str); !match {
        errorExit("invalid format: " + str)
}

tokens := strings.Split(str, ",")
ranges := make([]Range, len(tokens))
for idx, s := range tokens {
        r, ok := ParseRange(&s)
        if !ok {
                errorExit("invalid format: " + str)
        }
        ranges[idx] = r
}
return ranges

}

func delimiterRegexp(str string) Delimiter {

// Special handling of \t
str = strings.Replace(str, "\\t", "\t", -1)

// 1. Pattern does not contain any special character
if regexp.QuoteMeta(str) == str {
        return Delimiter{str: &str}
}

rx, e := regexp.Compile(str)
// 2. Pattern is not a valid regular expression
if e != nil {
        return Delimiter{str: &str}
}

// 3. Pattern as regular expression. Slow.
return Delimiter{regex: rx}

}

func isAlphabet(char uint8) bool {

return char >= 'a' && char <= 'z'

}

func isNumeric(char uint8) bool {

return char >= '0' && char <= '9'

}

func parseAlgo(str string) algo.Algo {

switch str {
case "v1":
        return algo.FuzzyMatchV1
case "v2":
        return algo.FuzzyMatchV2
default:
        errorExit("invalid algorithm (expected: v1 or v2)")
}
return algo.FuzzyMatchV2

}

func parseBorder(str string, optional bool) tui.BorderShape {

switch str {
case "rounded":
        return tui.BorderRounded
case "sharp":
        return tui.BorderSharp
case "horizontal":
        return tui.BorderHorizontal
case "vertical":
        return tui.BorderVertical
case "top":
        return tui.BorderTop
case "bottom":
        return tui.BorderBottom
case "left":
        return tui.BorderLeft
case "right":
        return tui.BorderRight
case "none":
        return tui.BorderNone
default:
        if optional && str == "" {
                return tui.BorderRounded
        }
        errorExit("invalid border style (expected: rounded|sharp|horizontal|vertical|top|bottom|left|right|none)")
}
return tui.BorderNone

}

func parseKeyChords(str string, message string) mapstring {

if len(str) == 0 {
        errorExit(message)
}

str = regexp.MustCompile("(?i)(alt-),").ReplaceAllString(str, "$1"+string([]rune{escapedComma}))
tokens := strings.Split(str, ",")
if str == "," || strings.HasPrefix(str, ",,") || strings.HasSuffix(str, ",,") || strings.Contains(str, ",,,") {
        tokens = append(tokens, ",")
}

chords := make(map[tui.Event]string)
for _, key := range tokens {
        if len(key) == 0 {
                continue // ignore
        }
        key = strings.ReplaceAll(key, string([]rune{escapedComma}), ",")
        lkey := strings.ToLower(key)
        add := func(e tui.EventType) {
                chords[e.AsEvent()] = key
        }
        switch lkey {
        case "up":
                add(tui.Up)
        case "down":
                add(tui.Down)
        case "left":
                add(tui.Left)
        case "right":
                add(tui.Right)
        case "enter", "return":
                add(tui.CtrlM)
        case "space":
                chords[tui.Key(' ')] = key
        case "bspace", "bs":
                add(tui.BSpace)
        case "ctrl-space":
                add(tui.CtrlSpace)
        case "ctrl-^", "ctrl-6":
                add(tui.CtrlCaret)
        case "ctrl-/", "ctrl-_":
                add(tui.CtrlSlash)
        case "ctrl-\\":
                add(tui.CtrlBackSlash)
        case "ctrl-]":
                add(tui.CtrlRightBracket)
        case "change":
                add(tui.Change)
        case "backward-eof":
                add(tui.BackwardEOF)
        case "alt-enter", "alt-return":
                chords[tui.CtrlAltKey('m')] = key
        case "alt-space":
                chords[tui.AltKey(' ')] = key
        case "alt-bs", "alt-bspace":
                add(tui.AltBS)
        case "alt-up":
                add(tui.AltUp)
        case "alt-down":
                add(tui.AltDown)
        case "alt-left":
                add(tui.AltLeft)
        case "alt-right":
                add(tui.AltRight)
        case "tab":
                add(tui.Tab)
        case "btab", "shift-tab":
                add(tui.BTab)
        case "esc":
                add(tui.ESC)
        case "del":
                add(tui.Del)
        case "home":
                add(tui.Home)
        case "end":
                add(tui.End)
        case "insert":
                add(tui.Insert)
        case "pgup", "page-up":
                add(tui.PgUp)
        case "pgdn", "page-down":
                add(tui.PgDn)
        case "alt-shift-up", "shift-alt-up":
                add(tui.AltSUp)
        case "alt-shift-down", "shift-alt-down":
                add(tui.AltSDown)
        case "alt-shift-left", "shift-alt-left":
                add(tui.AltSLeft)
        case "alt-shift-right", "shift-alt-right":
                add(tui.AltSRight)
        case "shift-up":
                add(tui.SUp)
        case "shift-down":
                add(tui.SDown)
        case "shift-left":
                add(tui.SLeft)
        case "shift-right":
                add(tui.SRight)
        case "left-click":
                add(tui.LeftClick)
        case "right-click":
                add(tui.RightClick)
        case "double-click":
                add(tui.DoubleClick)
        case "f10":
                add(tui.F10)
        case "f11":
                add(tui.F11)
        case "f12":
                add(tui.F12)
        default:
                runes := []rune(key)
                if len(key) == 10 && strings.HasPrefix(lkey, "ctrl-alt-") && isAlphabet(lkey[9]) {
                        chords[tui.CtrlAltKey(rune(key[9]))] = key
                } else if len(key) == 6 && strings.HasPrefix(lkey, "ctrl-") && isAlphabet(lkey[5]) {
                        add(tui.EventType(tui.CtrlA.Int() + int(lkey[5]) - 'a'))
                } else if len(runes) == 5 && strings.HasPrefix(lkey, "alt-") {
                        r := runes[4]
                        switch r {
                        case escapedColon:
                                r = ':'
                        case escapedComma:
                                r = ','
                        case escapedPlus:
                                r = '+'
                        }
                        chords[tui.AltKey(r)] = key
                } else if len(key) == 2 && strings.HasPrefix(lkey, "f") && key[1] >= '1' && key[1] <= '9' {
                        add(tui.EventType(tui.F1.Int() + int(key[1]) - '1'))
                } else if len(runes) == 1 {
                        chords[tui.Key(runes[0])] = key
                } else {
                        errorExit("unsupported key: " + key)
                }
        }
}
return chords

}

func parseTiebreak(str string) []criterion {

criteria := []criterion{byScore}
hasIndex := false
hasLength := false
hasBegin := false
hasEnd := false
check := func(notExpected *bool, name string) {
        if *notExpected {
                errorExit("duplicate sort criteria: " + name)
        }
        if hasIndex {
                errorExit("index should be the last criterion")
        }
        *notExpected = true
}
for _, str := range strings.Split(strings.ToLower(str), ",") {
        switch str {
        case "index":
                check(&hasIndex, "index")
        case "length":
                check(&hasLength, "length")
                criteria = append(criteria, byLength)
        case "begin":
                check(&hasBegin, "begin")
                criteria = append(criteria, byBegin)
        case "end":
                check(&hasEnd, "end")
                criteria = append(criteria, byEnd)
        default:
                errorExit("invalid sort criterion: " + str)
        }
}
return criteria

}

func dupeTheme(theme *tui.ColorTheme) *tui.ColorTheme {

dupe := *theme
return &dupe

}

func parseTheme(defaultTheme *tui.ColorTheme, str string) *tui.ColorTheme {

theme := dupeTheme(defaultTheme)
rrggbb := regexp.MustCompile("^#[0-9a-fA-F]{6}$")
for _, str := range strings.Split(strings.ToLower(str), ",") {
        switch str {
        case "dark":
                theme = dupeTheme(tui.Dark256)
        case "light":
                theme = dupeTheme(tui.Light256)
        case "16":
                theme = dupeTheme(tui.Default16)
        case "bw", "no":
                theme = tui.NoColorTheme()
        default:
                fail := func() {
                        errorExit("invalid color specification: " + str)
                }
                // Color is disabled
                if theme == nil {
                        continue
                }

                components := strings.Split(str, ":")
                if len(components) < 2 {
                        fail()
                }

                mergeAttr := func(cattr *tui.ColorAttr) {
                        for _, component := range components[1:] {
                                switch component {
                                case "regular":
                                        cattr.Attr = tui.AttrRegular
                                case "bold", "strong":
                                        cattr.Attr |= tui.Bold
                                case "dim":
                                        cattr.Attr |= tui.Dim
                                case "italic":
                                        cattr.Attr |= tui.Italic
                                case "underline":
                                        cattr.Attr |= tui.Underline
                                case "blink":
                                        cattr.Attr |= tui.Blink
                                case "reverse":
                                        cattr.Attr |= tui.Reverse
                                case "black":
                                        cattr.Color = tui.Color(0)
                                case "red":
                                        cattr.Color = tui.Color(1)
                                case "green":
                                        cattr.Color = tui.Color(2)
                                case "yellow":
                                        cattr.Color = tui.Color(3)
                                case "blue":
                                        cattr.Color = tui.Color(4)
                                case "magenta":
                                        cattr.Color = tui.Color(5)
                                case "cyan":
                                        cattr.Color = tui.Color(6)
                                case "white":
                                        cattr.Color = tui.Color(7)
                                case "bright-black", "gray", "grey":
                                        cattr.Color = tui.Color(8)
                                case "bright-red":
                                        cattr.Color = tui.Color(9)
                                case "bright-green":
                                        cattr.Color = tui.Color(10)
                                case "bright-yellow":
                                        cattr.Color = tui.Color(11)
                                case "bright-blue":
                                        cattr.Color = tui.Color(12)
                                case "bright-magenta":
                                        cattr.Color = tui.Color(13)
                                case "bright-cyan":
                                        cattr.Color = tui.Color(14)
                                case "bright-white":
                                        cattr.Color = tui.Color(15)
                                case "":
                                default:
                                        if rrggbb.MatchString(component) {
                                                cattr.Color = tui.HexToColor(component)
                                        } else {
                                                ansi32, err := strconv.Atoi(component)
                                                if err != nil || ansi32 < -1 || ansi32 > 255 {
                                                        fail()
                                                }
                                                cattr.Color = tui.Color(ansi32)
                                        }
                                }
                        }
                }
                switch components[0] {
                case "query", "input":
                        mergeAttr(&theme.Input)
                case "disabled":
                        mergeAttr(&theme.Disabled)
                case "fg":
                        mergeAttr(&theme.Fg)
                case "bg":
                        mergeAttr(&theme.Bg)
                case "preview-fg":
                        mergeAttr(&theme.PreviewFg)
                case "preview-bg":
                        mergeAttr(&theme.PreviewBg)
                case "fg+":
                        mergeAttr(&theme.Current)
                case "bg+":
                        mergeAttr(&theme.DarkBg)
                case "gutter":
                        mergeAttr(&theme.Gutter)
                case "hl":
                        mergeAttr(&theme.Match)
                case "hl+":
                        mergeAttr(&theme.CurrentMatch)
                case "border":
                        mergeAttr(&theme.Border)
                case "prompt":
                        mergeAttr(&theme.Prompt)
                case "spinner":
                        mergeAttr(&theme.Spinner)
                case "info":
                        mergeAttr(&theme.Info)
                case "pointer":
                        mergeAttr(&theme.Cursor)
                case "marker":
                        mergeAttr(&theme.Selected)
                case "header":
                        mergeAttr(&theme.Header)
                default:
                        fail()
                }
        }
}
return theme

}

var executeRegexp *regexp.Regexp

func firstKey(keymap mapstring) tui.Event {

for k := range keymap {
        return k
}
return tui.EventType(0).AsEvent()

}

const (

escapedColon = 0
escapedComma = 1
escapedPlus  = 2

)

func init() {

// Backreferences are not supported.
// "~!@#$%^&*;/|".each_char.map { |c| Regexp.escape(c) }.map { |c| "#{c}[^#{c}]*#{c}" }.join('|')
executeRegexp = regexp.MustCompile(
        `(?si)[:+](execute(?:-multi|-silent)?|reload|preview|change-prompt|unbind):.+|[:+](execute(?:-multi|-silent)?|reload|preview|change-prompt|unbind)(\([^)]*\)|\[[^\]]*\]|~[^~]*~|![^!]*!|@[^@]*@|\#[^\#]*\#|\$[^\$]*\$|%[^%]*%|\^[^\^]*\^|&[^&]*&|\*[^\*]*\*|;[^;]*;|/[^/]*/|\|[^\|]*\|)`)

}

func parseKeymap(keymap map[]action, str string) {

masked := executeRegexp.ReplaceAllStringFunc(str, func(src string) string {
        symbol := ":"
        if strings.HasPrefix(src, "+") {
                symbol = "+"
        }
        prefix := symbol + "execute"
        if strings.HasPrefix(src[1:], "reload") {
                prefix = symbol + "reload"
        } else if strings.HasPrefix(src[1:], "preview") {
                prefix = symbol + "preview"
        } else if strings.HasPrefix(src[1:], "unbind") {
                prefix = symbol + "unbind"
        } else if strings.HasPrefix(src[1:], "change-prompt") {
                prefix = symbol + "change-prompt"
        } else if src[len(prefix)] == '-' {
                c := src[len(prefix)+1]
                if c == 's' || c == 'S' {
                        prefix += "-silent"
                } else {
                        prefix += "-multi"
                }
        }
        return prefix + "(" + strings.Repeat(" ", len(src)-len(prefix)-2) + ")"
})
masked = strings.Replace(masked, "::", string([]rune{escapedColon, ':'}), -1)
masked = strings.Replace(masked, ",:", string([]rune{escapedComma, ':'}), -1)
masked = strings.Replace(masked, "+:", string([]rune{escapedPlus, ':'}), -1)

idx := 0
for _, pairStr := range strings.Split(masked, ",") {
        origPairStr := str[idx : idx+len(pairStr)]
        idx += len(pairStr) + 1

        pair := strings.SplitN(pairStr, ":", 2)
        if len(pair) < 2 {
                errorExit("bind action not specified: " + origPairStr)
        }
        var key tui.Event
        if len(pair[0]) == 1 && pair[0][0] == escapedColon {
                key = tui.Key(':')
        } else if len(pair[0]) == 1 && pair[0][0] == escapedComma {
                key = tui.Key(',')
        } else if len(pair[0]) == 1 && pair[0][0] == escapedPlus {
                key = tui.Key('+')
        } else {
                keys := parseKeyChords(pair[0], "key name required")
                key = firstKey(keys)
        }

        idx2 := len(pair[0]) + 1
        specs := strings.Split(pair[1], "+")
        actions := make([]action, 0, len(specs))
        appendAction := func(types ...actionType) {
                actions = append(actions, toActions(types...)...)
        }
        prevSpec := ""
        for specIndex, maskedSpec := range specs {
                spec := origPairStr[idx2 : idx2+len(maskedSpec)]
                idx2 += len(maskedSpec) + 1
                spec = prevSpec + spec
                specLower := strings.ToLower(spec)
                switch specLower {
                case "ignore":
                        appendAction(actIgnore)
                case "beginning-of-line":
                        appendAction(actBeginningOfLine)
                case "abort":
                        appendAction(actAbort)
                case "accept":
                        appendAction(actAccept)
                case "accept-non-empty":
                        appendAction(actAcceptNonEmpty)
                case "print-query":
                        appendAction(actPrintQuery)
                case "refresh-preview":
                        appendAction(actRefreshPreview)
                case "replace-query":
                        appendAction(actReplaceQuery)
                case "backward-char":
                        appendAction(actBackwardChar)
                case "backward-delete-char":
                        appendAction(actBackwardDeleteChar)
                case "backward-delete-char/eof":
                        appendAction(actBackwardDeleteCharEOF)
                case "backward-word":
                        appendAction(actBackwardWord)
                case "clear-screen":
                        appendAction(actClearScreen)
                case "delete-char":
                        appendAction(actDeleteChar)
                case "delete-char/eof":
                        appendAction(actDeleteCharEOF)
                case "deselect":
                        appendAction(actDeselect)
                case "end-of-line":
                        appendAction(actEndOfLine)
                case "cancel":
                        appendAction(actCancel)
                case "clear-query":
                        appendAction(actClearQuery)
                case "clear-selection":
                        appendAction(actClearSelection)
                case "forward-char":
                        appendAction(actForwardChar)
                case "forward-word":
                        appendAction(actForwardWord)
                case "jump":
                        appendAction(actJump)
                case "jump-accept":
                        appendAction(actJumpAccept)
                case "kill-line":
                        appendAction(actKillLine)
                case "kill-word":
                        appendAction(actKillWord)
                case "unix-line-discard", "line-discard":
                        appendAction(actUnixLineDiscard)
                case "unix-word-rubout", "word-rubout":
                        appendAction(actUnixWordRubout)
                case "yank":
                        appendAction(actYank)
                case "backward-kill-word":
                        appendAction(actBackwardKillWord)
                case "toggle-down":
                        appendAction(actToggle, actDown)
                case "toggle-up":
                        appendAction(actToggle, actUp)
                case "toggle-in":
                        appendAction(actToggleIn)
                case "toggle-out":
                        appendAction(actToggleOut)
                case "toggle-all":
                        appendAction(actToggleAll)
                case "toggle-search":
                        appendAction(actToggleSearch)
                case "select":
                        appendAction(actSelect)
                case "select-all":
                        appendAction(actSelectAll)
                case "deselect-all":
                        appendAction(actDeselectAll)
                case "close":
                        appendAction(actClose)
                case "toggle":
                        appendAction(actToggle)
                case "down":
                        appendAction(actDown)
                case "up":
                        appendAction(actUp)
                case "first", "top":
                        appendAction(actFirst)
                case "last":
                        appendAction(actLast)
                case "page-up":
                        appendAction(actPageUp)
                case "page-down":
                        appendAction(actPageDown)
                case "half-page-up":
                        appendAction(actHalfPageUp)
                case "half-page-down":
                        appendAction(actHalfPageDown)
                case "previous-history":
                        appendAction(actPreviousHistory)
                case "next-history":
                        appendAction(actNextHistory)
                case "toggle-preview":
                        appendAction(actTogglePreview)
                case "toggle-preview-wrap":
                        appendAction(actTogglePreviewWrap)
                case "toggle-sort":
                        appendAction(actToggleSort)
                case "preview-top":
                        appendAction(actPreviewTop)
                case "preview-bottom":
                        appendAction(actPreviewBottom)
                case "preview-up":
                        appendAction(actPreviewUp)
                case "preview-down":
                        appendAction(actPreviewDown)
                case "preview-page-up":
                        appendAction(actPreviewPageUp)
                case "preview-page-down":
                        appendAction(actPreviewPageDown)
                case "preview-half-page-up":
                        appendAction(actPreviewHalfPageUp)
                case "preview-half-page-down":
                        appendAction(actPreviewHalfPageDown)
                case "enable-search":
                        appendAction(actEnableSearch)
                case "disable-search":
                        appendAction(actDisableSearch)
                case "put":
                        if key.Type == tui.Rune && unicode.IsGraphic(key.Char) {
                                appendAction(actRune)
                        } else {
                                errorExit("unable to put non-printable character: " + pair[0])
                        }
                default:
                        t := isExecuteAction(specLower)
                        if t == actIgnore {
                                if specIndex == 0 && specLower == "" {
                                        actions = append(keymap[key], actions...)
                                } else {
                                        errorExit("unknown action: " + spec)
                                }
                        } else {
                                var offset int
                                switch t {
                                case actReload:
                                        offset = len("reload")
                                case actPreview:
                                        offset = len("preview")
                                case actChangePrompt:
                                        offset = len("change-prompt")
                                case actUnbind:
                                        offset = len("unbind")
                                case actExecuteSilent:
                                        offset = len("execute-silent")
                                case actExecuteMulti:
                                        offset = len("execute-multi")
                                default:
                                        offset = len("execute")
                                }
                                var actionArg string
                                if spec[offset] == ':' {
                                        if specIndex == len(specs)-1 {
                                                actionArg = spec[offset+1:]
                                                actions = append(actions, action{t: t, a: actionArg})
                                        } else {
                                                prevSpec = spec + "+"
                                                continue
                                        }
                                } else {
                                        actionArg = spec[offset+1 : len(spec)-1]
                                        actions = append(actions, action{t: t, a: actionArg})
                                }
                                if t == actUnbind {
                                        parseKeyChords(actionArg, "unbind target required")
                                }
                        }
                }
                prevSpec = ""
        }
        keymap[key] = actions
}

}

func isExecuteAction(str string) actionType {

matches := executeRegexp.FindAllStringSubmatch(":"+str, -1)
if matches == nil || len(matches) != 1 {
        return actIgnore
}
prefix := matches[0][1]
if len(prefix) == 0 {
        prefix = matches[0][2]
}
switch prefix {
case "reload":
        return actReload
case "unbind":
        return actUnbind
case "preview":
        return actPreview
case "change-prompt":
        return actChangePrompt
case "execute":
        return actExecute
case "execute-silent":
        return actExecuteSilent
case "execute-multi":
        return actExecuteMulti
}
return actIgnore

}

func parseToggleSort(keymap map[]action, str string) {

keys := parseKeyChords(str, "key name required")
if len(keys) != 1 {
        errorExit("multiple keys specified")
}
keymap[firstKey(keys)] = toActions(actToggleSort)

}

func strLines(str string) []string {

return strings.Split(strings.TrimSuffix(str, "\n"), "\n")

}

func parseSize(str string, maxPercent float64, label string) sizeSpec {

var val float64
percent := strings.HasSuffix(str, "%")
if percent {
        val = atof(str[:len(str)-1])
        if val < 0 {
                errorExit(label + " must be non-negative")
        }
        if val > maxPercent {
                errorExit(fmt.Sprintf("%s too large (max: %d%%)", label, int(maxPercent)))
        }
} else {
        if strings.Contains(str, ".") {
                errorExit(label + " (without %) must be a non-negative integer")
        }

        val = float64(atoi(str))
        if val < 0 {
                errorExit(label + " must be non-negative")
        }
}
return sizeSpec{val, percent}

}

func parseHeight(str string) sizeSpec {

size := parseSize(str, 100, "height")
return size

}

func parseLayout(str string) layoutType {

switch str {
case "default":
        return layoutDefault
case "reverse":
        return layoutReverse
case "reverse-list":
        return layoutReverseList
default:
        errorExit("invalid layout (expected: default / reverse / reverse-list)")
}
return layoutDefault

}

func parseInfoStyle(str string) infoStyle {

switch str {
case "default":
        return infoDefault
case "inline":
        return infoInline
case "hidden":
        return infoHidden
default:
        errorExit("invalid info style (expected: default / inline / hidden)")
}
return infoDefault

}

func parsePreviewWindow(opts *previewOpts, input string) {

delimRegex := regexp.MustCompile("[:,]") // : for backward compatibility
sizeRegex := regexp.MustCompile("^[0-9]+%?$")
offsetRegex := regexp.MustCompile(`^(\+{-?[0-9]+})?([+-][0-9]+)*(-?/[1-9][0-9]*)?$`)
headerRegex := regexp.MustCompile("^~(0|[1-9][0-9]*)$")
tokens := delimRegex.Split(input, -1)
for _, token := range tokens {
        switch token {
        case "":
        case "default":
                *opts = defaultPreviewOpts(opts.command)
        case "hidden":
                opts.hidden = true
        case "nohidden":
                opts.hidden = false
        case "wrap":
                opts.wrap = true
        case "nowrap":
                opts.wrap = false
        case "cycle":
                opts.cycle = true
        case "nocycle":
                opts.cycle = false
        case "up", "top":
                opts.position = posUp
        case "down", "bottom":
                opts.position = posDown
        case "left":
                opts.position = posLeft
        case "right":
                opts.position = posRight
        case "rounded", "border", "border-rounded":
                opts.border = tui.BorderRounded
        case "sharp", "border-sharp":
                opts.border = tui.BorderSharp
        case "noborder", "border-none":
                opts.border = tui.BorderNone
        case "border-horizontal":
                opts.border = tui.BorderHorizontal
        case "border-vertical":
                opts.border = tui.BorderVertical
        case "border-top":
                opts.border = tui.BorderTop
        case "border-bottom":
                opts.border = tui.BorderBottom
        case "border-left":
                opts.border = tui.BorderLeft
        case "border-right":
                opts.border = tui.BorderRight
        case "follow":
                opts.follow = true
        case "nofollow":
                opts.follow = false
        default:
                if headerRegex.MatchString(token) {
                        opts.headerLines = atoi(token[1:])
                } else if sizeRegex.MatchString(token) {
                        opts.size = parseSize(token, 99, "window size")
                } else if offsetRegex.MatchString(token) {
                        opts.scroll = token
                } else {
                        errorExit("invalid preview window option: " + token)
                }
        }
}

}

func parseMargin(opt string, margin string) [4]sizeSpec {

margins := strings.Split(margin, ",")
checked := func(str string) sizeSpec {
        return parseSize(str, 49, opt)
}
switch len(margins) {
case 1:
        m := checked(margins[0])
        return [4]sizeSpec{m, m, m, m}
case 2:
        tb := checked(margins[0])
        rl := checked(margins[1])
        return [4]sizeSpec{tb, rl, tb, rl}
case 3:
        t := checked(margins[0])
        rl := checked(margins[1])
        b := checked(margins[2])
        return [4]sizeSpec{t, rl, b, rl}
case 4:
        return [4]sizeSpec{
                checked(margins[0]), checked(margins[1]),
                checked(margins[2]), checked(margins[3])}
default:
        errorExit("invalid " + opt + ": " + margin)
}
return defaultMargin()

}

func parseOptions(opts *Options, allArgs []string) {

var historyMax int
if opts.History == nil {
        historyMax = defaultHistoryMax
} else {
        historyMax = opts.History.maxSize
}
setHistory := func(path string) {
        h, e := NewHistory(path, historyMax)
        if e != nil {
                errorExit(e.Error())
        }
        opts.History = h
}
setHistoryMax := func(max int) {
        historyMax = max
        if historyMax < 1 {
                errorExit("history max must be a positive integer")
        }
        if opts.History != nil {
                opts.History.maxSize = historyMax
        }
}
validateJumpLabels := false
validatePointer := false
validateMarker := false
for i := 0; i < len(allArgs); i++ {
        arg := allArgs[i]
        switch arg {
        case "-h", "--help":
                help(exitOk)
        case "-x", "--extended":
                opts.Extended = true
        case "-e", "--exact":
                opts.Fuzzy = false
        case "--extended-exact":
                // Note that we now don't have --no-extended-exact
                opts.Fuzzy = false
                opts.Extended = true
        case "+x", "--no-extended":
                opts.Extended = false
        case "+e", "--no-exact":
                opts.Fuzzy = true
        case "-q", "--query":
                opts.Query = nextString(allArgs, &i, "query string required")
        case "-f", "--filter":
                filter := nextString(allArgs, &i, "query string required")
                opts.Filter = &filter
        case "--literal":
                opts.Normalize = false
        case "--no-literal":
                opts.Normalize = true
        case "--algo":
                opts.FuzzyAlgo = parseAlgo(nextString(allArgs, &i, "algorithm required (v1|v2)"))
        case "--expect":
                for k, v := range parseKeyChords(nextString(allArgs, &i, "key names required"), "key names required") {
                        opts.Expect[k] = v
                }
        case "--no-expect":
                opts.Expect = make(map[tui.Event]string)
        case "--enabled", "--no-phony":
                opts.Phony = false
        case "--disabled", "--phony":
                opts.Phony = true
        case "--tiebreak":
                opts.Criteria = parseTiebreak(nextString(allArgs, &i, "sort criterion required"))
        case "--bind":
                parseKeymap(opts.Keymap, nextString(allArgs, &i, "bind expression required"))
        case "--color":
                _, spec := optionalNextString(allArgs, &i)
                if len(spec) == 0 {
                        opts.Theme = tui.EmptyTheme()
                } else {
                        opts.Theme = parseTheme(opts.Theme, spec)
                }
        case "--toggle-sort":
                parseToggleSort(opts.Keymap, nextString(allArgs, &i, "key name required"))
        case "-d", "--delimiter":
                opts.Delimiter = delimiterRegexp(nextString(allArgs, &i, "delimiter required"))
        case "-n", "--nth":
                opts.Nth = splitNth(nextString(allArgs, &i, "nth expression required"))
        case "--with-nth":
                opts.WithNth = splitNth(nextString(allArgs, &i, "nth expression required"))
        case "-s", "--sort":
                opts.Sort = optionalNumeric(allArgs, &i, 1)
        case "+s", "--no-sort":
                opts.Sort = 0
        case "--tac":
                opts.Tac = true
        case "--no-tac":
                opts.Tac = false
        case "-i":
                opts.Case = CaseIgnore
        case "+i":
                opts.Case = CaseRespect
        case "-m", "--multi":
                opts.Multi = optionalNumeric(allArgs, &i, maxMulti)
        case "+m", "--no-multi":
                opts.Multi = 0
        case "--ansi":
                opts.Ansi = true
        case "--no-ansi":
                opts.Ansi = false
        case "--no-mouse":
                opts.Mouse = false
        case "+c", "--no-color":
                opts.Theme = tui.NoColorTheme()
        case "+2", "--no-256":
                opts.Theme = tui.Default16
        case "--black":
                opts.Black = true
        case "--no-black":
                opts.Black = false
        case "--bold":
                opts.Bold = true
        case "--no-bold":
                opts.Bold = false
        case "--layout":
                opts.Layout = parseLayout(
                        nextString(allArgs, &i, "layout required (default / reverse / reverse-list)"))
        case "--reverse":
                opts.Layout = layoutReverse
        case "--no-reverse":
                opts.Layout = layoutDefault
        case "--cycle":
                opts.Cycle = true
        case "--no-cycle":
                opts.Cycle = false
        case "--keep-right":
                opts.KeepRight = true
        case "--no-keep-right":
                opts.KeepRight = false
        case "--hscroll":
                opts.Hscroll = true
        case "--no-hscroll":
                opts.Hscroll = false
        case "--hscroll-off":
                opts.HscrollOff = nextInt(allArgs, &i, "hscroll offset required")
        case "--scroll-off":
                opts.ScrollOff = nextInt(allArgs, &i, "scroll offset required")
        case "--filepath-word":
                opts.FileWord = true
        case "--no-filepath-word":
                opts.FileWord = false
        case "--info":
                opts.InfoStyle = parseInfoStyle(
                        nextString(allArgs, &i, "info style required"))
        case "--no-info":
                opts.InfoStyle = infoHidden
        case "--inline-info":
                opts.InfoStyle = infoInline
        case "--no-inline-info":
                opts.InfoStyle = infoDefault
        case "--jump-labels":
                opts.JumpLabels = nextString(allArgs, &i, "label characters required")
                validateJumpLabels = true
        case "-1", "--select-1":
                opts.Select1 = true
        case "+1", "--no-select-1":
                opts.Select1 = false
        case "-0", "--exit-0":
                opts.Exit0 = true
        case "+0", "--no-exit-0":
                opts.Exit0 = false
        case "--read0":
                opts.ReadZero = true
        case "--no-read0":
                opts.ReadZero = false
        case "--print0":
                opts.Printer = func(str string) { fmt.Print(str, "\x00") }
                opts.PrintSep = "\x00"
        case "--no-print0":
                opts.Printer = func(str string) { fmt.Println(str) }
                opts.PrintSep = "\n"
        case "--print-query":
                opts.PrintQuery = true
        case "--no-print-query":
                opts.PrintQuery = false
        case "--prompt":
                opts.Prompt = nextString(allArgs, &i, "prompt string required")
        case "--pointer":
                opts.Pointer = nextString(allArgs, &i, "pointer sign string required")
                validatePointer = true
        case "--marker":
                opts.Marker = nextString(allArgs, &i, "selected sign string required")
                validateMarker = true
        case "--sync":
                opts.Sync = true
        case "--no-sync":
                opts.Sync = false
        case "--async":
                opts.Sync = false
        case "--no-history":
                opts.History = nil
        case "--history":
                setHistory(nextString(allArgs, &i, "history file path required"))
        case "--history-size":
                setHistoryMax(nextInt(allArgs, &i, "history max size required"))
        case "--no-header":
                opts.Header = []string{}
        case "--no-header-lines":
                opts.HeaderLines = 0
        case "--header":
                opts.Header = strLines(nextString(allArgs, &i, "header string required"))
        case "--header-lines":
                opts.HeaderLines = atoi(
                        nextString(allArgs, &i, "number of header lines required"))
        case "--header-first":
                opts.HeaderFirst = true
        case "--no-header-first":
                opts.HeaderFirst = false
        case "--preview":
                opts.Preview.command = nextString(allArgs, &i, "preview command required")
        case "--no-preview":
                opts.Preview.command = ""
        case "--preview-window":
                parsePreviewWindow(&opts.Preview,
                        nextString(allArgs, &i, "preview window layout required: [up|down|left|right][,SIZE[%]][,border-BORDER_OPT][,wrap][,cycle][,hidden][,+SCROLL[OFFSETS][/DENOM]][,~HEADER_LINES][,default]"))
        case "--height":
                opts.Height = parseHeight(nextString(allArgs, &i, "height required: HEIGHT[%]"))
        case "--min-height":
                opts.MinHeight = nextInt(allArgs, &i, "height required: HEIGHT")
        case "--no-height":
                opts.Height = sizeSpec{}
        case "--no-margin":
                opts.Margin = defaultMargin()
        case "--no-padding":
                opts.Padding = defaultMargin()
        case "--no-border":
                opts.BorderShape = tui.BorderNone
        case "--border":
                hasArg, arg := optionalNextString(allArgs, &i)
                opts.BorderShape = parseBorder(arg, !hasArg)
        case "--no-unicode":
                opts.Unicode = false
        case "--unicode":
                opts.Unicode = true
        case "--margin":
                opts.Margin = parseMargin(
                        "margin",
                        nextString(allArgs, &i, "margin required (TRBL / TB,RL / T,RL,B / T,R,B,L)"))
        case "--padding":
                opts.Padding = parseMargin(
                        "padding",
                        nextString(allArgs, &i, "padding required (TRBL / TB,RL / T,RL,B / T,R,B,L)"))
        case "--tabstop":
                opts.Tabstop = nextInt(allArgs, &i, "tab stop required")
        case "--clear":
                opts.ClearOnExit = true
        case "--no-clear":
                opts.ClearOnExit = false
        case "--version":
                opts.Version = true
        default:
                if match, value := optString(arg, "--algo="); match {
                        opts.FuzzyAlgo = parseAlgo(value)
                } else if match, value := optString(arg, "-q", "--query="); match {
                        opts.Query = value
                } else if match, value := optString(arg, "-f", "--filter="); match {
                        opts.Filter = &value
                } else if match, value := optString(arg, "-d", "--delimiter="); match {
                        opts.Delimiter = delimiterRegexp(value)
                } else if match, value := optString(arg, "--border="); match {
                        opts.BorderShape = parseBorder(value, false)
                } else if match, value := optString(arg, "--prompt="); match {
                        opts.Prompt = value
                } else if match, value := optString(arg, "--pointer="); match {
                        opts.Pointer = value
                        validatePointer = true
                } else if match, value := optString(arg, "--marker="); match {
                        opts.Marker = value
                        validateMarker = true
                } else if match, value := optString(arg, "-n", "--nth="); match {
                        opts.Nth = splitNth(value)
                } else if match, value := optString(arg, "--with-nth="); match {
                        opts.WithNth = splitNth(value)
                } else if match, _ := optString(arg, "-s", "--sort="); match {
                        opts.Sort = 1 // Don't care
                } else if match, value := optString(arg, "-m", "--multi="); match {
                        opts.Multi = atoi(value)
                } else if match, value := optString(arg, "--height="); match {
                        opts.Height = parseHeight(value)
                } else if match, value := optString(arg, "--min-height="); match {
                        opts.MinHeight = atoi(value)
                } else if match, value := optString(arg, "--layout="); match {
                        opts.Layout = parseLayout(value)
                } else if match, value := optString(arg, "--info="); match {
                        opts.InfoStyle = parseInfoStyle(value)
                } else if match, value := optString(arg, "--toggle-sort="); match {
                        parseToggleSort(opts.Keymap, value)
                } else if match, value := optString(arg, "--expect="); match {
                        for k, v := range parseKeyChords(value, "key names required") {
                                opts.Expect[k] = v
                        }
                } else if match, value := optString(arg, "--tiebreak="); match {
                        opts.Criteria = parseTiebreak(value)
                } else if match, value := optString(arg, "--color="); match {
                        opts.Theme = parseTheme(opts.Theme, value)
                } else if match, value := optString(arg, "--bind="); match {
                        parseKeymap(opts.Keymap, value)
                } else if match, value := optString(arg, "--history="); match {
                        setHistory(value)
                } else if match, value := optString(arg, "--history-size="); match {
                        setHistoryMax(atoi(value))
                } else if match, value := optString(arg, "--header="); match {
                        opts.Header = strLines(value)
                } else if match, value := optString(arg, "--header-lines="); match {
                        opts.HeaderLines = atoi(value)
                } else if match, value := optString(arg, "--preview="); match {
                        opts.Preview.command = value
                } else if match, value := optString(arg, "--preview-window="); match {
                        parsePreviewWindow(&opts.Preview, value)
                } else if match, value := optString(arg, "--margin="); match {
                        opts.Margin = parseMargin("margin", value)
                } else if match, value := optString(arg, "--padding="); match {
                        opts.Padding = parseMargin("padding", value)
                } else if match, value := optString(arg, "--tabstop="); match {
                        opts.Tabstop = atoi(value)
                } else if match, value := optString(arg, "--hscroll-off="); match {
                        opts.HscrollOff = atoi(value)
                } else if match, value := optString(arg, "--scroll-off="); match {
                        opts.ScrollOff = atoi(value)
                } else if match, value := optString(arg, "--jump-labels="); match {
                        opts.JumpLabels = value
                        validateJumpLabels = true
                } else {
                        errorExit("unknown option: " + arg)
                }
        }
}

if opts.HeaderLines < 0 {
        errorExit("header lines must be a non-negative integer")
}

if opts.HscrollOff < 0 {
        errorExit("hscroll offset must be a non-negative integer")
}

if opts.ScrollOff < 0 {
        errorExit("scroll offset must be a non-negative integer")
}

if opts.Tabstop < 1 {
        errorExit("tab stop must be a positive integer")
}

if len(opts.JumpLabels) == 0 {
        errorExit("empty jump labels")
}

if validateJumpLabels {
        for _, r := range opts.JumpLabels {
                if r < 32 || r > 126 {
                        errorExit("non-ascii jump labels are not allowed")
                }
        }
}

if validatePointer {
        if err := validateSign(opts.Pointer, "pointer"); err != nil {
                errorExit(err.Error())
        }
}

if validateMarker {
        if err := validateSign(opts.Marker, "marker"); err != nil {
                errorExit(err.Error())
        }
}

}

func validateSign(sign string, signOptName string) error {

if sign == "" {
        return fmt.Errorf("%v cannot be empty", signOptName)
}
for _, r := range sign {
        if !unicode.IsGraphic(r) {
                return fmt.Errorf("invalid character in %v", signOptName)
        }
}
if runewidth.StringWidth(sign) > 2 {
        return fmt.Errorf("%v display width should be up to 2", signOptName)
}
return nil

}

func postProcessOptions(opts *Options) {

if !opts.Version && !tui.IsLightRendererSupported() && opts.Height.size > 0 {
        errorExit("--height option is currently not supported on this platform")
}
// Default actions for CTRL-N / CTRL-P when --history is set
if opts.History != nil {
        if _, prs := opts.Keymap[tui.CtrlP.AsEvent()]; !prs {
                opts.Keymap[tui.CtrlP.AsEvent()] = toActions(actPreviousHistory)
        }
        if _, prs := opts.Keymap[tui.CtrlN.AsEvent()]; !prs {
                opts.Keymap[tui.CtrlN.AsEvent()] = toActions(actNextHistory)
        }
}

// Extend the default key map
keymap := defaultKeymap()
for key, actions := range opts.Keymap {
        for _, act := range actions {
                if act.t == actToggleSort {
                        opts.ToggleSort = true
                }
        }
        keymap[key] = actions
}
opts.Keymap = keymap

// If we're not using extended search mode, --nth option becomes irrelevant
// if it contains the whole range
if !opts.Extended || len(opts.Nth) == 1 {
        for _, r := range opts.Nth {
                if r.begin == rangeEllipsis && r.end == rangeEllipsis {
                        opts.Nth = make([]Range, 0)
                        return
                }
        }
}

if opts.Bold {
        theme := opts.Theme
        boldify := func(c tui.ColorAttr) tui.ColorAttr {
                dup := c
                if !theme.Colored {
                        dup.Attr |= tui.Bold
                } else if (c.Attr & tui.AttrRegular) == 0 {
                        dup.Attr |= tui.Bold
                }
                return dup
        }
        theme.Current = boldify(theme.Current)
        theme.CurrentMatch = boldify(theme.CurrentMatch)
        theme.Prompt = boldify(theme.Prompt)
        theme.Input = boldify(theme.Input)
        theme.Cursor = boldify(theme.Cursor)
        theme.Spinner = boldify(theme.Spinner)
}

}

// ParseOptions parses command-line options func ParseOptions() *Options {

opts := defaultOptions()

// Options from Env var
words, _ := shellwords.Parse(os.Getenv("FZF_DEFAULT_OPTS"))
if len(words) > 0 {
        parseOptions(opts, words)
}

// Options from command-line arguments
parseOptions(opts, os.Args[1:])

postProcessOptions(opts)
return opts

}