local tableSort    = table.sort
local stringRep    = string.rep
local stringByte   = string.byte
local stringFormat = string.format
local tableConcat  = table.concat
local tostring     = tostring
local type         = type
local pairs        = pairs
local ipairs       = ipairs
local next         = next
local rawset       = rawset
local move         = table.move
local tableRemove  = table.remove
local setmetatable = debug.setmetatable
local mathType     = math.type
local mathCeil     = math.ceil
local getmetatable = getmetatable
local mathAbs      = math.abs
local mathRandom   = math.random
local ioOpen       = io.open
local utf8Len      = utf8.len
local getenv       = os.getenv
local getupvalue   = debug.getupvalue
local mathHuge     = math.huge
local inf          = 1 / 0
local nan          = 0 / 0
local error        = error
local assert       = assert

_ENV = nil

local function isInteger(n)
    if mathType then
        return mathType(n) == 'integer'
    else
        return type(n) == 'number' and n % 1 == 0
    end
end

local function formatNumber(n)
    if n == inf
    or n == -inf
    or n == nan
    or n ~= n then -- IEEE 标准中，NAN 不等于自己。但是某些实现中没有遵守这个规则
        return ('%q'):format(n)
    end
    if isInteger(n) then
        return tostring(n)
    end
    local str = ('%.10f'):format(n)
    str = str:gsub('%.?0*$', '')
    return str
end

local TAB = setmetatable({}, { __index = function (self, n)
    self[n] = stringRep('    ', n)
    return self[n]
end})

local RESERVED = {
    ['and']      = true,
    ['break']    = true,
    ['do']       = true,
    ['else']     = true,
    ['elseif']   = true,
    ['end']      = true,
    ['false']    = true,
    ['for']      = true,
    ['function'] = true,
    ['goto']     = true,
    ['if']       = true,
    ['in']       = true,
    ['local']    = true,
    ['nil']      = true,
    ['not']      = true,
    ['or']       = true,
    ['repeat']   = true,
    ['return']   = true,
    ['then']     = true,
    ['true']     = true,
    ['until']    = true,
    ['while']    = true,
}

---@class Utility
local m = {}

