diff options
Diffstat (limited to 'mac/.config/mpv/script-modules')
48 files changed, 9025 insertions, 0 deletions
diff --git a/mac/.config/mpv/script-modules/extended-menu.lua b/mac/.config/mpv/script-modules/extended-menu.lua new file mode 100644 index 0000000..b663e93 --- /dev/null +++ b/mac/.config/mpv/script-modules/extended-menu.lua @@ -0,0 +1,1214 @@ +local mp = require("mp") +local utils = require("mp.utils") +local assdraw = require("mp.assdraw") + +-- create namespace with default values +local em = { + + -- customisable values ------------------------------------------------------ + + loop_when_navigating = false, -- Loop when navigating through list + lines_to_show = 17, -- NOT including search line + pause_on_open = true, + resume_on_exit = "only-if-was-paused", -- another possible value is true + + -- styles (earlyer it was a table, but required many more steps to pass def-s + -- here from .conf file) + font_size = 21, + --font size scales by window + scale_by_window = false, + -- cursor 'width', useful to change if you have hidpi monitor + cursor_x_border = 0.3, + line_bottom_margin = 1, -- basically space between lines + text_color = { + default = "ffffff", + accent = "d8a07b", + current = "aaaaaa", + comment = "636363", + }, + menu_x_padding = 5, -- this padding for now applies only to 'left', not x + menu_y_padding = 2, -- but this one applies to both - top & bottom + + -- values that should be passed from main script ---------------------------- + + search_heading = "Default search heading", + -- 'full' is required from main script, 'current_i' is optional + -- others are 'private' + list = { + full = {}, + filtered = {}, + current_i = nil, + pointer_i = 1, + show_from_to = {}, + }, + -- field to compare with when searching for 'current value' by 'current_i' + index_field = "index", + -- fields to use when searching for string match / any other custom searching + -- if value has 0 length, then search list item itself + filter_by_fields = {}, + + -- 'private' values that are not supposed to be changed from the outside ---- + + is_active = false, + -- https://mpv.io/manual/master/#lua-scripting-mp-create-osd-overlay(format) + ass = mp.create_osd_overlay("ass-events"), + was_paused = false, -- flag that indicates that vid was paused by this script + + line = "", + -- if there was no cursor it wouldn't have been needed, but for now we need + -- variable below only to compare it with 'line' and see if we need to filter + prev_line = "", + cursor = 1, + history = {}, + history_pos = 1, + key_bindings = {}, + insert_mode = false, + + -- used only in 'update' func to get error text msgs + error_codes = { + no_match = "Match required", + no_submit_provided = "No submit function provided", + }, +} + +-- PRIVATE METHODS ------------------------------------------------------------ + +-- declare constructor function +function em:new(o) + o = o or {} + setmetatable(o, self) + self.__index = self + + -- some options might be customised by user in .conf file and read as strings + -- in that case parse those + if type(o.filter_by_fields) == "string" then + o.filter_by_fields = utils.parse_json(o.filter_by_fields) + end + + if type(o.text_color) == "string" then + o.text_color = utils.parse_json(o.text_color) + end + + return o +end + +-- this func is just a getter of a current list depending on search line +function em:current() + return self.line == "" and self.list.full or self.list.filtered +end + +-- REVIEW: how to get rid of this wrapper and handle filter func sideeffects +-- in a more elegant way? +function em:filter_wrapper() + -- handles sideeffect that are needed to be run on filtering list + -- cuz the filter func may be redefined in main script and therefore needs + -- to be straight forward - only doing filtering and returning the table + + -- passing current query just in case, so ppl can use it in their custom funcs + self.list.filtered = self:filter(self.line) + + self.prev_line = self.line + self.list.pointer_i = 1 + self:set_from_to(true) +end + +function em:set_from_to(reset_flag) + -- additional variables just for shorter var name + local i = self.list.pointer_i + local to_show = self.lines_to_show + local total = #self:current() + + if reset_flag or to_show >= total then + self.list.show_from_to = { 1, math.min(to_show, total) } + return + end + + -- If menu is opened with something already selected we want this 'selected' + -- to be displayed close to the middle of the menu. That's why 'show_from_to' + -- is not initially set, so we can know - if show_from_to length is 0 - it is + -- first call of this func in cur. init + if #self.list.show_from_to == 0 then + -- set show_from_to so chosen item will be displayed close to middle + local half_list = math.ceil(to_show / 2) + if i < half_list then + self.list.show_from_to = { 1, to_show } + elseif total - i < half_list then + self.list.show_from_to = { total - to_show + 1, total } + else + self.list.show_from_to = { i - half_list + 1, i - half_list + to_show } + end + else + table.unpack = table.unpack or unpack -- 5.1 compatibility + local first, last = table.unpack(self.list.show_from_to) + + -- handle cursor moving towards start / end bondary + if first ~= 1 and i - first < 2 then + self.list.show_from_to = { first - 1, last - 1 } + end + if last ~= total and last - i < 2 then + self.list.show_from_to = { first + 1, last + 1 } + end + + -- handle index jumps from beginning to end and backwards + if i > last then + self.list.show_from_to = { i - to_show + 1, i } + end + if i < first then + self.list.show_from_to = { 1, to_show } + end + end +end + +function em:change_selected_index(num) + self.list.pointer_i = self.list.pointer_i + num + if self.loop_when_navigating then + if self.list.pointer_i < 1 then + self.list.pointer_i = #self:current() + elseif self.list.pointer_i > #self:current() then + self.list.pointer_i = 1 + end + else + if self.list.pointer_i < 1 then + self.list.pointer_i = 1 + elseif self.list.pointer_i > #self:current() then + self.list.pointer_i = #self:current() + end + end + self:set_from_to() + self:update() +end + +-- Render the REPL and console as an ASS OSD +function em:update(err_code) + -- ASS tags documentation here - https://aegi.vmoe.info/docs/3.0/ASS_Tags/ + + -- do not bother if function was called to close the menu.. + if not self.is_active then + em.ass:remove() + return + end + + local line_height = self.font_size + self.line_bottom_margin + local _, h, aspect = mp.get_osd_size() + local wh = self.scale_by_window and 720 or h + local ww = wh * aspect + + -- '+ 1' below is a search string + local menu_y_pos = wh - (line_height * (self.lines_to_show + 1) + self.menu_y_padding * 2) + + -- didn't find better place to handle filtered list update + if self.line ~= self.prev_line then + self:filter_wrapper() + end + + local function get_background() + local a = self:ass_new_wrapper() + a:append("{\\1c&H1c1c1c\\1a&H19}") -- background color & opacity + a:pos(0, 0) + a:draw_start() + a:rect_cw(0, menu_y_pos, ww, wh) + a:draw_stop() + return a.text + end + + local function get_search_header() + local a = self:ass_new_wrapper() + + a:pos(self.menu_x_padding, menu_y_pos + self.menu_y_padding) + + local search_prefix = table.concat({ + self:get_font_color("accent"), + (#self:current() ~= 0 and self.list.pointer_i or "!"), + "/", + #self:current(), + "\\h\\h", + self.search_heading, + ":\\h", + }) + + a:append(search_prefix) + -- reset font color after search prefix + a:append(self:get_font_color("default")) + + -- Create the cursor glyph as an ASS drawing. ASS will draw the cursor + -- inline with the surrounding text, but it sets the advance to the width + -- of the drawing. So the cursor doesn't affect layout too much, make it as + -- thin as possible and make it appear to be 1px wide by giving it 0.5px + -- horizontal borders. + local cheight = self.font_size * 8 + -- TODO: maybe do it using draw_rect from ass? + local cglyph = "{\\r" -- styles reset + .. "\\1c&Hffffff&\\3c&Hffffff" -- font color and border color + .. "\\xbord" + .. self.cursor_x_border + .. "\\p4\\pbo24}" -- xborder, scale x8 and baseline offset + .. "m 0 0 l 0 " + .. cheight -- drawing just a line + .. "{\\p0\\r}" -- finish drawing and reset styles + local before_cur = self:ass_escape(self.line:sub(1, self.cursor - 1)) + local after_cur = self:ass_escape(self.line:sub(self.cursor)) + + a:append(table.concat({ + before_cur, + cglyph, + self:reset_styles(), + self:get_font_color("default"), + after_cur, + (err_code and "\\h" .. self.error_codes[err_code] or ""), + })) + + return a.text + + -- NOTE: perhaps this commented code will some day help me in coding cursor + -- like in M-x emacs menu: + -- Redraw the cursor with the REPL text invisible. This will make the + -- cursor appear in front of the text. + -- ass:new_event() + -- ass:an(1) + -- ass:append(style .. '{\\alpha&HFF&}> ' .. before_cur) + -- ass:append(cglyph) + -- ass:append(style .. '{\\alpha&HFF&}' .. after_cur) + end + + local function get_list() + local a = assdraw.ass_new() + + local function apply_highlighting(y) + a:new_event() + a:append(self:reset_styles()) + a:append("{\\1c&Hffffff\\1a&HE6}") -- background color & opacity + a:pos(0, 0) + a:draw_start() + a:rect_cw(0, y, ww, y + self.font_size) + a:draw_stop() + end + + -- REVIEW: maybe make another function 'get_line_str' and move there + -- everything from this for loop? + -- REVIEW: how to use something like table.unpack below? + for i = self.list.show_from_to[1], self.list.show_from_to[2] do + local value = assert(self:current()[i], "no value with index " .. i) + local y_offset = menu_y_pos + self.menu_y_padding + (line_height * (i - self.list.show_from_to[1] + 1)) + + if i == self.list.pointer_i then + apply_highlighting(y_offset) + end + + a:new_event() + a:append(self:reset_styles()) + a:pos(self.menu_x_padding, y_offset) + a:append(self:get_line(i, value)) + end + + return a.text + end + + em.ass.res_x = ww + em.ass.res_y = wh + em.ass.data = table.concat({ + get_background(), + get_search_header(), + get_list(), + }, "\n") + + em.ass:update() +end + +-- params: +-- - data : {list: {}, [current_i] : num} +function em:init(data) + self.list.full = data.list or {} + self.list.current_i = data.current_i or nil + self.list.pointer_i = data.current_i or 1 + self:set_active(true) +end + +function em:exit() + self:undefine_key_bindings() + collectgarbage() +end + +-- TODO: write some idle func like this +-- function idle() +-- if pending_selection then +-- gallery:set_selection(pending_selection) +-- pending_selection = nil +-- end +-- if ass_changed or geometry_changed then +-- local ww, wh = mp.get_osd_size() +-- if geometry_changed then +-- geometry_changed = false +-- compute_geometry(ww, wh) +-- end +-- if ass_changed then +-- ass_changed = false +-- mp.set_osd_ass(ww, wh, ass) +-- end +-- end +-- end +-- ... +-- and handle it as follows +-- init(): +-- mp.register_idle(idle) +-- idle() +-- exit(): +-- mp.unregister_idle(idle) +-- idle() +-- And in these observers he is setting a flag, that's being checked in func above +-- mp.observe_property("osd-width", "native", mark_geometry_stale) +-- mp.observe_property("osd-height", "native", mark_geometry_stale) + +-- PRIVATE METHODS END -------------------------------------------------------- + +-- PUBLIC METHODS ------------------------------------------------------------- + +function em:filter() + -- default filter func, might be redefined in main script + local result = {} + + local function get_full_search_str(v) + local str = "" + for _, key in ipairs(self.filter_by_fields) do + str = str .. (v[key] or "") + end + return str + end + + for _, v in ipairs(self.list.full) do + -- if filter_by_fields has 0 length, then search list item itself + if #self.filter_by_fields == 0 then + if self:search_method(v) then + table.insert(result, v) + end + else + -- NOTE: we might use search_method on fiels separately like this: + -- for _,key in ipairs(self.filter_by_fields) do + -- if self:search_method(v[key]) then table.insert(result, v) end + -- end + -- But since im planning to implement fuzzy search in future i need full + -- search string here + if self:search_method(get_full_search_str(v)) then + table.insert(result, v) + end + end + end + return result +end + +-- TODO: implement fuzzy search and maybe match highlights +function em:search_method(str) + -- also might be redefined by main script + + -- convert to string just to make sure.. + return tostring(str):lower():find(self.line:lower(), 1, true) +end + +-- this module requires submit function to be defined in main script +function em:submit() + self:update("no_submit_provided") +end + +function em:update_list(list) + -- for now this func doesn't handle cases when we have 'current_i' to update + -- it + self.list.full = list + if self.line ~= self.prev_line then + self:filter_wrapper() + end +end + +-- PUBLIC METHODS END --------------------------------------------------------- + +-- HELPER METHODS ------------------------------------------------------------- + +function em:get_line(_, v) -- [i]ndex, [v]alue + -- this func might be redefined in main script to get a custom-formatted line + -- default implementation of this func supposes that value.content field is a + -- String + local a = assdraw.ass_new() + local style = (self.list.current_i == v[self.index_field]) and "current" or "default" + + a:append(self:reset_styles()) + a:append(self:get_font_color(style)) + -- content as default field, which is holding string + -- no point in moving it to main object since content itself is being + -- composed in THIS function, that might (and most likely, should) be + -- redefined in main script + a:append(v.content or "Something is off in `get_line` func") + return a.text +end + +-- REVIEW: for now i don't see normal way of mergin this func with below one +-- but it's being used only once +function em:reset_styles() + local a = assdraw.ass_new() + -- alignment top left, no word wrapping, border 0, shadow 0 + a:append("{\\an7\\q2\\bord0\\shad0}") + a:append("{\\fs" .. self.font_size .. "}") + return a.text +end + +-- function to get rid of some copypaste +function em:ass_new_wrapper() + local a = assdraw.ass_new() + a:new_event() + a:append(self:reset_styles()) + return a +end + +function em:get_font_color(style) + return "{\\1c&H" .. self.text_color[style] .. "}" +end + +-- HELPER METHODS END --------------------------------------------------------- + +--[[ + The below code is a modified implementation of text input from mpv's console.lua: + https://github.com/mpv-player/mpv/blob/87c9eefb2928252497f6141e847b74ad1158bc61/player/lua/console.lua + + I was too lazy to list all modifications i've done to the script, but if u + rly need to see those - do diff with the original code +]] +-- + +------------------------------------------------------------------------------- +-- START ORIGINAL MPV CODE -- +------------------------------------------------------------------------------- + +-- Copyright (C) 2019 the mpv developers +-- +-- Permission to use, copy, modify, and/or distribute this software for any +-- purpose with or without fee is hereby granted, provided that the above +-- copyright notice and this permission notice appear in all copies. +-- +-- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +-- WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +-- MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY +-- SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +-- WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION +-- OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN +-- CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +function em:detect_platform() + local o = {} + -- Kind of a dumb way of detecting the platform but whatever + if mp.get_property_native("options/vo-mmcss-profile", o) ~= o then + return "windows" + elseif mp.get_property_native("options/macos-force-dedicated-gpu", o) ~= o then + return "macos" + elseif os.getenv("WAYLAND_DISPLAY") then + return "wayland" + end + return "x11" +end + +-- Escape a string for verbatim display on the OSD +function em:ass_escape(str) + -- There is no escape for '\' in ASS (I think?) but '\' is used verbatim if + -- it isn't followed by a recognised character, so add a zero-width + -- non-breaking space + str = str:gsub("\\", "\\\239\187\191") + str = str:gsub("{", "\\{") + str = str:gsub("}", "\\}") + -- Precede newlines with a ZWNBSP to prevent ASS's weird collapsing of + -- consecutive newlines + str = str:gsub("\n", "\239\187\191\\N") + -- Turn leading spaces into hard spaces to prevent ASS from stripping them + str = str:gsub("\\N ", "\\N\\h") + str = str:gsub("^ ", "\\h") + return str +end + +-- Set the REPL visibility ("enable", Esc) +function em:set_active(active) + if active == self.is_active then + return + end + if active then + self.is_active = true + self.insert_mode = false + mp.enable_messages("terminal-default") + self:define_key_bindings() + + -- set flag 'was_paused' only if vid wasn't paused before EM init + if self.pause_on_open and not mp.get_property_bool("pause", false) then + mp.set_property_bool("pause", true) + self.was_paused = true + end + + self:set_from_to() + self:update() + else + -- no need to call 'update' in this block cuz 'clear' method is calling it + self.is_active = false + self:undefine_key_bindings() + + if self.resume_on_exit == true or (self.resume_on_exit == "only-if-was-paused" and self.was_paused) then + mp.set_property_bool("pause", false) + end + + self:clear() + collectgarbage() + end +end + +-- Naive helper function to find the next UTF-8 character in 'str' after 'pos' +-- by skipping continuation bytes. Assumes 'str' contains valid UTF-8. +function em:next_utf8(str, pos) + if pos > str:len() then + return pos + end + repeat + pos = pos + 1 + until pos > str:len() or str:byte(pos) < 0x80 or str:byte(pos) > 0xbf + return pos +end + +-- As above, but finds the previous UTF-8 charcter in 'str' before 'pos' +function em:prev_utf8(str, pos) + if pos <= 1 then + return pos + end + repeat + pos = pos - 1 + until pos <= 1 or str:byte(pos) < 0x80 or str:byte(pos) > 0xbf + return pos +end + +-- Insert a character at the current cursor position (any_unicode) +function em:handle_char_input(c) + if self.insert_mode then + self.line = self.line:sub(1, self.cursor - 1) .. c .. self.line:sub(self:next_utf8(self.line, self.cursor)) + else + self.line = self.line:sub(1, self.cursor - 1) .. c .. self.line:sub(self.cursor) + end + self.cursor = self.cursor + #c + self:update() +end + +-- Remove the character behind the cursor (Backspace) +function em:handle_backspace() + if self.cursor <= 1 then + return + end + local prev = self:prev_utf8(self.line, self.cursor) + self.line = self.line:sub(1, prev - 1) .. self.line:sub(self.cursor) + self.cursor = prev + self:update() +end + +-- Remove the character in front of the cursor (Del) +function em:handle_del() + if self.cursor > self.line:len() then + return + end + self.line = self.line:sub(1, self.cursor - 1) .. self.line:sub(self:next_utf8(self.line, self.cursor)) + self:update() +end + +-- Toggle insert mode (Ins) +function em:handle_ins() + self.insert_mode = not self.insert_mode +end + +-- Move the cursor to the next character (Right) +function em:next_char() + self.cursor = self:next_utf8(self.line, self.cursor) + self:update() +end + +-- Move the cursor to the previous character (Left) +function em:prev_char() + self.cursor = self:prev_utf8(self.line, self.cursor) + self:update() +end + +-- Clear the current line (Ctrl+C) +function em:clear() + self.line = "" + self.prev_line = "" + + self.list.current_i = nil + self.list.pointer_i = 1 + self.list.filtered = {} + self.list.show_from_to = {} + + self.was_paused = false + + self.cursor = 1 + self.insert_mode = false + self.history_pos = #self.history + 1 + + self:update() +end + +-- Run the current command and clear the line (Enter) +function em:handle_enter() + if #self:current() == 0 then + self:update("no_match") + return + end + + if self.history[#self.history] ~= self.line then + self.history[#self.history + 1] = self.line + end + + self:submit(self:current()[self.list.pointer_i]) + self:set_active(false) +end + +-- Go to the specified position in the command history +function em:go_history(new_pos) + local old_pos = self.history_pos + self.history_pos = new_pos + + -- Restrict the position to a legal value + if self.history_pos > #self.history + 1 then + self.history_pos = #self.history + 1 + elseif self.history_pos < 1 then + self.history_pos = 1 + end + + -- Do nothing if the history position didn't actually change + if self.history_pos == old_pos then + return + end + + -- If the user was editing a non-history line, save it as the last history + -- entry. This makes it much less frustrating to accidentally hit Up/Down + -- while editing a line. + if old_pos == #self.history + 1 and self.line ~= "" and self.history[#self.history] ~= self.line then + self.history[#self.history + 1] = self.line + end + + -- Now show the history line (or a blank line for #history + 1) + if self.history_pos <= #self.history then + self.line = self.history[self.history_pos] + else + self.line = "" + end + self.cursor = self.line:len() + 1 + self.insert_mode = false + self:update() +end + +-- Go to the specified relative position in the command history (Up, Down) +function em:move_history(amount) + self:go_history(self.history_pos + amount) +end + +-- Go to the first command in the command history (PgUp) +function em:handle_pgup() + -- Determine the number of items to move up (half a page) + local half_page = math.ceil(self.lines_to_show / 2) + + -- Move the history position up by half a page + self:change_selected_index(-half_page) +end + +-- Stop browsing history and start editing a blank line (PgDown) +function em:handle_pgdown() + -- Determine the number of items to move down (half a page) + local half_page = math.ceil(self.lines_to_show / 2) + + -- Move the history position down by half a page + self:change_selected_index(half_page) +end + +-- Move to the start of the current word, or if already at the start, the start +-- of the previous word. (Ctrl+Left) +function em:prev_word() + -- This is basically the same as next_word() but backwards, so reverse the + -- string in order to do a "backwards" find. This wouldn't be as annoying + -- to do if Lua didn't insist on 1-based indexing. + self.cursor = self.line:len() + - select(2, self.line:reverse():find("%s*[^%s]*", self.line:len() - self.cursor + 2)) + + 1 + self:update() +end + +-- Move to the end of the current word, or if already at the end, the end of +-- the next word. (Ctrl+Right) +function em:next_word() + self.cursor = select(2, self.line:find("%s*[^%s]*", self.cursor)) + 1 + self:update() +end + +-- Move the cursor to the beginning of the line (HOME) +function em:go_home() + self.cursor = 1 + self:update() +end + +-- Move the cursor to the end of the line (END) +function em:go_end() + self.cursor = self.line:len() + 1 + self:update() +end + +-- Delete from the cursor to the beginning of the word (Ctrl+Backspace) +function em:del_word() + local before_cur = self.line:sub(1, self.cursor - 1) + local after_cur = self.line:sub(self.cursor) + + before_cur = before_cur:gsub("[^%s]+%s*$", "", 1) + self.line = before_cur .. after_cur + self.cursor = before_cur:len() + 1 + self:update() +end + +-- Delete from the cursor to the end of the word (Ctrl+Del) +function em:del_next_word() + if self.cursor > self.line:len() then + return + end + + local before_cur = self.line:sub(1, self.cursor - 1) + local after_cur = self.line:sub(self.cursor) + + after_cur = after_cur:gsub("^%s*[^%s]+", "", 1) + self.line = before_cur .. after_cur + self:update() +end + +-- Delete from the cursor to the end of the line (Ctrl+K) +function em:del_to_eol() + self.line = self.line:sub(1, self.cursor - 1) + self:update() +end + +-- Delete from the cursor back to the start of the line (Ctrl+U) +function em:del_to_start() + self.line = self.line:sub(self.cursor) + self.cursor = 1 + self:update() +end + +-- Returns a string of UTF-8 text from the clipboard (or the primary selection) +function em:get_clipboard(clip) + -- Pick a better default font for Windows and macOS + local platform = self:detect_platform() + + if platform == "x11" then + local res = utils.subprocess({ + args = { "xclip", "-selection", clip and "clipboard" or "primary", "-out" }, + playback_only = false, + }) + if not res.error then + return res.stdout + end + elseif platform == "wayland" then + local res = utils.subprocess({ + args = { "wl-paste", clip and "-n" or "-np" }, + playback_only = false, + }) + if not res.error then + return res.stdout + end + elseif platform == "windows" then + local res = utils.subprocess({ + args = { + "powershell", + "-NoProfile", + "-Command", + [[& { + Trap { + Write-Error -ErrorRecord $_ + Exit 1 + } + + $clip = "" + if (Get-Command "Get-Clipboard" -errorAction SilentlyContinue) { + $clip = Get-Clipboard -Raw -Format Text -TextFormatType UnicodeText + } else { + Add-Type -AssemblyName PresentationCore + $clip = [Windows.Clipboard]::GetText() + } + + $clip = $clip -Replace "`r","" + $u8clip = [System.Text.Encoding]::UTF8.GetBytes($clip) + [Console]::OpenStandardOutput().Write($u8clip, 0, $u8clip.Length) + }]], + }, + playback_only = false, + }) + if not res.error then + return res.stdout + end + elseif platform == "macos" then + local res = utils.subprocess({ + args = { "pbpaste" }, + playback_only = false, + }) + if not res.error then + return res.stdout + end + end + return "" +end + +-- Paste text from the window-system's clipboard. 'clip' determines whether the +-- clipboard or the primary selection buffer is used (on X11 and Wayland only.) +function em:paste(clip) + local text = self:get_clipboard(clip) + local before_cur = self.line:sub(1, self.cursor - 1) + local after_cur = self.line:sub(self.cursor) + self.line = before_cur .. text .. after_cur + self.cursor = self.cursor + text:len() + self:update() +end + +-- List of input bindings. This is a weird mashup between common GUI text-input +-- bindings and readline bindings. +function em:get_bindings() + local bindings = { + { + "ctrl+[", + function() + self:set_active(false) + end, + }, + { + "ctrl+g", + function() + self:set_active(false) + end, + }, + { + "esc", + function() + self:set_active(false) + end, + }, + { + "enter", + function() + self:handle_enter() + end, + }, + { + "kp_enter", + function() + self:handle_enter() + end, + }, + { + "ctrl+m", + function() + self:handle_enter() + end, + }, + { + "bs", + function() + self:handle_backspace() + end, + }, + { + "shift+bs", + function() + self:handle_backspace() + end, + }, + { + "ctrl+h", + function() + self:handle_backspace() + end, + }, + { + "del", + function() + self:handle_del() + end, + }, + { + "shift+del", + function() + self:handle_del() + end, + }, + { + "ins", + function() + self:handle_ins() + end, + }, + { + "shift+ins", + function() + self:paste(false) + end, + }, + { + "mbtn_mid", + function() + self:paste(false) + end, + }, + { + "left", + function() + self:prev_char() + end, + }, + { + "ctrl+b", + function() + self:prev_char() + end, + }, + { + "right", + function() + self:next_char() + end, + }, + { + "ctrl+f", + function() + self:next_char() + end, + }, + { + "ctrl+k", + function() + self:change_selected_index(-1) + end, + }, + { + "ctrl+p", + function() + self:change_selected_index(-1) + end, + }, + { + "ctrl+j", + function() + self:change_selected_index(1) + end, + }, + { + "ctrl+n", + function() + self:change_selected_index(1) + end, + }, + { + "up", + function() + self:move_history(-1) + end, + }, + { + "alt+p", + function() + self:move_history(-1) + end, + }, + { + "wheel_up", + function() + self:move_history(-1) + end, + }, + { + "down", + function() + self:move_history(1) + end, + }, + { + "alt+n", + function() + self:move_history(1) + end, + }, + { + "wheel_down", + function() + self:move_history(1) + end, + }, + { "wheel_left", function() end }, + { "wheel_right", function() end }, + { + "ctrl+left", + function() + self:prev_word() + end, + }, + { + "alt+b", + function() + self:prev_word() + end, + }, + { + "ctrl+right", + function() + self:next_word() + end, + }, + { + "alt+f", + function() + self:next_word() + end, + }, + { + "ctrl+a", + function() + self:go_home() + end, + }, + { + "home", + function() + self:go_home() + end, + }, + { + "ctrl+e", + function() + self:go_end() + end, + }, + { + "end", + function() + self:go_end() + end, + }, + { + "ctrl+shift+f", + function() + self:handle_pgdown() + end, + }, + { + "ctrl+shift+b", + function() + self:handle_pgup() + end, + }, + { + "pgdwn", + function() + self:handle_pgdown() + end, + }, + { + "pgup", + function() + self:handle_pgup() + end, + }, + { + "ctrl+c", + function() + self:clear() + end, + }, + { + "ctrl+d", + function() + self:handle_del() + end, + }, + { + "ctrl+u", + function() + self:del_to_start() + end, + }, + { + "ctrl+v", + function() + self:paste(true) + end, + }, + { + "meta+v", + function() + self:paste(true) + end, + }, + { + "ctrl+bs", + function() + self:del_word() + end, + }, + { + "ctrl+w", + function() + self:del_word() + end, + }, + { + "ctrl+del", + function() + self:del_next_word() + end, + }, + { + "alt+d", + function() + self:del_next_word() + end, + }, + { + "kp_dec", + function() + self:handle_char_input(".") + end, + }, + } + + for i = 0, 9 do + bindings[#bindings + 1] = { + "kp" .. i, + function() + self:handle_char_input("" .. i) + end, + } + end + + return bindings +end + +function em:text_input(info) + if info.key_text and (info.event == "press" or info.event == "down" or info.event == "repeat") then + self:handle_char_input(info.key_text) + end +end + +function em:define_key_bindings() + if #self.key_bindings > 0 then + return + end + for _, bind in ipairs(self:get_bindings()) do + -- Generate arbitrary name for removing the bindings later. + local name = "search_" .. (#self.key_bindings + 1) + self.key_bindings[#self.key_bindings + 1] = name + mp.add_forced_key_binding(bind[1], name, bind[2], { repeatable = true }) + end + mp.add_forced_key_binding("any_unicode", "search_input", function(...) + self:text_input(...) + end, { repeatable = true, complex = true }) + self.key_bindings[#self.key_bindings + 1] = "search_input" +end + +function em:undefine_key_bindings() + for _, name in ipairs(self.key_bindings) do + mp.remove_key_binding(name) + end + self.key_bindings = {} +end + +------------------------------------------------------------------------------- +-- END ORIGINAL MPV CODE -- +------------------------------------------------------------------------------- + +return em diff --git a/mac/.config/mpv/script-modules/gallery.lua b/mac/.config/mpv/script-modules/gallery.lua new file mode 100644 index 0000000..ee0be42 --- /dev/null +++ b/mac/.config/mpv/script-modules/gallery.lua @@ -0,0 +1,581 @@ +local utils = require("mp.utils") +local msg = require("mp.msg") +local assdraw = require("mp.assdraw") + +local gallery_mt = {} +gallery_mt.__index = gallery_mt + +function gallery_new() + local gallery = setmetatable({ + -- public, can be modified by user + items = {}, + item_to_overlay_path = function(index, item) + return "" + end, + item_to_thumbnail_params = function(index, item) + return "", 0 + end, + item_to_text = function(index, item) + return "", true + end, + item_to_border = function(index, item) + return 0, "" + end, + ass_show = function(ass) end, + config = { + background_color = "333333", + background_opacity = "33", + background_roundness = 5, + scrollbar = true, + scrollbar_left_side = false, + scrollbar_min_size = 10, + overlay_range = 0, + max_thumbnails = 64, + show_placeholders = true, + always_show_placeholders = false, + placeholder_color = "222222", + text_size = 28, + align_text = true, + accurate = false, + generate_thumbnails_with_mpv = false, + }, + + -- private, can be read but should not be modified + active = false, + geometry = { + ok = false, + position = { 0, 0 }, + size = { 0, 0 }, + min_spacing = { 0, 0 }, + thumbnail_size = { 0, 0 }, + rows = 0, + columns = 0, + effective_spacing = { 0, 0 }, + }, + view = { -- 1-based indices into the "playlist" array + first = 0, -- must be equal to N*columns + last = 0, -- must be > first and <= first + rows*columns + }, + overlays = { + active = {}, -- array of <=64 strings indicating the file associated to the current overlay (false if nothing) + missing = {}, -- associative array of thumbnail path to view index it should be shown at + }, + selection = nil, + ass = { + background = "", + selection = "", + scrollbar = "", + placeholders = "", + }, + generators = {}, -- list of generator scripts + }, gallery_mt) + + for i = 1, gallery.config.max_thumbnails do + gallery.overlays.active[i] = false + end + return gallery +end + +function gallery_mt.show_overlay(gallery, index_1, thumb_path) + local g = gallery.geometry + gallery.overlays.active[index_1] = thumb_path + local index_0 = index_1 - 1 + local x, y = gallery:view_index_position(index_0) + mp.commandv( + "overlay-add", + tostring(index_0 + gallery.config.overlay_range), + tostring(math.floor(x + 0.5)), + tostring(math.floor(y + 0.5)), + thumb_path, + "0", + "bgra", + tostring(g.thumbnail_size[1]), + tostring(g.thumbnail_size[2]), + tostring(4 * g.thumbnail_size[1]) + ) + mp.osd_message(" ", 0.01) +end + +function gallery_mt.remove_overlays(gallery) + for view_index, _ in pairs(gallery.overlays.active) do + mp.commandv("overlay-remove", gallery.config.overlay_range + view_index - 1) + gallery.overlays.active[view_index] = false + end + gallery.overlays.missing = {} +end + +local function file_exists(path) + local info = utils.file_info(path) + return info ~= nil and info.is_file +end + +function gallery_mt.refresh_overlays(gallery, force) + local todo = {} + local o = gallery.overlays + local g = gallery.geometry + o.missing = {} + for view_index = 1, g.rows * g.columns do + local index = gallery.view.first + view_index - 1 + local active = o.active[view_index] + if index > 0 and index <= #gallery.items then + local thumb_path = gallery.item_to_overlay_path(index, gallery.items[index]) + if not force and active == thumb_path then + -- nothing to do + elseif file_exists(thumb_path) then + gallery:show_overlay(view_index, thumb_path) + else + -- need to generate that thumbnail + o.active[view_index] = false + mp.commandv("overlay-remove", gallery.config.overlay_range + view_index - 1) + o.missing[thumb_path] = view_index + todo[#todo + 1] = { index = index, output = thumb_path } + end + else + -- might happen if we're close to the end of gallery.items + if active ~= false then + o.active[view_index] = false + mp.commandv("overlay-remove", gallery.config.overlay_range + view_index - 1) + end + end + end + if #gallery.generators >= 1 then + -- reverse iterate so that the first thumbnail is at the top of the stack + for i = #todo, 1, -1 do + local generator = gallery.generators[i % #gallery.generators + 1] + local t = todo[i] + local input_path, time = gallery.item_to_thumbnail_params(t.index, gallery.items[t.index]) + mp.commandv( + "script-message-to", + generator, + "push-thumbnail-front", + mp.get_script_name(), + input_path, + tostring(g.thumbnail_size[1]), + tostring(g.thumbnail_size[2]), + time, + t.output, + gallery.config.accurate and "true" or "false", + gallery.config.generate_thumbnails_with_mpv and "true" or "false" + ) + end + end +end + +function gallery_mt.index_at(gallery, mx, my) + local g = gallery.geometry + if mx < g.position[1] or my < g.position[2] then + return nil + end + mx = mx - g.position[1] + my = my - g.position[2] + if mx > g.size[1] or my > g.size[2] then + return nil + end + mx = mx - g.effective_spacing[1] + my = my - g.effective_spacing[2] + local on_column = (mx % (g.thumbnail_size[1] + g.effective_spacing[1])) < g.thumbnail_size[1] + local on_row = (my % (g.thumbnail_size[2] + g.effective_spacing[2])) < g.thumbnail_size[2] + if on_column and on_row then + local column = math.floor(mx / (g.thumbnail_size[1] + g.effective_spacing[1])) + local row = math.floor(my / (g.thumbnail_size[2] + g.effective_spacing[2])) + local index = gallery.view.first + row * g.columns + column + if index > 0 and index <= gallery.view.last then + return index + end + end + return nil +end + +function gallery_mt.compute_internal_geometry(gallery) + local g = gallery.geometry + g.rows = math.floor((g.size[2] - g.min_spacing[2]) / (g.thumbnail_size[2] + g.min_spacing[2])) + g.columns = math.floor((g.size[1] - g.min_spacing[1]) / (g.thumbnail_size[1] + g.min_spacing[1])) + if g.rows <= 0 or g.columns <= 0 then + g.rows = 0 + g.columns = 0 + g.effective_spacing[1] = g.size[1] + g.effective_spacing[2] = g.size[2] + return + end + if g.rows * g.columns > gallery.config.max_thumbnails then + local r = math.sqrt(g.rows * g.columns / gallery.config.max_thumbnails) + g.rows = math.floor(g.rows / r) + g.columns = math.floor(g.columns / r) + end + g.effective_spacing[1] = (g.size[1] - g.columns * g.thumbnail_size[1]) / (g.columns + 1) + g.effective_spacing[2] = (g.size[2] - g.rows * g.thumbnail_size[2]) / (g.rows + 1) +end + +-- makes sure that view.first and view.last are valid with regards to the playlist +-- and that selection is within the view +-- to be called after the playlist, view or selection was modified somehow +function gallery_mt.ensure_view_valid(gallery) + local g = gallery.geometry + if #gallery.items == 0 or g.rows == 0 or g.columns == 0 then + gallery.view.first = 0 + gallery.view.last = 0 + return + end + local v = gallery.view + local selection_row = math.floor((gallery.selection - 1) / g.columns) + local max_thumbs = g.rows * g.columns + local changed = false + + if v.last >= #gallery.items then + v.last = #gallery.items + if g.rows == 1 then + v.first = math.max(1, v.last - g.columns + 1) + else + local last_row = math.floor((v.last - 1) / g.columns) + local first_row = math.max(0, last_row - g.rows + 1) + v.first = 1 + first_row * g.columns + end + changed = true + elseif v.first == 0 or v.last == 0 or v.last - v.first + 1 ~= max_thumbs then + -- special case: the number of possible thumbnails was changed + -- just recreate the view such that the selection is in the middle row + local max_row = (#gallery.items - 1) / g.columns + 1 + local row_first = selection_row - math.floor((g.rows - 1) / 2) + local row_last = selection_row + math.floor((g.rows - 1) / 2) + g.rows % 2 + if row_first < 0 then + row_first = 0 + elseif row_last > max_row then + row_first = max_row - g.rows + 1 + end + v.first = 1 + row_first * g.columns + v.last = math.min(#gallery.items, v.first - 1 + max_thumbs) + return true + end + + if gallery.selection < v.first then + -- the selection is now on the first line + v.first = (g.rows == 1) and gallery.selection or selection_row * g.columns + 1 + v.last = math.min(#gallery.items, v.first + max_thumbs - 1) + changed = true + elseif gallery.selection > v.last then + v.last = (g.rows == 1) and gallery.selection or (selection_row + 1) * g.columns + v.first = math.max(1, v.last - max_thumbs + 1) + v.last = math.min(#gallery.items, v.last) + changed = true + end + return changed +end + +-- ass related stuff +function gallery_mt.refresh_background(gallery) + local g = gallery.geometry + local a = assdraw.ass_new() + a:new_event() + a:append("{\\an7}") + a:append("{\\bord0}") + a:append("{\\shad0}") + a:append("{\\1c&" .. gallery.config.background_color .. "}") + a:append("{\\1a&" .. gallery.config.background_opacity .. "}") + a:pos(0, 0) + a:draw_start() + a:round_rect_cw( + g.position[1], + g.position[2], + g.position[1] + g.size[1], + g.position[2] + g.size[2], + gallery.config.background_roundness + ) + a:draw_stop() + gallery.ass.background = a.text +end + +function gallery_mt.refresh_placeholders(gallery) + if not gallery.config.show_placeholders then + return + end + if gallery.view.first == 0 then + gallery.ass.placeholders = "" + return + end + local g = gallery.geometry + local a = assdraw.ass_new() + a:new_event() + a:append("{\\an7}") + a:append("{\\bord0}") + a:append("{\\shad0}") + a:append("{\\1c&" .. gallery.config.placeholder_color .. "}") + a:pos(0, 0) + a:draw_start() + for i = 0, gallery.view.last - gallery.view.first do + if gallery.config.always_show_placeholders or not gallery.overlays.active[i + 1] then + local x, y = gallery:view_index_position(i) + a:rect_cw(x, y, x + g.thumbnail_size[1], y + g.thumbnail_size[2]) + end + end + a:draw_stop() + gallery.ass.placeholders = a.text +end + +function gallery_mt.refresh_scrollbar(gallery) + if not gallery.config.scrollbar then + return + end + gallery.ass.scrollbar = "" + if gallery.view.first == 0 then + return + end + local g = gallery.geometry + local before = (gallery.view.first - 1) / #gallery.items + local after = (#gallery.items - gallery.view.last) / #gallery.items + -- don't show the scrollbar if everything is visible + if before + after == 0 then + return + end + local p = gallery.config.scrollbar_min_size / 100 + if before + after > 1 - p then + if before == 0 then + after = (1 - p) + elseif after == 0 then + before = (1 - p) + else + before, after = + before / after * (1 - p) / (1 + before / after), after / before * (1 - p) / (1 + after / before) + end + end + local dist_from_edge = g.size[2] * 0.015 + local y1 = g.position[2] + dist_from_edge + before * (g.size[2] - 2 * dist_from_edge) + local y2 = g.position[2] + g.size[2] - (dist_from_edge + after * (g.size[2] - 2 * dist_from_edge)) + local x1, x2 + if gallery.config.scrollbar_left_side then + x1 = g.position[1] + g.effective_spacing[1] / 2 - 2 + else + x1 = g.position[1] + g.size[1] - g.effective_spacing[1] / 2 - 2 + end + x2 = x1 + 4 + local scrollbar = assdraw.ass_new() + scrollbar:new_event() + scrollbar:append("{\\an7}") + scrollbar:append("{\\bord0}") + scrollbar:append("{\\shad0}") + scrollbar:append("{\\1c&AAAAAA&}") + scrollbar:pos(0, 0) + scrollbar:draw_start() + scrollbar:rect_cw(x1, y1, x2, y2) + scrollbar:draw_stop() + gallery.ass.scrollbar = scrollbar.text +end + +function gallery_mt.refresh_selection(gallery) + local v = gallery.view + if v.first == 0 then + gallery.ass.selection = "" + return + end + local selection_ass = assdraw.ass_new() + local g = gallery.geometry + local draw_frame = function(index, size, color) + local x, y = gallery:view_index_position(index - v.first) + selection_ass:new_event() + selection_ass:append("{\\an7}") + selection_ass:append("{\\bord" .. size .. "}") + selection_ass:append("{\\3c&" .. color .. "&}") + selection_ass:append("{\\1a&FF&}") + selection_ass:pos(0, 0) + selection_ass:draw_start() + selection_ass:rect_cw(x, y, x + g.thumbnail_size[1], y + g.thumbnail_size[2]) + selection_ass:draw_stop() + end + for i = v.first, v.last do + local size, color = gallery.item_to_border(i, gallery.items[i]) + if size > 0 then + draw_frame(i, size, color) + end + end + + for index = v.first, v.last do + local text = gallery.item_to_text(index, gallery.items[index]) + if text ~= "" then + selection_ass:new_event() + local an = 5 + local x, y = gallery:view_index_position(index - v.first) + x = x + g.thumbnail_size[1] / 2 + y = y + g.thumbnail_size[2] + gallery.config.text_size * 0.75 + if gallery.config.align_text then + local col = (index - v.first) % g.columns + if g.columns > 1 then + if col == 0 then + x = x - g.thumbnail_size[1] / 2 + an = 4 + elseif col == g.columns - 1 then + x = x + g.thumbnail_size[1] / 2 + an = 6 + end + end + end + selection_ass:an(an) + selection_ass:pos(x, y) + selection_ass:append(string.format("{\\fs%d}", gallery.config.text_size)) + selection_ass:append("{\\bord0}") + selection_ass:append(text) + end + end + gallery.ass.selection = selection_ass.text +end + +function gallery_mt.ass_refresh(gallery, selection, scrollbar, placeholders, background) + if not gallery.active then + return + end + if selection then + gallery:refresh_selection() + end + if scrollbar then + gallery:refresh_scrollbar() + end + if placeholders then + gallery:refresh_placeholders() + end + if background then + gallery:refresh_background() + end + gallery.ass_show(table.concat({ + gallery.ass.background, + gallery.ass.placeholders, + gallery.ass.selection, + gallery.ass.scrollbar, + }, "\n")) +end + +function gallery_mt.set_selection(gallery, selection) + if not selection or selection ~= selection then + return + end + local new_selection = math.max(1, math.min(selection, #gallery.items)) + if gallery.selection == new_selection then + return + end + gallery.selection = new_selection + if gallery.active then + if gallery:ensure_view_valid() then + gallery:refresh_overlays(false) + gallery:ass_refresh(true, true, true, false) + else + gallery:ass_refresh(true, false, false, false) + end + end +end + +function gallery_mt.set_geometry(gallery, x, y, w, h, sw, sh, tw, th) + if w <= 0 or h <= 0 or tw <= 0 or th <= 0 then + msg.warn("Invalid coordinates") + return + end + gallery.geometry.position = { x, y } + gallery.geometry.size = { w, h } + gallery.geometry.min_spacing = { sw, sh } + gallery.geometry.thumbnail_size = { tw, th } + gallery.geometry.ok = true + if not gallery.active then + return + end + if not gallery:enough_space() then + msg.warn("Not enough space to display something") + end + local old_total = gallery.geometry.rows * gallery.geometry.columns + gallery:compute_internal_geometry() + gallery:ensure_view_valid() + local new_total = gallery.geometry.rows * gallery.geometry.columns + for view_index = new_total + 1, old_total do + if gallery.overlays.active[view_index] then + mp.commandv("overlay-remove", gallery.config.overlay_range + view_index - 1) + gallery.overlays.active[view_index] = false + end + end + gallery:refresh_overlays(true) + gallery:ass_refresh(true, true, true, true) +end + +function gallery_mt.items_changed(gallery, new_sel) + gallery.selection = math.max(1, math.min(new_sel, #gallery.items)) + if not gallery.active then + return + end + gallery:ensure_view_valid() + gallery:refresh_overlays(false) + gallery:ass_refresh(true, true, true, false) +end + +function gallery_mt.thumbnail_generated(gallery, thumb_path) + if not gallery.active then + return + end + local view_index = gallery.overlays.missing[thumb_path] + if view_index == nil then + return + end + gallery:show_overlay(view_index, thumb_path) + if not gallery.config.always_show_placeholders then + gallery:ass_refresh(false, false, true, false) + end + gallery.overlays.missing[thumb_path] = nil +end + +function gallery_mt.add_generator(gallery, generator_name) + for _, g in ipairs(gallery.generators) do + if generator_name == g then + return + end + end + gallery.generators[#gallery.generators + 1] = generator_name +end + +function gallery_mt.view_index_position(gallery, index_0) + local g = gallery.geometry + return math.floor( + g.position[1] + g.effective_spacing[1] + (g.effective_spacing[1] + g.thumbnail_size[1]) * (index_0 % g.columns) + ), + math.floor( + g.position[2] + + g.effective_spacing[2] + + (g.effective_spacing[2] + g.thumbnail_size[2]) * math.floor(index_0 / g.columns) + ) +end + +function gallery_mt.enough_space(gallery) + if gallery.geometry.size[1] < gallery.geometry.thumbnail_size[1] + 2 * gallery.geometry.min_spacing[1] then + return false + end + if gallery.geometry.size[2] < gallery.geometry.thumbnail_size[2] + 2 * gallery.geometry.min_spacing[2] then + return false + end + return true +end + +function gallery_mt.activate(gallery) + if gallery.active then + return false + end + if not gallery:enough_space() then + msg.warn("Not enough space, refusing to start") + return false + end + if not gallery.geometry.ok then + msg.warn("Gallery geometry unitialized, refusing to start") + return false + end + gallery.active = true + if not gallery.selection then + gallery:set_selection(1) + end + gallery:compute_internal_geometry() + gallery:ensure_view_valid() + gallery:refresh_overlays(false) + gallery:ass_refresh(true, true, true, true) + return true +end + +function gallery_mt.deactivate(gallery) + if not gallery.active then + return + end + gallery.active = false + gallery:remove_overlays() + gallery.ass_show("") +end + +return { gallery_new = gallery_new } diff --git a/mac/.config/mpv/script-modules/input-console.lua b/mac/.config/mpv/script-modules/input-console.lua new file mode 100644 index 0000000..9128cba --- /dev/null +++ b/mac/.config/mpv/script-modules/input-console.lua @@ -0,0 +1,935 @@ +-- copied from here: https://github.com/mpv-player/mpv/blob/ebaf6a6cfa24a78d9041389974568b9db7df6a71/player/lua/console.lua + +-- Copyright (C) 2019 the mpv developers +-- +-- Permission to use, copy, modify, and/or distribute this software for any +-- purpose with or without fee is hereby granted, provided that the above +-- copyright notice and this permission notice appear in all copies. +-- +-- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +-- WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +-- MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY +-- SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +-- WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION +-- OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN +-- CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +local utils = require("mp.utils") +local options = require("mp.options") +local assdraw = require("mp.assdraw") + +-- Default options +local opts = { + -- All drawing is scaled by this value, including the text borders and the + -- cursor. Change it if you have a high-DPI display. + scale = 1.3, + -- Set the font used for the REPL and the console. This probably doesn't + -- have to be a monospaced font. + font = "", + -- Set the font size used for the REPL and the console. This will be + -- multiplied by "scale." + font_size = 16, +} + +function detect_platform() + local o = {} + -- Kind of a dumb way of detecting the platform but whatever + if mp.get_property_native("options/vo-mmcss-profile", o) ~= o then + return "windows" + elseif mp.get_property_native("options/macos-force-dedicated-gpu", o) ~= o then + return "macos" + elseif os.getenv("WAYLAND_DISPLAY") then + return "wayland" + end + return "x11" +end + +-- Pick a better default font for Windows and macOS +local platform = detect_platform() +if platform == "windows" then + opts.font = "Consolas" +elseif platform == "macos" then + opts.font = "Menlo" +else + opts.font = "monospace" +end + +-- Apply user-set options +options.read_options(opts) + +local repl_active = false +local insert_mode = false +local pending_update = false +local line = "" +local cursor = 1 +local history = {} +local history_pos = 1 +local log_buffer = {} +local key_bindings = {} +local global_margin_y = 0 + +local update_timer = nil +update_timer = mp.add_periodic_timer(0.05, function() + if pending_update then + update() + else + update_timer:kill() + end +end) +update_timer:kill() + +if utils.shared_script_property_observe then + utils.shared_script_property_observe("osc-margins", function(_, val) + if val then + -- formatted as "%f,%f,%f,%f" with left, right, top, bottom, each + -- value being the border size as ratio of the window size (0.0-1.0) + local vals = {} + for v in string.gmatch(val, "[^,]+") do + vals[#vals + 1] = tonumber(v) + end + global_margin_y = vals[4] -- bottom + else + global_margin_y = 0 + end + update() + end) +else + mp.observe_property("user-data/osc/margins", "native", function(_, val) + if val then + global_margin_y = val.b + else + global_margin_y = 0 + end + end) +end + +-- Add a line to the log buffer (which is limited to 100 lines) +function log_add(style, text) + log_buffer[#log_buffer + 1] = { style = style, text = text } + if #log_buffer > 100 then + table.remove(log_buffer, 1) + end + + if repl_active then + if not update_timer:is_enabled() then + update() + update_timer:resume() + else + pending_update = true + end + end +end + +-- Escape a string for verbatim display on the OSD +function ass_escape(str) + -- There is no escape for '\' in ASS (I think?) but '\' is used verbatim if + -- it isn't followed by a recognised character, so add a zero-width + -- non-breaking space + str = str:gsub("\\", "\\\239\187\191") + str = str:gsub("{", "\\{") + str = str:gsub("}", "\\}") + -- Precede newlines with a ZWNBSP to prevent ASS's weird collapsing of + -- consecutive newlines + str = str:gsub("\n", "\239\187\191\\N") + -- Turn leading spaces into hard spaces to prevent ASS from stripping them + str = str:gsub("\\N ", "\\N\\h") + str = str:gsub("^ ", "\\h") + return str +end + +-- Render the REPL and console as an ASS OSD +function update() + pending_update = false + + local dpi_scale = mp.get_property_native("display-hidpi-scale", 1.0) + + dpi_scale = dpi_scale * opts.scale + + local screenx, screeny, aspect = mp.get_osd_size() + screenx = screenx / dpi_scale + screeny = screeny / dpi_scale + + -- Clear the OSD if the REPL is not active + if not repl_active then + mp.set_osd_ass(screenx, screeny, "") + return + end + + local ass = assdraw.ass_new() + local style = "{\\r" + .. "\\1a&H00&\\3a&H00&\\4a&H99&" + .. "\\1c&Heeeeee&\\3c&H111111&\\4c&H000000&" + .. "\\fn" + .. opts.font + .. "\\fs" + .. opts.font_size + .. "\\bord1\\xshad0\\yshad1\\fsp0\\q1}" + -- Create the cursor glyph as an ASS drawing. ASS will draw the cursor + -- inline with the surrounding text, but it sets the advance to the width + -- of the drawing. So the cursor doesn't affect layout too much, make it as + -- thin as possible and make it appear to be 1px wide by giving it 0.5px + -- horizontal borders. + local cheight = opts.font_size * 8 + local cglyph = "{\\r" + .. "\\1a&H44&\\3a&H44&\\4a&H99&" + .. "\\1c&Heeeeee&\\3c&Heeeeee&\\4c&H000000&" + .. "\\xbord0.5\\ybord0\\xshad0\\yshad1\\p4\\pbo24}" + .. "m 0 0 l 1 0 l 1 " + .. cheight + .. " l 0 " + .. cheight + .. "{\\p0}" + local before_cur = ass_escape(line:sub(1, cursor - 1)) + local after_cur = ass_escape(line:sub(cursor)) + + -- Render log messages as ASS. This will render at most screeny / font_size + -- messages. + local log_ass = "" + local log_messages = #log_buffer + local log_max_lines = math.ceil(screeny / opts.font_size) + if log_max_lines < log_messages then + log_messages = log_max_lines + end + for i = #log_buffer - log_messages + 1, #log_buffer do + log_ass = log_ass .. style .. log_buffer[i].style .. ass_escape(log_buffer[i].text) + end + + ass:new_event() + ass:an(1) + ass:pos(2, screeny - 2 - global_margin_y * screeny) + ass:append(log_ass .. "\\N") + ass:append(style .. "> " .. before_cur) + ass:append(cglyph) + ass:append(style .. after_cur) + + -- Redraw the cursor with the REPL text invisible. This will make the + -- cursor appear in front of the text. + ass:new_event() + ass:an(1) + ass:pos(2, screeny - 2 - global_margin_y * screeny) + ass:append(style .. "{\\alpha&HFF&}> " .. before_cur) + ass:append(cglyph) + ass:append(style .. "{\\alpha&HFF&}" .. after_cur) + + mp.set_osd_ass(screenx, screeny, ass.text) +end + +-- Set the REPL visibility ("enable", Esc) +function set_active(active) + if active == repl_active then + return + end + if active then + repl_active = true + insert_mode = false + mp.enable_key_bindings("console-input", "allow-hide-cursor+allow-vo-dragging") + mp.enable_messages("terminal-default") + define_key_bindings() + else + repl_active = false + undefine_key_bindings() + mp.enable_messages("silent:terminal-default") + collectgarbage() + end + update() +end + +-- Show the repl if hidden and replace its contents with 'text' +-- (script-message-to repl type) +function show_and_type(text, cursor_pos) + text = text or "" + cursor_pos = tonumber(cursor_pos) + + -- Save the line currently being edited, just in case + if line ~= text and line ~= "" and history[#history] ~= line then + history[#history + 1] = line + end + + line = text + if cursor_pos ~= nil and cursor_pos >= 1 and cursor_pos <= line:len() + 1 then + cursor = math.floor(cursor_pos) + else + cursor = line:len() + 1 + end + history_pos = #history + 1 + insert_mode = false + if repl_active then + update() + else + set_active(true) + end +end + +-- Naive helper function to find the next UTF-8 character in 'str' after 'pos' +-- by skipping continuation bytes. Assumes 'str' contains valid UTF-8. +function next_utf8(str, pos) + if pos > str:len() then + return pos + end + repeat + pos = pos + 1 + until pos > str:len() or str:byte(pos) < 0x80 or str:byte(pos) > 0xbf + return pos +end + +-- As above, but finds the previous UTF-8 character in 'str' before 'pos' +function prev_utf8(str, pos) + if pos <= 1 then + return pos + end + repeat + pos = pos - 1 + until pos <= 1 or str:byte(pos) < 0x80 or str:byte(pos) > 0xbf + return pos +end + +-- Insert a character at the current cursor position (any_unicode) +function handle_char_input(c) + if insert_mode then + line = line:sub(1, cursor - 1) .. c .. line:sub(next_utf8(line, cursor)) + else + line = line:sub(1, cursor - 1) .. c .. line:sub(cursor) + end + cursor = cursor + #c + update() +end + +-- Remove the character behind the cursor (Backspace) +function handle_backspace() + if cursor <= 1 then + return + end + local prev = prev_utf8(line, cursor) + line = line:sub(1, prev - 1) .. line:sub(cursor) + cursor = prev + update() +end + +-- Remove the character in front of the cursor (Del) +function handle_del() + if cursor > line:len() then + return + end + line = line:sub(1, cursor - 1) .. line:sub(next_utf8(line, cursor)) + update() +end + +-- Toggle insert mode (Ins) +function handle_ins() + insert_mode = not insert_mode +end + +-- Move the cursor to the next character (Right) +function next_char(amount) + cursor = next_utf8(line, cursor) + update() +end + +-- Move the cursor to the previous character (Left) +function prev_char(amount) + cursor = prev_utf8(line, cursor) + update() +end + +-- Clear the current line (Ctrl+C) +function clear() + line = "" + cursor = 1 + insert_mode = false + history_pos = #history + 1 + update() +end + +-- Close the REPL if the current line is empty, otherwise delete the next +-- character (Ctrl+D) +function maybe_exit() + if line == "" then + set_active(false) + else + handle_del() + end +end + +function help_command(param) + local cmdlist = mp.get_property_native("command-list") + local error_style = "{\\1c&H7a77f2&}" + local output = "" + if param == "" then + output = "Available commands:\n" + for _, cmd in ipairs(cmdlist) do + output = output .. " " .. cmd.name + end + output = output .. "\n" + output = output .. 'Use "help command" to show information about a command.\n' + output = output .. "ESC or Ctrl+d exits the console.\n" + else + local cmd = nil + for _, curcmd in ipairs(cmdlist) do + if curcmd.name:find(param, 1, true) then + cmd = curcmd + if curcmd.name == param then + break -- exact match + end + end + end + if not cmd then + log_add(error_style, 'No command matches "' .. param .. '"!') + return + end + output = output .. 'Command "' .. cmd.name .. '"\n' + for _, arg in ipairs(cmd.args) do + output = output .. " " .. arg.name .. " (" .. arg.type .. ")" + if arg.optional then + output = output .. " (optional)" + end + output = output .. "\n" + end + if cmd.vararg then + output = output .. "This command supports variable arguments.\n" + end + end + log_add("", output) +end + +local enter_handler = nil + +-- Run the current command and clear the line (Enter) +function handle_enter() + if line == "" then + return + end + + if history[#history] ~= line then + history[#history + 1] = line + end + + if enter_handler then + enter_handler(line) + end + + set_active(false) + + clear() +end + +-- Go to the specified position in the command history +function go_history(new_pos) + local old_pos = history_pos + history_pos = new_pos + + -- Restrict the position to a legal value + if history_pos > #history + 1 then + history_pos = #history + 1 + elseif history_pos < 1 then + history_pos = 1 + end + + -- Do nothing if the history position didn't actually change + if history_pos == old_pos then + return + end + + -- If the user was editing a non-history line, save it as the last history + -- entry. This makes it much less frustrating to accidentally hit Up/Down + -- while editing a line. + if old_pos == #history + 1 and line ~= "" and history[#history] ~= line then + history[#history + 1] = line + end + + -- Now show the history line (or a blank line for #history + 1) + if history_pos <= #history then + line = history[history_pos] + else + line = "" + end + cursor = line:len() + 1 + insert_mode = false + update() +end + +-- Go to the specified relative position in the command history (Up, Down) +function move_history(amount) + go_history(history_pos + amount) +end + +-- Go to the first command in the command history (PgUp) +function handle_pgup() + go_history(1) +end + +-- Stop browsing history and start editing a blank line (PgDown) +function handle_pgdown() + go_history(#history + 1) +end + +-- Move to the start of the current word, or if already at the start, the start +-- of the previous word. (Ctrl+Left) +function prev_word() + -- This is basically the same as next_word() but backwards, so reverse the + -- string in order to do a "backwards" find. This wouldn't be as annoying + -- to do if Lua didn't insist on 1-based indexing. + cursor = line:len() - select(2, line:reverse():find("%s*[^%s]*", line:len() - cursor + 2)) + 1 + update() +end + +-- Move to the end of the current word, or if already at the end, the end of +-- the next word. (Ctrl+Right) +function next_word() + cursor = select(2, line:find("%s*[^%s]*", cursor)) + 1 + update() +end + +-- List of tab-completions: +-- pattern: A Lua pattern used in string:find. Should return the start and +-- end positions of the word to be completed in the first and second +-- capture groups (using the empty parenthesis notation "()") +-- list: A list of candidate completion values. +-- append: An extra string to be appended to the end of a successful +-- completion. It is only appended if 'list' contains exactly one +-- match. +function build_completers() + -- Build a list of commands, properties and options for tab-completion + local option_info = { + "name", + "type", + "set-from-commandline", + "set-locally", + "default-value", + "min", + "max", + "choices", + } + local cmd_list = {} + for i, cmd in ipairs(mp.get_property_native("command-list")) do + cmd_list[i] = cmd.name + end + local prop_list = mp.get_property_native("property-list") + for _, opt in ipairs(mp.get_property_native("options")) do + prop_list[#prop_list + 1] = "options/" .. opt + prop_list[#prop_list + 1] = "file-local-options/" .. opt + prop_list[#prop_list + 1] = "option-info/" .. opt + for _, p in ipairs(option_info) do + prop_list[#prop_list + 1] = "option-info/" .. opt .. "/" .. p + end + end + + return { + { pattern = "^%s*()[%w_-]+()$", list = cmd_list, append = " " }, + { pattern = "^%s*set%s+()[%w_/-]+()$", list = prop_list, append = " " }, + { pattern = '^%s*set%s+"()[%w_/-]+()$', list = prop_list, append = '" ' }, + { pattern = "^%s*add%s+()[%w_/-]+()$", list = prop_list, append = " " }, + { pattern = '^%s*add%s+"()[%w_/-]+()$', list = prop_list, append = '" ' }, + { pattern = "^%s*cycle%s+()[%w_/-]+()$", list = prop_list, append = " " }, + { pattern = '^%s*cycle%s+"()[%w_/-]+()$', list = prop_list, append = '" ' }, + { pattern = "^%s*multiply%s+()[%w_/-]+()$", list = prop_list, append = " " }, + { pattern = '^%s*multiply%s+"()[%w_/-]+()$', list = prop_list, append = '" ' }, + { pattern = "${()[%w_/-]+()$", list = prop_list, append = "}" }, + } +end + +-- Use 'list' to find possible tab-completions for 'part.' Returns the longest +-- common prefix of all the matching list items and a flag that indicates +-- whether the match was unique or not. +function complete_match(part, list) + local completion = nil + local full_match = false + + for _, candidate in ipairs(list) do + if candidate:sub(1, part:len()) == part then + if completion and completion ~= candidate then + local prefix_len = part:len() + while completion:sub(1, prefix_len + 1) == candidate:sub(1, prefix_len + 1) do + prefix_len = prefix_len + 1 + end + completion = candidate:sub(1, prefix_len) + full_match = false + else + completion = candidate + full_match = true + end + end + end + + return completion, full_match +end + +-- Complete the option or property at the cursor (TAB) +function complete() + local before_cur = line:sub(1, cursor - 1) + local after_cur = line:sub(cursor) + + -- Try the first completer that works + for _, completer in ipairs(build_completers()) do + -- Completer patterns should return the start and end of the word to be + -- completed as the first and second capture groups + local _, _, s, e = before_cur:find(completer.pattern) + if not s then + -- Multiple input commands can be separated by semicolons, so all + -- completions that are anchored at the start of the string with + -- '^' can start from a semicolon as well. Replace ^ with ; and try + -- to match again. + _, _, s, e = before_cur:find(completer.pattern:gsub("^^", ";")) + end + if s then + -- If the completer's pattern found a word, check the completer's + -- list for possible completions + local part = before_cur:sub(s, e) + local c, full = complete_match(part, completer.list) + if c then + -- If there was only one full match from the list, add + -- completer.append to the final string. This is normally a + -- space or a quotation mark followed by a space. + if full and completer.append then + c = c .. completer.append + end + + -- Insert the completion and update + before_cur = before_cur:sub(1, s - 1) .. c + cursor = before_cur:len() + 1 + line = before_cur .. after_cur + update() + return + end + end + end +end + +-- Move the cursor to the beginning of the line (HOME) +function go_home() + cursor = 1 + update() +end + +-- Move the cursor to the end of the line (END) +function go_end() + cursor = line:len() + 1 + update() +end + +-- Delete from the cursor to the beginning of the word (Ctrl+Backspace) +function del_word() + local before_cur = line:sub(1, cursor - 1) + local after_cur = line:sub(cursor) + + before_cur = before_cur:gsub("[^%s]+%s*$", "", 1) + line = before_cur .. after_cur + cursor = before_cur:len() + 1 + update() +end + +-- Delete from the cursor to the end of the word (Ctrl+Del) +function del_next_word() + if cursor > line:len() then + return + end + + local before_cur = line:sub(1, cursor - 1) + local after_cur = line:sub(cursor) + + after_cur = after_cur:gsub("^%s*[^%s]+", "", 1) + line = before_cur .. after_cur + update() +end + +-- Delete from the cursor to the end of the line (Ctrl+K) +function del_to_eol() + line = line:sub(1, cursor - 1) + update() +end + +-- Delete from the cursor back to the start of the line (Ctrl+U) +function del_to_start() + line = line:sub(cursor) + cursor = 1 + update() +end + +-- Empty the log buffer of all messages (Ctrl+L) +function clear_log_buffer() + log_buffer = {} + update() +end + +-- Returns a string of UTF-8 text from the clipboard (or the primary selection) +function get_clipboard(clip) + if platform == "x11" then + local res = utils.subprocess({ + args = { "xclip", "-selection", clip and "clipboard" or "primary", "-out" }, + playback_only = false, + }) + if not res.error then + return res.stdout + end + elseif platform == "wayland" then + local res = utils.subprocess({ + args = { "wl-paste", clip and "-n" or "-np" }, + playback_only = false, + }) + if not res.error then + return res.stdout + end + elseif platform == "windows" then + local res = utils.subprocess({ + args = { + "powershell", + "-NoProfile", + "-Command", + [[& { + Trap { + Write-Error -ErrorRecord $_ + Exit 1 + } + + $clip = "" + if (Get-Command "Get-Clipboard" -errorAction SilentlyContinue) { + $clip = Get-Clipboard -Raw -Format Text -TextFormatType UnicodeText + } else { + Add-Type -AssemblyName PresentationCore + $clip = [Windows.Clipboard]::GetText() + } + + $clip = $clip -Replace "`r","" + $u8clip = [System.Text.Encoding]::UTF8.GetBytes($clip) + [Console]::OpenStandardOutput().Write($u8clip, 0, $u8clip.Length) + }]], + }, + playback_only = false, + }) + if not res.error then + return res.stdout + end + elseif platform == "macos" then + local res = utils.subprocess({ + args = { "pbpaste" }, + playback_only = false, + }) + if not res.error then + return res.stdout + end + end + return "" +end + +-- Paste text from the window-system's clipboard. 'clip' determines whether the +-- clipboard or the primary selection buffer is used (on X11 and Wayland only.) +function paste(clip) + local text = get_clipboard(clip) + local before_cur = line:sub(1, cursor - 1) + local after_cur = line:sub(cursor) + line = before_cur .. text .. after_cur + cursor = cursor + text:len() + update() +end + +-- List of input bindings. This is a weird mashup between common GUI text-input +-- bindings and readline bindings. +function get_bindings() + local bindings = { + { + "esc", + function() + set_active(false) + end, + }, + { "enter", handle_enter }, + { "kp_enter", handle_enter }, + { + "shift+enter", + function() + handle_char_input("\n") + end, + }, + { "ctrl+j", handle_enter }, + { "ctrl+m", handle_enter }, + { "bs", handle_backspace }, + { "shift+bs", handle_backspace }, + { "ctrl+h", handle_backspace }, + { "del", handle_del }, + { "shift+del", handle_del }, + { "ins", handle_ins }, + { + "shift+ins", + function() + paste(false) + end, + }, + { + "mbtn_mid", + function() + paste(false) + end, + }, + { + "left", + function() + prev_char() + end, + }, + { + "ctrl+b", + function() + prev_char() + end, + }, + { + "right", + function() + next_char() + end, + }, + { + "ctrl+f", + function() + next_char() + end, + }, + { + "up", + function() + move_history(-1) + end, + }, + { + "ctrl+p", + function() + move_history(-1) + end, + }, + { + "wheel_up", + function() + move_history(-1) + end, + }, + { + "down", + function() + move_history(1) + end, + }, + { + "ctrl+n", + function() + move_history(1) + end, + }, + { + "wheel_down", + function() + move_history(1) + end, + }, + { "wheel_left", function() end }, + { "wheel_right", function() end }, + { "ctrl+left", prev_word }, + { "alt+b", prev_word }, + { "ctrl+right", next_word }, + { "alt+f", next_word }, + { "tab", complete }, + { "ctrl+i", complete }, + { "ctrl+a", go_home }, + { "home", go_home }, + { "ctrl+e", go_end }, + { "end", go_end }, + { "pgup", handle_pgup }, + { "pgdwn", handle_pgdown }, + { "ctrl+c", clear }, + { "ctrl+d", maybe_exit }, + { "ctrl+k", del_to_eol }, + { "ctrl+l", clear_log_buffer }, + { "ctrl+u", del_to_start }, + { + "ctrl+v", + function() + paste(true) + end, + }, + { + "meta+v", + function() + paste(true) + end, + }, + { "ctrl+bs", del_word }, + { "ctrl+w", del_word }, + { "ctrl+del", del_next_word }, + { "alt+d", del_next_word }, + { + "kp_dec", + function() + handle_char_input(".") + end, + }, + } + + for i = 0, 9 do + bindings[#bindings + 1] = { + "kp" .. i, + function() + handle_char_input("" .. i) + end, + } + end + + return bindings +end + +local function text_input(info) + if info.key_text and (info.event == "press" or info.event == "down" or info.event == "repeat") then + handle_char_input(info.key_text) + end +end + +function define_key_bindings() + if #key_bindings > 0 then + return + end + for _, bind in ipairs(get_bindings()) do + -- Generate arbitrary name for removing the bindings later. + local name = "_console_" .. (#key_bindings + 1) + key_bindings[#key_bindings + 1] = name + mp.add_forced_key_binding(bind[1], name, bind[2], { repeatable = true }) + end + mp.add_forced_key_binding("any_unicode", "_console_text", text_input, { repeatable = true, complex = true }) + key_bindings[#key_bindings + 1] = "_console_text" +end + +function undefine_key_bindings() + for _, name in ipairs(key_bindings) do + mp.remove_key_binding(name) + end + key_bindings = {} +end + +-- Add a global binding for enabling the REPL. While it's enabled, its bindings +-- will take over and it can be closed with ESC. +mp.add_key_binding(nil, "enable", function() + set_active(true) +end) + +-- Add a script-message to show the REPL and fill it with the provided text +mp.register_script_message("type", function(text, cursor_pos) + show_and_type(text, cursor_pos) +end) + +-- Redraw the REPL when the OSD size changes. This is needed because the +-- PlayRes of the OSD will need to be adjusted. +mp.observe_property("osd-width", "native", update) +mp.observe_property("osd-height", "native", update) +mp.observe_property("display-hidpi-scale", "native", update) + +-- Enable log messages. In silent mode, mpv will queue log messages in a buffer +-- until enable_messages is called again without the silent: prefix. +mp.enable_messages("silent:terminal-default") + +collectgarbage() + +return { + set_active = set_active, + is_repl_active = function() + return repl_active + end, + set_enter_handler = function(callback) + enter_handler = callback + end, +} diff --git a/mac/.config/mpv/script-modules/mpvSockets.lua b/mac/.config/mpv/script-modules/mpvSockets.lua new file mode 100644 index 0000000..d745540 --- /dev/null +++ b/mac/.config/mpv/script-modules/mpvSockets.lua @@ -0,0 +1,36 @@ +-- mpvSockets, one socket per instance, removes socket on exit + +local utils = require("mp.utils") + +local function get_temp_path() + local directory_seperator = package.config:match("([^\n]*)\n?") + local example_temp_file_path = os.tmpname() + + -- remove generated temp file + pcall(os.remove, example_temp_file_path) + + local seperator_idx = example_temp_file_path:reverse():find(directory_seperator) + local temp_path_length = #example_temp_file_path - seperator_idx + + return example_temp_file_path:sub(1, temp_path_length) +end + +tempDir = get_temp_path() + +function join_paths(...) + local arg = { ... } + path = "" + for i, v in ipairs(arg) do + path = utils.join_path(path, tostring(v)) + end + return path +end + +ppid = utils.getpid() +os.execute("mkdir " .. join_paths(tempDir, "mpvSockets") .. " 2>/dev/null") +mp.set_property("options/input-ipc-server", join_paths(tempDir, "mpvSockets", ppid)) + +function shutdown_handler() + os.remove(join_paths(tempDir, "mpvSockets", ppid)) +end +mp.register_event("shutdown", shutdown_handler) diff --git a/mac/.config/mpv/script-modules/scroll-list.lua b/mac/.config/mpv/script-modules/scroll-list.lua new file mode 100644 index 0000000..5d8f9fa --- /dev/null +++ b/mac/.config/mpv/script-modules/scroll-list.lua @@ -0,0 +1,293 @@ +local mp = require 'mp' +local scroll_list = { + global_style = [[]], + header_style = [[{\q2\fs35\c&00ccff&}]], + list_style = [[{\q2\fs25\c&Hffffff&}]], + wrapper_style = [[{\c&00ccff&\fs16}]], + cursor_style = [[{\c&00ccff&}]], + selected_style = [[{\c&Hfce788&}]], + + cursor = [[➤\h]], + indent = [[\h\h\h\h]], + + num_entries = 16, + wrap = false, + empty_text = "no entries" +} + +--formats strings for ass handling +--this function is based on a similar function from https://github.com/mpv-player/mpv/blob/master/player/lua/console.lua#L110 +function scroll_list.ass_escape(str, replace_newline) + if replace_newline == true then replace_newline = "\\\239\187\191n" end + + --escape the invalid single characters + str = str:gsub('[\\{}\n]', { + -- There is no escape for '\' in ASS (I think?) but '\' is used verbatim if + -- it isn't followed by a recognised character, so add a zero-width + -- non-breaking space + ['\\'] = '\\\239\187\191', + ['{'] = '\\{', + ['}'] = '\\}', + -- Precede newlines with a ZWNBSP to prevent ASS's weird collapsing of + -- consecutive newlines + ['\n'] = '\239\187\191\\N', + }) + + -- Turn leading spaces into hard spaces to prevent ASS from stripping them + str = str:gsub('\\N ', '\\N\\h') + str = str:gsub('^ ', '\\h') + + if replace_newline then + str = str:gsub("\\N", replace_newline) + end + return str +end + +--format and return the header string +function scroll_list:format_header_string(str) + return str +end + +--appends the entered text to the overlay +function scroll_list:append(text) + if text == nil then return end + self.ass.data = self.ass.data .. text + end + +--appends a newline character to the osd +function scroll_list:newline() + self.ass.data = self.ass.data .. '\\N' +end + +--re-parses the list into an ass string +--if the list is closed then it flags an update on the next open +function scroll_list:update() + if self.hidden then self.flag_update = true + else self:update_ass() end +end + +--prints the header to the overlay +function scroll_list:format_header() + self:append(self.header_style) + self:append(self:format_header_string(self.header)) + self:newline() +end + +--formats each line of the list and prints it to the overlay +function scroll_list:format_line(index, item) + self:append(self.list_style) + + if index == self.selected then self:append(self.cursor_style..self.cursor..self.selected_style) + else self:append(self.indent) end + + self:append(item.style) + self:append(item.ass) + self:newline() +end + +--refreshes the ass text using the contents of the list +function scroll_list:update_ass() + self.ass.data = self.global_style + self:format_header() + + if #self.list < 1 then + self:append(self.empty_text) + self.ass:update() + return + end + + local start = 1 + local finish = start+self.num_entries-1 + + --handling cursor positioning + local mid = math.ceil(self.num_entries/2)+1 + if self.selected+mid > finish then + local offset = self.selected - finish + mid + + --if we've overshot the end of the list then undo some of the offset + if finish + offset > #self.list then + offset = offset - ((finish+offset) - #self.list) + end + + start = start + offset + finish = finish + offset + end + + --making sure that we don't overstep the boundaries + if start < 1 then start = 1 end + local overflow = finish < #self.list + --this is necessary when the number of items in the dir is less than the max + if not overflow then finish = #self.list end + + --adding a header to show there are items above in the list + if start > 1 then self:append(self.wrapper_style..(start-1)..' item(s) above\\N\\N') end + + for i=start, finish do + self:format_line(i, self.list[i]) + end + + if overflow then self:append('\\N'..self.wrapper_style..#self.list-finish..' item(s) remaining') end + self.ass:update() +end + +--moves the selector down the list +function scroll_list:scroll_down() + if self.selected < #self.list then + self.selected = self.selected + 1 + self:update_ass() + elseif self.wrap then + self.selected = 1 + self:update_ass() + end +end + +--moves the selector up the list +function scroll_list:scroll_up() + if self.selected > 1 then + self.selected = self.selected - 1 + self:update_ass() + elseif self.wrap then + self.selected = #self.list + self:update_ass() + end +end + +--moves the selector to the list next page +function scroll_list:move_pagedown() + if #self.list > self.num_entries then + self.selected = self.selected + self.num_entries + if self.selected > #self.list then self.selected = #self.list end + self:update_ass() + end +end + +--moves the selector to the list previous page +function scroll_list:move_pageup() + if #self.list > self.num_entries then + self.selected = self.selected - self.num_entries + if self.selected < 1 then self.selected = 1 end + self:update_ass() + end +end + +--moves the selector to the list begin +function scroll_list:move_begin() + if #self.list > 1 then + self.selected = 1 + self:update_ass() + end +end + +--moves the selector to the list end +function scroll_list:move_end() + if #self.list > 1 then + self.selected = #self.list + self:update_ass() + end +end + +--adds the forced keybinds +function scroll_list:add_keybinds() + for _,v in ipairs(self.keybinds) do + mp.add_forced_key_binding(v[1], 'dynamic/'..self.ass.id..'/'..v[2], v[3], v[4]) + end +end + +--removes the forced keybinds +function scroll_list:remove_keybinds() + for _,v in ipairs(self.keybinds) do + mp.remove_key_binding('dynamic/'..self.ass.id..'/'..v[2]) + end +end + +--opens the list and sets the hidden flag +function scroll_list:open_list() + self.hidden = false + if not self.flag_update then self.ass:update() + else self.flag_update = false ; self:update_ass() end +end + +--closes the list and sets the hidden flag +function scroll_list:close_list() + self.hidden = true + self.ass:remove() +end + +--modifiable function that opens the list +function scroll_list:open() + if self.hidden then self:add_keybinds() end + self:open_list() +end + +--modifiable function that closes the list +function scroll_list:close() + self:remove_keybinds() + self:close_list() +end + +--toggles the list +function scroll_list:toggle() + if self.hidden then self:open() + else self:close() end +end + +--clears the list in-place +function scroll_list:clear() + local i = 1 + while self.list[i] do + self.list[i] = nil + i = i + 1 + end +end + +--added alias for ipairs(list.list) for lua 5.1 +function scroll_list:ipairs() + return ipairs(self.list) +end + +--append item to the end of the list +function scroll_list:insert(item) + self.list[#self.list + 1] = item +end + +local metatable = { + __index = function(t, key) + if scroll_list[key] ~= nil then return scroll_list[key] + elseif key == "__current" then return t.list[t.selected] + elseif type(key) == "number" then return t.list[key] end + end, + __newindex = function(t, key, value) + if type(key) == "number" then rawset(t.list, key, value) + else rawset(t, key, value) end + end, + __scroll_list = scroll_list, + __len = function(t) return #t.list end, + __ipairs = function(t) return ipairs(t.list) end +} + +--creates a new list object +function scroll_list:new() + local vars + vars = { + ass = mp.create_osd_overlay('ass-events'), + hidden = true, + flag_update = true, + + header = "header \\N ----------------------------------------------", + list = {}, + selected = 1, + + keybinds = { + {'DOWN', 'scroll_down', function() vars:scroll_down() end, {repeatable = true}}, + {'UP', 'scroll_up', function() vars:scroll_up() end, {repeatable = true}}, + {'PGDWN', 'move_pagedown', function() vars:move_pagedown() end, {}}, + {'PGUP', 'move_pageup', function() vars:move_pageup() end, {}}, + {'HOME', 'move_begin', function() vars:move_begin() end, {}}, + {'END', 'move_end', function() vars:move_end() end, {}}, + {'ESC', 'close_browser', function() vars:close() end, {}} + } + } + return setmetatable(vars, metatable) +end + +return scroll_list:new() diff --git a/mac/.config/mpv/script-modules/sha1.lua b/mac/.config/mpv/script-modules/sha1.lua new file mode 100644 index 0000000..6b19396 --- /dev/null +++ b/mac/.config/mpv/script-modules/sha1.lua @@ -0,0 +1,334 @@ +-- $Revision: 1.5 $ +-- $Date: 2014-09-10 16:54:25 $ + +-- This module was originally taken from http://cube3d.de/uploads/Main/sha1.txt. + +------------------------------------------------------------------------------- +-- SHA-1 secure hash computation, and HMAC-SHA1 signature computation, +-- in pure Lua (tested on Lua 5.1) +-- License: MIT +-- +-- Usage: +-- local hashAsHex = sha1.hex(message) -- returns a hex string +-- local hashAsData = sha1.bin(message) -- returns raw bytes +-- +-- local hmacAsHex = sha1.hmacHex(key, message) -- hex string +-- local hmacAsData = sha1.hmacBin(key, message) -- raw bytes +-- +-- +-- Pass sha1.hex() a string, and it returns a hash as a 40-character hex string. +-- For example, the call +-- +-- local hash = sha1.hex("iNTERFACEWARE") +-- +-- puts the 40-character string +-- +-- "e76705ffb88a291a0d2f9710a5471936791b4819" +-- +-- into the variable 'hash' +-- +-- Pass sha1.hmacHex() a key and a message, and it returns the signature as a +-- 40-byte hex string. +-- +-- +-- The two "bin" versions do the same, but return the 20-byte string of raw +-- data that the 40-byte hex strings represent. +-- +------------------------------------------------------------------------------- +-- +-- Description +-- Due to the lack of bitwise operations in 5.1, this version uses numbers to +-- represents the 32bit words that we combine with binary operations. The basic +-- operations of byte based "xor", "or", "and" are all cached in a combination +-- table (several 64k large tables are built on startup, which +-- consumes some memory and time). The caching can be switched off through +-- setting the local cfg_caching variable to false. +-- For all binary operations, the 32 bit numbers are split into 8 bit values +-- that are combined and then merged again. +-- +-- Algorithm: http://www.itl.nist.gov/fipspubs/fip180-1.htm +-- +------------------------------------------------------------------------------- + +sha1 = {} + +-- set this to false if you don't want to build several 64k sized tables when +-- loading this file (takes a while but grants a boost of factor 13) +local cfg_caching = false + +-- local storing of global functions (minor speedup) +local floor, modf = math.floor, math.modf +local char, format, rep = string.char, string.format, string.rep + +-- merge 4 bytes to an 32 bit word +local function bytes_to_w32(a, b, c, d) return a * 0x1000000 + b * 0x10000 + c * 0x100 + d end + +-- split a 32 bit word into four 8 bit numbers +local function w32_to_bytes(i) + return floor(i / 0x1000000) % 0x100, floor(i / 0x10000) % 0x100, floor(i / 0x100) % 0x100, i % 0x100 +end + +-- shift the bits of a 32 bit word. Don't use negative values for "bits" +local function w32_rot(bits, a) + local b2 = 2 ^ (32 - bits) + local a, b = modf(a / b2) + return a + b * b2 * (2 ^ (bits)) +end + +-- caching function for functions that accept 2 arguments, both of values between +-- 0 and 255. The function to be cached is passed, all values are calculated +-- during loading and a function is returned that returns the cached values (only) +local function cache2arg(fn) + if not cfg_caching then return fn end + local lut = {} + for i = 0, 0xffff do + local a, b = floor(i / 0x100), i % 0x100 + lut[i] = fn(a, b) + end + return function(a, b) + return lut[a * 0x100 + b] + end +end + +-- splits an 8-bit number into 8 bits, returning all 8 bits as booleans +local function byte_to_bits(b) + local b = function(n) + local b = floor(b / n) + return b % 2 == 1 + end + return b(1), b(2), b(4), b(8), b(16), b(32), b(64), b(128) +end + +-- builds an 8bit number from 8 booleans +local function bits_to_byte(a, b, c, d, e, f, g, h) + local function n(b, x) return b and x or 0 end + + return n(a, 1) + n(b, 2) + n(c, 4) + n(d, 8) + n(e, 16) + n(f, 32) + n(g, 64) + n(h, 128) +end + +-- debug function for visualizing bits in a string +local function bits_to_string(a, b, c, d, e, f, g, h) + local function x(b) return b and "1" or "0" end + + return ("%s%s%s%s %s%s%s%s"):format(x(a), x(b), x(c), x(d), x(e), x(f), x(g), x(h)) +end + +-- debug function for converting a 8-bit number as bit string +local function byte_to_bit_string(b) + return bits_to_string(byte_to_bits(b)) +end + +-- debug function for converting a 32 bit number as bit string +local function w32_to_bit_string(a) + if type(a) == "string" then return a end + local aa, ab, ac, ad = w32_to_bytes(a) + local s = byte_to_bit_string + return ("%s %s %s %s"):format(s(aa):reverse(), s(ab):reverse(), s(ac):reverse(), s(ad):reverse()):reverse() +end + +-- bitwise "and" function for 2 8bit number +local band = cache2arg(function(a, b) + local A, B, C, D, E, F, G, H = byte_to_bits(b) + local a, b, c, d, e, f, g, h = byte_to_bits(a) + return bits_to_byte( + A and a, B and b, C and c, D and d, + E and e, F and f, G and g, H and h) +end) + +-- bitwise "or" function for 2 8bit numbers +local bor = cache2arg(function(a, b) + local A, B, C, D, E, F, G, H = byte_to_bits(b) + local a, b, c, d, e, f, g, h = byte_to_bits(a) + return bits_to_byte( + A or a, B or b, C or c, D or d, + E or e, F or f, G or g, H or h) +end) + +-- bitwise "xor" function for 2 8bit numbers +local bxor = cache2arg(function(a, b) + local A, B, C, D, E, F, G, H = byte_to_bits(b) + local a, b, c, d, e, f, g, h = byte_to_bits(a) + return bits_to_byte( + A ~= a, B ~= b, C ~= c, D ~= d, + E ~= e, F ~= f, G ~= g, H ~= h) +end) + +-- bitwise complement for one 8bit number +local function bnot(x) + return 255 - (x % 256) +end + +-- creates a function to combine to 32bit numbers using an 8bit combination function +local function w32_comb(fn) + return function(a, b) + local aa, ab, ac, ad = w32_to_bytes(a) + local ba, bb, bc, bd = w32_to_bytes(b) + return bytes_to_w32(fn(aa, ba), fn(ab, bb), fn(ac, bc), fn(ad, bd)) + end +end + +-- create functions for and, xor and or, all for 2 32bit numbers +local w32_and = w32_comb(band) +local w32_xor = w32_comb(bxor) +local w32_or = w32_comb(bor) + +-- xor function that may receive a variable number of arguments +local function w32_xor_n(a, ...) + local aa, ab, ac, ad = w32_to_bytes(a) + for i = 1, select('#', ...) do + local ba, bb, bc, bd = w32_to_bytes(select(i, ...)) + aa, ab, ac, ad = bxor(aa, ba), bxor(ab, bb), bxor(ac, bc), bxor(ad, bd) + end + return bytes_to_w32(aa, ab, ac, ad) +end + +-- combining 3 32bit numbers through binary "or" operation +local function w32_or3(a, b, c) + local aa, ab, ac, ad = w32_to_bytes(a) + local ba, bb, bc, bd = w32_to_bytes(b) + local ca, cb, cc, cd = w32_to_bytes(c) + return bytes_to_w32( + bor(aa, bor(ba, ca)), bor(ab, bor(bb, cb)), bor(ac, bor(bc, cc)), bor(ad, bor(bd, cd)) + ) +end + +-- binary complement for 32bit numbers +local function w32_not(a) + return 4294967295 - (a % 4294967296) +end + +-- adding 2 32bit numbers, cutting off the remainder on 33th bit +local function w32_add(a, b) return (a + b) % 4294967296 end + +-- adding n 32bit numbers, cutting off the remainder (again) +local function w32_add_n(a, ...) + for i = 1, select('#', ...) do + a = (a + select(i, ...)) % 4294967296 + end + return a +end + +-- converting the number to a hexadecimal string +local function w32_to_hexstring(w) return format("%08x", w) end + +-- calculating the SHA1 for some text +function sha1.hex(msg) + local H0, H1, H2, H3, H4 = 0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0 + local msg_len_in_bits = #msg * 8 + + local first_append = char(0x80) -- append a '1' bit plus seven '0' bits + + local non_zero_message_bytes = #msg + 1 + 8 -- the +1 is the appended bit 1, the +8 are for the final appended length + local current_mod = non_zero_message_bytes % 64 + local second_append = current_mod > 0 and rep(char(0), 64 - current_mod) or "" + + -- now to append the length as a 64-bit number. + local B1, R1 = modf(msg_len_in_bits / 0x01000000) + local B2, R2 = modf(0x01000000 * R1 / 0x00010000) + local B3, R3 = modf(0x00010000 * R2 / 0x00000100) + local B4 = 0x00000100 * R3 + + local L64 = char(0) .. char(0) .. char(0) .. char(0) -- high 32 bits + .. char(B1) .. char(B2) .. char(B3) .. char(B4) -- low 32 bits + + msg = msg .. first_append .. second_append .. L64 + + assert(#msg % 64 == 0) + + local chunks = #msg / 64 + + local W = {} + local start, A, B, C, D, E, f, K, TEMP + local chunk = 0 + + while chunk < chunks do + -- + -- break chunk up into W[0] through W[15] + -- + start, chunk = chunk * 64 + 1, chunk + 1 + + for t = 0, 15 do + W[t] = bytes_to_w32(msg:byte(start, start + 3)) + start = start + 4 + end + + -- + -- build W[16] through W[79] + -- + for t = 16, 79 do + -- For t = 16 to 79 let Wt = S1(Wt-3 XOR Wt-8 XOR Wt-14 XOR Wt-16). + W[t] = w32_rot(1, w32_xor_n(W[t - 3], W[t - 8], W[t - 14], W[t - 16])) + end + + A, B, C, D, E = H0, H1, H2, H3, H4 + + for t = 0, 79 do + if t <= 19 then + -- (B AND C) OR ((NOT B) AND D) + f = w32_or(w32_and(B, C), w32_and(w32_not(B), D)) + K = 0x5A827999 + elseif t <= 39 then + -- B XOR C XOR D + f = w32_xor_n(B, C, D) + K = 0x6ED9EBA1 + elseif t <= 59 then + -- (B AND C) OR (B AND D) OR (C AND D + f = w32_or3(w32_and(B, C), w32_and(B, D), w32_and(C, D)) + K = 0x8F1BBCDC + else + -- B XOR C XOR D + f = w32_xor_n(B, C, D) + K = 0xCA62C1D6 + end + + -- TEMP = S5(A) + ft(B,C,D) + E + Wt + Kt; + A, B, C, D, E = w32_add_n(w32_rot(5, A), f, E, W[t], K), + A, w32_rot(30, B), C, D + end + -- Let H0 = H0 + A, H1 = H1 + B, H2 = H2 + C, H3 = H3 + D, H4 = H4 + E. + H0, H1, H2, H3, H4 = w32_add(H0, A), w32_add(H1, B), w32_add(H2, C), w32_add(H3, D), w32_add(H4, E) + end + local f = w32_to_hexstring + return f(H0) .. f(H1) .. f(H2) .. f(H3) .. f(H4) +end + +local function hex_to_binary(hex) + return hex:gsub('..', function(hexval) + return string.char(tonumber(hexval, 16)) + end) +end + +function sha1.bin(msg) + return hex_to_binary(sha1.hex(msg)) +end + +local xor_with_0x5c = {} +local xor_with_0x36 = {} +-- building the lookuptables ahead of time (instead of littering the source code +-- with precalculated values) +for i = 0, 0xff do + xor_with_0x5c[char(i)] = char(bxor(i, 0x5c)) + xor_with_0x36[char(i)] = char(bxor(i, 0x36)) +end + +local blocksize = 64 -- 512 bits + +function sha1.hmacHex(key, text) + assert(type(key) == 'string', "key passed to hmacHex should be a string") + assert(type(text) == 'string', "text passed to hmacHex should be a string") + + if #key > blocksize then + key = sha1.bin(key) + end + + local key_xord_with_0x36 = key:gsub('.', xor_with_0x36) .. string.rep(string.char(0x36), blocksize - #key) + local key_xord_with_0x5c = key:gsub('.', xor_with_0x5c) .. string.rep(string.char(0x5c), blocksize - #key) + + return sha1.hex(key_xord_with_0x5c .. sha1.bin(key_xord_with_0x36 .. text)) +end + +function sha1.hmacBin(key, text) + return hex_to_binary(sha1.hmacHex(key, text)) +end + +return sha1 diff --git a/mac/.config/mpv/script-modules/user-input-module.lua b/mac/.config/mpv/script-modules/user-input-module.lua new file mode 100644 index 0000000..f15d5c4 --- /dev/null +++ b/mac/.config/mpv/script-modules/user-input-module.lua @@ -0,0 +1,126 @@ +--[[ + This is a module designed to interface with mpv-user-input + https://github.com/CogentRedTester/mpv-user-input + + Loading this script as a module will return a table with two functions to format + requests to get and cancel user-input requests. See the README for details. + + Alternatively, developers can just paste these functions directly into their script, + however this is not recommended as there is no guarantee that the formatting of + these requests will remain the same for future versions of user-input. +]] + +local API_VERSION = "0.1.0" + +local mp = require 'mp' +local msg = require "mp.msg" +local utils = require 'mp.utils' +local mod = {} + +local name = mp.get_script_name() +local counter = 1 + +local function pack(...) + local t = {...} + t.n = select("#", ...) + return t +end + +local request_mt = {} + +-- ensures the option tables are correctly formatted based on the input +local function format_options(options, response_string) + return { + response = response_string, + version = API_VERSION, + id = name..'/'..(options.id or ""), + source = name, + request_text = ("[%s] %s"):format(options.source or name, options.request_text or options.text or "requesting user input:"), + default_input = options.default_input, + cursor_pos = tonumber(options.cursor_pos), + queueable = options.queueable and true, + replace = options.replace and true + } +end + +-- cancels the request +function request_mt:cancel() + assert(self.uid, "request object missing UID") + mp.commandv("script-message-to", "user_input", "cancel-user-input/uid", self.uid) +end + +-- updates the options for the request +function request_mt:update(options) + assert(self.uid, "request object missing UID") + options = utils.format_json( format_options(options) ) + mp.commandv("script-message-to", "user_input", "update-user-input/uid", self.uid, options) +end + +-- sends a request to ask the user for input using formatted options provided +-- creates a script message to recieve the response and call fn +function mod.get_user_input(fn, options, ...) + options = options or {} + local response_string = name.."/__user_input_request/"..counter + counter = counter + 1 + + local request = { + uid = response_string, + passthrough_args = pack(...), + callback = fn, + pending = true + } + + -- create a callback for user-input to respond to + mp.register_script_message(response_string, function(response) + mp.unregister_script_message(response_string) + request.pending = false + + response = utils.parse_json(response) + request.callback(response.line, response.err, unpack(request.passthrough_args, 1, request.passthrough_args.n)) + end) + + -- send the input command + options = utils.format_json( format_options(options, response_string) ) + mp.commandv("script-message-to", "user_input", "request-user-input", options) + + return setmetatable(request, { __index = request_mt }) +end + +-- runs the request synchronously using coroutines +-- takes the option table and an optional coroutine resume function +function mod.get_user_input_co(options, co_resume) + local co, main = coroutine.running() + assert(not main and co, "get_user_input_co must be run from within a coroutine") + + local uid = {} + local request = mod.get_user_input(function(line, err) + if co_resume then + co_resume(uid, line, err) + else + local success, er = coroutine.resume(co, uid, line, err) + if not success then + msg.warn(debug.traceback(co)) + msg.error(er) + end + end + end, options) + + -- if the uid was not sent then the coroutine was resumed by the user. + -- we will treat this as a cancellation request + local success, line, err = coroutine.yield(request) + if success ~= uid then + request:cancel() + request.callback = function() end + return nil, "cancelled" + end + + return line, err +end + +-- sends a request to cancel all input requests with the given id +function mod.cancel_user_input(id) + id = name .. '/' .. (id or "") + mp.commandv("script-message-to", "user_input", "cancel-user-input/id", id) +end + +return mod
\ No newline at end of file diff --git a/mac/.config/mpv/script-modules/utf8/LICENSE b/mac/.config/mpv/script-modules/utf8/LICENSE new file mode 100644 index 0000000..fd3b301 --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2016 Stepets + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/mac/.config/mpv/script-modules/utf8/README.md b/mac/.config/mpv/script-modules/utf8/README.md new file mode 100644 index 0000000..0c31574 --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/README.md @@ -0,0 +1,93 @@ +# utf8.lua +pure-lua 5.3 regex library for Lua 5.3, Lua 5.1, LuaJIT + +This library provides simple way to add UTF-8 support into your application. + +#### Example: +```Lua +local utf8 = require('.utf8'):init() +for k,v in pairs(utf8) do + string[k] = v +end + +local str = "пыщпыщ ололоо я водитель нло" +print(str:find("(.л.+)н")) +-- 8 26 ололоо я водитель + +print(str:gsub("ло+", "보라")) +-- пыщпыщ о보라보라 я водитель н보라 3 + +print(str:match("^п[лопыщ ]*я")) +-- пыщпыщ ололоо я +``` + +#### Usage: + +This library can be used as drop-in replacement for vanilla string library. It exports all vanilla functions under `raw` sub-object. + +```Lua +local utf8 = require('.utf8'):init() +local str = "пыщпыщ ололоо я водитель нло" +utf8.gsub(str, "ло+", "보라") +-- пыщпыщ о보라보라 я водитель н보라 3 +utf8.raw.gsub(str, "ло+", "보라") +-- пыщпыщ о보라보라о я водитель н보라 3 +``` + +It also provides all functions from Lua 5.3 UTF-8 [module](https://www.lua.org/manual/5.3/manual.html#6.5) except `utf8.len (s [, i [, j]])`. If you need to validate your strings use `utf8.validate(str, byte_pos)` or iterate over with `utf8.validator`. + +Please note that library assumes regexes are valid UTF-8 strings, if you need to manipulate individual bytes use vanilla functions under `utf8.raw`. + + +#### Installation: + +Download repository to your project folder. (no rockspecs yet) + +Examples assume library placed under `utf8` subfolder not `utf8.lua`. + +As of Lua 5.3 default `utf8` module has precedence over user-provided. In this case you can specify full module path (`.utf8`). + +#### Configuration: + +Library is highly modular. You can provide your implementation for almost any function used. Library already has several back-ends: +- [Runtime character class processing](charclass/runtime/init.lua) using hardcoded codepoint ranges or using native functions through `ffi`. +- [Basic functions](primitives/init.lua) for working with UTF-8 characters have specializations for `ffi`-enabled runtime and for tarantool. + +Probably most interesting [customizations](init.lua) are `utf8.config.loadstring` and `utf8.config.cache` if you want to precompile your regexes. + +```Lua +local utf8 = require('.utf8') +utf8.config = { + cache = my_smart_cache, +} +utf8:init() +``` + +For `lower` and `upper` functions to work in environments where `ffi` cannot be used, you can specify substitution tables ([data example](https://github.com/artemshein/luv/blob/master/utf8data.lua)) + +```Lua +local utf8 = require('.utf8') +utf8.config = { + conversion = { + uc_lc = utf8_uc_lc, + lc_uc = utf8_lc_uc + }, +} +utf8:init() +``` +Customization is done before initialization. If you want, you can change configuration after `init`, it might work for everything but modules. All of them should be reloaded. + +#### [Documentation:](test/test.lua) + +#### Issue reporting: + +Please provide example script that causes error together with environment description and debug output. Debug output can be obtained like: +```Lua +local utf8 = require('.utf8') +utf8.config = { + debug = utf8:require("util").debug +} +utf8:init() +-- your code +``` +Default logger used is [`io.write`](https://www.lua.org/manual/5.3/manual.html#pdf-io.write) and can be changed by specifying `logger = my_logger` in configuration diff --git a/mac/.config/mpv/script-modules/utf8/begins/compiletime/parser.lua b/mac/.config/mpv/script-modules/utf8/begins/compiletime/parser.lua new file mode 100644 index 0000000..c54c0df --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/begins/compiletime/parser.lua @@ -0,0 +1,17 @@ +return function(utf8) + +utf8.config.begins = utf8.config.begins or { + utf8:require "begins.compiletime.vanilla" +} + +function utf8.regex.compiletime.begins.parse(regex, c, bs, ctx) + for _, m in ipairs(utf8.config.begins) do + local functions, move = m.parse(regex, c, bs, ctx) + utf8.debug("begins", _, c, bs, move, functions) + if functions then + return functions, move + end + end +end + +end diff --git a/mac/.config/mpv/script-modules/utf8/begins/compiletime/vanilla.lua b/mac/.config/mpv/script-modules/utf8/begins/compiletime/vanilla.lua new file mode 100644 index 0000000..bcafa17 --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/begins/compiletime/vanilla.lua @@ -0,0 +1,60 @@ +return function(utf8) + +local matchers = { + sliding = function() + return [[ + add(function(ctx) -- sliding + while ctx.pos <= ctx.len do + local clone = ctx:clone() + -- debug('starting from', clone, "start_pos", clone.pos) + clone.result.start = clone.pos + clone:next_function() + clone:get_function()(clone) + + ctx:next_char() + end + ctx:terminate() + end) +]] + end, + fromstart = function(ctx) + return [[ + add(function(ctx) -- fromstart + if ctx.byte_pos > ctx.len then + return + end + ctx.result.start = ctx.pos + ctx:next_function() + ctx:get_function()(ctx) + ctx:terminate() + end) +]] + end, +} + +local function default() + return matchers.sliding() +end + +local function parse(regex, c, bs, ctx) + if bs ~= 1 then return end + + local functions + local skip = 0 + + if c == '^' then + functions = matchers.fromstart() + skip = 1 + else + functions = matchers.sliding() + end + + return functions, skip +end + +return { + parse = parse, + default = default, +} + +end diff --git a/mac/.config/mpv/script-modules/utf8/charclass/compiletime/builder.lua b/mac/.config/mpv/script-modules/utf8/charclass/compiletime/builder.lua new file mode 100644 index 0000000..9d9c603 --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/charclass/compiletime/builder.lua @@ -0,0 +1,128 @@ +return function(utf8) + +local byte = utf8.byte +local unpack = utf8.config.unpack + +local builder = {} +local mt = {__index = builder} + +utf8.regex.compiletime.charclass.builder = builder + +function builder.new() + return setmetatable({}, mt) +end + +function builder:invert() + self.inverted = true + return self +end + +function builder:internal() -- is it enclosed in [] + self.internal = true + return self +end + +function builder:with_codes(...) + local codes = {...} + self.codes = self.codes or {} + + for _, v in ipairs(codes) do + table.insert(self.codes, type(v) == "number" and v or byte(v)) + end + + table.sort(self.codes) + return self +end + +function builder:with_ranges(...) + local ranges = {...} + self.ranges = self.ranges or {} + + for _, v in ipairs(ranges) do + table.insert(self.ranges, v) + end + + return self +end + +function builder:with_classes(...) + local classes = {...} + self.classes = self.classes or {} + + for _, v in ipairs(classes) do + table.insert(self.classes, v) + end + + return self +end + +function builder:without_classes(...) + local not_classes = {...} + self.not_classes = self.not_classes or {} + + for _, v in ipairs(not_classes) do + table.insert(self.not_classes, v) + end + + return self +end + +function builder:include(b) + if not b.inverted then + if b.codes then + self:with_codes(unpack(b.codes)) + end + if b.ranges then + self:with_ranges(unpack(b.ranges)) + end + if b.classes then + self:with_classes(unpack(b.classes)) + end + if b.not_classes then + self:without_classes(unpack(b.not_classes)) + end + else + self.includes = self.includes or {} + self.includes[#self.includes + 1] = b + end + return self +end + +function builder:build() + if self.codes and #self.codes == 1 and not self.inverted and not self.ranges and not self.classes and not self.not_classes and not self.includes then + return "{test = function(self, cc) return cc == " .. self.codes[1] .. " end}" + else + local codes_list = table.concat(self.codes or {}, ', ') + local ranges_list = '' + for i, r in ipairs(self.ranges or {}) do ranges_list = ranges_list .. (i > 1 and ', {' or '{') .. tostring(r[1]) .. ', ' .. tostring(r[2]) .. '}' end + local classes_list = '' + if self.classes then classes_list = "'" .. table.concat(self.classes, "', '") .. "'" end + local not_classes_list = '' + if self.not_classes then not_classes_list = "'" .. table.concat(self.not_classes, "', '") .. "'" end + + local subs_list = '' + for i, r in ipairs(self.includes or {}) do subs_list = subs_list .. (i > 1 and ', ' or '') .. r:build() .. '' end + + local src = [[cl.new():with_codes( + ]] .. codes_list .. [[ + ):with_ranges( + ]] .. ranges_list .. [[ + ):with_classes( + ]] .. classes_list .. [[ + ):without_classes( + ]] .. not_classes_list .. [[ + ):with_subs( + ]] .. subs_list .. [[ + )]] + + if self.inverted then + src = src .. ':invert()' + end + + return src + end +end + +return builder + +end diff --git a/mac/.config/mpv/script-modules/utf8/charclass/compiletime/parser.lua b/mac/.config/mpv/script-modules/utf8/charclass/compiletime/parser.lua new file mode 100644 index 0000000..4f1d4a9 --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/charclass/compiletime/parser.lua @@ -0,0 +1,21 @@ +return function(utf8) + +utf8.config.compiletime_charclasses = utf8.config.compiletime_charclasses or { + utf8:require "charclass.compiletime.vanilla", + utf8:require "charclass.compiletime.range", + utf8:require "charclass.compiletime.stub", +} + +function utf8.regex.compiletime.charclass.parse(regex, c, bs, ctx) + utf8.debug("parse charclass():", regex, c, bs, regex[bs]) + for _, p in ipairs(utf8.config.compiletime_charclasses) do + local charclass, nbs = p(regex, c, bs, ctx) + if charclass then + ctx.prev_class = charclass:build() + utf8.debug("cc", ctx.prev_class, _, c, bs, nbs) + return charclass, nbs + end + end +end + +end diff --git a/mac/.config/mpv/script-modules/utf8/charclass/compiletime/range.lua b/mac/.config/mpv/script-modules/utf8/charclass/compiletime/range.lua new file mode 100644 index 0000000..2996234 --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/charclass/compiletime/range.lua @@ -0,0 +1,44 @@ +return function(utf8) + +local cl = utf8.regex.compiletime.charclass.builder + +local next = utf8.util.next + +return function(str, c, bs, ctx) + if not ctx.internal then return end + + local nbs = bs + + local r1, r2 + + local c, nbs = c, bs + if c == '%' then + c, nbs = next(str, nbs) + r1 = c + else + r1 = c + end + + utf8.debug("range r1", r1, nbs) + + c, nbs = next(str, nbs) + if c ~= '-' then return end + + c, nbs = next(str, nbs) + if c == '%' then + c, nbs = next(str, nbs) + r2 = c + elseif c ~= '' and c ~= ']' then + r2 = c + end + + utf8.debug("range r2", r2, nbs) + + if r1 and r2 then + return cl.new():with_ranges{utf8.byte(r1), utf8.byte(r2)}, utf8.next(str, nbs) - bs + else + return + end +end + +end diff --git a/mac/.config/mpv/script-modules/utf8/charclass/compiletime/stub.lua b/mac/.config/mpv/script-modules/utf8/charclass/compiletime/stub.lua new file mode 100644 index 0000000..395d05c --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/charclass/compiletime/stub.lua @@ -0,0 +1,9 @@ +return function(utf8) + +local cl = utf8.regex.compiletime.charclass.builder + +return function(str, c, bs, ctx) + return cl.new():with_codes(c), utf8.next(str, bs) - bs +end + +end diff --git a/mac/.config/mpv/script-modules/utf8/charclass/compiletime/vanilla.lua b/mac/.config/mpv/script-modules/utf8/charclass/compiletime/vanilla.lua new file mode 100644 index 0000000..8e7f0b3 --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/charclass/compiletime/vanilla.lua @@ -0,0 +1,131 @@ +return function(utf8) + +local cl = utf8:require "charclass.compiletime.builder" + +local next = utf8.util.next + +local token = 1 + +local function parse(str, c, bs, ctx) + local tttt = token + token = token + 1 + + local class + local nbs = bs + utf8.debug("cc_parse", tttt, str, c, nbs, next(str, nbs)) + + if c == '%' then + c, nbs = next(str, bs) + if c == '' then + error("malformed pattern (ends with '%')") + end + local _c = utf8.raw.lower(c) + local matched + if _c == 'a' then + matched = ('alpha') + elseif _c == 'c' then + matched = ('cntrl') + elseif _c == 'd' then + matched = ('digit') + elseif _c == 'g' then + matched = ('graph') + elseif _c == 'l' then + matched = ('lower') + elseif _c == 'p' then + matched = ('punct') + elseif _c == 's' then + matched = ('space') + elseif _c == 'u' then + matched = ('upper') + elseif _c == 'w' then + matched = ('alnum') + elseif _c == 'x' then + matched = ('xdigit') + end + + if matched then + if _c ~= c then + class = cl.new():without_classes(matched) + else + class = cl.new():with_classes(matched) + end + elseif _c == 'z' then + class = cl.new():with_codes(0) + if _c ~= c then + class = class:invert() + end + else + class = cl.new():with_codes(c) + end + elseif c == '[' and not ctx.internal then + local old_internal = ctx.internal + ctx.internal = true + class = cl.new() + local firstletter = true + while true do + local prev_nbs = nbs + c, nbs = next(str, nbs) + utf8.debug("next", tttt, c, nbs) + if c == '^' and firstletter then + class:invert() + local nc, nnbs = next(str, nbs) + if nc == ']' then + class:with_codes(nc) + nbs = nnbs + end + elseif c == ']' then + if firstletter then + class:with_codes(c) + else + utf8.debug('] on pos', tttt, nbs) + break + end + elseif c == '' then + error "malformed pattern (missing ']')" + else + local sub_class, skip = utf8.regex.compiletime.charclass.parse(str, c, nbs, ctx) + nbs = prev_nbs + skip + utf8.debug("include", tttt, bs, prev_nbs, nbs, skip) + class:include(sub_class) + end + firstletter = false + end + ctx.internal = old_internal + elseif c == '.' then + if not ctx.internal then + class = cl.new():invert() + else + class = cl.new():with_codes(c) + end + end + + return class, utf8.next(str, nbs) - bs +end + +return parse + +end + +--[[ + x: (where x is not one of the magic characters ^$()%.[]*+-?) represents the character x itself. + .: (a dot) represents all characters. + %a: represents all letters. + %c: represents all control characters. + %d: represents all digits. + %g: represents all printable characters except space. + %l: represents all lowercase letters. + %p: represents all punctuation characters. + %s: represents all space characters. + %u: represents all uppercase letters. + %w: represents all alphanumeric characters. + %x: represents all hexadecimal digits. + %x: (where x is any non-alphanumeric character) represents the character x. This is the standard way to escape the magic characters. Any non-alphanumeric character (including all punctuation characters, even the non-magical) can be preceded by a '%' when used to represent itself in a pattern. + [set]: represents the class which is the union of all characters in set. A range of characters can be specified by separating the end characters of the range, in ascending order, with a '-'. All classes %x described above can also be used as components in set. All other characters in set represent themselves. For example, [%w_] (or [_%w]) represents all alphanumeric characters plus the underscore, [0-7] represents the octal digits, and [0-7%l%-] represents the octal digits plus the lowercase letters plus the '-' character. + + You can put a closing square bracket in a set by positioning it as the first character in the set. You can put a hyphen in a set by positioning it as the first or the last character in the set. (You can also use an escape for both cases.) + + The interaction between ranges and classes is not defined. Therefore, patterns like [%a-z] or [a-%%] have no meaning. + [^set]: represents the complement of set, where set is interpreted as above. + +For all classes represented by single letters (%a, %c, etc.), the corresponding uppercase letter represents the complement of the class. For instance, %S represents all non-space characters. +]] diff --git a/mac/.config/mpv/script-modules/utf8/charclass/runtime/base.lua b/mac/.config/mpv/script-modules/utf8/charclass/runtime/base.lua new file mode 100644 index 0000000..33d7713 --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/charclass/runtime/base.lua @@ -0,0 +1,184 @@ +return function(utf8) + +local class = {} +local mt = {__index = class} + +local utf8gensub = utf8.gensub + +function class.new() + return setmetatable({}, mt) +end + +function class:invert() + self.inverted = true + return self +end + +function class:with_codes(...) + local codes = {...} + self.codes = self.codes or {} + + for _, v in ipairs(codes) do + table.insert(self.codes, v) + end + + table.sort(self.codes) + return self +end + +function class:with_ranges(...) + local ranges = {...} + self.ranges = self.ranges or {} + + for _, v in ipairs(ranges) do + table.insert(self.ranges, v) + end + + return self +end + +function class:with_classes(...) + local classes = {...} + self.classes = self.classes or {} + + for _, v in ipairs(classes) do + table.insert(self.classes, v) + end + + return self +end + +function class:without_classes(...) + local not_classes = {...} + self.not_classes = self.not_classes or {} + + for _, v in ipairs(not_classes) do + table.insert(self.not_classes, v) + end + + return self +end + +function class:with_subs(...) + local subs = {...} + self.subs = self.subs or {} + + for _, v in ipairs(subs) do + table.insert(self.subs, v) + end + + return self +end + +function class:in_codes(item) + if not self.codes or #self.codes == 0 then return nil end + + local head, tail = 1, #self.codes + local mid = math.floor((head + tail)/2) + while (tail - head) > 1 do + if self.codes[mid] > item then + tail = mid + else + head = mid + end + mid = math.floor((head + tail)/2) + end + if self.codes[head] == item then + return true, head + elseif self.codes[tail] == item then + return true, tail + else + return false + end +end + +function class:in_ranges(char_code) + if not self.ranges or #self.ranges == 0 then return nil end + + for _,r in ipairs(self.ranges) do + if r[1] <= char_code and char_code <= r[2] then + return true + end + end + return false +end + +function class:in_classes(char_code) + if not self.classes or #self.classes == 0 then return nil end + + for _, class in ipairs(self.classes) do + if self:is(class, char_code) then + return true + end + end + return false +end + +function class:in_not_classes(char_code) + if not self.not_classes or #self.not_classes == 0 then return nil end + + for _, class in ipairs(self.not_classes) do + if self:is(class, char_code) then + return true + end + end + return false +end + +function class:is(class, char_code) + error("not implemented") +end + +function class:in_subs(char_code) + if not self.subs or #self.subs == 0 then return nil end + + for _, c in ipairs(self.subs) do + if not c:test(char_code) then + return false + end + end + return true +end + +function class:test(char_code) + local result = self:do_test(char_code) + -- utf8.debug('class:test', result, "'" .. (char_code and utf8.char(char_code) or 'nil') .. "'", char_code) + return result +end + +function class:do_test(char_code) + if not char_code then return false end + local in_not_classes = self:in_not_classes(char_code) + if in_not_classes then + return not not self.inverted + end + local in_codes = self:in_codes(char_code) + if in_codes then + return not self.inverted + end + local in_ranges = self:in_ranges(char_code) + if in_ranges then + return not self.inverted + end + local in_classes = self:in_classes(char_code) + if in_classes then + return not self.inverted + end + local in_subs = self:in_subs(char_code) + if in_subs then + return not self.inverted + end + if (in_codes == nil) + and (in_ranges == nil) + and (in_classes == nil) + and (in_subs == nil) + and (in_not_classes == false) then + return not self.inverted + else + return not not self.inverted + end +end + +return class + +end diff --git a/mac/.config/mpv/script-modules/utf8/charclass/runtime/dummy.lua b/mac/.config/mpv/script-modules/utf8/charclass/runtime/dummy.lua new file mode 100644 index 0000000..1faddc1 --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/charclass/runtime/dummy.lua @@ -0,0 +1,41 @@ +return function(utf8) + +local base = utf8:require "charclass.runtime.base" + +local dummy = setmetatable({}, {__index = base}) +local mt = {__index = dummy} + +function dummy.new() + return setmetatable({}, mt) +end + +function dummy:with_classes(...) + local classes = {...} + for _, c in ipairs(classes) do + if c == 'alpha' then self:with_ranges({65, 90}, {97, 122}) + elseif c == 'cntrl' then self:with_ranges({0, 31}):with_codes(127) + elseif c == 'digit' then self:with_ranges({48, 57}) + elseif c == 'graph' then self:with_ranges({1, 8}, {14, 31}, {33, 132}, {134, 159}, {161, 5759}, {5761, 8191}, {8203, 8231}, {8234, 8238}, {8240, 8286}, {8288, 12287}) + elseif c == 'lower' then self:with_ranges({97, 122}) + elseif c == 'punct' then self:with_ranges({33, 47}, {58, 64}, {91, 96}, {123, 126}) + elseif c == 'space' then self:with_ranges({9, 13}):with_codes(32, 133, 160, 5760):with_ranges({8192, 8202}):with_codes(8232, 8233, 8239, 8287, 12288) + elseif c == 'upper' then self:with_ranges({65, 90}) + elseif c == 'alnum' then self:with_ranges({48, 57}, {65, 90}, {97, 122}) + elseif c == 'xdigit' then self:with_ranges({48, 57}, {65, 70}, {97, 102}) + end + end + return self +end + +function dummy:without_classes(...) + local classes = {...} + if #classes > 0 then + return self:with_subs(dummy.new():with_classes(...):invert()) + else + return self + end +end + +return dummy + +end diff --git a/mac/.config/mpv/script-modules/utf8/charclass/runtime/init.lua b/mac/.config/mpv/script-modules/utf8/charclass/runtime/init.lua new file mode 100644 index 0000000..e71d037 --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/charclass/runtime/init.lua @@ -0,0 +1,22 @@ +return function(utf8) + +local provided = utf8.config.runtime_charclasses + +if provided then + if type(provided) == "table" then + return provided + elseif type(provided) == "function" then + return provided(utf8) + else + return utf8:require(provided) + end +end + +local ffi = pcall(require, "ffi") +if not ffi then + return utf8:require "charclass.runtime.dummy" +else + return utf8:require "charclass.runtime.native" +end + +end diff --git a/mac/.config/mpv/script-modules/utf8/charclass/runtime/native.lua b/mac/.config/mpv/script-modules/utf8/charclass/runtime/native.lua new file mode 100644 index 0000000..f7b7890 --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/charclass/runtime/native.lua @@ -0,0 +1,47 @@ +return function(utf8) + +os.setlocale(utf8.config.locale, "ctype") + +local ffi = require("ffi") +ffi.cdef[[ + int iswalnum(int c); + int iswalpha(int c); + int iswascii(int c); + int iswblank(int c); + int iswcntrl(int c); + int iswdigit(int c); + int iswgraph(int c); + int iswlower(int c); + int iswprint(int c); + int iswpunct(int c); + int iswspace(int c); + int iswupper(int c); + int iswxdigit(int c); +]] + +local base = utf8:require "charclass.runtime.base" + +local native = setmetatable({}, {__index = base}) +local mt = {__index = native} + +function native.new() + return setmetatable({}, mt) +end + +function native:is(class, char_code) + if class == 'alpha' then return ffi.C.iswalpha(char_code) ~= 0 + elseif class == 'cntrl' then return ffi.C.iswcntrl(char_code) ~= 0 + elseif class == 'digit' then return ffi.C.iswdigit(char_code) ~= 0 + elseif class == 'graph' then return ffi.C.iswgraph(char_code) ~= 0 + elseif class == 'lower' then return ffi.C.iswlower(char_code) ~= 0 + elseif class == 'punct' then return ffi.C.iswpunct(char_code) ~= 0 + elseif class == 'space' then return ffi.C.iswspace(char_code) ~= 0 + elseif class == 'upper' then return ffi.C.iswupper(char_code) ~= 0 + elseif class == 'alnum' then return ffi.C.iswalnum(char_code) ~= 0 + elseif class == 'xdigit' then return ffi.C.iswxdigit(char_code) ~= 0 + end +end + +return native + +end diff --git a/mac/.config/mpv/script-modules/utf8/context/compiletime.lua b/mac/.config/mpv/script-modules/utf8/context/compiletime.lua new file mode 100644 index 0000000..621204d --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/context/compiletime.lua @@ -0,0 +1,18 @@ +return function(utf8) + +local begins = utf8.config.begins +local ends = utf8.config.ends + +return { + new = function() + return { + prev_class = nil, + begins = begins[1].default(), + ends = ends[1].default(), + funcs = {}, + internal = false, -- hack for ranges, flags if parser is in [] + } + end +} + +end diff --git a/mac/.config/mpv/script-modules/utf8/context/runtime.lua b/mac/.config/mpv/script-modules/utf8/context/runtime.lua new file mode 100644 index 0000000..6fb024c --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/context/runtime.lua @@ -0,0 +1,112 @@ +return function(utf8) + +local utf8unicode = utf8.unicode +local utf8sub = utf8.sub +local sub = utf8.raw.sub +local byte = utf8.raw.byte +local utf8len = utf8.len +local utf8next = utf8.next +local rawgsub = utf8.raw.gsub +local utf8offset = utf8.offset +local utf8char = utf8.char + +local util = utf8.util + +local ctx = {} +local mt = { + __index = ctx, + __tostring = function(self) + return rawgsub([[str: '${str}', char: ${pos} '${char}', func: ${func_pos}]], "${(.-)}", { + str = self.str, + pos = self.pos, + char = self:get_char(), + func_pos = self.func_pos, + }) + end +} + +function ctx.new(obj) + obj = obj or {} + local res = setmetatable({ + pos = obj.pos or 1, + byte_pos = obj.pos or 1, + str = assert(obj.str, "str is required"), + len = obj.len, + rawlen = obj.rawlen, + bytes = obj.bytes, + offsets = obj.offsets, + starts = obj.starts or nil, + functions = obj.functions or {}, + func_pos = obj.func_pos or 1, + ends = obj.ends or nil, + result = obj.result and util.copy(obj.result) or {}, + captures = obj.captures and util.copy(obj.captures, true) or {active = {}}, + modified = false, + }, mt) + if not res.bytes then + local str = res.str + local l = #str + local bytes = utf8.config.int32array(l) + local offsets = utf8.config.int32array(l) + local c, bs, i = nil, 1, 1 + while bs <= l do + bytes[i] = utf8unicode(str, bs, bs) + offsets[i] = bs + bs = utf8.next(str, bs) + i = i + 1 + end + res.bytes = bytes + res.offsets = offsets + res.byte_pos = res.pos + res.len = i + res.rawlen = l + end + + return res +end + +function ctx:clone() + return self:new() +end + +function ctx:next_char() + self.pos = self.pos + 1 + self.byte_pos = self.pos +end + +function ctx:prev_char() + self.pos = self.pos - 1 + self.byte_pos = self.pos +end + +function ctx:get_char() + if self.len <= self.pos then return "" end + return utf8char(self.bytes[self.pos]) +end + +function ctx:get_charcode() + if self.len <= self.pos then return nil end + return self.bytes[self.pos] +end + +function ctx:next_function() + self.func_pos = self.func_pos + 1 +end + +function ctx:get_function() + return self.functions[self.func_pos] +end + +function ctx:done() + utf8.debug('done', self) + coroutine.yield(self, self.result, self.captures) +end + +function ctx:terminate() + utf8.debug('terminate', self) + coroutine.yield(nil) +end + +return ctx + +end diff --git a/mac/.config/mpv/script-modules/utf8/ends/compiletime/parser.lua b/mac/.config/mpv/script-modules/utf8/ends/compiletime/parser.lua new file mode 100644 index 0000000..f966e94 --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/ends/compiletime/parser.lua @@ -0,0 +1,17 @@ +return function(utf8) + +utf8.config.ends = utf8.config.ends or { + utf8:require "ends.compiletime.vanilla" +} + +function utf8.regex.compiletime.ends.parse(regex, c, bs, ctx) + for _, m in ipairs(utf8.config.ends) do + local functions, move = m.parse(regex, c, bs, ctx) + utf8.debug("ends", _, c, bs, move, functions) + if functions then + return functions, move + end + end +end + +end diff --git a/mac/.config/mpv/script-modules/utf8/ends/compiletime/vanilla.lua b/mac/.config/mpv/script-modules/utf8/ends/compiletime/vanilla.lua new file mode 100644 index 0000000..5fe7eb3 --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/ends/compiletime/vanilla.lua @@ -0,0 +1,46 @@ +return function(utf8) + +local matchers = { + any = function() + return [[ + add(function(ctx) -- any + ctx.result.finish = ctx.pos - 1 + ctx:done() + end) +]] + end, + toend = function(ctx) + return [[ + add(function(ctx) -- toend + ctx.result.finish = ctx.pos - 1 + ctx.modified = true + if ctx.pos == utf8len(ctx.str) + 1 then ctx:done() end + end) +]] + end, +} + +local len = utf8.raw.len + +local function default() + return matchers.any() +end + +local function parse(regex, c, bs, ctx) + local functions + local skip = 0 + + if bs == len(regex) and c == '$' then + functions = matchers.toend() + skip = 1 + end + + return functions, skip +end + +return { + parse = parse, + default = default, +} + +end diff --git a/mac/.config/mpv/script-modules/utf8/functions/lua53.lua b/mac/.config/mpv/script-modules/utf8/functions/lua53.lua new file mode 100644 index 0000000..26e6f23 --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/functions/lua53.lua @@ -0,0 +1,152 @@ +return function(utf8) + +local utf8sub = utf8.sub +local utf8gensub = utf8.gensub +local unpack = utf8.config.unpack +local generate_matcher_function = utf8:require 'regex_parser' + +local +function get_matcher_function(regex, plain) + local res + if utf8.config.cache then + res = utf8.config.cache[plain and "plain" or "regex"][regex] + end + if res then + return res + end + res = generate_matcher_function(regex, plain) + if utf8.config.cache then + utf8.config.cache[plain and "plain" or "regex"][regex] = res + end + return res +end + +local function utf8find(str, regex, init, plain) + local func = get_matcher_function(regex, plain) + init = ((init or 1) < 0) and (utf8.len(str) + init + 1) or init + local ctx, result, captures = func(str, init, utf8) + if not ctx then return nil end + + utf8.debug('ctx:', ctx) + utf8.debug('result:', result) + utf8.debug('captures:', captures) + + return result.start, result.finish, unpack(captures) +end + +local function utf8match(str, regex, init) + local func = get_matcher_function(regex, false) + init = ((init or 1) < 0) and (utf8.len(str) + init + 1) or init + local ctx, result, captures = func(str, init, utf8) + if not ctx then return nil end + + utf8.debug('ctx:', ctx) + utf8.debug('result:', result) + utf8.debug('captures:', captures) + + if #captures > 0 then return unpack(captures) end + + return utf8sub(str, result.start, result.finish) +end + +local function utf8gmatch(str, regex) + regex = (utf8sub(regex,1,1) ~= '^') and regex or '%' .. regex + local func = get_matcher_function(regex, false) + local ctx, result, captures + local continue_pos = 1 + + return function() + ctx, result, captures = func(str, continue_pos, utf8) + + if not ctx then return nil end + + utf8.debug('ctx:', ctx) + utf8.debug('result:', result) + utf8.debug('captures:', captures) + + continue_pos = math.max(result.finish + 1, result.start + 1) + if #captures > 0 then + return unpack(captures) + else + return utf8sub(str, result.start, result.finish) + end + end +end + +local function replace(repl, args) + local ret = '' + if type(repl) == 'string' then + local ignore = false + local num + for _, c in utf8gensub(repl) do + if not ignore then + if c == '%' then + ignore = true + else + ret = ret .. c + end + else + num = tonumber(c) + if num then + ret = ret .. assert(args[num], "invalid capture index %" .. c) + else + ret = ret .. c + end + ignore = false + end + end + elseif type(repl) == 'table' then + ret = repl[args[1]] or args[0] + elseif type(repl) == 'function' then + ret = repl(unpack(args, 1)) or args[0] + end + return ret +end + +local function utf8gsub(str, regex, repl, limit) + limit = limit or -1 + local subbed = '' + local prev_sub_finish = 1 + + local func = get_matcher_function(regex, false) + local ctx, result, captures + local continue_pos = 1 + + local n = 0 + while limit ~= n do + ctx, result, captures = func(str, continue_pos, utf8) + if not ctx then break end + + utf8.debug('ctx:', ctx) + utf8.debug('result:', result) + utf8.debug('result:', utf8sub(str, result.start, result.finish)) + utf8.debug('captures:', captures) + + continue_pos = math.max(result.finish + 1, result.start + 1) + local args + if #captures > 0 then + args = {[0] = utf8sub(str, result.start, result.finish), unpack(captures)} + else + args = {[0] = utf8sub(str, result.start, result.finish)} + args[1] = args[0] + end + + subbed = subbed .. utf8sub(str, prev_sub_finish, result.start - 1) + subbed = subbed .. replace(repl, args) + prev_sub_finish = result.finish + 1 + n = n + 1 + + end + + return subbed .. utf8sub(str, prev_sub_finish), n +end + +-- attaching high-level functions +utf8.find = utf8find +utf8.match = utf8match +utf8.gmatch = utf8gmatch +utf8.gsub = utf8gsub + +return utf8 + +end diff --git a/mac/.config/mpv/script-modules/utf8/init.lua b/mac/.config/mpv/script-modules/utf8/init.lua new file mode 100644 index 0000000..d2f72a4 --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/init.lua @@ -0,0 +1,71 @@ +local module_path = ... +module_path = module_path:match("^(.-)init$") or (module_path .. '.') + +local ffi_enabled, ffi = pcall(require, 'ffi') + +local utf8 = { + config = {}, + default = { + debug = nil, + logger = io.write, + loadstring = (loadstring or load), + unpack = (unpack or table.unpack), + cache = { + regex = setmetatable({},{ + __mode = 'kv' + }), + plain = setmetatable({},{ + __mode = 'kv' + }), + }, + locale = nil, + int32array = function(size) + if ffi_enabled then + return ffi.new("uint32_t[?]", size + 1) + else + return {} + end + end, + conversion = { + uc_lc = nil, + lc_uc = nil + } + }, + regex = { + compiletime = { + charclass = {}, + begins = {}, + ends = {}, + modifier = {}, + } + }, + util = {}, +} + +function utf8:require(name) + local full_module_path = module_path .. name + if package.loaded[full_module_path] then + return package.loaded[full_module_path] + end + + local mod = require(full_module_path) + if type(mod) == 'function' then + mod = mod(self) + package.loaded[full_module_path] = mod + end + return mod +end + +function utf8:init() + for k, v in pairs(self.default) do + self.config[k] = self.config[k] or v + end + + self:require "util" + self:require "primitives.init" + self:require "functions.lua53" + + return self +end + +return utf8 diff --git a/mac/.config/mpv/script-modules/utf8/modifier/compiletime/frontier.lua b/mac/.config/mpv/script-modules/utf8/modifier/compiletime/frontier.lua new file mode 100644 index 0000000..cf0f4ab --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/modifier/compiletime/frontier.lua @@ -0,0 +1,50 @@ +return function(utf8) + +local matchers = { + frontier = function(class, name) + local class_name = 'class' .. name + return [[ + local ]] .. class_name .. [[ = ]] .. class .. [[ + + add(function(ctx) -- frontier + ctx:prev_char() + local prev_charcode = ctx:get_charcode() or 0 + ctx:next_char() + local charcode = ctx:get_charcode() or 0 + -- debug("frontier pos", ctx.pos, "prev_charcode", prev_charcode, "charcode", charcode) + if ]] .. class_name .. [[:test(prev_charcode) then return end + if ]] .. class_name .. [[:test(charcode) then + ctx:next_function() + return ctx:get_function()(ctx) + end + end) +]] + end, + simple = utf8:require("modifier.compiletime.simple").simple, +} + +local function parse(regex, c, bs, ctx) + local functions, nbs, class + + if c == '%' then + if utf8.raw.sub(regex, bs + 1, bs + 1) ~= 'f' then return end + if utf8.raw.sub(regex, bs + 2, bs + 2) ~= '[' then error("missing '[' after '%f' in pattern") end + + functions = {} + if ctx.prev_class then + table.insert(functions, matchers.simple(ctx.prev_class, tostring(bs))) + ctx.prev_class = nil + end + class, nbs = utf8.regex.compiletime.charclass.parse(regex, '[', bs + 2, ctx) + nbs = nbs + 2 + table.insert(functions, matchers.frontier(class:build(), tostring(bs))) + end + + return functions, nbs +end + +return { + parse = parse, +} + +end diff --git a/mac/.config/mpv/script-modules/utf8/modifier/compiletime/parser.lua b/mac/.config/mpv/script-modules/utf8/modifier/compiletime/parser.lua new file mode 100644 index 0000000..9149f71 --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/modifier/compiletime/parser.lua @@ -0,0 +1,20 @@ +return function(utf8) + +utf8.config.modifier = utf8.config.modifier or { + utf8:require "modifier.compiletime.vanilla", + utf8:require "modifier.compiletime.frontier", + utf8:require "modifier.compiletime.stub", +} + +function utf8.regex.compiletime.modifier.parse(regex, c, bs, ctx) + for _, m in ipairs(utf8.config.modifier) do + local functions, move = m.parse(regex, c, bs, ctx) + utf8.debug("mod", _, c, bs, move, functions and utf8.config.unpack(functions)) + if functions then + ctx.prev_class = nil + return functions, move + end + end +end + +end diff --git a/mac/.config/mpv/script-modules/utf8/modifier/compiletime/simple.lua b/mac/.config/mpv/script-modules/utf8/modifier/compiletime/simple.lua new file mode 100644 index 0000000..1a28b85 --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/modifier/compiletime/simple.lua @@ -0,0 +1,23 @@ +return function(utf8) + +local matchers = { + simple = function(class, name) + local class_name = 'class' .. name + return [[ + local ]] .. class_name .. [[ = ]] .. class .. [[ + + add(function(ctx) -- simple + -- debug(ctx, 'simple', ']] .. class_name .. [[') + if ]] .. class_name .. [[:test(ctx:get_charcode()) then + ctx:next_char() + ctx:next_function() + return ctx:get_function()(ctx) + end + end) +]] + end, +} + +return matchers + +end diff --git a/mac/.config/mpv/script-modules/utf8/modifier/compiletime/stub.lua b/mac/.config/mpv/script-modules/utf8/modifier/compiletime/stub.lua new file mode 100644 index 0000000..e1289a6 --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/modifier/compiletime/stub.lua @@ -0,0 +1,28 @@ +return function(utf8) + +local matchers = utf8:require("modifier.compiletime.simple") + +local function parse(regex, c, bs, ctx) + local functions + + if ctx.prev_class then + functions = { matchers.simple(ctx.prev_class, tostring(bs)) } + ctx.prev_class = nil + end + + return functions, 0 +end + +local function check(ctx) + if ctx.prev_class then + table.insert(ctx.funcs, matchers.simple(ctx.prev_class, tostring(ctx.pos))) + ctx.prev_class = nil + end +end + +return { + parse = parse, + check = check, +} + +end diff --git a/mac/.config/mpv/script-modules/utf8/modifier/compiletime/vanilla.lua b/mac/.config/mpv/script-modules/utf8/modifier/compiletime/vanilla.lua new file mode 100644 index 0000000..96e79d2 --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/modifier/compiletime/vanilla.lua @@ -0,0 +1,270 @@ +return function(utf8) + +local utf8unicode = utf8.byte +local sub = utf8.raw.sub + +local matchers = { + star = function(class, name) + local class_name = 'class' .. name + return [[ + local ]] .. class_name .. [[ = ]] .. class .. [[ + + add(function(ctx) -- star + -- debug(ctx, 'star', ']] .. class_name .. [[') + local clone = ctx:clone() + while ]] .. class_name .. [[:test(clone:get_charcode()) do + clone:next_char() + end + local pos = clone.pos + while pos >= ctx.pos do + clone.pos = pos + clone.func_pos = ctx.func_pos + clone:next_function() + clone:get_function()(clone) + if clone.modified then + clone = ctx:clone() + end + pos = pos - 1 + end + end) +]] + end, + minus = function(class, name) + local class_name = 'class' .. name + return [[ + local ]] .. class_name .. [[ = ]] .. class .. [[ + + add(function(ctx) -- minus + -- debug(ctx, 'minus', ']] .. class_name .. [[') + + local clone = ctx:clone() + local pos + repeat + pos = clone.pos + clone:next_function() + clone:get_function()(clone) + if clone.modified then + clone = ctx:clone() + clone.pos = pos + else + clone.pos = pos + clone.func_pos = ctx.func_pos + end + local match = ]] .. class_name .. [[:test(clone:get_charcode()) + clone:next_char() + until not match + end) +]] + end, + question = function(class, name) + local class_name = 'class' .. name + return [[ + local ]] .. class_name .. [[ = ]] .. class .. [[ + + add(function(ctx) -- question + -- debug(ctx, 'question', ']] .. class_name .. [[') + local saved = ctx:clone() + if ]] .. class_name .. [[:test(ctx:get_charcode()) then + ctx:next_char() + ctx:next_function() + ctx:get_function()(ctx) + end + ctx = saved + ctx:next_function() + return ctx:get_function()(ctx) + end) +]] + end, + capture_start = function(number) + return [[ + add(function(ctx) + ctx.modified = true + -- debug(ctx, 'capture_start', ']] .. tostring(number) .. [[') + table.insert(ctx.captures.active, { id = ]] .. tostring(number) .. [[, start = ctx.pos }) + ctx:next_function() + return ctx:get_function()(ctx) + end) +]] + end, + capture_finish = function(number) + return [[ + add(function(ctx) + ctx.modified = true + -- debug(ctx, 'capture_finish', ']] .. tostring(number) .. [[') + local cap = table.remove(ctx.captures.active) + cap.finish = ctx.pos + local b, e = ctx.offsets[cap.start], ctx.offsets[cap.finish] + if cap.start < 1 then + b = 1 + elseif cap.start >= ctx.len then + b = ctx.rawlen + 1 + end + if cap.finish < 1 then + e = 1 + elseif cap.finish >= ctx.len then + e = ctx.rawlen + 1 + end + ctx.captures[cap.id] = rawsub(ctx.str, b, e - 1) + -- debug('capture#' .. tostring(cap.id), '[' .. tostring(cap.start).. ',' .. tostring(cap.finish) .. ']' , 'is', ctx.captures[cap.id]) + ctx:next_function() + return ctx:get_function()(ctx) + end) +]] + end, + capture_position = function(number) + return [[ + add(function(ctx) + ctx.modified = true + -- debug(ctx, 'capture_position', ']] .. tostring(number) .. [[') + ctx.captures[ ]] .. tostring(number) .. [[ ] = ctx.pos + ctx:next_function() + return ctx:get_function()(ctx) + end) +]] + end, + capture = function(number) + return [[ + add(function(ctx) + -- debug(ctx, 'capture', ']] .. tostring(number) .. [[') + local cap = ctx.captures[ ]] .. tostring(number) .. [[ ] + local len = utf8len(cap) + local check = utf8sub(ctx.str, ctx.pos, ctx.pos + len - 1) + -- debug("capture check:", cap, check) + if cap == check then + ctx.pos = ctx.pos + len + ctx:next_function() + return ctx:get_function()(ctx) + end + end) +]] + end, + balancer = function(pair, name) + local class_name = 'class' .. name + return [[ + + add(function(ctx) -- balancer + local d, b = ]] .. tostring(utf8unicode(pair[1])) .. [[, ]] .. tostring(utf8unicode(pair[2])) .. [[ + if ctx:get_charcode() ~= d then return end + local balance = 0 + repeat + local c = ctx:get_charcode() + if c == nil then return end + + if c == d then + balance = balance + 1 + elseif c == b then + balance = balance - 1 + end + -- debug("balancer: balance=", balance, ", d=", d, ", b=", b, ", charcode=", ctx:get_charcode()) + ctx:next_char() + until balance == 0 or (balance == 2 and d == b) + ctx:next_function() + return ctx:get_function()(ctx) + end) +]] + end, + simple = utf8:require("modifier.compiletime.simple").simple, +} + +local next = utf8.util.next + +local function parse(regex, c, bs, ctx) + local functions, nbs = nil, bs + if c == '%' then + c, nbs = next(regex, bs) + utf8.debug("next", c, bs) + if c == '' then + error("malformed pattern (ends with '%')") + end + if utf8.raw.find('123456789', c, 1, true) then + functions = { matchers.capture(tonumber(c)) } + nbs = utf8.next(regex, nbs) + elseif c == 'b' then + local d, b + d, nbs = next(regex, nbs) + b, nbs = next(regex, nbs) + assert(d ~= '' and b ~= '', "unbalanced pattern") + functions = { matchers.balancer({d, b}, tostring(bs)) } + nbs = utf8.next(regex, nbs) + end + + if functions and ctx.prev_class then + table.insert(functions, 1, matchers.simple(ctx.prev_class, tostring(bs))) + end + elseif c == '*' and ctx.prev_class then + functions = { + matchers.star( + ctx.prev_class, + tostring(bs) + ) + } + nbs = bs + 1 + elseif c == '+' and ctx.prev_class then + functions = { + matchers.simple( + ctx.prev_class, + tostring(bs) + ), + matchers.star( + ctx.prev_class, + tostring(bs) + ) + } + nbs = bs + 1 + elseif c == '-' and ctx.prev_class then + functions = { + matchers.minus( + ctx.prev_class, + tostring(bs) + ) + } + nbs = bs + 1 + elseif c == '?' and ctx.prev_class then + functions = { + matchers.question( + ctx.prev_class, + tostring(bs) + ) + } + nbs = bs + 1 + elseif c == '(' then + ctx.capture = ctx.capture or {balance = 0, id = 0} + ctx.capture.id = ctx.capture.id + 1 + local nc = next(regex, nbs) + if nc == ')' then + functions = {matchers.capture_position(ctx.capture.id)} + nbs = bs + 2 + else + ctx.capture.balance = ctx.capture.balance + 1 + functions = {matchers.capture_start(ctx.capture.id)} + nbs = bs + 1 + end + if ctx.prev_class then + table.insert(functions, 1, matchers.simple(ctx.prev_class, tostring(bs))) + end + elseif c == ')' then + ctx.capture = ctx.capture or {balance = 0, id = 0} + functions = { matchers.capture_finish(ctx.capture.id) } + + ctx.capture.balance = ctx.capture.balance - 1 + assert(ctx.capture.balance >= 0, 'invalid capture: "(" missing') + + if ctx.prev_class then + table.insert(functions, 1, matchers.simple(ctx.prev_class, tostring(bs))) + end + nbs = bs + 1 + end + + return functions, nbs - bs +end + +local function check(ctx) + if ctx.capture then assert(ctx.capture.balance == 0, 'invalid capture: ")" missing') end +end + +return { + parse = parse, + check = check, +} + +end diff --git a/mac/.config/mpv/script-modules/utf8/primitives/dummy.lua b/mac/.config/mpv/script-modules/utf8/primitives/dummy.lua new file mode 100644 index 0000000..a4665f5 --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/primitives/dummy.lua @@ -0,0 +1,555 @@ +-- $Id: utf8.lua 179 2009-04-03 18:10:03Z pasta $ +-- +-- Provides UTF-8 aware string functions implemented in pure lua: +-- * utf8len(s) +-- * utf8sub(s, i, j) +-- * utf8reverse(s) +-- * utf8char(unicode) +-- * utf8unicode(s, i, j) +-- * utf8gensub(s, sub_len) +-- * utf8find(str, regex, init, plain) +-- * utf8match(str, regex, init) +-- * utf8gmatch(str, regex, all) +-- * utf8gsub(str, regex, repl, limit) +-- +-- All functions behave as their non UTF-8 aware counterparts with the exception +-- that UTF-8 characters are used instead of bytes for all units. + +--[[ +Copyright (c) 2006-2007, Kyle Smith +All rights reserved. + +Contributors: + Alimov Stepan + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + * Neither the name of the author nor the names of its contributors may be + used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +--]] + +-- ABNF from RFC 3629 +-- +-- UTF8-octets = *( UTF8-char ) +-- UTF8-char = UTF8-1 / UTF8-2 / UTF8-3 / UTF8-4 +-- UTF8-1 = %x00-7F +-- UTF8-2 = %xC2-DF UTF8-tail +-- UTF8-3 = %xE0 %xA0-BF UTF8-tail / %xE1-EC 2( UTF8-tail ) / +-- %xED %x80-9F UTF8-tail / %xEE-EF 2( UTF8-tail ) +-- UTF8-4 = %xF0 %x90-BF 2( UTF8-tail ) / %xF1-F3 3( UTF8-tail ) / +-- %xF4 %x80-8F 2( UTF8-tail ) +-- UTF8-tail = %x80-BF +-- +return function(utf8) + +local byte = string.byte +local char = string.char +local dump = string.dump +local find = string.find +local format = string.format +local len = string.len +local lower = string.lower +local rep = string.rep +local sub = string.sub +local upper = string.upper + +local utf8charpattern = '[%z\1-\127\194-\244][\128-\191]*' + +local function utf8symbollen(byte) + return not byte and 0 or (byte < 0x80 and 1) or (byte >= 0xF0 and 4) or (byte >= 0xE0 and 3) or (byte >= 0xC0 and 2) or 1 +end + +local head_table = utf8.config.int32array(256) +for i = 0, 255 do + head_table[i] = utf8symbollen(i) +end +head_table[256] = 0 + +local function utf8charbytes(str, bs) + return head_table[byte(str, bs) or 256] +end + +local function utf8next(str, bs) + return bs + utf8charbytes(str, bs) +end + +-- returns the number of characters in a UTF-8 string +local function utf8len (str) + local bs = 1 + local bytes = len(str) + local length = 0 + + while bs <= bytes do + length = length + 1 + bs = utf8next(str, bs) + end + + return length +end + +-- functions identically to string.sub except that i and j are UTF-8 characters +-- instead of bytes +local function utf8sub (s, i, j) + -- argument defaults + j = j or -1 + + local bs = 1 + local bytes = len(s) + local length = 0 + + local l = (i >= 0 and j >= 0) or utf8len(s) + i = (i >= 0) and i or l + i + 1 + j = (j >= 0) and j or l + j + 1 + + if i > j then + return "" + end + + local start, finish = 1, bytes + + while bs <= bytes do + length = length + 1 + + if length == i then + start = bs + end + + bs = utf8next(s, bs) + + if length == j then + finish = bs - 1 + break + end + end + + if i > length then start = bytes + 1 end + if j < 1 then finish = 0 end + + return sub(s, start, finish) +end + +-- http://en.wikipedia.org/wiki/Utf8 +-- http://developer.coronalabs.com/code/utf-8-conversion-utility +local function utf8char(...) + local codes = {...} + local result = {} + + for _, unicode in ipairs(codes) do + + if unicode <= 0x7F then + result[#result + 1] = unicode + elseif unicode <= 0x7FF then + local b0 = 0xC0 + math.floor(unicode / 0x40); + local b1 = 0x80 + (unicode % 0x40); + result[#result + 1] = b0 + result[#result + 1] = b1 + elseif unicode <= 0xFFFF then + local b0 = 0xE0 + math.floor(unicode / 0x1000); + local b1 = 0x80 + (math.floor(unicode / 0x40) % 0x40); + local b2 = 0x80 + (unicode % 0x40); + result[#result + 1] = b0 + result[#result + 1] = b1 + result[#result + 1] = b2 + elseif unicode <= 0x10FFFF then + local code = unicode + local b3= 0x80 + (code % 0x40); + code = math.floor(code / 0x40) + local b2= 0x80 + (code % 0x40); + code = math.floor(code / 0x40) + local b1= 0x80 + (code % 0x40); + code = math.floor(code / 0x40) + local b0= 0xF0 + code; + + result[#result + 1] = b0 + result[#result + 1] = b1 + result[#result + 1] = b2 + result[#result + 1] = b3 + else + error 'Unicode cannot be greater than U+10FFFF!' + end + + end + + return char(utf8.config.unpack(result)) +end + + +local shift_6 = 2^6 +local shift_12 = 2^12 +local shift_18 = 2^18 + +local utf8unicode +utf8unicode = function(str, ibs, jbs) + if ibs > jbs then return end + + local ch,bytes + + bytes = utf8charbytes(str, ibs) + if bytes == 0 then return end + + local unicode + + if bytes == 1 then unicode = byte(str, ibs, ibs) end + if bytes == 2 then + local byte0,byte1 = byte(str, ibs, ibs + 1) + if byte0 and byte1 then + local code0,code1 = byte0-0xC0,byte1-0x80 + unicode = code0*shift_6 + code1 + else + unicode = byte0 + end + end + if bytes == 3 then + local byte0,byte1,byte2 = byte(str, ibs, ibs + 2) + if byte0 and byte1 and byte2 then + local code0,code1,code2 = byte0-0xE0,byte1-0x80,byte2-0x80 + unicode = code0*shift_12 + code1*shift_6 + code2 + else + unicode = byte0 + end + end + if bytes == 4 then + local byte0,byte1,byte2,byte3 = byte(str, ibs, ibs + 3) + if byte0 and byte1 and byte2 and byte3 then + local code0,code1,code2,code3 = byte0-0xF0,byte1-0x80,byte2-0x80,byte3-0x80 + unicode = code0*shift_18 + code1*shift_12 + code2*shift_6 + code3 + else + unicode = byte0 + end + end + + if ibs == jbs then + return unicode + else + return unicode,utf8unicode(str, ibs+bytes, jbs) + end +end + +local function utf8byte(str, i, j) + if #str == 0 then return end + + local ibs, jbs + + if i or j then + i = i or 1 + j = j or i + + local str_len = utf8len(str) + i = i < 0 and str_len + i + 1 or i + j = j < 0 and str_len + j + 1 or j + j = j > str_len and str_len or j + + if i > j then return end + + for p = 1, i - 1 do + ibs = utf8next(str, ibs or 1) + end + + if i == j then + jbs = ibs + else + for p = 1, j - 1 do + jbs = utf8next(str, jbs or 1) + end + end + + if not ibs or not jbs then + return nil + end + else + ibs, jbs = 1, 1 + end + + return utf8unicode(str, ibs, jbs) +end + +local function utf8gensub(str, sub_len) + sub_len = sub_len or 1 + local max_len = #str + return function(skip_ptr, bs) + bs = (bs and bs or 1) + (skip_ptr and (skip_ptr[1] or 0) or 0) + + local nbs = bs + if bs > max_len then return nil end + for i = 1, sub_len do + nbs = utf8next(str, nbs) + end + + return nbs, sub(str, bs, nbs - 1), bs + end +end + +local function utf8reverse (s) + local result = '' + for _, w in utf8gensub(s) do result = w .. result end + return result +end + +local function utf8validator(str, bs) + bs = bs or 1 + + if type(str) ~= "string" then + error("bad argument #1 to 'utf8charbytes' (string expected, got ".. type(str).. ")") + end + if type(bs) ~= "number" then + error("bad argument #2 to 'utf8charbytes' (number expected, got ".. type(bs).. ")") + end + + local c = byte(str, bs) + if not c then return end + + -- determine bytes needed for character, based on RFC 3629 + + -- UTF8-1 + if c >= 0 and c <= 127 then + return bs + 1 + elseif c >= 128 and c <= 193 then + return bs + 1, bs, 1, c + -- UTF8-2 + elseif c >= 194 and c <= 223 then + local c2 = byte(str, bs + 1) + if not c2 or c2 < 128 or c2 > 191 then + return bs + 2, bs, 2, c2 + end + + return bs + 2 + -- UTF8-3 + elseif c >= 224 and c <= 239 then + local c2 = byte(str, bs + 1) + + if not c2 then + return bs + 2, bs, 2, c2 + end + + -- validate byte 2 + if c == 224 and (c2 < 160 or c2 > 191) then + return bs + 2, bs, 2, c2 + elseif c == 237 and (c2 < 128 or c2 > 159) then + return bs + 2, bs, 2, c2 + elseif c2 < 128 or c2 > 191 then + return bs + 2, bs, 2, c2 + end + + local c3 = byte(str, bs + 2) + if not c3 or c3 < 128 or c3 > 191 then + return bs + 3, bs, 3, c3 + end + + return bs + 3 + -- UTF8-4 + elseif c >= 240 and c <= 244 then + local c2 = byte(str, bs + 1) + + if not c2 then + return bs + 2, bs, 2, c2 + end + + -- validate byte 2 + if c == 240 and (c2 < 144 or c2 > 191) then + return bs + 2, bs, 2, c2 + elseif c == 244 and (c2 < 128 or c2 > 143) then + return bs + 2, bs, 2, c2 + elseif c2 < 128 or c2 > 191 then + return bs + 2, bs, 2, c2 + end + + local c3 = byte(str, bs + 2) + if not c3 or c3 < 128 or c3 > 191 then + return bs + 3, bs, 3, c3 + end + + local c4 = byte(str, bs + 3) + if not c4 or c4 < 128 or c4 > 191 then + return bs + 4, bs, 4, c4 + end + + return bs + 4 + else -- c > 245 + return bs + 1, bs, 1, c + end +end + +local function utf8validate(str, byte_pos) + local result = {} + for nbs, bs, part, code in utf8validator, str, byte_pos do + if bs then + result[#result + 1] = { pos = bs, part = part, code = code } + end + end + return #result == 0, result +end + +local function utf8codes(str) + local max_len = #str + local bs = 1 + return function(skip_ptr) + if bs > max_len then return nil end + local pbs = bs + bs = utf8next(str, pbs) + + return pbs, utf8unicode(str, pbs, pbs), pbs + end +end + + +--[[-- +differs from Lua 5.3 utf8.offset in accepting any byte positions (not only head byte) for all n values + +h - head, c - continuation, t - tail +hhhccthccthccthcthhh + ^ start byte pos +searching current charracter head by moving backwards +hhhccthccthccthcthhh + ^ head + +n == 0: current position +n > 0: n jumps forward +n < 0: n more scans backwards +--]]-- +local function utf8offset(str, n, bs) + local l = #str + if not bs then + if n < 0 then + bs = l + 1 + else + bs = 1 + end + end + if bs <= 0 or bs > l + 1 then + error("bad argument #3 to 'offset' (position out of range)") + end + + if n == 0 then + if bs == l + 1 then + return bs + end + while true do + local b = byte(str, bs) + if (0 < b and b < 127) + or (194 < b and b < 244) then + return bs + end + bs = bs - 1 + if bs < 1 then + return + end + end + elseif n < 0 then + bs = bs - 1 + repeat + if bs < 1 then + return + end + + local b = byte(str, bs) + if (0 < b and b < 127) + or (194 < b and b < 244) then + n = n + 1 + end + bs = bs - 1 + until n == 0 + return bs + 1 + else + while true do + if bs > l then + return + end + + local b = byte(str, bs) + if (0 < b and b < 127) + or (194 < b and b < 244) then + n = n - 1 + for i = 1, n do + if bs > l then + return + end + bs = utf8next(str, bs) + end + return bs + end + bs = bs - 1 + end + end + +end + +local function utf8replace (s, mapping) + if type(s) ~= "string" then + error("bad argument #1 to 'utf8replace' (string expected, got ".. type(s).. ")") + end + if type(mapping) ~= "table" then + error("bad argument #2 to 'utf8replace' (table expected, got ".. type(mapping).. ")") + end + local result = utf8.raw.gsub( s, utf8charpattern, mapping ) + return result +end + +local function utf8upper (s) + return utf8replace(s, utf8.config.conversion.lc_uc) +end + +if utf8.config.conversion.lc_uc then + upper = utf8upper +end + +local function utf8lower (s) + return utf8replace(s, utf8.config.conversion.uc_lc) +end + +if utf8.config.conversion.uc_lc then + lower = utf8lower +end + +utf8.len = utf8len +utf8.sub = utf8sub +utf8.reverse = utf8reverse +utf8.char = utf8char +utf8.unicode = utf8unicode +utf8.byte = utf8byte +utf8.next = utf8next +utf8.gensub = utf8gensub +utf8.validator = utf8validator +utf8.validate = utf8validate +utf8.dump = dump +utf8.format = format +utf8.lower = lower +utf8.upper = upper +utf8.rep = rep +utf8.raw = {} +for k,v in pairs(string) do + utf8.raw[k] = v +end + +utf8.charpattern = utf8charpattern +utf8.offset = utf8offset +if _VERSION == 'Lua 5.3' then + local utf8_53 = require "utf8" + utf8.codes = utf8_53.codes + utf8.codepoint = utf8_53.codepoint + utf8.len53 = utf8_53.len +else + utf8.codes = utf8codes + utf8.codepoint = utf8unicode +end + +return utf8 + +end diff --git a/mac/.config/mpv/script-modules/utf8/primitives/init.lua b/mac/.config/mpv/script-modules/utf8/primitives/init.lua new file mode 100644 index 0000000..df28ef3 --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/primitives/init.lua @@ -0,0 +1,23 @@ +return function(utf8) + +local provided = utf8.config.primitives + +if provided then + if type(provided) == "table" then + return provided + elseif type(provided) == "function" then + return provided(utf8) + else + return utf8:require(provided) + end +end + +if pcall(require, "tarantool") then + return utf8:require "primitives.tarantool" +elseif pcall(require, "ffi") then + return utf8:require "primitives.native" +else + return utf8:require "primitives.dummy" +end + +end diff --git a/mac/.config/mpv/script-modules/utf8/primitives/native.lua b/mac/.config/mpv/script-modules/utf8/primitives/native.lua new file mode 100644 index 0000000..c9aca54 --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/primitives/native.lua @@ -0,0 +1,57 @@ +return function(utf8) + +local ffi = require("ffi") +if ffi.os == "Windows" then + os.setlocale(utf8.config.locale or "english_us.65001", "ctype") + ffi.cdef[[ + short towupper(short c); + short towlower(short c); + ]] +else + os.setlocale(utf8.config.locale or "C.UTF-8", "ctype") + ffi.cdef[[ + int towupper(int c); + int towlower(int c); + ]] +end + +utf8:require "primitives.dummy" + +if not utf8.config.conversion.uc_lc then + function utf8.lower(str) + local bs = 1 + local nbs + local bytes = utf8.raw.len(str) + local res = {} + + while bs <= bytes do + nbs = utf8.next(str, bs) + local cp = utf8.unicode(str, bs, nbs) + res[#res + 1] = ffi.C.towlower(cp) + bs = nbs + end + + return utf8.char(utf8.config.unpack(res)) + end +end + +if not utf8.config.conversion.lc_uc then + function utf8.upper(str) + local bs = 1 + local nbs + local bytes = utf8.raw.len(str) + local res = {} + + while bs <= bytes do + nbs = utf8.next(str, bs) + local cp = utf8.unicode(str, bs, nbs) + res[#res + 1] = ffi.C.towupper(cp) + bs = nbs + end + + return utf8.char(utf8.config.unpack(res)) + end +end + +return utf8 +end diff --git a/mac/.config/mpv/script-modules/utf8/primitives/tarantool.lua b/mac/.config/mpv/script-modules/utf8/primitives/tarantool.lua new file mode 100644 index 0000000..c38acf6 --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/primitives/tarantool.lua @@ -0,0 +1,13 @@ +return function(utf8) + +utf8:require "primitives.dummy" + +local tnt_utf8 = utf8.config.tarantool_utf8 or require("utf8") + +utf8.lower = tnt_utf8.lower +utf8.upper = tnt_utf8.upper +utf8.len = tnt_utf8.len +utf8.char = tnt_utf8.char + +return utf8 +end diff --git a/mac/.config/mpv/script-modules/utf8/regex_parser.lua b/mac/.config/mpv/script-modules/utf8/regex_parser.lua new file mode 100644 index 0000000..3190f1b --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/regex_parser.lua @@ -0,0 +1,80 @@ +return function(utf8) + +utf8:require "modifier.compiletime.parser" +utf8:require "charclass.compiletime.parser" +utf8:require "begins.compiletime.parser" +utf8:require "ends.compiletime.parser" + +local gensub = utf8.gensub +local sub = utf8.sub + +local parser_context = utf8:require "context.compiletime" + +return function(regex, plain) + utf8.debug("regex", regex) + local ctx = parser_context:new() + + local skip = {0} + for nbs, c, bs in gensub(regex, 0), skip do + repeat -- continue + skip[1] = 0 + + c = utf8.raw.sub(regex, bs, utf8.next(regex, bs) - 1) + + local functions, move = utf8.regex.compiletime.begins.parse(regex, c, bs, ctx) + if functions then + ctx.begins = functions + skip[1] = move + end + if skip[1] ~= 0 then break end + + local functions, move = utf8.regex.compiletime.ends.parse(regex, c, bs, ctx) + if functions then + ctx.ends = functions + skip[1] = move + end + if skip[1] ~= 0 then break end + + local functions, move = utf8.regex.compiletime.modifier.parse(regex, c, bs, ctx) + if functions then + for _, f in ipairs(functions) do + ctx.funcs[#ctx.funcs + 1] = f + end + skip[1] = move + end + if skip[1] ~= 0 then break end + + local charclass, move = utf8.regex.compiletime.charclass.parse(regex, c, bs, ctx) + if charclass then skip[1] = move end + until true -- continue + end + + for _, m in ipairs(utf8.config.modifier) do + if m.check then m.check(ctx) end + end + + local src = [[ + return function(str, init, utf8) + local ctx = utf8:require("context.runtime").new({str = str, pos = init or 1}) + local cl = utf8:require("charclass.runtime.init") + local utf8sub = utf8.sub + local rawsub = utf8.raw.sub + local utf8len = utf8.len + local utf8next = utf8.next + local debug = utf8.debug + local function add(fun) + ctx.functions[#ctx.functions + 1] = fun + end + ]] .. ctx.begins + for _, v in ipairs(ctx.funcs) do src = src .. v end + src = src .. ctx.ends .. [[ + return coroutine.wrap(ctx:get_function())(ctx) + end + ]] + + utf8.debug(regex, src) + + return assert(utf8.config.loadstring(src, (plain and "plain " or "") .. regex))() +end + +end diff --git a/mac/.config/mpv/script-modules/utf8/test.sh b/mac/.config/mpv/script-modules/utf8/test.sh new file mode 100755 index 0000000..b8d2d63 --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/test.sh @@ -0,0 +1,23 @@ +#!/bin/sh + +set -xe + +lua53=$(which lua5.3 || which true) +lua51=$(which lua5.1 || which true) +luajit=$(which luajit || which true) + +for test in \ + test/charclass_compiletime.lua \ + test/charclass_runtime.lua \ + test/context_runtime.lua \ + test/test.lua \ + test/test_compat.lua \ + test/test_pm.lua \ + test/test_utf8data.lua +do + $lua53 $test + $lua51 $test + $luajit $test +done + +echo "tests passed" diff --git a/mac/.config/mpv/script-modules/utf8/test/charclass_compiletime.lua b/mac/.config/mpv/script-modules/utf8/test/charclass_compiletime.lua new file mode 100644 index 0000000..05d762d --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/test/charclass_compiletime.lua @@ -0,0 +1,165 @@ +local utf8 = require "init" +utf8.config = { + debug = nil, +-- debug = utf8:require("util").debug, +} +utf8:init() + +local ctx = utf8:require("context.compiletime"):new() + +local equals = require 'test.util'.equals +local assert = require 'test.util'.assert +local assert_equals = require 'test.util'.assert_equals +local parse = utf8.regex.compiletime.charclass.parse + +assert_equals({parse("aabb", "a", 1, ctx)}, {{codes = {utf8.byte("a")}}, 1}) +assert_equals({parse("aabb", "a", 2, ctx)}, {{codes = {utf8.byte("a")}}, 1}) +assert_equals({parse("aabb", "b", 3, ctx)}, {{codes = {utf8.byte("b")}}, 1}) +assert_equals({parse("aabb", "b", 4, ctx)}, {{codes = {utf8.byte("b")}}, 1}) + +assert_equals({parse("aa%ab", "%", 3, ctx)}, {{classes = {'alpha'}}, 2}) +assert_equals({parse("aac%Ab", "%", 4, ctx)}, {{not_classes = {'alpha'}}, 2}) +assert_equals({parse("aa.b", ".", 3, ctx)}, {{inverted = true}, 1}) + +assert_equals({parse("aa[c]b", "[", 3, ctx)}, { + {codes = {utf8.byte("c")}, ranges = nil, classes = nil, not_classes = nil}, + utf8.raw.len("[c]") +}) + +assert_equals({parse("aa[%A]b", "[", 3, ctx)}, { + {codes = nil, ranges = nil, classes = nil, not_classes = {'alpha'}}, + utf8.raw.len("[%A]") +}) + +assert_equals({parse("[^%p%d%s%c]+", "[", 1, ctx)}, { + {codes = nil, ranges = nil, classes = {'punct', 'digit', 'space', 'cntrl'}, not_classes = nil, inverted = true}, + utf8.raw.len("[^%p%d%s%c]") +}) + +assert_equals({parse("aa[[c]]b", "[", 3, ctx)}, { + {codes = {utf8.byte("["), utf8.byte("c")}, ranges = nil, classes = nil, not_classes = nil}, + utf8.raw.len("[[c]") +}) + +assert_equals({parse("aa[%a[c]]b", "[", 3, ctx)}, { + {codes = {utf8.byte("["), utf8.byte("c")}, ranges = nil, classes = {'alpha'}, not_classes = nil}, + utf8.raw.len("[%a[c]") +}) + +assert_equals({parse("aac-db", "c", 3, ctx)}, { + {codes = {utf8.byte("c")}}, + utf8.raw.len("c") +}) + +assert_equals({parse("aa[c-d]b", "[", 3, ctx)}, { + {codes = nil, ranges = {{utf8.byte("c"),utf8.byte("d")}}, classes = nil, not_classes = nil}, + utf8.raw.len("[c-d]") +}) +assert_equals(ctx.internal, false) + +assert_equals({parse("aa[c-]]b", "[", 3, ctx)}, { + {codes = {utf8.byte("-"), utf8.byte("c")}, ranges = nil, classes = nil, not_classes = nil}, + utf8.raw.len("[c-]") +}) +assert_equals(ctx.internal, false) + +assert_equals({parse("aad-", "d", 3, ctx)}, { + {codes = {utf8.byte("d")}}, + utf8.raw.len("d") +}) +assert_equals(ctx.internal, false) + +ctx.internal = false +assert_equals({parse(".", ".", 1, ctx)}, { + {inverted = true}, + utf8.raw.len(".") +}) + +assert_equals({parse("[.]", "[", 1, ctx)}, { + {codes = {utf8.byte(".")}}, + utf8.raw.len("[.]") +}) + +assert_equals({parse("%?", "%", 1, ctx)}, { + {codes = {utf8.byte("?")}}, + utf8.raw.len("%?") +}) + +assert_equals({parse("[]]", "[", 1, ctx)}, { + {codes = {utf8.byte("]")}}, + utf8.raw.len("[]]") +}) + +assert_equals({parse("[^]]", "[", 1, ctx)}, { + {codes = {utf8.byte("]")}, inverted = true}, + utf8.raw.len("[^]]") +}) + +--[[-- +multibyte chars +--]]-- + +assert_equals({parse("ббюю", "б", #"" + 1, ctx)}, {{codes = {utf8.byte("б")}}, utf8.raw.len("б")}) +assert_equals({parse("ббюю", "б", #"б" + 1, ctx)}, {{codes = {utf8.byte("б")}}, utf8.raw.len("б")}) +assert_equals({parse("ббюю", "ю", #"бб" + 1, ctx)}, {{codes = {utf8.byte("ю")}}, utf8.raw.len("ю")}) +assert_equals({parse("ббюю", "ю", #"ббю" + 1, ctx)}, {{codes = {utf8.byte("ю")}}, utf8.raw.len("ю")}) + +assert_equals({parse("бб%aю", "%", #"бб" + 1, ctx)}, {{classes = {'alpha'}}, 2}) +assert_equals({parse("ббц%Aю", "%", #"ббц" + 1, ctx)}, {{not_classes = {'alpha'}}, 2}) +assert_equals({parse("бб.ю", ".", #"бб" + 1, ctx)}, {{inverted = true}, 1}) + +assert_equals({parse("бб[ц]ю", "[", #"бб" + 1, ctx)}, { + {codes = {utf8.byte("ц")}, ranges = nil, classes = nil, not_classes = nil}, + utf8.raw.len("[ц]") +}) + +assert_equals({parse("бб[%A]ю", "[", #"бб" + 1, ctx)}, { + {codes = nil, ranges = nil, classes = nil, not_classes = {'alpha'}}, + utf8.raw.len("[%A]") +}) + +assert_equals({parse("бб[[ц]]ю", "[", #"бб" + 1, ctx)}, { + {codes = {utf8.byte("["), utf8.byte("ц")}, ranges = nil, classes = nil, not_classes = nil}, + utf8.raw.len("[[ц]") +}) + +assert_equals({parse("бб[%a[ц]]ю", "[", #"бб" + 1, ctx)}, { + {codes = {utf8.byte("["), utf8.byte("ц")}, ranges = nil, classes = {'alpha'}, not_classes = nil}, + utf8.raw.len("[%a[ц]") +}) + +ctx.internal = true +assert_equals({parse("ббц-ыю", "ц", #"бб" + 1, ctx)}, { + {ranges = {{utf8.byte("ц"),utf8.byte("ы")}}}, + utf8.raw.len("ц-ы") +}) + +ctx.internal = false +assert_equals({parse("бб[ц-ы]ю", "[", #"бб" + 1, ctx)}, { + {codes = nil, ranges = {{utf8.byte("ц"),utf8.byte("ы")}}, classes = nil, not_classes = nil}, + utf8.raw.len("[ц-ы]") +}) + +assert_equals({parse("бб[ц-]]ю", "[", #"бб" + 1, ctx)}, { + {codes = {utf8.byte("-"), utf8.byte("ц")}, ranges = nil, classes = nil, not_classes = nil}, + utf8.raw.len("[ц-]") +}) + +assert_equals({parse("ббы-", "ы", #"бб" + 1, ctx)}, { + {codes = {utf8.byte("ы")}}, + utf8.raw.len("ы") +}) + +ctx.internal = true +assert_equals({parse("ббы-цю", "ы", #"бб" + 1, ctx)}, { + {ranges = {{utf8.byte("ы"),utf8.byte("ц")}}}, + utf8.raw.len("ы-ц") +}) + +ctx.internal = false +assert_equals({parse("бб[ы]ю", "[", #"бб" + 1, ctx)}, { + {codes = {utf8.byte("ы")}, ranges = nil, classes = nil, not_classes = nil}, + utf8.raw.len("[ы]") +}) + +print "OK" diff --git a/mac/.config/mpv/script-modules/utf8/test/charclass_runtime.lua b/mac/.config/mpv/script-modules/utf8/test/charclass_runtime.lua new file mode 100644 index 0000000..616af14 --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/test/charclass_runtime.lua @@ -0,0 +1,116 @@ +local utf8 = require("init") +utf8.config = { + debug = nil, --utf8:require("util").debug +} +utf8:init() + +local cl = utf8:require("charclass.runtime.init") + +local equals = require('test.util').equals +local assert = require('test.util').assert +local assert_equals = require('test.util').assert_equals + +assert_equals(true, cl.new() + :with_codes(utf8.byte' ') + :invert() + :in_codes(utf8.byte' ')) + +assert_equals(false, cl.new() + :with_codes(utf8.byte' ') + :invert() + :test(utf8.byte' ')) + +assert_equals(false, cl.new() + :with_codes() + :with_ranges() + :with_classes('space') + :without_classes() + :with_subs() + :invert() + :test(utf8.byte(' '))) + +assert_equals(true, cl.new() + :with_codes() + :with_ranges() + :with_classes() + :without_classes('space') + :with_subs() + :invert() + :test(utf8.byte(' '))) + +assert_equals(false, cl.new() + :with_codes() + :with_ranges() + :with_classes() + :without_classes() + :with_subs(cl.new():with_classes('space')) + :invert() + :test(utf8.byte(' '))) + +assert_equals(true, cl.new() + :with_codes() + :with_ranges() + :with_classes() + :without_classes() + :with_subs(cl.new():with_classes('space'):invert()) + :invert() + :test(utf8.byte(' '))) + +assert_equals(true, cl.new() + :with_codes() + :with_ranges() + :with_classes('punct', 'digit', 'space', 'cntrl') + :without_classes() + :with_subs() + :invert() + :test(utf8.byte'П') +) + +assert_equals(true, cl.new() + :with_codes() + :with_ranges() + :with_classes('punct', 'digit', 'space', 'cntrl') + :without_classes() + :with_subs() + :invert() + :test(utf8.byte'и') +) + +assert_equals(true, cl.new() + :with_codes() + :with_ranges() + :with_classes() + :without_classes('space') + :with_subs() + :test(utf8.byte'f') +) + +assert_equals(false, cl.new() + :with_codes() + :with_ranges() + :with_classes() + :without_classes('space') + :with_subs() + :test(utf8.byte'\n') +) + +assert_equals(false, cl.new() + :with_codes() + :with_ranges() + :with_classes('lower') + :without_classes() + :with_subs() + :invert() + :test(nil) +) + +assert_equals(false, cl.new() + :with_codes() + :with_ranges() + :with_classes('lower') + :without_classes() + :with_subs() + :test(nil) +) + +print "OK" diff --git a/mac/.config/mpv/script-modules/utf8/test/context_runtime.lua b/mac/.config/mpv/script-modules/utf8/test/context_runtime.lua new file mode 100644 index 0000000..9a177bf --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/test/context_runtime.lua @@ -0,0 +1,82 @@ +local utf8 = require("init"):init() + +local context = utf8:require('context.runtime') + +local equals = require('test.util').equals +local assert = require('test.util').assert +local assert_equals = require('test.util').assert_equals + +local ctx_en +local ctx_ru +local function setup() + ctx_en = context.new({str = 'asdf'}) + ctx_ru = context.new({str = 'фыва'}) +end + +local test_get_char = (function() + setup() + + assert_equals('a', ctx_en:get_char()) + assert_equals('ф', ctx_ru:get_char()) +end)() + +local test_get_charcode = (function() + setup() + + assert_equals(utf8.byte'a', ctx_en:get_charcode()) + assert_equals(utf8.byte'ф', ctx_ru:get_charcode()) +end)() + +local test_next_char = (function() + setup() + + assert_equals(1, ctx_en.pos) + assert_equals(1, ctx_ru.pos) + + ctx_ru:next_char() + ctx_en:next_char() + + assert_equals(2, ctx_en.pos) + assert_equals(2, ctx_ru.pos) + + assert_equals('s', ctx_en:get_char()) + assert_equals('ы', ctx_ru:get_char()) + assert_equals(utf8.byte's', ctx_en:get_charcode()) + assert_equals(utf8.byte'ы', ctx_ru:get_charcode()) +end)() + +local test_clone = (function() + setup() + + local clone = ctx_en:clone() + + assert(getmetatable(clone) == getmetatable(ctx_en)) + assert_equals(clone, ctx_en) + + ctx_en:next_char() + + assert_equals('a', clone:get_char()) + assert_equals('s', ctx_en:get_char()) + +end)() + +local test_last_char = (function() + ctx_en = context.new({str = 'asdf', pos = 4}) + ctx_ru = context.new({str = 'фыва', pos = 4}) + + assert_equals('f', ctx_en:get_char()) + assert_equals('а', ctx_ru:get_char()) + + ctx_ru:next_char() + ctx_en:next_char() + + assert_equals(5, ctx_en.pos) + assert_equals(5, ctx_ru.pos) + + assert_equals("", ctx_en:get_char()) + assert_equals("", ctx_ru:get_char()) + assert_equals(nil, ctx_en:get_charcode()) + assert_equals(nil, ctx_ru:get_charcode()) +end)() + +print('OK') diff --git a/mac/.config/mpv/script-modules/utf8/test/strict.lua b/mac/.config/mpv/script-modules/utf8/test/strict.lua new file mode 100644 index 0000000..7324644 --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/test/strict.lua @@ -0,0 +1,42 @@ +--[[-- +strict.lua from http://metalua.luaforge.net/src/lib/strict.lua.html +--]]-- + +-- +-- strict.lua +-- checks uses of undeclared global variables +-- All global variables must be 'declared' through a regular assignment +-- (even assigning nil will do) in a main chunk before being used +-- anywhere or assigned to inside a function. +-- + +local mt = getmetatable(_G) +if mt == nil then + mt = {} + setmetatable(_G, mt) +end + +__STRICT = true +mt.__declared = {} + +mt.__newindex = function (t, n, v) + if __STRICT and not mt.__declared[n] then + local w = debug.getinfo(2, "S").what + if w ~= "main" and w ~= "C" then + error("assign to undeclared variable '"..n.."'", 2) + end + mt.__declared[n] = true + end + rawset(t, n, v) +end + +mt.__index = function (t, n) + if not mt.__declared[n] and debug.getinfo(2, "S").what ~= "C" then + error("variable '"..n.."' is not declared", 2) + end + return rawget(t, n) +end + +function global(...) + for _, v in ipairs{...} do mt.__declared[v] = true end +end diff --git a/mac/.config/mpv/script-modules/utf8/test/test.lua b/mac/.config/mpv/script-modules/utf8/test/test.lua new file mode 100644 index 0000000..8653b5d --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/test/test.lua @@ -0,0 +1,205 @@ +local utf8 = require('init') +utf8.config = { + debug = nil, +-- debug = utf8:require("util").debug, +} +utf8:init() + +for k,v in pairs(utf8) do + string[k] = v +end + +local LUA_51, LUA_53 = false, false +if "\xe4" == "xe4" then -- lua5.1 + LUA_51 = true +else -- luajit lua5.3 + LUA_53 = true +end + +local FFI_ENABLED = false +if pcall(require, "ffi") then + FFI_ENABLED = true +end + +local res = {} + +local equals = require 'test.util'.equals +local assert = require 'test.util'.assert +local assert_equals = require 'test.util'.assert_equals + +if FFI_ENABLED then + assert_equals(("АБВ"):lower(), "абв") + assert_equals(("абв"):upper(), "АБВ") +end + +res = {} +for _, w in ("123456789"):gensub(2), {1} do res[#res + 1] = w end +assert_equals({"23", "56", "89"}, res) + +assert_equals(0, ("фыва"):next(0)) +assert_equals(100, ("фыва"):next(100)) +assert_equals(#"ф" + 1, ("фыва"):next(1)) +assert_equals("ыва", utf8.raw.sub("фыва", ("фыва"):next(1))) + +res = {} +for p, c in ("абвгд"):codes() do res[#res + 1] = {p, c} end +assert_equals({ + {1, utf8.byte'а'}, + {#'а' + 1, utf8.byte'б'}, + {#'аб' + 1, utf8.byte'в'}, + {#'абв' + 1, utf8.byte'г'}, + {#'абвг' + 1, utf8.byte'д'}, +}, res) + +assert_equals(1, utf8.offset('abcde', 0)) + +assert_equals(1, utf8.offset('abcde', 1)) +assert_equals(5, utf8.offset('abcde', 5)) +assert_equals(6, utf8.offset('abcde', 6)) +assert_equals(nil, utf8.offset('abcde', 7)) + +assert_equals(5, utf8.offset('abcde', -1)) +assert_equals(1, utf8.offset('abcde', -5)) +assert_equals(nil, utf8.offset('abcde', -6)) + +assert_equals(1, utf8.offset('abcde', 0, 1)) +assert_equals(3, utf8.offset('abcde', 0, 3)) +assert_equals(6, utf8.offset('abcde', 0, 6)) + +assert_equals(3, utf8.offset('abcde', 1, 3)) +assert_equals(5, utf8.offset('abcde', 3, 3)) +assert_equals(6, utf8.offset('abcde', 4, 3)) +assert_equals(nil, utf8.offset('abcde', 5, 3)) + +assert_equals(2, utf8.offset('abcde', -1, 3)) +assert_equals(1, utf8.offset('abcde', -2, 3)) +assert_equals(5, utf8.offset('abcde', -1, 6)) +assert_equals(nil, utf8.offset('abcde', -3, 3)) + +assert_equals(1, utf8.offset('абвгд', 0)) + +assert_equals(1, utf8.offset('абвгд', 1)) +assert_equals(#'абвг' + 1, utf8.offset('абвгд', 5)) +assert_equals(#'абвгд' + 1, utf8.offset('абвгд', 6)) +assert_equals(nil, utf8.offset('абвгд', 7)) + +assert_equals(#'абвг' + 1, utf8.offset('абвгд', -1)) +assert_equals(1, utf8.offset('абвгд', -5)) +assert_equals(nil, utf8.offset('абвгд', -6)) + +assert_equals(1, utf8.offset('абвгд', 0, 1)) +assert_equals(1, utf8.offset('абвгд', 0, 2)) +assert_equals(#'аб' + 1, utf8.offset('абвгд', 0, #'аб' + 1)) +assert_equals(#'аб' + 1, utf8.offset('абвгд', 0, #'аб' + 2)) +assert_equals(#'абвгд' + 1, utf8.offset('абвгд', 0, #'абвгд' + 1)) + +assert_equals(#'аб' + 1, utf8.offset('абвгд', 1, #'аб' + 1)) +assert_equals(#'абвг' + 1, utf8.offset('абвгд', 3, #'аб' + 1)) +assert_equals(#'абвгд' + 1, utf8.offset('абвгд', 4, #'аб' + 1)) +assert_equals(#'абвгд' + 1, utf8.offset('абвгд', 4, #'аб' + 2)) +assert_equals(nil, utf8.offset('абвгд', 5, #'аб' + 1)) + +assert_equals(#'а' + 1, utf8.offset('абвгд', -1, #'аб' + 1)) +assert_equals(1, utf8.offset('абвгд', -2, #'аб' + 1)) +assert_equals(#'абвг' + 1, utf8.offset('абвгд', -1, #'абвгд' + 1)) +assert_equals(nil, utf8.offset('абвгд', -3, #'аб' + 1)) + +assert(("фыва"):validate()) +assert_equals({false, {{ pos = #"ф" + 1, part = 1, code = 255 }} }, {("ф\255ыва"):validate()}) +if LUA_53 then + assert_equals({false, {{ pos = #"ф" + 1, part = 1, code = 0xFF }} }, {("ф\xffыва"):validate()}) +end + +assert_equals(nil, ("aabb"):find("%bcd")) +assert_equals({1, 4}, {("aabb"):find("%bab")}) +assert_equals({1, 2}, {("aba"):find('%bab')}) + +res = {} +for w in ("aacaabbcabbacbaacab"):gmatch('%bab') do res[#res + 1] = w end +assert_equals({"acaabbcabb", "acb", "ab"}, res) + +assert_equals({1, 0}, {("aacaabbcabbacbaacab"):find('%f[acb]')}) +assert_equals("a", ("aba"):match('%f[ab].')) + +res = {} +for w in ("aacaabbcabbacbaacab"):gmatch('%f[ab]') do res[#res + 1] = w end +assert_equals({"", "", "", "", ""}, res) + +assert_equals({"HaacHaabbcHabbacHbaacHab", 5}, {("aacaabbcabbacbaacab"):gsub('%f[ab]', 'H')}) + +res = {} +for w in ("Привет, мир, от Lua"):gmatch("[^%p%d%s%c]+") do res[#res + 1] = w end +assert_equals({"Привет", "мир", "от", "Lua"}, res) + +res = {} +for k, v in ("从=世界, 到=Lua"):gmatch("([^%p%s%c]+)=([^%p%s%c]+)") do res[k] = v end +assert_equals({["到"] = "Lua", ["从"] = "世界"}, res) + +assert_equals("Ahoj Ahoj světe světe", ("Ahoj světe"):gsub("([^%p%s%c]+)", "%1 %1")) + +assert_equals("Ahoj Ahoj světe", ("Ahoj světe"):gsub("[^%p%s%c]+", "%0 %0", 1)) + +assert_equals("κόσμο γεια Lua από", ("γεια κόσμο από Lua"):gsub("([^%p%s%c]+)%s*([^%p%s%c]+)", "%2 %1")) + +assert_equals({8, 27, "ололоо я водитель э"}, {("пыщпыщ ололоо я водитель энло"):find("(.л.+)н")}) + +assert_equals({"пыщпыщ о보라보라 я водитель эн보라", 3}, {("пыщпыщ ололоо я водитель энло"):gsub("ло+", "보라")}) + +assert_equals("пыщпыщ ололоо я", ("пыщпыщ ололоо я водитель энло"):match("^п[лопыщ ]*я")) + +assert_equals("в", ("пыщпыщ ололоо я водитель энло"):match("[в-д]+")) + +assert_equals(nil, ('abc abc'):match('([^%s]+)%s%s')) -- https://github.com/Stepets/utf8.lua/issues/2 + +res = {} +for w in ("aacabbacbbcaabbcbacaa"):gmatch("a+b") do res[#res + 1] = w end +assert_equals({"ab","aab"}, res) + +res = {} +for w in ("aacabbacbbcaabbcbacaa"):gmatch("a-b") do res[#res + 1] = w end +assert_equals({"ab","b","b","b","aab","b","b"}, res) + +res = {} +for w in ("aacabbacbbcaabbcbacaa"):gmatch("a*b") do res[#res + 1] = w end +assert_equals({"ab","b","b","b","aab","b","b"}, res) + +res = {} +for w in ("aacabbacbbcaabbcbacaa"):gmatch("ba+") do res[#res + 1] = w end +assert_equals({"ba","ba"}, res) + +res = {} +for w in ("aacabbacbbcaabbcbacaa"):gmatch("ba-") do res[#res + 1] = w end +assert_equals({"b","b","b","b","b","b","b"}, res) + +res = {} +for w in ("aacabbacbbcaabbcbacaa"):gmatch("ba*") do res[#res + 1] = w end +assert_equals({"b","ba","b","b","b","b","ba"}, res) + +assert_equals({"bacbbcaabbcba", "ba"}, {("aacabbacbbcaabbcbacaa"):match("((ba+).*%2)")}) +assert_equals({"bbacbbcaabbcb", "b"}, {("aacabbacbbcaabbcbacaa"):match("((ba*).*%2)")}) + +res = {} +for w in ("aacabbacbbcaabbcbacaa"):gmatch("((b+a*).-%2)") do res[#res + 1] = w end +assert_equals({"bbacbb", "bb"}, res) + +assert_equals("a**", ("a**v"):match("a**+")) +assert_equals("a", ("a**v"):match("a**-")) + +assert_equals({"test", "."}, {("test.lua"):match("(.-)([.])")}) + +-- https://github.com/Stepets/utf8.lua/issues/3 +assert_equals({"ab", "c"}, {("abc"):match("^([ab]-)([^b]*)$")}) +assert_equals({"ab", ""}, {("ab"):match("^([ab]-)([^b]*)$")}) +assert_equals({"items.", ""}, {("items."):match("^(.-)([^.]*)$")}) +assert_equals({"", "items"}, {("items"):match("^(.-)([^.]*)$")}) + +-- https://github.com/Stepets/utf8.lua/issues/4 +assert_equals({"ab.123", 1}, {("ab.?"):gsub("%?", "123")}) + +-- https://github.com/Stepets/utf8.lua/issues/5 +assert_equals({"ab", 1}, {("ab"):gsub("a", "%0")}) +assert_equals({"ab", 1}, {("ab"):gsub("a", "%1")}) + +assert_equals("c", ("abc"):match("c", -1)) + +print("\ntests passed\n") diff --git a/mac/.config/mpv/script-modules/utf8/test/test_compat.lua b/mac/.config/mpv/script-modules/utf8/test/test_compat.lua new file mode 100644 index 0000000..d5042a5 --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/test/test_compat.lua @@ -0,0 +1,109 @@ +local utf8 = require 'init' +utf8.config = { + debug = nil, --utf8:require("util").debug +} +utf8:init() +print('testing utf8 library') + +local LUA_51, LUA_53 = false, false +if "\xe4" == "xe4" then -- lua5.1 + LUA_51 = true +else -- luajit lua5.3 + LUA_53 = true +end + +assert(utf8.sub("123456789",2,4) == "234") +assert(utf8.sub("123456789",7) == "789") +assert(utf8.sub("123456789",7,6) == "") +assert(utf8.sub("123456789",7,7) == "7") +assert(utf8.sub("123456789",0,0) == "") +assert(utf8.sub("123456789",-10,10) == "123456789") +assert(utf8.sub("123456789",1,9) == "123456789") +assert(utf8.sub("123456789",-10,-20) == "") +assert(utf8.sub("123456789",-1) == "9") +assert(utf8.sub("123456789",-4) == "6789") +assert(utf8.sub("123456789",-6, -4) == "456") +if not _no32 then + assert(utf8.sub("123456789",-2^31, -4) == "123456") + assert(utf8.sub("123456789",-2^31, 2^31 - 1) == "123456789") + assert(utf8.sub("123456789",-2^31, -2^31) == "") +end +assert(utf8.sub("\000123456789",3,5) == "234") +assert(utf8.sub("\000123456789", 8) == "789") +print('+') + +assert(utf8.find("123456789", "345") == 3) +local a,b = utf8.find("123456789", "345") +assert(utf8.sub("123456789", a, b) == "345") +assert(utf8.find("1234567890123456789", "345", 3) == 3) +assert(utf8.find("1234567890123456789", "345", 4) == 13) +assert(utf8.find("1234567890123456789", "346", 4) == nil) +assert(utf8.find("1234567890123456789", ".45", -9) == 13) +assert(utf8.find("abcdefg", "\0", 5, 1) == nil) +assert(utf8.find("", "") == 1) +assert(utf8.find("", "", 1) == 1) +assert(not utf8.find("", "", 2)) +assert(utf8.find('', 'aaa', 1) == nil) +assert(('alo(.)alo'):find('(.)', 1, 1) == 4) +print('+') + +assert(utf8.len("") == 0) +assert(utf8.len("\0\0\0") == 3) +assert(utf8.len("1234567890") == 10) + +assert(utf8.byte("a") == 97) +if LUA_51 then + assert(utf8.byte("�") > 127) +else + assert(utf8.byte("\xe4") > 127) +end +assert(utf8.byte(utf8.char(255)) == 255) +assert(utf8.byte(utf8.char(0)) == 0) +assert(utf8.byte("\0") == 0) +assert(utf8.byte("\0\0alo\0x", -1) == string.byte('x')) +assert(utf8.byte("ba", 2) == 97) +assert(utf8.byte("\n\n", 2, -1) == 10) +assert(utf8.byte("\n\n", 2, 2) == 10) +assert(utf8.byte("") == nil) +assert(utf8.byte("hi", -3) == nil) +assert(utf8.byte("hi", 3) == nil) +assert(utf8.byte("hi", 9, 10) == nil) +assert(utf8.byte("hi", 2, 1) == nil) +assert(utf8.char() == "") +if LUA_53 then + assert(utf8.raw.char(0, 255, 0) == "\0\255\0") -- fails due 255 can't be utf8 byte + assert(utf8.char(0, 255, 0) == "\0\195\191\0") + assert(utf8.raw.char(0, utf8.byte("\xe4"), 0) == "\0\xe4\0") + assert(utf8.char(0, utf8.byte("\xe4"), 0) == "\0\195\164\0") + assert(utf8.raw.char(utf8.raw.byte("\xe4l\0�u", 1, -1)) == "\xe4l\0�u") + assert(utf8.raw.char(utf8.raw.byte("\xe4l\0�u", 1, -1)) == "\xe4l\0�u") + assert(utf8.raw.char(utf8.raw.byte("\xe4l\0�u", 1, 0)) == "") + assert(utf8.raw.char(utf8.raw.byte("\xe4l\0�u", -10, 100)) == "\xe4l\0�u") +end + +assert(utf8.upper("ab\0c") == "AB\0C") +assert(utf8.lower("\0ABCc%$") == "\0abcc%$") +assert(utf8.rep('teste', 0) == '') +assert(utf8.rep('t�s\00t�', 2) == 't�s\0t�t�s\000t�') +assert(utf8.rep('', 10) == '') +print('+') + +assert(utf8.upper("ab\0c") == "AB\0C") +assert(utf8.lower("\0ABCc%$") == "\0abcc%$") + +assert(utf8.reverse"" == "") +assert(utf8.reverse"\0\1\2\3" == "\3\2\1\0") +assert(utf8.reverse"\0001234" == "4321\0") + +for i=0,30 do assert(utf8.len(string.rep('a', i)) == i) end + +print('+') + +do + local f = utf8.gmatch("1 2 3 4 5", "%d+") + assert(f() == "1") + local co = coroutine.wrap(f) + assert(co() == "2") +end + +print('OK') diff --git a/mac/.config/mpv/script-modules/utf8/test/test_pm.lua b/mac/.config/mpv/script-modules/utf8/test/test_pm.lua new file mode 100644 index 0000000..9c8e472 --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/test/test_pm.lua @@ -0,0 +1,392 @@ +--[[-- +MIT License + +Copyright (c) 2018 Xavier Wang + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +--]]-- + +local utf8 = require 'init' +utf8.config = { + debug = nil, --utf8:require("util").debug, +} +utf8:init() + +print('testing pattern matching') + +local +function f(s, p) + local i,e = utf8.find(s, p) + if i then return utf8.sub(s, i, e) end +end + +local +function f1(s, p) + p = utf8.gsub(p, "%%([0-9])", function (s) return "%" .. (tonumber(s)+1) end) + p = utf8.gsub(p, "^(^?)", "%1()", 1) + p = utf8.gsub(p, "($?)$", "()%1", 1) + local t = {utf8.match(s, p)} + return utf8.sub(s, t[1], t[#t] - 1) +end + +local +a,b = utf8.find('', '') -- empty patterns are tricky +assert(a == 1 and b == 0); +a,b = utf8.find('alo', '') +assert(a == 1 and b == 0) +a,b = utf8.find('a\0o a\0o a\0o', 'a', 1) -- first position +assert(a == 1 and b == 1) +a,b = utf8.find('a\0o a\0o a\0o', 'a\0o', 2) -- starts in the midle +assert(a == 5 and b == 7) +a,b = utf8.find('a\0o a\0o a\0o', 'a\0o', 9) -- starts in the midle +assert(a == 9 and b == 11) +a,b = utf8.find('a\0a\0a\0a\0\0ab', '\0ab', 2); -- finds at the end +assert(a == 9 and b == 11); +a,b = utf8.find('a\0a\0a\0a\0\0ab', 'b') -- last position +assert(a == 11 and b == 11) +assert(utf8.find('a\0a\0a\0a\0\0ab', 'b\0') == nil) -- check ending +assert(utf8.find('', '\0') == nil) +assert(utf8.find('alo123alo', '12') == 4) +assert(utf8.find('alo123alo', '^12') == nil) + +assert(utf8.match("aaab", ".*b") == "aaab") +assert(utf8.match("aaa", ".*a") == "aaa") +assert(utf8.match("b", ".*b") == "b") + +assert(utf8.match("aaab", ".+b") == "aaab") +assert(utf8.match("aaa", ".+a") == "aaa") +assert(not utf8.match("b", ".+b")) + +assert(utf8.match("aaab", ".?b") == "ab") +assert(utf8.match("aaa", ".?a") == "aa") +assert(utf8.match("b", ".?b") == "b") + +assert(f('aloALO', '%l*') == 'alo') +assert(f('aLo_ALO', '%a*') == 'aLo') + +assert(f(" \n\r*&\n\r xuxu \n\n", "%g%g%g+") == "xuxu") + +assert(f('aaab', 'a*') == 'aaa'); +assert(f('aaa', '^.*$') == 'aaa'); +assert(f('aaa', 'b*') == ''); +assert(f('aaa', 'ab*a') == 'aa') +assert(f('aba', 'ab*a') == 'aba') +assert(f('aaab', 'a+') == 'aaa') +assert(f('aaa', '^.+$') == 'aaa') +assert(f('aaa', 'b+') == nil) +assert(f('aaa', 'ab+a') == nil) +assert(f('aba', 'ab+a') == 'aba') +assert(f('a$a', '.$') == 'a') +assert(f('a$a', '.%$') == 'a$') +assert(f('a$a', '.$.') == 'a$a') +assert(f('a$a', '$$') == nil) +assert(f('a$b', 'a$') == nil) +assert(f('a$a', '$') == '') +assert(f('', 'b*') == '') +assert(f('aaa', 'bb*') == nil) +assert(f('aaab', 'a-') == '') +assert(f('aaa', '^.-$') == 'aaa') +assert(f('aabaaabaaabaaaba', 'b.*b') == 'baaabaaabaaab') +assert(f('aabaaabaaabaaaba', 'b.-b') == 'baaab') +assert(f('alo xo', '.o$') == 'xo') +assert(f(' \n isto é assim', '%S%S*') == 'isto') +assert(f(' \n isto é assim', '%S*$') == 'assim') +assert(f(' \n isto é assim', '[a-z]*$') == 'assim') +assert(f('um caracter ? extra', '[^%sa-z]') == '?') +assert(f('', 'a?') == '') +assert(f('á', 'á?') == 'á') +assert(f('ábl', 'á?b?l?') == 'ábl') +assert(f(' ábl', 'á?b?l?') == '') +assert(f('aa', '^aa?a?a') == 'aa') +assert(f(']]]áb', '[^]]') == 'á') +assert(f("0alo alo", "%x*") == "0a") +assert(f("alo alo", "%C+") == "alo alo") +print('+') + +assert(f1('alo alx 123 b\0o b\0o', '(..*) %1') == "b\0o b\0o") +assert(f1('axz123= 4= 4 34', '(.+)=(.*)=%2 %1') == '3= 4= 4 3') +assert(f1('=======', '^(=*)=%1$') == '=======') +assert(utf8.match('==========', '^([=]*)=%1$') == nil) + +local function range (i, j) + if i <= j then + return i, range(i+1, j) + end +end + +local abc = utf8.char(range(0, 255)); + +assert(utf8.len(abc) == 256) +assert(string.len(abc) == 384) + +local +function strset (p) + local res = {s=''} + utf8.gsub(abc, p, function (c) res.s = res.s .. c end) + return res.s +end; + +local a, b, c, d, e, t + +-- local E = utf8.escape +-- assert(utf8.len(strset(E'[%200-%210]')) == 11) + +assert(strset('[a-z]') == "abcdefghijklmnopqrstuvwxyz") +assert(strset('[a-z%d]') == strset('[%da-uu-z]')) +assert(strset('[a-]') == "-a") +assert(strset('[^%W]') == strset('[%w]')) +assert(strset('[]%%]') == '%]') +assert(strset('[a%-z]') == '-az') +assert(strset('[%^%[%-a%]%-b]') == '-[]^ab') +-- assert(strset('%Z') == strset(E'[%1-%255]')) +-- assert(strset('.') == strset(E'[%1-%255%%z]')) +print('+'); + +assert(utf8.match("alo xyzK", "(%w+)K") == "xyz") +assert(utf8.match("254 K", "(%d*)K") == "") +assert(utf8.match("alo ", "(%w*)$") == "") +assert(utf8.match("alo ", "(%w+)$") == nil) +assert(utf8.find("(álo)", "%(á") == 1) +a, b, c, d, e = utf8.match("âlo alo", "^(((.).).* (%w*))$") +assert(a == 'âlo alo' and b == 'âl' and c == 'â' and d == 'alo' and e == nil) +a, b, c, d = utf8.match('0123456789', '(.+(.?)())') +assert(a == '0123456789' and b == '' and c == 11 and d == nil) +print('+') + +assert(utf8.gsub('ülo ülo', 'ü', 'x') == 'xlo xlo') +assert(utf8.gsub('alo úlo ', ' +$', '') == 'alo úlo') -- trim +assert(utf8.gsub(' alo alo ', '^%s*(.-)%s*$', '%1') == 'alo alo') -- double trim +assert(utf8.gsub('alo alo \n 123\n ', '%s+', ' ') == 'alo alo 123 ') +t = "abç d" +a, b = utf8.gsub(t, '(.)', '%1@') +assert('@'..a == utf8.gsub(t, '', '@') and b == 5) +a, b = utf8.gsub('abçd', '(.)', '%0@', 2) +assert(a == 'a@b@çd' and b == 2) +assert(utf8.gsub('alo alo', '()[al]', '%1') == '12o 56o') +assert(utf8.gsub("abc=xyz", "(%w*)(%p)(%w+)", "%3%2%1-%0") == + "xyz=abc-abc=xyz") +assert(utf8.gsub("abc", "%w", "%1%0") == "aabbcc") +assert(utf8.gsub("abc", "%w+", "%0%1") == "abcabc") +assert(utf8.gsub('áéí', '$', '\0óú') == 'áéí\0óú') +assert(utf8.gsub('', '^', 'r') == 'r') +assert(utf8.gsub('', '$', 'r') == 'r') +print('+') + +assert(utf8.gsub("um (dois) tres (quatro)", "(%(%w+%))", utf8.upper) == + "um (DOIS) tres (QUATRO)") + +do + local function setglobal (n,v) rawset(_G, n, v) end + utf8.gsub("a=roberto,roberto=a", "(%w+)=(%w%w*)", setglobal) + assert(_G.a=="roberto" and _G.roberto=="a") +end + +function f(a,b) return utf8.gsub(a,'.',b) end +assert(utf8.gsub("trocar tudo em |teste|b| é |beleza|al|", "|([^|]*)|([^|]*)|", f) == + "trocar tudo em bbbbb é alalalalalal") + +local function dostring (s) return (loadstring or load)(s)() or "" end +assert(utf8.gsub("alo $a=1$ novamente $return a$", "$([^$]*)%$", dostring) == + "alo novamente 1") + +x = utf8.gsub("$local utf8=require'init' x=utf8.gsub('alo', '.', utf8.upper)$ assim vai para $return x$", + "$([^$]*)%$", dostring) +assert(x == ' assim vai para ALO') + +local s,r +t = {} +s = 'a alo jose joao' +r = utf8.gsub(s, '()(%w+)()', function (a,w,b) + assert(utf8.len(w) == b-a); + t[a] = b-a; + end) +assert(s == r and t[1] == 1 and t[3] == 3 and t[7] == 4 and t[13] == 4) + +local +function isbalanced (s) + return utf8.find(utf8.gsub(s, "%b()", ""), "[()]") == nil +end + +assert(isbalanced("(9 ((8))(\0) 7) \0\0 a b ()(c)() a")) +assert(not isbalanced("(9 ((8) 7) a b (\0 c) a")) +assert(utf8.gsub("alo 'oi' alo", "%b''", '"') == 'alo " alo') + + +local t = {"apple", "orange", "lime"; n=0} +assert(utf8.gsub("x and x and x", "x", function () t.n=t.n+1; return t[t.n] end) + == "apple and orange and lime") + +t = {n=0} +utf8.gsub("first second word", "%w%w*", function (w) t.n=t.n+1; t[t.n] = w end) +assert(t[1] == "first" and t[2] == "second" and t[3] == "word" and t.n == 3) + +t = {n=0} +assert(utf8.gsub("first second word", "%w+", + function (w) t.n=t.n+1; t[t.n] = w end, 2) == "first second word") +assert(t[1] == "first" and t[2] == "second" and t[3] == nil) + +assert(not pcall(utf8.gsub, "alo", "(.", print)) +assert(not pcall(utf8.gsub, "alo", ".)", print)) +assert(not pcall(utf8.gsub, "alo", "(.", {})) +assert(not pcall(utf8.gsub, "alo", "(.)", "%2")) +assert(not pcall(utf8.gsub, "alo", "(%1)", "a")) +--[[-- +Stepets: ignoring this test because it's probably bug in Lua. + %0 should be interpreted as capture reference only in replacement arg + it doesn't have sense in pattern +--]]-- +-- assert(not pcall(utf8.gsub, "alo", "(%0)", "a")) + +-- bug since 2.5 (C-stack overflow) +-- todo: benchmark OOM +-- do +-- local function f (size) +-- local s = string.rep("a", size) +-- local p = string.rep(".?", size) +-- return pcall(utf8.match, s, p) +-- end +-- local r, m = f(80) +-- assert(r and #m == 80) +-- r, m = f(200000) +-- assert(not r and utf8.find(m, "too complex")) +-- end + +-- if not _soft then +-- -- big strings +-- local a = string.rep('a', 300000) +-- assert(utf8.find(a, '^a*.?$')) +-- assert(not utf8.find(a, '^a*.?b$')) +-- assert(utf8.find(a, '^a-.?$')) + +-- -- bug in 5.1.2 +-- a = string.rep('a', 10000) .. string.rep('b', 10000) +-- assert(not pcall(utf8.gsub, a, 'b')) +-- end + +-- recursive nest of gsubs +local function rev (s) + return utf8.gsub(s, "(.)(.+)", function (c,s1) return rev(s1)..c end) +end + +local x = "abcdef" +assert(rev(rev(x)) == x) + + +-- gsub with tables +assert(utf8.gsub("alo alo", ".", {}) == "alo alo") +assert(utf8.gsub("alo alo", "(.)", {a="AA", l=""}) == "AAo AAo") +assert(utf8.gsub("alo alo", "(.).", {a="AA", l="K"}) == "AAo AAo") +assert(utf8.gsub("alo alo", "((.)(.?))", {al="AA", o=false}) == "AAo AAo") + +assert(utf8.gsub("alo alo", "().", {2,5,6}) == "256 alo") + +t = {}; setmetatable(t, {__index = function (t,s) return utf8.upper(s) end}) +assert(utf8.gsub("a alo b hi", "%w%w+", t) == "a ALO b HI") + + +-- tests for gmatch +local a = 0 +for i in utf8.gmatch('abcde', '()') do assert(i == a+1); a=i end +assert(a==6) + +t = {n=0} +for w in utf8.gmatch("first second word", "%w+") do + t.n=t.n+1; t[t.n] = w +end +assert(t[1] == "first" and t[2] == "second" and t[3] == "word") + +t = {3, 6, 9} +for i in utf8.gmatch ("xuxx uu ppar r", "()(.)%2") do + assert(i == table.remove(t, 1)) +end +assert(#t == 0) + +t = {} +for i,j in utf8.gmatch("13 14 10 = 11, 15= 16, 22=23", "(%d+)%s*=%s*(%d+)") do + t[i] = j +end +a = 0 +for k,v in pairs(t) do assert(k+1 == v+0); a=a+1 end +assert(a == 3) + + +-- tests for `%f' (`frontiers') + +assert(utf8.gsub("aaa aa a aaa a", "%f[%w]a", "x") == "xaa xa x xaa x") +assert(utf8.gsub("[[]] [][] [[[[", "%f[[].", "x") == "x[]] x]x] x[[[") +assert(utf8.gsub("01abc45de3", "%f[%d]", ".") == ".01abc.45de.3") +assert(utf8.gsub("01abc45 de3x", "%f[%D]%w", ".") == "01.bc45 de3.") +-- local u = utf8.escape +-- assert(utf8.gsub("function", u"%%f[%1-%255]%%w", ".") == ".unction") +-- assert(utf8.gsub("function", u"%%f[^%1-%255]", ".") == "function.") + +--[[-- +Stepets: %z is Lua 5.1 class for representing \0 + Lua 5.2, Lua 5.3 doesn't have it in documentation. So it's considered deprecated. +--]]-- +assert(utf8.find("a", "%f[a]") == 1) +assert(utf8.find("a", "%f[^%z]") == 1) +assert(utf8.find("a", "%f[^%l]") == 2) +assert(utf8.find("aba", "%f[a%z]") == 3) +assert(utf8.find("aba", "%f[%z]") == 4) +assert(not utf8.find("aba", "%f[%l%z]")) +assert(not utf8.find("aba", "%f[^%l%z]")) + +local i, e = utf8.find(" alo aalo allo", "%f[%S].-%f[%s].-%f[%S]") +assert(i == 2 and e == 5) +local k = utf8.match(" alo aalo allo", "%f[%S](.-%f[%s].-%f[%S])") +assert(k == 'alo ') + +local a = {1, 5, 9, 14, 17,} +for k in utf8.gmatch("alo alo th02 is 1hat", "()%f[%w%d]") do + assert(table.remove(a, 1) == k) +end +assert(#a == 0) + +-- malformed patterns +local function malform (p, m) + m = m or "malformed" + local r, msg = pcall(utf8.find, "a", p) + assert(not r and utf8.find(msg, m)) +end + +malform("[a") +malform("[]") +malform("[^]") +malform("[a%]") +malform("[a%") +malform("%b", "unbalanced") +malform("%ba", "unbalanced") +malform("%") +malform("%f", "missing") + +-- \0 in patterns +assert(utf8.match("ab\0\1\2c", "[\0-\2]+") == "\0\1\2") +assert(utf8.match("ab\0\1\2c", "[\0-\0]+") == "\0") +assert(utf8.find("b$a", "$\0?") == 2) +assert(utf8.find("abc\0efg", "%\0") == 4) +assert(utf8.match("abc\0efg\0\1e\1g", "%b\0\1") == "\0efg\0\1e\1") +assert(utf8.match("abc\0\0\0", "%\0+") == "\0\0\0") +assert(utf8.match("abc\0\0\0", "%\0%\0?") == "\0\0") + +-- magic char after \0 +assert(utf8.find("abc\0\0","\0.") == 4) +assert(utf8.find("abcx\0\0abc\0abc","x\0\0abc\0a.") == 4) + +print('OK') diff --git a/mac/.config/mpv/script-modules/utf8/test/test_utf8data.lua b/mac/.config/mpv/script-modules/utf8/test/test_utf8data.lua new file mode 100644 index 0000000..e915b2b --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/test/test_utf8data.lua @@ -0,0 +1,15 @@ +local utf8uclc = require('init') +utf8uclc.config = { + debug = nil, +-- debug = utf8:require("util").debug, + conversion = { + uc_lc = setmetatable({}, {__index = function(self, idx) return "l" end}), + lc_uc = setmetatable({}, {__index = function(self, idx) return "u" end}), + } +} +utf8uclc:init() + +local assert_equals = require 'test.util'.assert_equals + +assert_equals(utf8uclc.lower("фыва"), "llll") +assert_equals(utf8uclc.upper("фыва"), "uuuu") diff --git a/mac/.config/mpv/script-modules/utf8/test/util.lua b/mac/.config/mpv/script-modules/utf8/test/util.lua new file mode 100644 index 0000000..bdc25e5 --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/test/util.lua @@ -0,0 +1,75 @@ +require "test.strict" + +local function equals(t1, t2) + for k,v in pairs(t1) do + if t2[k] == nil then return false end + if type(t2[k]) == 'cdata' and type(v) == 'cdata' then + return true -- don't know how to compare + elseif type(t2[k]) == 'table' and type(v) == 'table' then + if not equals(t2[k], v) then return false end + else + if t2[k] ~= v then return false end + end + end + for k,v in pairs(t2) do + if t1[k] == nil then return false end + if type(t1[k]) == 'cdata' and type(v) == 'cdata' then + return true -- don't know how to compare + elseif type(t1[k]) == 'table' and type(v) == 'table' then + if not equals(t1[k], v) then return false end + else + if t1[k] ~= v then return false end + end + end + return true +end + +local old_tostring = tostring +local function tostring(v) + local type = type(v) + if type == 'table' then + local tbl = "{" + for k,v in pairs(v) do + tbl = tbl .. tostring(k) .. ' = ' .. tostring(v) .. ', ' + end + return tbl .. '}' + else + return old_tostring(v) + end +end + +local old_assert = assert +local assert = function(cond, ...) + if not cond then + local data = {...} + local msg = "" + for _, v in pairs(data) do + local type = type(v) + if type == 'table' then + local tbl = "{" + for k,v in pairs(v) do + tbl = tbl .. tostring(k) .. ' = ' .. tostring(v) .. ', ' + end + msg = msg .. tbl .. '}' + else + msg = msg .. tostring(v) + end + end + error(#data > 0 and msg or "assertion failed!") + end + return cond +end + +local function assert_equals(a,b) + assert( + type(a) == 'table' and type(b) == 'table' and equals(a,b) or a == b, + "expected: ", a and a or tostring(a), "\n", + "got: ", b and b or tostring(b) + ) +end + +return { + equals = equals, + assert = assert, + assert_equals = assert_equals, +} diff --git a/mac/.config/mpv/script-modules/utf8/util.lua b/mac/.config/mpv/script-modules/utf8/util.lua new file mode 100644 index 0000000..7723626 --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8/util.lua @@ -0,0 +1,64 @@ +return function(utf8) + +function utf8.util.copy(obj, deep) + if type(obj) == 'table' then + local result = {} + if deep then + for k,v in pairs(obj) do + result[k] = utf8.util.copy(v, true) + end + else + for k,v in pairs(obj) do + result[k] = v + end + end + return result + else + return obj + end +end + +local function dump(val, tab) + tab = tab or '' + + if type(val) == 'table' then + utf8.config.logger('{\n') + for k,v in pairs(val) do + utf8.config.logger(tab .. tostring(k) .. " = ") + dump(v, tab .. '\t') + utf8.config.logger("\n") + end + utf8.config.logger(tab .. '}\n') + else + utf8.config.logger(tostring(val)) + end +end + +function utf8.util.debug(...) + local t = {...} + for _, v in ipairs(t) do + if type(v) == "table" and not (getmetatable(v) or {}).__tostring then + dump(v, '\t') + else + utf8.config.logger(tostring(v), " ") + end + end + + utf8.config.logger('\n') +end + +function utf8.debug(...) + if utf8.config.debug then + utf8.config.debug(...) + end +end + +function utf8.util.next(str, bs) + local nbs1 = utf8.next(str, bs) + local nbs2 = utf8.next(str, nbs1) + return utf8.raw.sub(str, nbs1, nbs2 - 1), nbs1 +end + +return utf8.util + +end diff --git a/mac/.config/mpv/script-modules/utf8_data.lua b/mac/.config/mpv/script-modules/utf8_data.lua new file mode 100644 index 0000000..bec6b9e --- /dev/null +++ b/mac/.config/mpv/script-modules/utf8_data.lua @@ -0,0 +1,1865 @@ +utf8_lc_uc = { + ["a"] = "A", + ["b"] = "B", + ["c"] = "C", + ["d"] = "D", + ["e"] = "E", + ["f"] = "F", + ["g"] = "G", + ["h"] = "H", + ["i"] = "I", + ["j"] = "J", + ["k"] = "K", + ["l"] = "L", + ["m"] = "M", + ["n"] = "N", + ["o"] = "O", + ["p"] = "P", + ["q"] = "Q", + ["r"] = "R", + ["s"] = "S", + ["t"] = "T", + ["u"] = "U", + ["v"] = "V", + ["w"] = "W", + ["x"] = "X", + ["y"] = "Y", + ["z"] = "Z", + ["µ"] = "Μ", + ["à"] = "À", + ["á"] = "Á", + ["â"] = "Â", + ["ã"] = "Ã", + ["ä"] = "Ä", + ["å"] = "Å", + ["æ"] = "Æ", + ["ç"] = "Ç", + ["è"] = "È", + ["é"] = "É", + ["ê"] = "Ê", + ["ë"] = "Ë", + ["ì"] = "Ì", + ["í"] = "Í", + ["î"] = "Î", + ["ï"] = "Ï", + ["ð"] = "Ð", + ["ñ"] = "Ñ", + ["ò"] = "Ò", + ["ó"] = "Ó", + ["ô"] = "Ô", + ["õ"] = "Õ", + ["ö"] = "Ö", + ["ø"] = "Ø", + ["ù"] = "Ù", + ["ú"] = "Ú", + ["û"] = "Û", + ["ü"] = "Ü", + ["ý"] = "Ý", + ["þ"] = "Þ", + ["ÿ"] = "Ÿ", + ["ā"] = "Ā", + ["ă"] = "Ă", + ["ą"] = "Ą", + ["ć"] = "Ć", + ["ĉ"] = "Ĉ", + ["ċ"] = "Ċ", + ["č"] = "Č", + ["ď"] = "Ď", + ["đ"] = "Đ", + ["ē"] = "Ē", + ["ĕ"] = "Ĕ", + ["ė"] = "Ė", + ["ę"] = "Ę", + ["ě"] = "Ě", + ["ĝ"] = "Ĝ", + ["ğ"] = "Ğ", + ["ġ"] = "Ġ", + ["ģ"] = "Ģ", + ["ĥ"] = "Ĥ", + ["ħ"] = "Ħ", + ["ĩ"] = "Ĩ", + ["ī"] = "Ī", + ["ĭ"] = "Ĭ", + ["į"] = "Į", + ["ı"] = "I", + ["ij"] = "IJ", + ["ĵ"] = "Ĵ", + ["ķ"] = "Ķ", + ["ĺ"] = "Ĺ", + ["ļ"] = "Ļ", + ["ľ"] = "Ľ", + ["ŀ"] = "Ŀ", + ["ł"] = "Ł", + ["ń"] = "Ń", + ["ņ"] = "Ņ", + ["ň"] = "Ň", + ["ŋ"] = "Ŋ", + ["ō"] = "Ō", + ["ŏ"] = "Ŏ", + ["ő"] = "Ő", + ["œ"] = "Œ", + ["ŕ"] = "Ŕ", + ["ŗ"] = "Ŗ", + ["ř"] = "Ř", + ["ś"] = "Ś", + ["ŝ"] = "Ŝ", + ["ş"] = "Ş", + ["š"] = "Š", + ["ţ"] = "Ţ", + ["ť"] = "Ť", + ["ŧ"] = "Ŧ", + ["ũ"] = "Ũ", + ["ū"] = "Ū", + ["ŭ"] = "Ŭ", + ["ů"] = "Ů", + ["ű"] = "Ű", + ["ų"] = "Ų", + ["ŵ"] = "Ŵ", + ["ŷ"] = "Ŷ", + ["ź"] = "Ź", + ["ż"] = "Ż", + ["ž"] = "Ž", + ["ſ"] = "S", + ["ƀ"] = "Ƀ", + ["ƃ"] = "Ƃ", + ["ƅ"] = "Ƅ", + ["ƈ"] = "Ƈ", + ["ƌ"] = "Ƌ", + ["ƒ"] = "Ƒ", + ["ƕ"] = "Ƕ", + ["ƙ"] = "Ƙ", + ["ƚ"] = "Ƚ", + ["ƞ"] = "Ƞ", + ["ơ"] = "Ơ", + ["ƣ"] = "Ƣ", + ["ƥ"] = "Ƥ", + ["ƨ"] = "Ƨ", + ["ƭ"] = "Ƭ", + ["ư"] = "Ư", + ["ƴ"] = "Ƴ", + ["ƶ"] = "Ƶ", + ["ƹ"] = "Ƹ", + ["ƽ"] = "Ƽ", + ["ƿ"] = "Ƿ", + ["Dž"] = "DŽ", + ["dž"] = "DŽ", + ["Lj"] = "LJ", + ["lj"] = "LJ", + ["Nj"] = "NJ", + ["nj"] = "NJ", + ["ǎ"] = "Ǎ", + ["ǐ"] = "Ǐ", + ["ǒ"] = "Ǒ", + ["ǔ"] = "Ǔ", + ["ǖ"] = "Ǖ", + ["ǘ"] = "Ǘ", + ["ǚ"] = "Ǚ", + ["ǜ"] = "Ǜ", + ["ǝ"] = "Ǝ", + ["ǟ"] = "Ǟ", + ["ǡ"] = "Ǡ", + ["ǣ"] = "Ǣ", + ["ǥ"] = "Ǥ", + ["ǧ"] = "Ǧ", + ["ǩ"] = "Ǩ", + ["ǫ"] = "Ǫ", + ["ǭ"] = "Ǭ", + ["ǯ"] = "Ǯ", + ["Dz"] = "DZ", + ["dz"] = "DZ", + ["ǵ"] = "Ǵ", + ["ǹ"] = "Ǹ", + ["ǻ"] = "Ǻ", + ["ǽ"] = "Ǽ", + ["ǿ"] = "Ǿ", + ["ȁ"] = "Ȁ", + ["ȃ"] = "Ȃ", + ["ȅ"] = "Ȅ", + ["ȇ"] = "Ȇ", + ["ȉ"] = "Ȉ", + ["ȋ"] = "Ȋ", + ["ȍ"] = "Ȍ", + ["ȏ"] = "Ȏ", + ["ȑ"] = "Ȑ", + ["ȓ"] = "Ȓ", + ["ȕ"] = "Ȕ", + ["ȗ"] = "Ȗ", + ["ș"] = "Ș", + ["ț"] = "Ț", + ["ȝ"] = "Ȝ", + ["ȟ"] = "Ȟ", + ["ȣ"] = "Ȣ", + ["ȥ"] = "Ȥ", + ["ȧ"] = "Ȧ", + ["ȩ"] = "Ȩ", + ["ȫ"] = "Ȫ", + ["ȭ"] = "Ȭ", + ["ȯ"] = "Ȯ", + ["ȱ"] = "Ȱ", + ["ȳ"] = "Ȳ", + ["ȼ"] = "Ȼ", + ["ɂ"] = "Ɂ", + ["ɇ"] = "Ɇ", + ["ɉ"] = "Ɉ", + ["ɋ"] = "Ɋ", + ["ɍ"] = "Ɍ", + ["ɏ"] = "Ɏ", + ["ɓ"] = "Ɓ", + ["ɔ"] = "Ɔ", + ["ɖ"] = "Ɖ", + ["ɗ"] = "Ɗ", + ["ə"] = "Ə", + ["ɛ"] = "Ɛ", + ["ɠ"] = "Ɠ", + ["ɣ"] = "Ɣ", + ["ɨ"] = "Ɨ", + ["ɩ"] = "Ɩ", + ["ɫ"] = "Ɫ", + ["ɯ"] = "Ɯ", + ["ɲ"] = "Ɲ", + ["ɵ"] = "Ɵ", + ["ɽ"] = "Ɽ", + ["ʀ"] = "Ʀ", + ["ʃ"] = "Ʃ", + ["ʈ"] = "Ʈ", + ["ʉ"] = "Ʉ", + ["ʊ"] = "Ʊ", + ["ʋ"] = "Ʋ", + ["ʌ"] = "Ʌ", + ["ʒ"] = "Ʒ", + ["ͅ"] = "Ι", + ["ͻ"] = "Ͻ", + ["ͼ"] = "Ͼ", + ["ͽ"] = "Ͽ", + ["ά"] = "Ά", + ["έ"] = "Έ", + ["ή"] = "Ή", + ["ί"] = "Ί", + ["α"] = "Α", + ["β"] = "Β", + ["γ"] = "Γ", + ["δ"] = "Δ", + ["ε"] = "Ε", + ["ζ"] = "Ζ", + ["η"] = "Η", + ["θ"] = "Θ", + ["ι"] = "Ι", + ["κ"] = "Κ", + ["λ"] = "Λ", + ["μ"] = "Μ", + ["ν"] = "Ν", + ["ξ"] = "Ξ", + ["ο"] = "Ο", + ["π"] = "Π", + ["ρ"] = "Ρ", + ["ς"] = "Σ", + ["σ"] = "Σ", + ["τ"] = "Τ", + ["υ"] = "Υ", + ["φ"] = "Φ", + ["χ"] = "Χ", + ["ψ"] = "Ψ", + ["ω"] = "Ω", + ["ϊ"] = "Ϊ", + ["ϋ"] = "Ϋ", + ["ό"] = "Ό", + ["ύ"] = "Ύ", + ["ώ"] = "Ώ", + ["ϐ"] = "Β", + ["ϑ"] = "Θ", + ["ϕ"] = "Φ", + ["ϖ"] = "Π", + ["ϙ"] = "Ϙ", + ["ϛ"] = "Ϛ", + ["ϝ"] = "Ϝ", + ["ϟ"] = "Ϟ", + ["ϡ"] = "Ϡ", + ["ϣ"] = "Ϣ", + ["ϥ"] = "Ϥ", + ["ϧ"] = "Ϧ", + ["ϩ"] = "Ϩ", + ["ϫ"] = "Ϫ", + ["ϭ"] = "Ϭ", + ["ϯ"] = "Ϯ", + ["ϰ"] = "Κ", + ["ϱ"] = "Ρ", + ["ϲ"] = "Ϲ", + ["ϵ"] = "Ε", + ["ϸ"] = "Ϸ", + ["ϻ"] = "Ϻ", + ["а"] = "А", + ["б"] = "Б", + ["в"] = "В", + ["г"] = "Г", + ["д"] = "Д", + ["е"] = "Е", + ["ж"] = "Ж", + ["з"] = "З", + ["и"] = "И", + ["й"] = "Й", + ["к"] = "К", + ["л"] = "Л", + ["м"] = "М", + ["н"] = "Н", + ["о"] = "О", + ["п"] = "П", + ["р"] = "Р", + ["с"] = "С", + ["т"] = "Т", + ["у"] = "У", + ["ф"] = "Ф", + ["х"] = "Х", + ["ц"] = "Ц", + ["ч"] = "Ч", + ["ш"] = "Ш", + ["щ"] = "Щ", + ["ъ"] = "Ъ", + ["ы"] = "Ы", + ["ь"] = "Ь", + ["э"] = "Э", + ["ю"] = "Ю", + ["я"] = "Я", + ["ѐ"] = "Ѐ", + ["ё"] = "Ё", + ["ђ"] = "Ђ", + ["ѓ"] = "Ѓ", + ["є"] = "Є", + ["ѕ"] = "Ѕ", + ["і"] = "І", + ["ї"] = "Ї", + ["ј"] = "Ј", + ["љ"] = "Љ", + ["њ"] = "Њ", + ["ћ"] = "Ћ", + ["ќ"] = "Ќ", + ["ѝ"] = "Ѝ", + ["ў"] = "Ў", + ["џ"] = "Џ", + ["ѡ"] = "Ѡ", + ["ѣ"] = "Ѣ", + ["ѥ"] = "Ѥ", + ["ѧ"] = "Ѧ", + ["ѩ"] = "Ѩ", + ["ѫ"] = "Ѫ", + ["ѭ"] = "Ѭ", + ["ѯ"] = "Ѯ", + ["ѱ"] = "Ѱ", + ["ѳ"] = "Ѳ", + ["ѵ"] = "Ѵ", + ["ѷ"] = "Ѷ", + ["ѹ"] = "Ѹ", + ["ѻ"] = "Ѻ", + ["ѽ"] = "Ѽ", + ["ѿ"] = "Ѿ", + ["ҁ"] = "Ҁ", + ["ҋ"] = "Ҋ", + ["ҍ"] = "Ҍ", + ["ҏ"] = "Ҏ", + ["ґ"] = "Ґ", + ["ғ"] = "Ғ", + ["ҕ"] = "Ҕ", + ["җ"] = "Җ", + ["ҙ"] = "Ҙ", + ["қ"] = "Қ", + ["ҝ"] = "Ҝ", + ["ҟ"] = "Ҟ", + ["ҡ"] = "Ҡ", + ["ң"] = "Ң", + ["ҥ"] = "Ҥ", + ["ҧ"] = "Ҧ", + ["ҩ"] = "Ҩ", + ["ҫ"] = "Ҫ", + ["ҭ"] = "Ҭ", + ["ү"] = "Ү", + ["ұ"] = "Ұ", + ["ҳ"] = "Ҳ", + ["ҵ"] = "Ҵ", + ["ҷ"] = "Ҷ", + ["ҹ"] = "Ҹ", + ["һ"] = "Һ", + ["ҽ"] = "Ҽ", + ["ҿ"] = "Ҿ", + ["ӂ"] = "Ӂ", + ["ӄ"] = "Ӄ", + ["ӆ"] = "Ӆ", + ["ӈ"] = "Ӈ", + ["ӊ"] = "Ӊ", + ["ӌ"] = "Ӌ", + ["ӎ"] = "Ӎ", + ["ӏ"] = "Ӏ", + ["ӑ"] = "Ӑ", + ["ӓ"] = "Ӓ", + ["ӕ"] = "Ӕ", + ["ӗ"] = "Ӗ", + ["ә"] = "Ә", + ["ӛ"] = "Ӛ", + ["ӝ"] = "Ӝ", + ["ӟ"] = "Ӟ", + ["ӡ"] = "Ӡ", + ["ӣ"] = "Ӣ", + ["ӥ"] = "Ӥ", + ["ӧ"] = "Ӧ", + ["ө"] = "Ө", + ["ӫ"] = "Ӫ", + ["ӭ"] = "Ӭ", + ["ӯ"] = "Ӯ", + ["ӱ"] = "Ӱ", + ["ӳ"] = "Ӳ", + ["ӵ"] = "Ӵ", + ["ӷ"] = "Ӷ", + ["ӹ"] = "Ӹ", + ["ӻ"] = "Ӻ", + ["ӽ"] = "Ӽ", + ["ӿ"] = "Ӿ", + ["ԁ"] = "Ԁ", + ["ԃ"] = "Ԃ", + ["ԅ"] = "Ԅ", + ["ԇ"] = "Ԇ", + ["ԉ"] = "Ԉ", + ["ԋ"] = "Ԋ", + ["ԍ"] = "Ԍ", + ["ԏ"] = "Ԏ", + ["ԑ"] = "Ԑ", + ["ԓ"] = "Ԓ", + ["ա"] = "Ա", + ["բ"] = "Բ", + ["գ"] = "Գ", + ["դ"] = "Դ", + ["ե"] = "Ե", + ["զ"] = "Զ", + ["է"] = "Է", + ["ը"] = "Ը", + ["թ"] = "Թ", + ["ժ"] = "Ժ", + ["ի"] = "Ի", + ["լ"] = "Լ", + ["խ"] = "Խ", + ["ծ"] = "Ծ", + ["կ"] = "Կ", + ["հ"] = "Հ", + ["ձ"] = "Ձ", + ["ղ"] = "Ղ", + ["ճ"] = "Ճ", + ["մ"] = "Մ", + ["յ"] = "Յ", + ["ն"] = "Ն", + ["շ"] = "Շ", + ["ո"] = "Ո", + ["չ"] = "Չ", + ["պ"] = "Պ", + ["ջ"] = "Ջ", + ["ռ"] = "Ռ", + ["ս"] = "Ս", + ["վ"] = "Վ", + ["տ"] = "Տ", + ["ր"] = "Ր", + ["ց"] = "Ց", + ["ւ"] = "Ւ", + ["փ"] = "Փ", + ["ք"] = "Ք", + ["օ"] = "Օ", + ["ֆ"] = "Ֆ", + ["ᵽ"] = "Ᵽ", + ["ḁ"] = "Ḁ", + ["ḃ"] = "Ḃ", + ["ḅ"] = "Ḅ", + ["ḇ"] = "Ḇ", + ["ḉ"] = "Ḉ", + ["ḋ"] = "Ḋ", + ["ḍ"] = "Ḍ", + ["ḏ"] = "Ḏ", + ["ḑ"] = "Ḑ", + ["ḓ"] = "Ḓ", + ["ḕ"] = "Ḕ", + ["ḗ"] = "Ḗ", + ["ḙ"] = "Ḙ", + ["ḛ"] = "Ḛ", + ["ḝ"] = "Ḝ", + ["ḟ"] = "Ḟ", + ["ḡ"] = "Ḡ", + ["ḣ"] = "Ḣ", + ["ḥ"] = "Ḥ", + ["ḧ"] = "Ḧ", + ["ḩ"] = "Ḩ", + ["ḫ"] = "Ḫ", + ["ḭ"] = "Ḭ", + ["ḯ"] = "Ḯ", + ["ḱ"] = "Ḱ", + ["ḳ"] = "Ḳ", + ["ḵ"] = "Ḵ", + ["ḷ"] = "Ḷ", + ["ḹ"] = "Ḹ", + ["ḻ"] = "Ḻ", + ["ḽ"] = "Ḽ", + ["ḿ"] = "Ḿ", + ["ṁ"] = "Ṁ", + ["ṃ"] = "Ṃ", + ["ṅ"] = "Ṅ", + ["ṇ"] = "Ṇ", + ["ṉ"] = "Ṉ", + ["ṋ"] = "Ṋ", + ["ṍ"] = "Ṍ", + ["ṏ"] = "Ṏ", + ["ṑ"] = "Ṑ", + ["ṓ"] = "Ṓ", + ["ṕ"] = "Ṕ", + ["ṗ"] = "Ṗ", + ["ṙ"] = "Ṙ", + ["ṛ"] = "Ṛ", + ["ṝ"] = "Ṝ", + ["ṟ"] = "Ṟ", + ["ṡ"] = "Ṡ", + ["ṣ"] = "Ṣ", + ["ṥ"] = "Ṥ", + ["ṧ"] = "Ṧ", + ["ṩ"] = "Ṩ", + ["ṫ"] = "Ṫ", + ["ṭ"] = "Ṭ", + ["ṯ"] = "Ṯ", + ["ṱ"] = "Ṱ", + ["ṳ"] = "Ṳ", + ["ṵ"] = "Ṵ", + ["ṷ"] = "Ṷ", + ["ṹ"] = "Ṹ", + ["ṻ"] = "Ṻ", + ["ṽ"] = "Ṽ", + ["ṿ"] = "Ṿ", + ["ẁ"] = "Ẁ", + ["ẃ"] = "Ẃ", + ["ẅ"] = "Ẅ", + ["ẇ"] = "Ẇ", + ["ẉ"] = "Ẉ", + ["ẋ"] = "Ẋ", + ["ẍ"] = "Ẍ", + ["ẏ"] = "Ẏ", + ["ẑ"] = "Ẑ", + ["ẓ"] = "Ẓ", + ["ẕ"] = "Ẕ", + ["ẛ"] = "Ṡ", + ["ạ"] = "Ạ", + ["ả"] = "Ả", + ["ấ"] = "Ấ", + ["ầ"] = "Ầ", + ["ẩ"] = "Ẩ", + ["ẫ"] = "Ẫ", + ["ậ"] = "Ậ", + ["ắ"] = "Ắ", + ["ằ"] = "Ằ", + ["ẳ"] = "Ẳ", + ["ẵ"] = "Ẵ", + ["ặ"] = "Ặ", + ["ẹ"] = "Ẹ", + ["ẻ"] = "Ẻ", + ["ẽ"] = "Ẽ", + ["ế"] = "Ế", + ["ề"] = "Ề", + ["ể"] = "Ể", + ["ễ"] = "Ễ", + ["ệ"] = "Ệ", + ["ỉ"] = "Ỉ", + ["ị"] = "Ị", + ["ọ"] = "Ọ", + ["ỏ"] = "Ỏ", + ["ố"] = "Ố", + ["ồ"] = "Ồ", + ["ổ"] = "Ổ", + ["ỗ"] = "Ỗ", + ["ộ"] = "Ộ", + ["ớ"] = "Ớ", + ["ờ"] = "Ờ", + ["ở"] = "Ở", + ["ỡ"] = "Ỡ", + ["ợ"] = "Ợ", + ["ụ"] = "Ụ", + ["ủ"] = "Ủ", + ["ứ"] = "Ứ", + ["ừ"] = "Ừ", + ["ử"] = "Ử", + ["ữ"] = "Ữ", + ["ự"] = "Ự", + ["ỳ"] = "Ỳ", + ["ỵ"] = "Ỵ", + ["ỷ"] = "Ỷ", + ["ỹ"] = "Ỹ", + ["ἀ"] = "Ἀ", + ["ἁ"] = "Ἁ", + ["ἂ"] = "Ἂ", + ["ἃ"] = "Ἃ", + ["ἄ"] = "Ἄ", + ["ἅ"] = "Ἅ", + ["ἆ"] = "Ἆ", + ["ἇ"] = "Ἇ", + ["ἐ"] = "Ἐ", + ["ἑ"] = "Ἑ", + ["ἒ"] = "Ἒ", + ["ἓ"] = "Ἓ", + ["ἔ"] = "Ἔ", + ["ἕ"] = "Ἕ", + ["ἠ"] = "Ἠ", + ["ἡ"] = "Ἡ", + ["ἢ"] = "Ἢ", + ["ἣ"] = "Ἣ", + ["ἤ"] = "Ἤ", + ["ἥ"] = "Ἥ", + ["ἦ"] = "Ἦ", + ["ἧ"] = "Ἧ", + ["ἰ"] = "Ἰ", + ["ἱ"] = "Ἱ", + ["ἲ"] = "Ἲ", + ["ἳ"] = "Ἳ", + ["ἴ"] = "Ἴ", + ["ἵ"] = "Ἵ", + ["ἶ"] = "Ἶ", + ["ἷ"] = "Ἷ", + ["ὀ"] = "Ὀ", + ["ὁ"] = "Ὁ", + ["ὂ"] = "Ὂ", + ["ὃ"] = "Ὃ", + ["ὄ"] = "Ὄ", + ["ὅ"] = "Ὅ", + ["ὑ"] = "Ὑ", + ["ὓ"] = "Ὓ", + ["ὕ"] = "Ὕ", + ["ὗ"] = "Ὗ", + ["ὠ"] = "Ὠ", + ["ὡ"] = "Ὡ", + ["ὢ"] = "Ὢ", + ["ὣ"] = "Ὣ", + ["ὤ"] = "Ὤ", + ["ὥ"] = "Ὥ", + ["ὦ"] = "Ὦ", + ["ὧ"] = "Ὧ", + ["ὰ"] = "Ὰ", + ["ά"] = "Ά", + ["ὲ"] = "Ὲ", + ["έ"] = "Έ", + ["ὴ"] = "Ὴ", + ["ή"] = "Ή", + ["ὶ"] = "Ὶ", + ["ί"] = "Ί", + ["ὸ"] = "Ὸ", + ["ό"] = "Ό", + ["ὺ"] = "Ὺ", + ["ύ"] = "Ύ", + ["ὼ"] = "Ὼ", + ["ώ"] = "Ώ", + ["ᾀ"] = "ᾈ", + ["ᾁ"] = "ᾉ", + ["ᾂ"] = "ᾊ", + ["ᾃ"] = "ᾋ", + ["ᾄ"] = "ᾌ", + ["ᾅ"] = "ᾍ", + ["ᾆ"] = "ᾎ", + ["ᾇ"] = "ᾏ", + ["ᾐ"] = "ᾘ", + ["ᾑ"] = "ᾙ", + ["ᾒ"] = "ᾚ", + ["ᾓ"] = "ᾛ", + ["ᾔ"] = "ᾜ", + ["ᾕ"] = "ᾝ", + ["ᾖ"] = "ᾞ", + ["ᾗ"] = "ᾟ", + ["ᾠ"] = "ᾨ", + ["ᾡ"] = "ᾩ", + ["ᾢ"] = "ᾪ", + ["ᾣ"] = "ᾫ", + ["ᾤ"] = "ᾬ", + ["ᾥ"] = "ᾭ", + ["ᾦ"] = "ᾮ", + ["ᾧ"] = "ᾯ", + ["ᾰ"] = "Ᾰ", + ["ᾱ"] = "Ᾱ", + ["ᾳ"] = "ᾼ", + ["ι"] = "Ι", + ["ῃ"] = "ῌ", + ["ῐ"] = "Ῐ", + ["ῑ"] = "Ῑ", + ["ῠ"] = "Ῠ", + ["ῡ"] = "Ῡ", + ["ῥ"] = "Ῥ", + ["ῳ"] = "ῼ", + ["ⅎ"] = "Ⅎ", + ["ⅰ"] = "Ⅰ", + ["ⅱ"] = "Ⅱ", + ["ⅲ"] = "Ⅲ", + ["ⅳ"] = "Ⅳ", + ["ⅴ"] = "Ⅴ", + ["ⅵ"] = "Ⅵ", + ["ⅶ"] = "Ⅶ", + ["ⅷ"] = "Ⅷ", + ["ⅸ"] = "Ⅸ", + ["ⅹ"] = "Ⅹ", + ["ⅺ"] = "Ⅺ", + ["ⅻ"] = "Ⅻ", + ["ⅼ"] = "Ⅼ", + ["ⅽ"] = "Ⅽ", + ["ⅾ"] = "Ⅾ", + ["ⅿ"] = "Ⅿ", + ["ↄ"] = "Ↄ", + ["ⓐ"] = "Ⓐ", + ["ⓑ"] = "Ⓑ", + ["ⓒ"] = "Ⓒ", + ["ⓓ"] = "Ⓓ", + ["ⓔ"] = "Ⓔ", + ["ⓕ"] = "Ⓕ", + ["ⓖ"] = "Ⓖ", + ["ⓗ"] = "Ⓗ", + ["ⓘ"] = "Ⓘ", + ["ⓙ"] = "Ⓙ", + ["ⓚ"] = "Ⓚ", + ["ⓛ"] = "Ⓛ", + ["ⓜ"] = "Ⓜ", + ["ⓝ"] = "Ⓝ", + ["ⓞ"] = "Ⓞ", + ["ⓟ"] = "Ⓟ", + ["ⓠ"] = "Ⓠ", + ["ⓡ"] = "Ⓡ", + ["ⓢ"] = "Ⓢ", + ["ⓣ"] = "Ⓣ", + ["ⓤ"] = "Ⓤ", + ["ⓥ"] = "Ⓥ", + ["ⓦ"] = "Ⓦ", + ["ⓧ"] = "Ⓧ", + ["ⓨ"] = "Ⓨ", + ["ⓩ"] = "Ⓩ", + ["ⰰ"] = "Ⰰ", + ["ⰱ"] = "Ⰱ", + ["ⰲ"] = "Ⰲ", + ["ⰳ"] = "Ⰳ", + ["ⰴ"] = "Ⰴ", + ["ⰵ"] = "Ⰵ", + ["ⰶ"] = "Ⰶ", + ["ⰷ"] = "Ⰷ", + ["ⰸ"] = "Ⰸ", + ["ⰹ"] = "Ⰹ", + ["ⰺ"] = "Ⰺ", + ["ⰻ"] = "Ⰻ", + ["ⰼ"] = "Ⰼ", + ["ⰽ"] = "Ⰽ", + ["ⰾ"] = "Ⰾ", + ["ⰿ"] = "Ⰿ", + ["ⱀ"] = "Ⱀ", + ["ⱁ"] = "Ⱁ", + ["ⱂ"] = "Ⱂ", + ["ⱃ"] = "Ⱃ", + ["ⱄ"] = "Ⱄ", + ["ⱅ"] = "Ⱅ", + ["ⱆ"] = "Ⱆ", + ["ⱇ"] = "Ⱇ", + ["ⱈ"] = "Ⱈ", + ["ⱉ"] = "Ⱉ", + ["ⱊ"] = "Ⱊ", + ["ⱋ"] = "Ⱋ", + ["ⱌ"] = "Ⱌ", + ["ⱍ"] = "Ⱍ", + ["ⱎ"] = "Ⱎ", + ["ⱏ"] = "Ⱏ", + ["ⱐ"] = "Ⱐ", + ["ⱑ"] = "Ⱑ", + ["ⱒ"] = "Ⱒ", + ["ⱓ"] = "Ⱓ", + ["ⱔ"] = "Ⱔ", + ["ⱕ"] = "Ⱕ", + ["ⱖ"] = "Ⱖ", + ["ⱗ"] = "Ⱗ", + ["ⱘ"] = "Ⱘ", + ["ⱙ"] = "Ⱙ", + ["ⱚ"] = "Ⱚ", + ["ⱛ"] = "Ⱛ", + ["ⱜ"] = "Ⱜ", + ["ⱝ"] = "Ⱝ", + ["ⱞ"] = "Ⱞ", + ["ⱡ"] = "Ⱡ", + ["ⱥ"] = "Ⱥ", + ["ⱦ"] = "Ⱦ", + ["ⱨ"] = "Ⱨ", + ["ⱪ"] = "Ⱪ", + ["ⱬ"] = "Ⱬ", + ["ⱶ"] = "Ⱶ", + ["ⲁ"] = "Ⲁ", + ["ⲃ"] = "Ⲃ", + ["ⲅ"] = "Ⲅ", + ["ⲇ"] = "Ⲇ", + ["ⲉ"] = "Ⲉ", + ["ⲋ"] = "Ⲋ", + ["ⲍ"] = "Ⲍ", + ["ⲏ"] = "Ⲏ", + ["ⲑ"] = "Ⲑ", + ["ⲓ"] = "Ⲓ", + ["ⲕ"] = "Ⲕ", + ["ⲗ"] = "Ⲗ", + ["ⲙ"] = "Ⲙ", + ["ⲛ"] = "Ⲛ", + ["ⲝ"] = "Ⲝ", + ["ⲟ"] = "Ⲟ", + ["ⲡ"] = "Ⲡ", + ["ⲣ"] = "Ⲣ", + ["ⲥ"] = "Ⲥ", + ["ⲧ"] = "Ⲧ", + ["ⲩ"] = "Ⲩ", + ["ⲫ"] = "Ⲫ", + ["ⲭ"] = "Ⲭ", + ["ⲯ"] = "Ⲯ", + ["ⲱ"] = "Ⲱ", + ["ⲳ"] = "Ⲳ", + ["ⲵ"] = "Ⲵ", + ["ⲷ"] = "Ⲷ", + ["ⲹ"] = "Ⲹ", + ["ⲻ"] = "Ⲻ", + ["ⲽ"] = "Ⲽ", + ["ⲿ"] = "Ⲿ", + ["ⳁ"] = "Ⳁ", + ["ⳃ"] = "Ⳃ", + ["ⳅ"] = "Ⳅ", + ["ⳇ"] = "Ⳇ", + ["ⳉ"] = "Ⳉ", + ["ⳋ"] = "Ⳋ", + ["ⳍ"] = "Ⳍ", + ["ⳏ"] = "Ⳏ", + ["ⳑ"] = "Ⳑ", + ["ⳓ"] = "Ⳓ", + ["ⳕ"] = "Ⳕ", + ["ⳗ"] = "Ⳗ", + ["ⳙ"] = "Ⳙ", + ["ⳛ"] = "Ⳛ", + ["ⳝ"] = "Ⳝ", + ["ⳟ"] = "Ⳟ", + ["ⳡ"] = "Ⳡ", + ["ⳣ"] = "Ⳣ", + ["ⴀ"] = "Ⴀ", + ["ⴁ"] = "Ⴁ", + ["ⴂ"] = "Ⴂ", + ["ⴃ"] = "Ⴃ", + ["ⴄ"] = "Ⴄ", + ["ⴅ"] = "Ⴅ", + ["ⴆ"] = "Ⴆ", + ["ⴇ"] = "Ⴇ", + ["ⴈ"] = "Ⴈ", + ["ⴉ"] = "Ⴉ", + ["ⴊ"] = "Ⴊ", + ["ⴋ"] = "Ⴋ", + ["ⴌ"] = "Ⴌ", + ["ⴍ"] = "Ⴍ", + ["ⴎ"] = "Ⴎ", + ["ⴏ"] = "Ⴏ", + ["ⴐ"] = "Ⴐ", + ["ⴑ"] = "Ⴑ", + ["ⴒ"] = "Ⴒ", + ["ⴓ"] = "Ⴓ", + ["ⴔ"] = "Ⴔ", + ["ⴕ"] = "Ⴕ", + ["ⴖ"] = "Ⴖ", + ["ⴗ"] = "Ⴗ", + ["ⴘ"] = "Ⴘ", + ["ⴙ"] = "Ⴙ", + ["ⴚ"] = "Ⴚ", + ["ⴛ"] = "Ⴛ", + ["ⴜ"] = "Ⴜ", + ["ⴝ"] = "Ⴝ", + ["ⴞ"] = "Ⴞ", + ["ⴟ"] = "Ⴟ", + ["ⴠ"] = "Ⴠ", + ["ⴡ"] = "Ⴡ", + ["ⴢ"] = "Ⴢ", + ["ⴣ"] = "Ⴣ", + ["ⴤ"] = "Ⴤ", + ["ⴥ"] = "Ⴥ", + ["ａ"] = "Ａ", + ["ｂ"] = "Ｂ", + ["ｃ"] = "Ｃ", + ["ｄ"] = "Ｄ", + ["ｅ"] = "Ｅ", + ["ｆ"] = "Ｆ", + ["ｇ"] = "Ｇ", + ["ｈ"] = "Ｈ", + ["ｉ"] = "Ｉ", + ["ｊ"] = "Ｊ", + ["ｋ"] = "Ｋ", + ["ｌ"] = "Ｌ", + ["ｍ"] = "Ｍ", + ["ｎ"] = "Ｎ", + ["ｏ"] = "Ｏ", + ["ｐ"] = "Ｐ", + ["ｑ"] = "Ｑ", + ["ｒ"] = "Ｒ", + ["ｓ"] = "Ｓ", + ["ｔ"] = "Ｔ", + ["ｕ"] = "Ｕ", + ["ｖ"] = "Ｖ", + ["ｗ"] = "Ｗ", + ["ｘ"] = "Ｘ", + ["ｙ"] = "Ｙ", + ["ｚ"] = "Ｚ", + ["𐐨"] = "𐐀", + ["𐐩"] = "𐐁", + ["𐐪"] = "𐐂", + ["𐐫"] = "𐐃", + ["𐐬"] = "𐐄", + ["𐐭"] = "𐐅", + ["𐐮"] = "𐐆", + ["𐐯"] = "𐐇", + ["𐐰"] = "𐐈", + ["𐐱"] = "𐐉", + ["𐐲"] = "𐐊", + ["𐐳"] = "𐐋", + ["𐐴"] = "𐐌", + ["𐐵"] = "𐐍", + ["𐐶"] = "𐐎", + ["𐐷"] = "𐐏", + ["𐐸"] = "𐐐", + ["𐐹"] = "𐐑", + ["𐐺"] = "𐐒", + ["𐐻"] = "𐐓", + ["𐐼"] = "𐐔", + ["𐐽"] = "𐐕", + ["𐐾"] = "𐐖", + ["𐐿"] = "𐐗", + ["𐑀"] = "𐐘", + ["𐑁"] = "𐐙", + ["𐑂"] = "𐐚", + ["𐑃"] = "𐐛", + ["𐑄"] = "𐐜", + ["𐑅"] = "𐐝", + ["𐑆"] = "𐐞", + ["𐑇"] = "𐐟", + ["𐑈"] = "𐐠", + ["𐑉"] = "𐐡", + ["𐑊"] = "𐐢", + ["𐑋"] = "𐐣", + ["𐑌"] = "𐐤", + ["𐑍"] = "𐐥", + ["𐑎"] = "𐐦", + ["𐑏"] = "𐐧", +} + + +utf8_uc_lc = { + ["A"] = "a", + ["B"] = "b", + ["C"] = "c", + ["D"] = "d", + ["E"] = "e", + ["F"] = "f", + ["G"] = "g", + ["H"] = "h", + ["I"] = "i", + ["J"] = "j", + ["K"] = "k", + ["L"] = "l", + ["M"] = "m", + ["N"] = "n", + ["O"] = "o", + ["P"] = "p", + ["Q"] = "q", + ["R"] = "r", + ["S"] = "s", + ["T"] = "t", + ["U"] = "u", + ["V"] = "v", + ["W"] = "w", + ["X"] = "x", + ["Y"] = "y", + ["Z"] = "z", + ["À"] = "à", + ["Á"] = "á", + ["Â"] = "â", + ["Ã"] = "ã", + ["Ä"] = "ä", + ["Å"] = "å", + ["Æ"] = "æ", + ["Ç"] = "ç", + ["È"] = "è", + ["É"] = "é", + ["Ê"] = "ê", + ["Ë"] = "ë", + ["Ì"] = "ì", + ["Í"] = "í", + ["Î"] = "î", + ["Ï"] = "ï", + ["Ð"] = "ð", + ["Ñ"] = "ñ", + ["Ò"] = "ò", + ["Ó"] = "ó", + ["Ô"] = "ô", + ["Õ"] = "õ", + ["Ö"] = "ö", + ["Ø"] = "ø", + ["Ù"] = "ù", + ["Ú"] = "ú", + ["Û"] = "û", + ["Ü"] = "ü", + ["Ý"] = "ý", + ["Þ"] = "þ", + ["Ā"] = "ā", + ["Ă"] = "ă", + ["Ą"] = "ą", + ["Ć"] = "ć", + ["Ĉ"] = "ĉ", + ["Ċ"] = "ċ", + ["Č"] = "č", + ["Ď"] = "ď", + ["Đ"] = "đ", + ["Ē"] = "ē", + ["Ĕ"] = "ĕ", + ["Ė"] = "ė", + ["Ę"] = "ę", + ["Ě"] = "ě", + ["Ĝ"] = "ĝ", + ["Ğ"] = "ğ", + ["Ġ"] = "ġ", + ["Ģ"] = "ģ", + ["Ĥ"] = "ĥ", + ["Ħ"] = "ħ", + ["Ĩ"] = "ĩ", + ["Ī"] = "ī", + ["Ĭ"] = "ĭ", + ["Į"] = "į", + ["İ"] = "i", + ["IJ"] = "ij", + ["Ĵ"] = "ĵ", + ["Ķ"] = "ķ", + ["Ĺ"] = "ĺ", + ["Ļ"] = "ļ", + ["Ľ"] = "ľ", + ["Ŀ"] = "ŀ", + ["Ł"] = "ł", + ["Ń"] = "ń", + ["Ņ"] = "ņ", + ["Ň"] = "ň", + ["Ŋ"] = "ŋ", + ["Ō"] = "ō", + ["Ŏ"] = "ŏ", + ["Ő"] = "ő", + ["Œ"] = "œ", + ["Ŕ"] = "ŕ", + ["Ŗ"] = "ŗ", + ["Ř"] = "ř", + ["Ś"] = "ś", + ["Ŝ"] = "ŝ", + ["Ş"] = "ş", + ["Š"] = "š", + ["Ţ"] = "ţ", + ["Ť"] = "ť", + ["Ŧ"] = "ŧ", + ["Ũ"] = "ũ", + ["Ū"] = "ū", + ["Ŭ"] = "ŭ", + ["Ů"] = "ů", + ["Ű"] = "ű", + ["Ų"] = "ų", + ["Ŵ"] = "ŵ", + ["Ŷ"] = "ŷ", + ["Ÿ"] = "ÿ", + ["Ź"] = "ź", + ["Ż"] = "ż", + ["Ž"] = "ž", + ["Ɓ"] = "ɓ", + ["Ƃ"] = "ƃ", + ["Ƅ"] = "ƅ", + ["Ɔ"] = "ɔ", + ["Ƈ"] = "ƈ", + ["Ɖ"] = "ɖ", + ["Ɗ"] = "ɗ", + ["Ƌ"] = "ƌ", + ["Ǝ"] = "ǝ", + ["Ə"] = "ə", + ["Ɛ"] = "ɛ", + ["Ƒ"] = "ƒ", + ["Ɠ"] = "ɠ", + ["Ɣ"] = "ɣ", + ["Ɩ"] = "ɩ", + ["Ɨ"] = "ɨ", + ["Ƙ"] = "ƙ", + ["Ɯ"] = "ɯ", + ["Ɲ"] = "ɲ", + ["Ɵ"] = "ɵ", + ["Ơ"] = "ơ", + ["Ƣ"] = "ƣ", + ["Ƥ"] = "ƥ", + ["Ʀ"] = "ʀ", + ["Ƨ"] = "ƨ", + ["Ʃ"] = "ʃ", + ["Ƭ"] = "ƭ", + ["Ʈ"] = "ʈ", + ["Ư"] = "ư", + ["Ʊ"] = "ʊ", + ["Ʋ"] = "ʋ", + ["Ƴ"] = "ƴ", + ["Ƶ"] = "ƶ", + ["Ʒ"] = "ʒ", + ["Ƹ"] = "ƹ", + ["Ƽ"] = "ƽ", + ["DŽ"] = "dž", + ["Dž"] = "dž", + ["LJ"] = "lj", + ["Lj"] = "lj", + ["NJ"] = "nj", + ["Nj"] = "nj", + ["Ǎ"] = "ǎ", + ["Ǐ"] = "ǐ", + ["Ǒ"] = "ǒ", + ["Ǔ"] = "ǔ", + ["Ǖ"] = "ǖ", + ["Ǘ"] = "ǘ", + ["Ǚ"] = "ǚ", + ["Ǜ"] = "ǜ", + ["Ǟ"] = "ǟ", + ["Ǡ"] = "ǡ", + ["Ǣ"] = "ǣ", + ["Ǥ"] = "ǥ", + ["Ǧ"] = "ǧ", + ["Ǩ"] = "ǩ", + ["Ǫ"] = "ǫ", + ["Ǭ"] = "ǭ", + ["Ǯ"] = "ǯ", + ["DZ"] = "dz", + ["Dz"] = "dz", + ["Ǵ"] = "ǵ", + ["Ƕ"] = "ƕ", + ["Ƿ"] = "ƿ", + ["Ǹ"] = "ǹ", + ["Ǻ"] = "ǻ", + ["Ǽ"] = "ǽ", + ["Ǿ"] = "ǿ", + ["Ȁ"] = "ȁ", + ["Ȃ"] = "ȃ", + ["Ȅ"] = "ȅ", + ["Ȇ"] = "ȇ", + ["Ȉ"] = "ȉ", + ["Ȋ"] = "ȋ", + ["Ȍ"] = "ȍ", + ["Ȏ"] = "ȏ", + ["Ȑ"] = "ȑ", + ["Ȓ"] = "ȓ", + ["Ȕ"] = "ȕ", + ["Ȗ"] = "ȗ", + ["Ș"] = "ș", + ["Ț"] = "ț", + ["Ȝ"] = "ȝ", + ["Ȟ"] = "ȟ", + ["Ƞ"] = "ƞ", + ["Ȣ"] = "ȣ", + ["Ȥ"] = "ȥ", + ["Ȧ"] = "ȧ", + ["Ȩ"] = "ȩ", + ["Ȫ"] = "ȫ", + ["Ȭ"] = "ȭ", + ["Ȯ"] = "ȯ", + ["Ȱ"] = "ȱ", + ["Ȳ"] = "ȳ", + ["Ⱥ"] = "ⱥ", + ["Ȼ"] = "ȼ", + ["Ƚ"] = "ƚ", + ["Ⱦ"] = "ⱦ", + ["Ɂ"] = "ɂ", + ["Ƀ"] = "ƀ", + ["Ʉ"] = "ʉ", + ["Ʌ"] = "ʌ", + ["Ɇ"] = "ɇ", + ["Ɉ"] = "ɉ", + ["Ɋ"] = "ɋ", + ["Ɍ"] = "ɍ", + ["Ɏ"] = "ɏ", + ["Ά"] = "ά", + ["Έ"] = "έ", + ["Ή"] = "ή", + ["Ί"] = "ί", + ["Ό"] = "ό", + ["Ύ"] = "ύ", + ["Ώ"] = "ώ", + ["Α"] = "α", + ["Β"] = "β", + ["Γ"] = "γ", + ["Δ"] = "δ", + ["Ε"] = "ε", + ["Ζ"] = "ζ", + ["Η"] = "η", + ["Θ"] = "θ", + ["Ι"] = "ι", + ["Κ"] = "κ", + ["Λ"] = "λ", + ["Μ"] = "μ", + ["Ν"] = "ν", + ["Ξ"] = "ξ", + ["Ο"] = "ο", + ["Π"] = "π", + ["Ρ"] = "ρ", + ["Σ"] = "σ", + ["Τ"] = "τ", + ["Υ"] = "υ", + ["Φ"] = "φ", + ["Χ"] = "χ", + ["Ψ"] = "ψ", + ["Ω"] = "ω", + ["Ϊ"] = "ϊ", + ["Ϋ"] = "ϋ", + ["Ϙ"] = "ϙ", + ["Ϛ"] = "ϛ", + ["Ϝ"] = "ϝ", + ["Ϟ"] = "ϟ", + ["Ϡ"] = "ϡ", + ["Ϣ"] = "ϣ", + ["Ϥ"] = "ϥ", + ["Ϧ"] = "ϧ", + ["Ϩ"] = "ϩ", + ["Ϫ"] = "ϫ", + ["Ϭ"] = "ϭ", + ["Ϯ"] = "ϯ", + ["ϴ"] = "θ", + ["Ϸ"] = "ϸ", + ["Ϲ"] = "ϲ", + ["Ϻ"] = "ϻ", + ["Ͻ"] = "ͻ", + ["Ͼ"] = "ͼ", + ["Ͽ"] = "ͽ", + ["Ѐ"] = "ѐ", + ["Ё"] = "ё", + ["Ђ"] = "ђ", + ["Ѓ"] = "ѓ", + ["Є"] = "є", + ["Ѕ"] = "ѕ", + ["І"] = "і", + ["Ї"] = "ї", + ["Ј"] = "ј", + ["Љ"] = "љ", + ["Њ"] = "њ", + ["Ћ"] = "ћ", + ["Ќ"] = "ќ", + ["Ѝ"] = "ѝ", + ["Ў"] = "ў", + ["Џ"] = "џ", + ["А"] = "а", + ["Б"] = "б", + ["В"] = "в", + ["Г"] = "г", + ["Д"] = "д", + ["Е"] = "е", + ["Ж"] = "ж", + ["З"] = "з", + ["И"] = "и", + ["Й"] = "й", + ["К"] = "к", + ["Л"] = "л", + ["М"] = "м", + ["Н"] = "н", + ["О"] = "о", + ["П"] = "п", + ["Р"] = "р", + ["С"] = "с", + ["Т"] = "т", + ["У"] = "у", + ["Ф"] = "ф", + ["Х"] = "х", + ["Ц"] = "ц", + ["Ч"] = "ч", + ["Ш"] = "ш", + ["Щ"] = "щ", + ["Ъ"] = "ъ", + ["Ы"] = "ы", + ["Ь"] = "ь", + ["Э"] = "э", + ["Ю"] = "ю", + ["Я"] = "я", + ["Ѡ"] = "ѡ", + ["Ѣ"] = "ѣ", + ["Ѥ"] = "ѥ", + ["Ѧ"] = "ѧ", + ["Ѩ"] = "ѩ", + ["Ѫ"] = "ѫ", + ["Ѭ"] = "ѭ", + ["Ѯ"] = "ѯ", + ["Ѱ"] = "ѱ", + ["Ѳ"] = "ѳ", + ["Ѵ"] = "ѵ", + ["Ѷ"] = "ѷ", + ["Ѹ"] = "ѹ", + ["Ѻ"] = "ѻ", + ["Ѽ"] = "ѽ", + ["Ѿ"] = "ѿ", + ["Ҁ"] = "ҁ", + ["Ҋ"] = "ҋ", + ["Ҍ"] = "ҍ", + ["Ҏ"] = "ҏ", + ["Ґ"] = "ґ", + ["Ғ"] = "ғ", + ["Ҕ"] = "ҕ", + ["Җ"] = "җ", + ["Ҙ"] = "ҙ", + ["Қ"] = "қ", + ["Ҝ"] = "ҝ", + ["Ҟ"] = "ҟ", + ["Ҡ"] = "ҡ", + ["Ң"] = "ң", + ["Ҥ"] = "ҥ", + ["Ҧ"] = "ҧ", + ["Ҩ"] = "ҩ", + ["Ҫ"] = "ҫ", + ["Ҭ"] = "ҭ", + ["Ү"] = "ү", + ["Ұ"] = "ұ", + ["Ҳ"] = "ҳ", + ["Ҵ"] = "ҵ", + ["Ҷ"] = "ҷ", + ["Ҹ"] = "ҹ", + ["Һ"] = "һ", + ["Ҽ"] = "ҽ", + ["Ҿ"] = "ҿ", + ["Ӏ"] = "ӏ", + ["Ӂ"] = "ӂ", + ["Ӄ"] = "ӄ", + ["Ӆ"] = "ӆ", + ["Ӈ"] = "ӈ", + ["Ӊ"] = "ӊ", + ["Ӌ"] = "ӌ", + ["Ӎ"] = "ӎ", + ["Ӑ"] = "ӑ", + ["Ӓ"] = "ӓ", + ["Ӕ"] = "ӕ", + ["Ӗ"] = "ӗ", + ["Ә"] = "ә", + ["Ӛ"] = "ӛ", + ["Ӝ"] = "ӝ", + ["Ӟ"] = "ӟ", + ["Ӡ"] = "ӡ", + ["Ӣ"] = "ӣ", + ["Ӥ"] = "ӥ", + ["Ӧ"] = "ӧ", + ["Ө"] = "ө", + ["Ӫ"] = "ӫ", + ["Ӭ"] = "ӭ", + ["Ӯ"] = "ӯ", + ["Ӱ"] = "ӱ", + ["Ӳ"] = "ӳ", + ["Ӵ"] = "ӵ", + ["Ӷ"] = "ӷ", + ["Ӹ"] = "ӹ", + ["Ӻ"] = "ӻ", + ["Ӽ"] = "ӽ", + ["Ӿ"] = "ӿ", + ["Ԁ"] = "ԁ", + ["Ԃ"] = "ԃ", + ["Ԅ"] = "ԅ", + ["Ԇ"] = "ԇ", + ["Ԉ"] = "ԉ", + ["Ԋ"] = "ԋ", + ["Ԍ"] = "ԍ", + ["Ԏ"] = "ԏ", + ["Ԑ"] = "ԑ", + ["Ԓ"] = "ԓ", + ["Ա"] = "ա", + ["Բ"] = "բ", + ["Գ"] = "գ", + ["Դ"] = "դ", + ["Ե"] = "ե", + ["Զ"] = "զ", + ["Է"] = "է", + ["Ը"] = "ը", + ["Թ"] = "թ", + ["Ժ"] = "ժ", + ["Ի"] = "ի", + ["Լ"] = "լ", + ["Խ"] = "խ", + ["Ծ"] = "ծ", + ["Կ"] = "կ", + ["Հ"] = "հ", + ["Ձ"] = "ձ", + ["Ղ"] = "ղ", + ["Ճ"] = "ճ", + ["Մ"] = "մ", + ["Յ"] = "յ", + ["Ն"] = "ն", + ["Շ"] = "շ", + ["Ո"] = "ո", + ["Չ"] = "չ", + ["Պ"] = "պ", + ["Ջ"] = "ջ", + ["Ռ"] = "ռ", + ["Ս"] = "ս", + ["Վ"] = "վ", + ["Տ"] = "տ", + ["Ր"] = "ր", + ["Ց"] = "ց", + ["Ւ"] = "ւ", + ["Փ"] = "փ", + ["Ք"] = "ք", + ["Օ"] = "օ", + ["Ֆ"] = "ֆ", + ["Ⴀ"] = "ⴀ", + ["Ⴁ"] = "ⴁ", + ["Ⴂ"] = "ⴂ", + ["Ⴃ"] = "ⴃ", + ["Ⴄ"] = "ⴄ", + ["Ⴅ"] = "ⴅ", + ["Ⴆ"] = "ⴆ", + ["Ⴇ"] = "ⴇ", + ["Ⴈ"] = "ⴈ", + ["Ⴉ"] = "ⴉ", + ["Ⴊ"] = "ⴊ", + ["Ⴋ"] = "ⴋ", + ["Ⴌ"] = "ⴌ", + ["Ⴍ"] = "ⴍ", + ["Ⴎ"] = "ⴎ", + ["Ⴏ"] = "ⴏ", + ["Ⴐ"] = "ⴐ", + ["Ⴑ"] = "ⴑ", + ["Ⴒ"] = "ⴒ", + ["Ⴓ"] = "ⴓ", + ["Ⴔ"] = "ⴔ", + ["Ⴕ"] = "ⴕ", + ["Ⴖ"] = "ⴖ", + ["Ⴗ"] = "ⴗ", + ["Ⴘ"] = "ⴘ", + ["Ⴙ"] = "ⴙ", + ["Ⴚ"] = "ⴚ", + ["Ⴛ"] = "ⴛ", + ["Ⴜ"] = "ⴜ", + ["Ⴝ"] = "ⴝ", + ["Ⴞ"] = "ⴞ", + ["Ⴟ"] = "ⴟ", + ["Ⴠ"] = "ⴠ", + ["Ⴡ"] = "ⴡ", + ["Ⴢ"] = "ⴢ", + ["Ⴣ"] = "ⴣ", + ["Ⴤ"] = "ⴤ", + ["Ⴥ"] = "ⴥ", + ["Ḁ"] = "ḁ", + ["Ḃ"] = "ḃ", + ["Ḅ"] = "ḅ", + ["Ḇ"] = "ḇ", + ["Ḉ"] = "ḉ", + ["Ḋ"] = "ḋ", + ["Ḍ"] = "ḍ", + ["Ḏ"] = "ḏ", + ["Ḑ"] = "ḑ", + ["Ḓ"] = "ḓ", + ["Ḕ"] = "ḕ", + ["Ḗ"] = "ḗ", + ["Ḙ"] = "ḙ", + ["Ḛ"] = "ḛ", + ["Ḝ"] = "ḝ", + ["Ḟ"] = "ḟ", + ["Ḡ"] = "ḡ", + ["Ḣ"] = "ḣ", + ["Ḥ"] = "ḥ", + ["Ḧ"] = "ḧ", + ["Ḩ"] = "ḩ", + ["Ḫ"] = "ḫ", + ["Ḭ"] = "ḭ", + ["Ḯ"] = "ḯ", + ["Ḱ"] = "ḱ", + ["Ḳ"] = "ḳ", + ["Ḵ"] = "ḵ", + ["Ḷ"] = "ḷ", + ["Ḹ"] = "ḹ", + ["Ḻ"] = "ḻ", + ["Ḽ"] = "ḽ", + ["Ḿ"] = "ḿ", + ["Ṁ"] = "ṁ", + ["Ṃ"] = "ṃ", + ["Ṅ"] = "ṅ", + ["Ṇ"] = "ṇ", + ["Ṉ"] = "ṉ", + ["Ṋ"] = "ṋ", + ["Ṍ"] = "ṍ", + ["Ṏ"] = "ṏ", + ["Ṑ"] = "ṑ", + ["Ṓ"] = "ṓ", + ["Ṕ"] = "ṕ", + ["Ṗ"] = "ṗ", + ["Ṙ"] = "ṙ", + ["Ṛ"] = "ṛ", + ["Ṝ"] = "ṝ", + ["Ṟ"] = "ṟ", + ["Ṡ"] = "ṡ", + ["Ṣ"] = "ṣ", + ["Ṥ"] = "ṥ", + ["Ṧ"] = "ṧ", + ["Ṩ"] = "ṩ", + ["Ṫ"] = "ṫ", + ["Ṭ"] = "ṭ", + ["Ṯ"] = "ṯ", + ["Ṱ"] = "ṱ", + ["Ṳ"] = "ṳ", + ["Ṵ"] = "ṵ", + ["Ṷ"] = "ṷ", + ["Ṹ"] = "ṹ", + ["Ṻ"] = "ṻ", + ["Ṽ"] = "ṽ", + ["Ṿ"] = "ṿ", + ["Ẁ"] = "ẁ", + ["Ẃ"] = "ẃ", + ["Ẅ"] = "ẅ", + ["Ẇ"] = "ẇ", + ["Ẉ"] = "ẉ", + ["Ẋ"] = "ẋ", + ["Ẍ"] = "ẍ", + ["Ẏ"] = "ẏ", + ["Ẑ"] = "ẑ", + ["Ẓ"] = "ẓ", + ["Ẕ"] = "ẕ", + ["Ạ"] = "ạ", + ["Ả"] = "ả", + ["Ấ"] = "ấ", + ["Ầ"] = "ầ", + ["Ẩ"] = "ẩ", + ["Ẫ"] = "ẫ", + ["Ậ"] = "ậ", + ["Ắ"] = "ắ", + ["Ằ"] = "ằ", + ["Ẳ"] = "ẳ", + ["Ẵ"] = "ẵ", + ["Ặ"] = "ặ", + ["Ẹ"] = "ẹ", + ["Ẻ"] = "ẻ", + ["Ẽ"] = "ẽ", + ["Ế"] = "ế", + ["Ề"] = "ề", + ["Ể"] = "ể", + ["Ễ"] = "ễ", + ["Ệ"] = "ệ", + ["Ỉ"] = "ỉ", + ["Ị"] = "ị", + ["Ọ"] = "ọ", + ["Ỏ"] = "ỏ", + ["Ố"] = "ố", + ["Ồ"] = "ồ", + ["Ổ"] = "ổ", + ["Ỗ"] = "ỗ", + ["Ộ"] = "ộ", + ["Ớ"] = "ớ", + ["Ờ"] = "ờ", + ["Ở"] = "ở", + ["Ỡ"] = "ỡ", + ["Ợ"] = "ợ", + ["Ụ"] = "ụ", + ["Ủ"] = "ủ", + ["Ứ"] = "ứ", + ["Ừ"] = "ừ", + ["Ử"] = "ử", + ["Ữ"] = "ữ", + ["Ự"] = "ự", + ["Ỳ"] = "ỳ", + ["Ỵ"] = "ỵ", + ["Ỷ"] = "ỷ", + ["Ỹ"] = "ỹ", + ["Ἀ"] = "ἀ", + ["Ἁ"] = "ἁ", + ["Ἂ"] = "ἂ", + ["Ἃ"] = "ἃ", + ["Ἄ"] = "ἄ", + ["Ἅ"] = "ἅ", + ["Ἆ"] = "ἆ", + ["Ἇ"] = "ἇ", + ["Ἐ"] = "ἐ", + ["Ἑ"] = "ἑ", + ["Ἒ"] = "ἒ", + ["Ἓ"] = "ἓ", + ["Ἔ"] = "ἔ", + ["Ἕ"] = "ἕ", + ["Ἠ"] = "ἠ", + ["Ἡ"] = "ἡ", + ["Ἢ"] = "ἢ", + ["Ἣ"] = "ἣ", + ["Ἤ"] = "ἤ", + ["Ἥ"] = "ἥ", + ["Ἦ"] = "ἦ", + ["Ἧ"] = "ἧ", + ["Ἰ"] = "ἰ", + ["Ἱ"] = "ἱ", + ["Ἲ"] = "ἲ", + ["Ἳ"] = "ἳ", + ["Ἴ"] = "ἴ", + ["Ἵ"] = "ἵ", + ["Ἶ"] = "ἶ", + ["Ἷ"] = "ἷ", + ["Ὀ"] = "ὀ", + ["Ὁ"] = "ὁ", + ["Ὂ"] = "ὂ", + ["Ὃ"] = "ὃ", + ["Ὄ"] = "ὄ", + ["Ὅ"] = "ὅ", + ["Ὑ"] = "ὑ", + ["Ὓ"] = "ὓ", + ["Ὕ"] = "ὕ", + ["Ὗ"] = "ὗ", + ["Ὠ"] = "ὠ", + ["Ὡ"] = "ὡ", + ["Ὢ"] = "ὢ", + ["Ὣ"] = "ὣ", + ["Ὤ"] = "ὤ", + ["Ὥ"] = "ὥ", + ["Ὦ"] = "ὦ", + ["Ὧ"] = "ὧ", + ["ᾈ"] = "ᾀ", + ["ᾉ"] = "ᾁ", + ["ᾊ"] = "ᾂ", + ["ᾋ"] = "ᾃ", + ["ᾌ"] = "ᾄ", + ["ᾍ"] = "ᾅ", + ["ᾎ"] = "ᾆ", + ["ᾏ"] = "ᾇ", + ["ᾘ"] = "ᾐ", + ["ᾙ"] = "ᾑ", + ["ᾚ"] = "ᾒ", + ["ᾛ"] = "ᾓ", + ["ᾜ"] = "ᾔ", + ["ᾝ"] = "ᾕ", + ["ᾞ"] = "ᾖ", + ["ᾟ"] = "ᾗ", + ["ᾨ"] = "ᾠ", + ["ᾩ"] = "ᾡ", + ["ᾪ"] = "ᾢ", + ["ᾫ"] = "ᾣ", + ["ᾬ"] = "ᾤ", + ["ᾭ"] = "ᾥ", + ["ᾮ"] = "ᾦ", + ["ᾯ"] = "ᾧ", + ["Ᾰ"] = "ᾰ", + ["Ᾱ"] = "ᾱ", + ["Ὰ"] = "ὰ", + ["Ά"] = "ά", + ["ᾼ"] = "ᾳ", + ["Ὲ"] = "ὲ", + ["Έ"] = "έ", + ["Ὴ"] = "ὴ", + ["Ή"] = "ή", + ["ῌ"] = "ῃ", + ["Ῐ"] = "ῐ", + ["Ῑ"] = "ῑ", + ["Ὶ"] = "ὶ", + ["Ί"] = "ί", + ["Ῠ"] = "ῠ", + ["Ῡ"] = "ῡ", + ["Ὺ"] = "ὺ", + ["Ύ"] = "ύ", + ["Ῥ"] = "ῥ", + ["Ὸ"] = "ὸ", + ["Ό"] = "ό", + ["Ὼ"] = "ὼ", + ["Ώ"] = "ώ", + ["ῼ"] = "ῳ", + ["Ω"] = "ω", + ["K"] = "k", + ["Å"] = "å", + ["Ⅎ"] = "ⅎ", + ["Ⅰ"] = "ⅰ", + ["Ⅱ"] = "ⅱ", + ["Ⅲ"] = "ⅲ", + ["Ⅳ"] = "ⅳ", + ["Ⅴ"] = "ⅴ", + ["Ⅵ"] = "ⅵ", + ["Ⅶ"] = "ⅶ", + ["Ⅷ"] = "ⅷ", + ["Ⅸ"] = "ⅸ", + ["Ⅹ"] = "ⅹ", + ["Ⅺ"] = "ⅺ", + ["Ⅻ"] = "ⅻ", + ["Ⅼ"] = "ⅼ", + ["Ⅽ"] = "ⅽ", + ["Ⅾ"] = "ⅾ", + ["Ⅿ"] = "ⅿ", + ["Ↄ"] = "ↄ", + ["Ⓐ"] = "ⓐ", + ["Ⓑ"] = "ⓑ", + ["Ⓒ"] = "ⓒ", + ["Ⓓ"] = "ⓓ", + ["Ⓔ"] = "ⓔ", + ["Ⓕ"] = "ⓕ", + ["Ⓖ"] = "ⓖ", + ["Ⓗ"] = "ⓗ", + ["Ⓘ"] = "ⓘ", + ["Ⓙ"] = "ⓙ", + ["Ⓚ"] = "ⓚ", + ["Ⓛ"] = "ⓛ", + ["Ⓜ"] = "ⓜ", + ["Ⓝ"] = "ⓝ", + ["Ⓞ"] = "ⓞ", + ["Ⓟ"] = "ⓟ", + ["Ⓠ"] = "ⓠ", + ["Ⓡ"] = "ⓡ", + ["Ⓢ"] = "ⓢ", + ["Ⓣ"] = "ⓣ", + ["Ⓤ"] = "ⓤ", + ["Ⓥ"] = "ⓥ", + ["Ⓦ"] = "ⓦ", + ["Ⓧ"] = "ⓧ", + ["Ⓨ"] = "ⓨ", + ["Ⓩ"] = "ⓩ", + ["Ⰰ"] = "ⰰ", + ["Ⰱ"] = "ⰱ", + ["Ⰲ"] = "ⰲ", + ["Ⰳ"] = "ⰳ", + ["Ⰴ"] = "ⰴ", + ["Ⰵ"] = "ⰵ", + ["Ⰶ"] = "ⰶ", + ["Ⰷ"] = "ⰷ", + ["Ⰸ"] = "ⰸ", + ["Ⰹ"] = "ⰹ", + ["Ⰺ"] = "ⰺ", + ["Ⰻ"] = "ⰻ", + ["Ⰼ"] = "ⰼ", + ["Ⰽ"] = "ⰽ", + ["Ⰾ"] = "ⰾ", + ["Ⰿ"] = "ⰿ", + ["Ⱀ"] = "ⱀ", + ["Ⱁ"] = "ⱁ", + ["Ⱂ"] = "ⱂ", + ["Ⱃ"] = "ⱃ", + ["Ⱄ"] = "ⱄ", + ["Ⱅ"] = "ⱅ", + ["Ⱆ"] = "ⱆ", + ["Ⱇ"] = "ⱇ", + ["Ⱈ"] = "ⱈ", + ["Ⱉ"] = "ⱉ", + ["Ⱊ"] = "ⱊ", + ["Ⱋ"] = "ⱋ", + ["Ⱌ"] = "ⱌ", + ["Ⱍ"] = "ⱍ", + ["Ⱎ"] = "ⱎ", + ["Ⱏ"] = "ⱏ", + ["Ⱐ"] = "ⱐ", + ["Ⱑ"] = "ⱑ", + ["Ⱒ"] = "ⱒ", + ["Ⱓ"] = "ⱓ", + ["Ⱔ"] = "ⱔ", + ["Ⱕ"] = "ⱕ", + ["Ⱖ"] = "ⱖ", + ["Ⱗ"] = "ⱗ", + ["Ⱘ"] = "ⱘ", + ["Ⱙ"] = "ⱙ", + ["Ⱚ"] = "ⱚ", + ["Ⱛ"] = "ⱛ", + ["Ⱜ"] = "ⱜ", + ["Ⱝ"] = "ⱝ", + ["Ⱞ"] = "ⱞ", + ["Ⱡ"] = "ⱡ", + ["Ɫ"] = "ɫ", + ["Ᵽ"] = "ᵽ", + ["Ɽ"] = "ɽ", + ["Ⱨ"] = "ⱨ", + ["Ⱪ"] = "ⱪ", + ["Ⱬ"] = "ⱬ", + ["Ⱶ"] = "ⱶ", + ["Ⲁ"] = "ⲁ", + ["Ⲃ"] = "ⲃ", + ["Ⲅ"] = "ⲅ", + ["Ⲇ"] = "ⲇ", + ["Ⲉ"] = "ⲉ", + ["Ⲋ"] = "ⲋ", + ["Ⲍ"] = "ⲍ", + ["Ⲏ"] = "ⲏ", + ["Ⲑ"] = "ⲑ", + ["Ⲓ"] = "ⲓ", + ["Ⲕ"] = "ⲕ", + ["Ⲗ"] = "ⲗ", + ["Ⲙ"] = "ⲙ", + ["Ⲛ"] = "ⲛ", + ["Ⲝ"] = "ⲝ", + ["Ⲟ"] = "ⲟ", + ["Ⲡ"] = "ⲡ", + ["Ⲣ"] = "ⲣ", + ["Ⲥ"] = "ⲥ", + ["Ⲧ"] = "ⲧ", + ["Ⲩ"] = "ⲩ", + ["Ⲫ"] = "ⲫ", + ["Ⲭ"] = "ⲭ", + ["Ⲯ"] = "ⲯ", + ["Ⲱ"] = "ⲱ", + ["Ⲳ"] = "ⲳ", + ["Ⲵ"] = "ⲵ", + ["Ⲷ"] = "ⲷ", + ["Ⲹ"] = "ⲹ", + ["Ⲻ"] = "ⲻ", + ["Ⲽ"] = "ⲽ", + ["Ⲿ"] = "ⲿ", + ["Ⳁ"] = "ⳁ", + ["Ⳃ"] = "ⳃ", + ["Ⳅ"] = "ⳅ", + ["Ⳇ"] = "ⳇ", + ["Ⳉ"] = "ⳉ", + ["Ⳋ"] = "ⳋ", + ["Ⳍ"] = "ⳍ", + ["Ⳏ"] = "ⳏ", + ["Ⳑ"] = "ⳑ", + ["Ⳓ"] = "ⳓ", + ["Ⳕ"] = "ⳕ", + ["Ⳗ"] = "ⳗ", + ["Ⳙ"] = "ⳙ", + ["Ⳛ"] = "ⳛ", + ["Ⳝ"] = "ⳝ", + ["Ⳟ"] = "ⳟ", + ["Ⳡ"] = "ⳡ", + ["Ⳣ"] = "ⳣ", + ["Ａ"] = "ａ", + ["Ｂ"] = "ｂ", + ["Ｃ"] = "ｃ", + ["Ｄ"] = "ｄ", + ["Ｅ"] = "ｅ", + ["Ｆ"] = "ｆ", + ["Ｇ"] = "ｇ", + ["Ｈ"] = "ｈ", + ["Ｉ"] = "ｉ", + ["Ｊ"] = "ｊ", + ["Ｋ"] = "ｋ", + ["Ｌ"] = "ｌ", + ["Ｍ"] = "ｍ", + ["Ｎ"] = "ｎ", + ["Ｏ"] = "ｏ", + ["Ｐ"] = "ｐ", + ["Ｑ"] = "ｑ", + ["Ｒ"] = "ｒ", + ["Ｓ"] = "ｓ", + ["Ｔ"] = "ｔ", + ["Ｕ"] = "ｕ", + ["Ｖ"] = "ｖ", + ["Ｗ"] = "ｗ", + ["Ｘ"] = "ｘ", + ["Ｙ"] = "ｙ", + ["Ｚ"] = "ｚ", + ["𐐀"] = "𐐨", + ["𐐁"] = "𐐩", + ["𐐂"] = "𐐪", + ["𐐃"] = "𐐫", + ["𐐄"] = "𐐬", + ["𐐅"] = "𐐭", + ["𐐆"] = "𐐮", + ["𐐇"] = "𐐯", + ["𐐈"] = "𐐰", + ["𐐉"] = "𐐱", + ["𐐊"] = "𐐲", + ["𐐋"] = "𐐳", + ["𐐌"] = "𐐴", + ["𐐍"] = "𐐵", + ["𐐎"] = "𐐶", + ["𐐏"] = "𐐷", + ["𐐐"] = "𐐸", + ["𐐑"] = "𐐹", + ["𐐒"] = "𐐺", + ["𐐓"] = "𐐻", + ["𐐔"] = "𐐼", + ["𐐕"] = "𐐽", + ["𐐖"] = "𐐾", + ["𐐗"] = "𐐿", + ["𐐘"] = "𐑀", + ["𐐙"] = "𐑁", + ["𐐚"] = "𐑂", + ["𐐛"] = "𐑃", + ["𐐜"] = "𐑄", + ["𐐝"] = "𐑅", + ["𐐞"] = "𐑆", + ["𐐟"] = "𐑇", + ["𐐠"] = "𐑈", + ["𐐡"] = "𐑉", + ["𐐢"] = "𐑊", + ["𐐣"] = "𐑋", + ["𐐤"] = "𐑌", + ["𐐥"] = "𐑍", + ["𐐦"] = "𐑎", + ["𐐧"] = "𐑏", +} + + +return { + utf8_lc_uc = utf8_lc_uc, + utf8_uc_lc = utf8_uc_lc, +} |