--- 打印表的结构
---@param tbl any
---@param option? table
---@return string
function m.dump(tbl, option)
    if not option then
        option = {}
    end
    if type(tbl) ~= 'table' then
        return ('%s'):format(tbl)
    end
    local lines = {}
    local mark = {}
    local stack = {}
    lines[#lines+1] = '{'
    local function unpack(tbl)
        local deep = #stack
        mark[tbl] = (mark[tbl] or 0) + 1
        local keys = {}
        local keymap = {}
        local integerFormat = '[%d]'
        local alignment = 0
        if #tbl >= 10 then
            local width = #tostring(#tbl)
            integerFormat = ('[%%0%dd]'):format(mathCeil(width))
        end
        for key in pairs(tbl) do
            if type(key) == 'string' then
                if not key:match('^[%a_][%w_]*$')
                or RESERVED[key]
                or option['longStringKey']
                then
                    keymap[key] = ('[%q]'):format(key)
                else
                    keymap[key] = ('%s'):format(key)
                end
            elseif isInteger(key) then
                keymap[key] = integerFormat:format(key)
            else
                keymap[key] = ('["<%s>"]'):format(tostring(key))
            end
            keys[#keys+1] = key
            if option['alignment'] then
                if #keymap[key] > alignment then
                    alignment = #keymap[key]
                end
            end
        end
        local mt = getmetatable(tbl)
        if not mt or not mt.__pairs then
            if option['sorter'] then
                option['sorter'](keys, keymap)
            else
                tableSort(keys, function (a, b)
                    return keymap[a] < keymap[b]
                end)
            end
        end
        for _, key in ipairs(keys) do
            local keyWord = keymap[key]
            if option['noArrayKey']
                and isInteger(key)
                and key <= #tbl
            then
                keyWord = ''
            else
                if #keyWord < alignment then
                    keyWord = keyWord .. (' '):rep(alignment - #keyWord) .. ' = '
                else
                    keyWord = keyWord .. ' = '
                end
            end
            local value = tbl[key]
            local tp = type(value)
            local format = option['format'] and option['format'][key]
            if format then
                value = format(value, unpack, deep+1, stack)
                tp    = type(value)
            end
            if tp == 'table' then
                if mark[value] and mark[value] > 0 then
                    lines[#lines+1] = ('%s%s%s,'):format(TAB[deep+1], keyWord, option['loop'] or '"<Loop>"')
                elseif deep >= (option['deep'] or mathHuge) then
                    lines[#lines+1] = ('%s%s%s,'):format(TAB[deep+1], keyWord, '"<Deep>"')
                else
                    lines[#lines+1] = ('%s%s{'):format(TAB[deep+1], keyWord)
                    stack[#stack+1] = key
                    unpack(value)
                    stack[#stack] = nil
                    lines[#lines+1] = ('%s},'):format(TAB[deep+1])
                end
            elseif tp == 'string' then
                lines[#lines+1] = ('%s%s%q,'):format(TAB[deep+1], keyWord, value)
            elseif tp == 'number' then
                lines[#lines+1] = ('%s%s%s,'):format(TAB[deep+1], keyWord, (option['number'] or formatNumber)(value))
            elseif tp == 'nil' then
            else
                lines[#lines+1] = ('%s%s%s,'):format(TAB[deep+1], keyWord, tostring(value))
            end
        end
        mark[tbl] = mark[tbl] - 1
    end
    unpack(tbl)
    lines[#lines+1] = '}'
    return tableConcat(lines, '\r\n')
end

--- 递归判断A与B是否相等
---@param valueA any
---@param valueB any
---@return boolean
function m.equal(valueA, valueB)
    local hasChecked = {}

    local function equal(a, b)
        local tp1 = type(a)
        local tp2 = type(b)
        if tp1 ~= tp2 then
            return false
        end
        if tp1 == 'table' then
            if hasChecked[a] then
                return true
            end
            hasChecked[a] = true
            local mark = {}
            for k, v in pairs(a) do
                mark[k] = true
                local res = equal(v, b[k])
                if not res then
                    return false
                end
            end
            for k in pairs(b) do
                if not mark[k] then
                    return false
                end
            end
            return true
        elseif tp1 == 'number' then
            if mathAbs(a - b) <= 1e-10 then
                return true
            end
            return tostring(a) == tostring(b)
        else
            return a == b
        end
    end

    return equal(valueA, valueB)
end

local function sortTable(tbl)
    if not tbl then
        tbl = {}
    end
    local mt = {}
    local keys = {}
    local mark = {}
    local n = 0
    for key in next, tbl do
        n=n+1;keys[n] = key
        mark[key] = true
    end
    tableSort(keys)
    function mt:__newindex(key, value)
        rawset(self, key, value)
        n=n+1;keys[n] = key
        mark[key] = true
        if type(value) == 'table' then
            sortTable(value)
        end
    end
    function mt:__pairs()
        local list = {}
        local m = 0
        for key in next, self do
            if not mark[key] then
                m=m+1;list[m] = key
            end
        end
        if m > 0 then
            move(keys, 1, n, m+1)
            tableSort(list)
            for i = 1, m do
                local key = list[i]
                keys[i] = key
                mark[key] = true
            end
            n = n + m
        end
        local i = 0
        return function ()
            i = i + 1
            local key = keys[i]
            return key, self[key]
        end
    end

    return setmetatable(tbl, mt)
end

--- 创建一个有序表
---@param tbl? table
---@return table
function m.container(tbl)
    return sortTable(tbl)
end

--- 读取文件
---@param path string
---@param keepBom? boolean
---@return string? text
---@return string? errMsg
function m.loadFile(path, keepBom)
    local f, e = ioOpen(path, 'rb')
    if not f then
        return nil, e
    end
    local text = f:read 'a'
    f:close()
    if not text then
        return nil
    end
    if not keepBom then
        if text:sub(1, 3) == '\xEF\xBB\xBF' then
            return text:sub(4)
        end
        if text:sub(1, 2) == '\xFF\xFE'
        or text:sub(1, 2) == '\xFE\xFF' then
            return text:sub(3)
        end
    end
    return text
end

--- 写入文件
---@param path string
---@param content string
---@return boolean ok
---@return string? errMsg
function m.saveFile(path, content)
    local f, e = ioOpen(path, "wb")

    if f then
        f:write(content)
        f:close()
        return true
    else
        return false, e
    end
end

--- 计数器
---@param init? integer
---@param step? integer
---@return fun():integer
function m.counter(init, step)
    if not step then
        step = 1
    end
    local current = init and (init - 1) or 0
    return function ()
        current = current + step
        return current
    end
end

--- 排序后遍历
---@generic K, V
---@param t table<K, V>
---@param sorter? fun(a: K, b: K): boolean
---@return fun(): K, V
function m.sortPairs(t, sorter)
    local keys = {}
    for k in pairs(t) do
        keys[#keys+1] = k
    end
    tableSort(keys, sorter)
    local i = 0
    return function ()
        i = i + 1
        local k = keys[i]
        return k, t[k]
    end
end

--- 深拷贝（不处理元表）
---@param source  table
---@param target? table
---@return table
function m.deepCopy(source, target)
    local mark = {}
    local function copy(a, b)
        if type(a) ~= 'table' then
            return a
        end
        if mark[a] then
            return mark[a]
        end
        if not b then
            b = {}
        end
        mark[a] = b
        for k, v in pairs(a) do
            b[copy(k)] = copy(v)
        end
        return b
    end
    return copy(source, target)
end

--- 序列化
---@param t table
---@return table
function m.unpack(t)
    local result = {}
    local tid = 0
    local cache = {}
    local function unpack(o)
        local id = cache[o]
        if not id then
            tid = tid + 1
            id = tid
            cache[o] = tid
            if type(o) == 'table' then
                local new = {}
                result[tid] = new
                for k, v in next, o do
                    new[unpack(k)] = unpack(v)
                end
            else
                result[id] = o
            end
        end
        return id
    end
    unpack(t)
    return result
end

--- 反序列化
---@param t table
---@return table
function m.pack(t)
    local cache = {}
    local function pack(id)
        local o = cache[id]
        if o then
            return o
        end
        o = t[id]
        if type(o) == 'table' then
            local new = {}
            cache[id] = new
            for k, v in next, o do
                new[pack(k)] = pack(v)
            end
            return new
        else
            cache[id] = o
            return o
        end
    end
    return pack(1)
end

--- defer
local deferMT = { __close = function (self) self[1]() end }
function m.defer(callback)
    return setmetatable({ callback }, deferMT)
end

function m.enableCloseFunction()
    setmetatable(function () end, { __close = function (f) f() end })
end

local esc = {
    ["'"]  = [[\']],
    ['"']  = [[\"]],
    ['\r'] = [[\r]],
    ['\n'] = '\\\n',
}

function m.viewString(str, quo)
    if not quo then
        if str:find('[\r\n]') then
            quo = '[['
        elseif not str:find("'", 1, true) and str:find('"', 1, true) then
            quo = "'"
        else
            quo = '"'
        end
    end
    if quo == "'" then
        str = str:gsub('[\000-\008\011-\012\014-\031\127]', function (char)
            return ('\\%03d'):format(char:byte())
        end)
        return quo .. str:gsub([=[['\r\n]]=], esc) .. quo
    elseif quo == '"' then
        str = str:gsub('[\000-\008\011-\012\014-\031\127]', function (char)
            return ('\\%03d'):format(char:byte())
        end)
        return quo .. str:gsub([=[["\r\n]]=], esc) .. quo
    else
        local eqnum = #quo - 2
        local fsymb = ']' .. ('='):rep(eqnum) .. ']'
        if not str:find(fsymb, 1, true) then
            str = str:gsub('[\000-\008\011-\012\014-\031\127]', '')
            return quo .. str .. fsymb
        end
        for i = 0, 10 do
            local fsymb = ']' .. ('='):rep(i) .. ']'
            if not str:find(fsymb, 1, true) then
                local ssymb = '[' .. ('='):rep(i) .. '['
                str = str:gsub('[\000-\008\011-\012\014-\031\127]', '')
                return ssymb .. str .. fsymb
            end
        end
        return m.viewString(str, '"')
    end
end

function m.viewLiteral(v)
    local tp = type(v)
    if tp == 'nil' then
        return 'nil'
    elseif tp == 'string' then
        return m.viewString(v)
    elseif tp == 'boolean' then
        return tostring(v)
    elseif tp == 'number' then
        if isInteger(v) then
            return tostring(v)
        else
            return formatNumber(v)
        end
    end
    return nil
end

function m.utf8Len(str, start, finish)
    local len = 0
    for _ = 1, 10000 do
        local clen, pos = utf8Len(str, start, finish, true)
        if clen then
            len = len + clen
            break
        else
            len = len + 1 + utf8Len(str, start, pos - 1, true)
            start = pos + 1
        end
    end
    return len
end

-- 把数组中的元素顺序*原地*反转
---@param arr any[]
---@return any[]
function m.revertArray(arr)
    local len = #arr
    if len <= 1 then
        return arr
    end
    for x = 1, len // 2 do
        local y = len - x + 1
        arr[x], arr[y] = arr[y], arr[x]
    end
    return arr
end

-- 创建一个value-key表
---@generic K, V
---@param t table<K, V>
---@return table<V, K>
function m.revertMap(t)
    local nt = {}
    for k, v in pairs(t) do
        nt[v] = k
    end
    return nt
end

function m.randomSortTable(t, max)
    local len = #t
    if len <= 1 then
        return t
    end
    if not max or max > len then
        max = len
    end
    for x = 1, max do
        local y = mathRandom(len)
        t[x], t[y] = t[y], t[x]
    end
    return t
end

function m.tableMultiRemove(t, index)
    local mark = {}
    for i = 1, #index do
        local v = index[i]
        mark[v] = true
    end
    local offset = 0
    local me = 1
    local len = #t
    while true do
        local it = me + offset
        if it > len then
            for i = me, len do
                t[i] = nil
            end
            break
        end
        if mark[it] then
            offset = offset + 1
        else
            if me ~= it then
                t[me] = t[it]
            end
            me = me + 1
        end
    end
end

---遍历文本的每一行
---@param text string
---@param keepNL? boolean # 保留换行符
---@return fun():string?, integer?
function m.eachLine(text, keepNL)
    local offset = 1
    local lineCount = 0
    local lastLine
    return function ()
        lineCount = lineCount + 1
        if offset > #text then
            if not lastLine then
                lastLine = ''
                return '', lineCount
            end
            return nil
        end
        local nl = text:find('[\r\n]', offset)
        if not nl then
            lastLine = text:sub(offset)
            offset = #text + 1
            return lastLine, lineCount
        end
        local line
        if text:sub(nl, nl + 1) == '\r\n' then
            if keepNL then
                line = text:sub(offset, nl + 1)
            else
                line = text:sub(offset, nl - 1)
            end
            offset = nl + 2
        else
            if keepNL then
                line = text:sub(offset, nl)
            else
                line = text:sub(offset, nl - 1)
            end
            offset = nl + 1
        end
        return line, lineCount
    end
end

---@alias SortByScoreCallback fun(o: any): integer

-- 按照分数排序，分数越高越靠前
---@param tbl any[]
---@param callbacks SortByScoreCallback | SortByScoreCallback[]
function m.sortByScore(tbl, callbacks)
    if type(callbacks) ~= 'table' then
        callbacks = { callbacks }
    end
    local size = #callbacks
    local scoreCache = {}
    for i = 1, size do
        scoreCache[i] = {}
    end
    tableSort(tbl, function (a, b)
        for i = 1, size do
            local callback = callbacks[i]
            local cache    = scoreCache[i]
            local sa       = cache[a] or callback(a)
            local sb       = cache[b] or callback(b)
            cache[a] = sa
            cache[b] = sb
            if sa > sb then
                return true
            elseif sa < sb then
                return false
            end
        end
        return false
    end)
end

---@param arr any[]
---@return SortByScoreCallback
function m.sortCallbackOfIndex(arr)
    ---@type table<any, integer>
    local indexMap = m.revertMap(arr)
    return function (v)
        return - indexMap[v]
    end
end

---使用多个排序器排序，如果前一个排序器返回相等，则使用后一个排序器。
---排序器返回 `true` 表示 `a` 在 `b` 前面，返回 `false` 表示 `a` 在 `b` 后面。
---返回 `nil` 表示排序器无法比较 `a` 和 `b`或者 `a` 和 `b` 相等。
---@generic T
---@param tbl T[]
---@param sorter fun(a: T, b: T): boolean?
---@param ... fun(a: T, b: T): boolean?
function m.sort(tbl, sorter, ...)
    local sorters = { sorter, ... }
    tableSort(tbl, function (a, b)
        for _, f in ipairs(sorters) do
            local res = f(a, b)
            if res ~= nil then
                return res
            end
        end
        return false
    end)
end

---@param datas any[]
---@param scores integer[]
---@return SortByScoreCallback
function m.sortCallbackOfScore(datas, scores)
    local map = {}
    for i = 1, #datas do
        local data = datas[i]
        local score = scores[i]
        map[data] = score
    end
    return function (v)
        return map[v]
    end
end

---裁剪字符串
---@param str string
---@param mode? '"left"'|'"right"'
---@return string
function m.trim(str, mode)
    if mode == "left" then
        return (str:gsub('^%s+', ''))
    end
    if mode == "right" then
        return (str:gsub('%s+$', ''))
    end
    return (str:match '^%s*(.-)%s*$')
end

---@param path string
---@param env? { [string]: string }
---@return string
function m.expandPath(path, env)
    if path:sub(1, 1) == '~' then
        local home = getenv('HOME')
        if not home then -- has to be Windows
            home = getenv 'USERPROFILE' or (getenv 'HOMEDRIVE' .. getenv 'HOMEPATH')
        end
        return home .. path:sub(2)
    elseif path:sub(1, 1) == '$' then
        path = path:gsub('%$([%w_]+)', function (name)
            return env and env[name] or getenv(name) or ''
        end)
        return path
    end
    return path
end

---@generic T
---@param l T[]
---@return { [T]: true }
function m.arrayToHash(l)
    local t = {}
    for i = 1, #l do
        t[l[i]] = true
    end
    return t
end

---@class switch
---@field cachedCases string[]
---@field map table<string, function>
---@field _default fun(...):...
local switchMT = {}
switchMT.__index = switchMT

---@param name string
---@return switch
function switchMT:case(name)
    self.cachedCases[#self.cachedCases+1] = name
    return self
end

---@param callback async fun(...):...
---@return switch
function switchMT:call(callback)
    for i = 1, #self.cachedCases do
        local name = self.cachedCases[i]
        self.cachedCases[i] = nil
        if self.map[name] then
            error('Repeated fields:' .. tostring(name))
        end
        self.map[name] = callback
    end
    return self
end

---@param callback fun(...):...
---@return switch
function switchMT:default(callback)
    self._default = callback
    return self
end

function switchMT:getMap()
    return self.map
end

---@param name string
---@return boolean
function switchMT:has(name)
    return self.map[name] ~= nil
end

---@param name string
---@param ... any
---@return ...
function switchMT:__call(name, ...)
    local callback = self.map[name] or self._default
    if not callback then
        return
    end
    return callback(...)
end

---@return switch
function m.switch()
    local obj = setmetatable({
        map = {},
        cachedCases = {},
    }, switchMT)
    return obj
end

---@param f async fun()
---@param name string
---@return any, boolean
function m.getUpvalue(f, name)
    for i = 1, 999 do
        local uname, value = getupvalue(f, i)
        if not uname then
            break
        end
        if name == uname then
            return value, true
        end
    end
    return nil, false
end

---@param str string
---@param head string
---@param ignoreCase? boolean
---@return boolean
function m.stringStartWith(str, head, ignoreCase)
    if ignoreCase then
        return str:sub(1, #head):lower() == head:lower()
    else
        return str:sub(1, #head) == head
    end
end

---@param str string
---@param tail string
---@param ignoreCase? boolean
---@return boolean
function m.stringEndWith(str, tail, ignoreCase)
    if ignoreCase then
        return str:sub(-#tail):lower() == tail:lower()
    else
        return str:sub(-#tail) == tail
    end
end

---@param str1 string
---@param str2 string
---@param ignoreCase? boolean
---@return boolean
function m.stringEqual(str1, str2, ignoreCase)
    if ignoreCase then
        return str1:lower() == str2:lower()
    else
        return str1 == str2
    end
end

function m.defaultTable(default)
    return setmetatable({}, { __index = function (t, k)
        if k == nil then
            return nil
        end
        local v = default(k)
        t[k] = v
        return v
    end })
end

function m.multiTable(max, default)
    local mts = {}
    for i = 1, max - 1 do
        if i < max - 1 then
            mts[i] = { __index = function (t, k)
                local v = setmetatable({}, mts[i + 1])
                t[k] = v
                return v
            end }
        elseif default then
            mts[i] = { __index = function (t, k)
                local v = default(k)
                t[k] = v
                return v
            end }
        else
            mts[i] = { __index = function (t, k)
                local v = {}
                t[k] = v
                return v
            end }
        end
    end

    return setmetatable({}, mts[1])
end

---@param t table
---@param sorter boolean|function
---@return any[]
function m.getTableKeys(t, sorter)
    local keys = {}
    for k in pairs(t) do
        keys[#keys+1] = k
    end
    if sorter == true then
        tableSort(keys)
    elseif type(sorter) == 'function' then
        tableSort(keys, sorter)
    end
    return keys
end

function m.arrayHas(array, value)
    for i = 1, #array do
        if array[i] == value then
            return true
        end
    end
    return false
end

function m.arrayIndexOf(array, value)
    for i = 1, #array do
        if array[i] == value then
            return i
        end
    end
    return nil
end

function m.arrayInsert(array, value)
    if not m.arrayHas(array, value) then
        array[#array+1] = value
    end
end

function m.arrayRemove(array, value)
    for i = 1, #array do
        if array[i] == value then
            tableRemove(array, i)
            return
        end
    end
end

---@param a1 any[]
---@param a2 any[]
---@return any[]
function m.arrayOverlap(a1, a2)
    local result = {}
    local set = m.arrayToHash(a2)
    for i = 1, #a1 do
        local v = a1[i]
        if set[v] then
            result[#result+1] = v
        end
    end
    return result
end

m.MODE_K  = { __mode = 'k' }
m.MODE_V  = { __mode = 'v' }
m.MODE_KV = { __mode = 'kv' }

---@generic T: fun(param: any):any
---@param func T
---@return T
function m.cacheReturn(func)
    local cache = {}
    return function (param)
        if cache[param] == nil then
            cache[param] = func(param)
        end
        return cache[param]
    end
end

---@param a table
---@param b table
---@return table
function m.tableMerge(a, b)
    for k, v in pairs(b) do
        a[k] = v
    end
    return a
end

---@param a any[]
---@param b any[]
---@return any[]
function m.arrayMerge(a, b)
    for i = 1, #b do
        a[#a+1] = b[i]
    end
    return a
end

---@generic K
---@param t { [K]: any }
---@return K[]
function m.keysOf(t)
    local keys = {}
    for k in pairs(t) do
        keys[#keys+1] = k
    end
    return keys
end

---@generic V
---@param t { [any]: V }
---@return V[]
function m.valuesOf(t)
    local values = {}
    for _, v in pairs(t) do
        values[#values+1] = v
    end
    return values
end

---@param t table
---@return integer
function m.countTable(t)
    local count = 0
    for _ in pairs(t) do
        count = count + 1
    end
    return count
end

---@param arr any[]
function m.arrayRemoveDuplicate(arr)
    local mark = {}
    local offset = 0
    local len = #arr
    for i = 1, len do
        local v = arr[i]
        if mark[v] then
            offset = offset + 1
        else
            arr[i - offset] = v
            mark[v] = true
        end
    end
    for i = len - offset + 1, len do
        arr[i] = nil
    end
end

---@generic V, R
---@param t V[]
---@param callback fun(v: V, k: integer): R
---@return R[]
function m.map(t, callback)
    local nt = {}
    for k, v in ipairs(t) do
        nt[k] = callback(v, k)
    end
    return nt
end

local sbyteMap = {
    [stringByte '_'] = 200,
}

---@param a string
---@param b string
---@return boolean
function m.stringLess(a, b)
    for i = 1, #a do
        if i > #b then
            return false
        end
        local c1 = stringByte(a, i, i)
        local c2 = stringByte(b, i, i)
        c1 = sbyteMap[c1] or c1
        c2 = sbyteMap[c2] or c2
        if c1 ~= c2 then
            return c1 < c2
        end
    end
    return true
end

---@param v any
---@param d any
---@return any
function m.default(v, d)
    if v == nil then
        return d
    end
    return v
end

---@generic T
---@param arr T[]
---@param k integer
---@param sorter? fun(a: T, b: T): boolean
---@return T[]
function m.sortK(arr, k, sorter)
    if not sorter then
        sorter = function (a, b)
            return a < b
        end
    end
    if k <= 0 then
        return arr
    end
    if k >= (#arr // 2) then
        tableSort(arr, sorter)
        return arr
    end

    local offset = 1

    local function sort(left, right)
        if left >= right then
            return
        end
        if left > k then
            return
        end
        -- 对这部分进行快排
        local index = left + offset % (right - left)
        local pivot = arr[index]
        offset = offset << 1
        if offset == 0 then
            offset = 1
        end
        arr[index], arr[right] = arr[right], arr[index]
        local i = left
        for j = left, right - 1 do
            if sorter(arr[j], pivot) then
                arr[i], arr[j] = arr[j], arr[i]
                i = i + 1
            end
        end
        arr[i], arr[right] = arr[right], arr[i]
        sort(i + 1, right)
        sort(left, i - 1)
    end

    sort(1, #arr)
    return arr
end

---@class string
---@operator mod(table): string
---@operator div(string): string

function m.enableFormatString()
    local mt = getmetatable('')
    mt.__mod = function (str, args)
        local count = 0
        return str:gsub('%b{}', function (key)
            local k, fmt = key:match('^{(.-):(.+)}$')
            if not k then
                k = key:sub(2, -2)
            end
            local value
            if k == '' then
                count = count + 1
                value = args[count]
            else
                value = args[k]
            end
            if value == nil and k:find('{', 1, true) then
                return '{' .. k % args .. '}'
            end
            if fmt then
                value = stringFormat('%' .. fmt, value)
            else
                value = tostring(value)
            end
            return value
        end)
    end
end

function m.enableDividStringAsPath()
    local mt = getmetatable('')
    mt.__div = function (str, path)
        assert(type(path) == 'string', 'Path must be a string')
        if str == '' then
            return path
        end
        if path == '' then
            return str
        end
        if path:sub(1, 1) == '/' then
            path = path:sub(2)
        end
        if str:sub(-1) == '/' then
            str = str:sub(1, -2)
        end
        return str .. '/' .. path
    end
end

---@param str string
---@param sep string
---@return string[]
function m.split(str, sep)
    local result = {}
    local offset = 1
    while offset <= #str do
        local s, e = str:find(sep, offset, true)
        if not s then
            result[#result+1] = str:sub(offset)
            break
        end
        result[#result+1] = str:sub(offset, s - 1)
        offset = e + 1
    end
    return result
end

---@generic T
---@param str string
---@param left string
---@param right string
---@param callback fun(content: string, inside: boolean): T
---@return T[]
function m.replaceInside(str, left, right, callback)
    local result = {}
    local offset = 1
    while offset <= #str do
        local ls, le = str:find(left, offset, true)
        if not ls then
            if offset <= #str then
                result[#result+1] = callback(str:sub(offset), false)
            end
            break
        end
        if ls > offset then
            result[#result+1] = callback(str:sub(offset, ls - 1), false)
        end

        local rs, re = str:find(right, le + 1, true)
        if not rs then
            if ls < #str then
                result[#result+1] = callback(str:sub(ls), true)
            end
            break
        end
        if rs > le + 1 then
            result[#result+1] = callback(str:sub(le + 1, rs - 1), true)
        end
        offset = re + 1
    end
    return result
end

---@param str string
---@return string
function m.asKey(str)
    if str:match('^[%a_][%w_]*$') and not RESERVED[str] then
        return str
    end
    return ('[%q]'):format(str)
end

---@param ... table
---@return table
function m.mergeStruct(...)
    local result
    local copyed = {}

    local function merge(a, b)
        if copyed[b] then
            return copyed[b]
        end
        if type(b) ~= 'table' then
            return b
        end
        if not a then
            a = {}
        end
        copyed[b] = a
        local usedKeys = {}
        for i, v in ipairs(b) do
            a[#a+1] = v
            usedKeys[i] = true
        end
        for k, v in pairs(b) do
            if not usedKeys[k] then
                a[k] = merge(a[k], v)
            end
        end
        return a
    end

    for _, t in ipairs { ... } do
        result = merge(result, t)
    end

    return result
end

return m
