-- mod-version:3

-- LSP style snippet parser
-- shamelessly 'inspired by' (stolen from) LuaSnip
-- https://github.com/L3MON4D3/LuaSnip/blob/master/lua/luasnip/util/parser/neovim_parser.lua

local core     = require 'core'
local common   = require 'core.common'
local Doc      = require 'core.doc'
local system   = require 'system'
local regex    = require 'regex'
local snippets = require 'plugins.snippets'

local json do
	local ok, j 
	for _, p in ipairs {
		'plugins.json', 'plugins.lsp.json', 'plugins.lintplus.json',
		'libraries.json'
	} do
		ok, j = pcall(require, p)
		if ok then json = j; break end
	end
end


local B = snippets.builder

local LAST_CONVERTED_ID = { }
local THREAD_KEY = { }


-- node factories

local function doc_syntax(doc, k)
	return doc.syntax and doc.syntax[k]
end

local variables = {
	-- LSP
	TM_SELECTED_TEXT         = function(ctx) return ctx.selection end,
	TM_CURRENT_LINE          = function(ctx) return ctx.doc.lines[ctx.line] end,
	TM_CURRENT_WORD          = function(ctx) return ctx.partial end,
	TM_LINE_INDEX            = function(ctx) return ctx.line - 1 end,
	TM_LINE_NUMBER           = function(ctx) return ctx.line end,
	TM_FILENAME              = function(ctx) return ctx.doc.filename:match('[^/%\\]*$') or '' end,
	TM_FILENAME_BASE         = function(ctx) return ctx.doc.filename:match('([^/%\\]*)%.%w*$') or ctx.doc.filename end,
	TM_DIRECTORY             = function(ctx) return ctx.doc.filename:match('([^/%\\]*)[/%\\].*$') or '' end,
	TM_FILEPATH              = function(ctx) return common.dirname(ctx.doc.abs_filename) or '' end,
	-- VSCode
	RELATIVE_FILEPATH        = function(ctx) return core.normalize_to_project_dir(ctx.doc.filename) end,
	CLIPBOARD                = function()    return system.get_clipboard() end,
	-- https://github.com/lite-xl/lite-xl/pull/1455
	WORKSPACE_NAME           = function(ctx) return end,
	WORKSPACE_FOLDER         = function(ctx) return end,
	CURSOR_INDEX             = function(ctx) return ctx.col - 1 end,
	CURSOR_NUMBER            = function(ctx) return ctx.col end,
	CURRENT_YEAR             = function()    return os.date('%G') end,
	CURRENT_YEAR_SHORT       = function()    return os.date('%g') end,
	CURRENT_MONTH            = function()    return os.date('%m') end,
	CURRENT_MONTH_NAME       = function()    return os.date('%B') end,
	CURRENT_MONTH_NAME_SHORT = function()    return os.date('%b') end,
	CURRENT_DATE             = function()    return os.date('%d') end,
	CURRENT_DAY_NAME         = function()    return os.date('%A') end,
	CURRENT_DAY_NAME_SHORT   = function()    return os.date('%a') end,
	CURRENT_HOUR             = function()    return os.date('%H') end,
	CURRENT_MINUTE           = function()    return os.date('%M') end,
	CURRENT_SECOND           = function()    return os.date('%S') end,
	CURRENT_SECONDS_UNIX     = function()    return os.time() end,
	RANDOM                   = function()    return string.format('%06d', math.random(999999)) end,
	RANDOM_HEX               = function()    return string.format('%06x', math.random(0xFFFFFF)) end,
	BLOCK_COMMENT_START      = function(ctx) return (doc_syntax(ctx.doc, 'block_comment') or { })[1] end,
	BLOCK_COMMENT_END        = function(ctx) return (doc_syntax(ctx.doc, 'block_comment') or { })[2] end,
	LINE_COMMENT             = function(ctx) return doc_syntax(ctx.doc, 'comment') end
	-- https://code.visualstudio.com/docs/editor/userdefinedsnippets#_variables
	-- UUID
}

local formatters; formatters = {
	downcase   = string.lower,
	upcase     = string.upper,
	capitalize = function(str)
		return str:sub(1, 1):upper() .. str:sub(2)
	end,
	pascalcase = function(str)
		local t = { }
		for s in str:gmatch('%w+') do
			table.insert(t, formatters.capitalize(s))
		end
		return table.concat(t)
	end,
	camelcase  = function(str)
		str = formatters.pascalcase(str)
		return str:sub(1, 1):lower() .. str:sub(2)
	end
}

local function to_text(v, _s)
	return v.esc
end

local function format_fn(v, _s)
	local id = tonumber(v[2])

	-- $1 | ${1}
	if #v < 4 then
		return function(captures)
			return captures[id] or ''
		end
	end

	-- ${1:...}
	local t = v[3][2][1] -- token after the ':' | (else when no token)
	local i = v[3][2][2] -- formatter | if | (else when no if)
	local e = v[3][2][4] -- (else when if)

	if t == '/' then
		local f = formatters[i]
		return function(captures)
			local c = captures[id]
			return c and f(c) or ''
		end
	elseif t == '+' then
		return function(captures)
			return captures[id] and i or ''
		end
	elseif t == '?' then
		return function(captures)
			return captures[id] and i or e
		end
	elseif t == '-' then
		return function(captures)
			return captures[id] or i
		end
	else
		return function(captures)
			return captures[id] or t
		end
	end
end

local function transform_fn(v, _s)
	local reg = regex.compile(v[2], v[#v])
	local fmt = v[4]

	if type(fmt) ~= 'table' then
		return function(str)
			return reg:gsub(str, '')
		end
	end

	local t = { }
	for _, f in ipairs(fmt) do
		if type(f) == 'string' then
			table.insert(t, f)
		else
			break
		end
	end

	if #t == #fmt then
		t = table.concat(t)
		return function(str)
			return reg:gsub(str, t)
		end
	end

	return function(str)
		local captures = { reg:match(str) }
		for k, v in ipairs(captures) do
			if type(v) ~= 'string' then
				captures[k] = nil
			end
		end
		local t = { }
		for _, f in ipairs(fmt) do
			if type(f) == 'string' then
				table.insert(t, f)
			else
				table.insert(t, f(captures))
			end
		end
		return table.concat(t)
	end
end

local function text_node(v, _s)
	return B.static(v.esc)
end

local function variable_node(v, _s)
	local name = v[2]
	local var = variables[name]

	local id
	if not var then
		if not _s._converted_variables then
			id = os.time()
			_s._converted_variables = { [name] = id, [LAST_CONVERTED_ID] = id }
		else
			id = _s._converted_variables[name]
			if not id then
				id = _s._converted_variables[LAST_CONVERTED_ID] + 1
				_s._converted_variables[name] = id
				_s._converted_variables[LAST_CONVERTED_ID] = id
			end
		end
	end

	if #v ~= 4 then
		return var and B.static(var) or B.user(id, name)
	end

	if type(v[3]) == 'table' then
		-- vscode accepts empty default -> var name
		return var and B.static(var) or B.user(id, v[3][2] or name)
	end

	if not var then
		return B.user(id, nil, v[3])
	end

	return type(var) ~= 'function' and B.static(var) or B.static(function(ctx)
		return v[3](var(ctx))
	end)
end

local function tabstop_node(v, _s)
	local t = v[3] and v[3] ~= '}' and v[3] or nil
	return B.user(tonumber(v[2]), nil, t)
end

local function choice_node(v, _s)
	local id = tonumber(v[2])
	local c = { [v[4]] = true }
	if #v == 6 then
		for _, _c in ipairs(v[5]) do
			c[_c[2]] = true
		end
	end
	_s:choice(id, c)
	return B.user(id)
end

local function placeholder_node(v, _s)
	local id = tonumber(v[2])
	if #v > 4 then _s:default(id, v[4]) end
	return B.user(id)
end

local function build_snippet(v, _s)
	for _, n in ipairs(v) do _s:add(n) end
	return _s:ok()
end


-- parser metatable

local P do
	local mt = {
		__call = function(mt, parser, converter)
			return setmetatable({ parser = parser, converter = converter }, mt)
		end,
		-- allows 'lazy arguments'
		-- i.e can use a yet to be defined rule in a previous rule
		__index = function(t, k)
			return function(...) return t[k](...) end
		end
	}

	P = setmetatable({
		__call = function(t, str, at, _s)
			local r = t.parser(str, at, _s)
			if r.ok and t.converter then
				r.value = t.converter(r.value, _s)
			end
			return r
		end
	}, mt)
end


-- utils

local function toset(t)
	local r = { }
	for _, v in pairs(t or { }) do
		r[v] = true
	end
	return r
end

local function fail(at)
	return { at = at }
end

local function ok(at, v)
	return { ok = true, at = at, value = v }
end


-- base + combinators

local function token(t)
	return function(str, at)
		local to = at + #t
		return t == str:sub(at, to - 1) and ok(to, t) or fail(at)
	end
end

local function consume(stops, escapes)
	stops, escapes = toset(stops), toset(escapes)
	return function(str, at)
		local to = at
		local raw, esc = { }, { }
		local c = str:sub(to, to)
		while to <= #str and not stops[c] do
			if c == '\\' then
				table.insert(raw, c)
				to = to + 1
				c = str:sub(to, to)
				if not stops[c] and not escapes[c] then
					table.insert(esc, '\\')
				end
			end
			table.insert(raw, c)
			table.insert(esc, c)
			to = to + 1
			c = str:sub(to, to)
		end
		return to ~= at
			and ok(to, { raw = table.concat(raw), esc = table.concat(esc) })
			or fail(at)
	end
end

local function pattern(p)
	return function(str, at)
		local r = str:match('^' .. p, at)
		return r and ok(at + #r, r) or fail(at)
	end
end

local function maybe(p)
	return function(str, at, ...)
		local r = p(str, at, ...)
		return ok(r.at, r.value)
	end
end

local function rep(p)
	return function(str, at, ...)
		local v, to, r = { }, at, ok(at)
		while to <= #str and r.ok do
			table.insert(v, r.value)
			to = r.at
			r = p(str, to, ...)
		end
		return #v > 0 and ok(to, v) or fail(at)
	end
end

local function any(...)
	local t = { ... }
	return function(str, at, ...)
		for _, p in ipairs(t) do
			local r = p(str, at, ...)
			if r.ok then return r end
		end
		return fail(at)
	end
end

local function seq(...)
	local t = { ... }
	return function(str, at, ...)
		local v, to = { }, at
		for _, p in ipairs(t) do
			local r = p(str, to, ...)
			if r.ok then
				table.insert(v, r.value)
				to = r.at
			else
				return fail(at)
			end
		end
		return ok(to, v)
	end
end


-- grammar rules

-- token cache
local t = setmetatable({ },
	{
		__index = function(t, k)
			local fn = token(k)
			rawset(t, k, fn)
			return fn
		end
	}
)

P.int = pattern('%d+')

P.var = pattern('[%a_][%w_]*')

-- '}' needs to be escaped in normal text (i.e #0)
local __text0 = consume({ '$' },      { '\\', '}' })
local __text1 = consume({ '}' },      { '\\' })
local __text2 = consume({ ':' },      { '\\' })
local __text3 = consume({ '/' },      { '\\' })
local __text4 = consume({ '$', '}' }, { '\\' })
local __text5 = consume({ ',', '|' }, { '\\' })
local __text6 = consume({ "$", "/" }, { "\\" })

P._if1  = P(__text1, to_text)
P._if2  = P(__text2, to_text)
P._else = P(__text1, to_text)

P.options = pattern('%l*')

P.regex = P(__text3, to_text)

P.format = P(any(
	seq(t['$'],  P.int),
	seq(t['${'], P.int, maybe(seq(t[':'], any(
		seq(t['/'], any(t['upcase'], t['downcase'], t['capitalize'], t['pascalcase'], t['camelcase'])),
		seq(t['+'], P._if1),
		seq(t['?'], P._if2, t[':'], P._else),
		seq(t['-'], P._else),
		P._else
	))), t['}'])
), format_fn)

P.transform_text = P(__text6, to_text)
P.transform = P(
	seq(t['/'], P.regex, t['/'], rep(any(P.format, P.transform_text)), t['/'], P.options),
	transform_fn
)

P.variable_text = P(__text4, text_node)
P.variable = P(any(
	seq(t['$'],  P.var),
	seq(t['${'], P.var, maybe(any(
		-- grammar says a single mandatory 'any' for default, vscode seems to accept any*
		seq(t[':'], maybe(rep(any(P.dollars, P.variable_text)))),
		P.transform
	)), t['}'])
), variable_node)

P.choice_text = P(__text5, to_text)
P.choice = P(
	seq(t['${'], P.int, t['|'], P.choice_text, maybe(rep(seq(t[','], P.choice_text))), t['|}']),
	choice_node
)

P.placeholder_text = P(__text4, text_node)
P.placeholder = P(
	seq(t['${'], P.int, t[':'], maybe(rep(any(P.dollars, P.placeholder_text))), t['}']),
	placeholder_node
)

P.tabstop = P(any(
	seq(t['$'],  P.int),
	-- transform isnt specified in the grammar but seems to be supported by vscode
	seq(t['${'], P.int, maybe(P.transform), t['}'])
), tabstop_node)


P.dollars = any(P.tabstop, P.placeholder, P.choice, P.variable)

P.text = P(__text0, text_node)
P.any = any(P.dollars, P.text)

P.snippet = P(rep(P.any), build_snippet)


-- JSON files

-- defined at the end of the file
local extensions

local fstate = { NOT_DONE = 'not done', QUEUED = 'queued', DONE = 'done' }
local queue = { }
local files = { }
local files2exts = { }
local exts2files = { }

local function parse_file(file)
	if files[file] == fstate.DONE then return end
	files[file] = fstate.DONE

	local _f = io.open(file)
	if not _f then
		core.error('[LSP snippets] Could not open \'%s\'', file)
		return
	end
	local ok, r = pcall(json.decode, _f:read('a'))
	_f:close()
	if not ok then
		core.error('[LSP snippets] %s: %s', file, r:match('%d+:%s+(.*)'))
		return false
	end

	local exts = file:match('%.json$') and files2exts[file]
	for i, s in pairs(r) do
		-- apparently body can be a single string
		local template = type(s.body) == 'table'
			and table.concat(s.body, '\n')
			or s.body
		if not template or template == '' then
			core.warn('[LSP snippets] missing \'body\' for %s (%s)', i, file)
			goto continue
		end

		-- https://code.visualstudio.com/docs/editor/userdefinedsnippets#_language-snippet-scope
		local scope
		if not exts and s.scope then
			local tmp = { }
			for _, l in ipairs(s.scope) do
				for _, e in ipairs(extensions[l:lower()]) do
					tmp[e] = true
				end
			end
			scope = { }
			for l in pairs(tmp) do
				table.insert(scope, l)
			end
		end

		-- prefix may be an array
		local triggers = type(s.prefix) ~= 'table' and { s.prefix } or s.prefix
		if #triggers == 0 then
			core.warn('[LSP snippets] missing \'prefix\' for %s (%s)', i, file)
			goto continue
		end

		for _, t in ipairs(triggers) do
			snippets.add {
				trigger = t,
				format = 'lsp',
				files = exts or scope,
				info = i,
				desc = s.description,
				template = template
			}
		end

		::continue::
	end

	return true
end

local function pop()
	while #queue > 0 do
		repeat until parse_file(table.remove(queue)) ~= nil
		if #queue > 0 then coroutine.yield() end
	end
end

local function enqueue(filename)
	if not core.threads[THREAD_KEY] then
		core.add_thread(pop, THREAD_KEY)
	end
	files[filename] = fstate.QUEUED
	table.insert(queue, filename)
end

local function add_file(filename, exts)
	if files[filename] then return end

	if filename:match('%.code%-snippets$') then
		enqueue(filename)
		return
	end

	if not filename:match('%.json$') then return end

	if not exts then
		local lang_name = filename:match('([^/%\\]*)%.%w*$'):lower()
		exts = extensions[lang_name]
		if not exts then return end
	end

	files[filename] = fstate.NOT_DONE
	exts = type(exts) == 'string' and { exts } or exts
	for _, e in ipairs(exts) do
		files2exts[filename] = files2exts[filename] or { }
		table.insert(files2exts[filename], '%.' .. e .. '$')
		exts2files[e] = exts2files[e] or { }
		table.insert(exts2files[e], filename)
	end
end

local function for_filename(name)
	if not name then return end
	local ext = name:match('%.(.*)$')
	if not ext then return end
	local _files = exts2files[ext]
	if not _files then return end
	for _, f in ipairs(_files) do
		if files[f] == fstate.NOT_DONE then
			enqueue(f)
		end
	end
end

local doc_new = Doc.new
function Doc:new(filename, ...)
	doc_new(self, filename, ...)
	for_filename(filename)
end

local doc_set_filename = Doc.set_filename
function Doc:set_filename(filename, ...)
	doc_set_filename(self, filename, ...)
	for_filename(filename)
end


-- API

local M = { }

function M.parse(template)
	local _s = B.new()
	local r = P.snippet(template, 1, _s)
	if not r.ok then
		return B.new():s(template):ok()
	elseif r.at == #template + 1 then
		return r.value
	else
		return _s:s(template:sub(r.at + 1)):ok()
	end
end

snippets.parsers.lsp = M.parse

local warned = false
function M.add_paths(paths)
	if not json then
		if not warned then
			core.error(
				'[LSP snippets] Could not add snippet file(s):' ..
				'JSON plugin not found'
			)
			warned = true
		end
		return
	end

	paths = type(paths) ~= 'table' and { paths } or paths

	for _, p in ipairs(paths) do
		-- non absolute paths are treated as relative from USERDIR
		p = not common.is_absolute_path(p) and (USERDIR .. PATHSEP .. p) or p
		local finfo = system.get_file_info(p)

		-- if path of a directory, add every file it contains and directories
		-- whose name is that of a lang
		if finfo and finfo.type == 'dir' then
			for _, f in ipairs(system.list_dir(p)) do
				f = p .. PATHSEP .. f
				finfo = system.get_file_info(f)
				if not finfo or finfo.type == 'file' then
					add_file(f)
				else
					-- only if the directory's name matches a language
					local lang_name = f:match('[^/%\\]*$'):lower()
					local exts = extensions[lang_name]
					for _, f2 in ipairs(system.list_dir(f)) do
						f2 = f .. PATHSEP .. f2
						finfo = system.get_file_info(f2)
						if not finfo or finfo.type == 'file' then
							add_file(f2, exts)
						end
					end
				end
			end
		-- if path of a file, add the file
		else
			add_file(p)
		end
	end
end


-- arbitrarily cleaned up extension dump from https://gist.github.com/ppisarczyk/43962d06686722d26d176fad46879d41
-- nothing after this

-- 90% of these are still useless but cba

extensions = {
	['ats'] = { 'dats', 'hats', 'sats', },
	['ada'] = { 'adb', 'ada', 'ads', },
	['agda'] = { 'agda', },
	['asciidoc'] = { 'asciidoc', 'adoc', 'asc', },
	['assembly'] = { 'asm', 'nasm', },
	['autohotkey'] = { 'ahk', 'ahkl', },
	['awk'] = { 'awk', 'auk', 'gawk', 'mawk', 'nawk', },
	['batchfile'] = { 'bat', 'cmd', },
	['c'] = { 'c', 'h', },
	['c#'] = { 'cs', 'cake', 'cshtml', 'csx', },
	['c++'] = { 'cpp', 'c++', 'cc', 'cp', 'cxx', 'h', 'h++', 'hh', 'hpp', 'hxx', },
	['cmake'] = { 'cmake', 'cmake.in', },
	['cobol'] = { 'cob', 'cbl', 'ccp', 'cobol', 'cpy', },
	['css'] = { 'css', },
	['clean'] = { 'icl', 'dcl', },
	['clojure'] = { 'clj', 'boot', 'cl2', 'cljc', 'cljs', 'cljs.hl', 'cljscm', 'cljx', 'hic', },
	['common lisp'] = { 'lisp', 'asd', 'cl', 'l', 'lsp', 'ny', 'podsl', 'sexp', },
	['component pascal'] = { 'cp', 'cps', },
	['coq'] = { 'coq', 'v', },
	['crystal'] = { 'cr', },
	['cuda'] = { 'cu', 'cuh', },
	['d'] = { 'd', 'di', },
	['dart'] = { 'dart', },
	['dockerfile'] = { 'dockerfile', },
	['eiffel'] = { 'e', },
	['elixir'] = { 'ex', 'exs', },
	['elm'] = { 'elm', },
	['emacs lisp'] = { 'el', 'emacs', 'emacs.desktop', },
	['erlang'] = { 'erl', 'es', 'escript', 'hrl', 'xrl', 'yrl', },
	['f#'] = { 'fs', 'fsi', 'fsx', },
	['fortran'] = { 'f90', 'f', 'f03', 'f08', 'f77', 'f95', 'for', 'fpp', },
	['factor'] = { 'factor', },
	['forth'] = { 'fth', '4th', 'f', 'for', 'forth', 'fr', 'frt', 'fs', },
	['go'] = { 'go', },
	['groff'] = { 'man', '1', '1in', '1m', '1x', '2', '3', '3in', '3m', '3qt', '3x', '4', '5', '6', '7', '8', '9', 'l', 'me', 'ms', 'n', 'rno', 'roff', },
	['groovy'] = { 'groovy', 'grt', 'gtpl', 'gvy', },
	['html'] = { 'html', 'htm', 'html.hl', 'xht', 'xhtml', },
	['haskell'] = { 'hs', 'hsc', },
	['idris'] = { 'idr', 'lidr', },
	['jsx'] = { 'jsx', },
	['java'] = { 'java', },
	['javascript'] = { 'js', },
	['julia'] = { 'jl', },
	['jupyter notebook'] = { 'ipynb', },
	['kotlin'] = { 'kt', 'ktm', 'kts', },
	['lean'] = { 'lean', 'hlean', },
	['less'] = { 'less', },
	['lua'] = { 'lua', 'fcgi', 'nse', 'pd_lua', 'rbxs', 'wlua', },
	['markdown'] = { 'md', 'markdown', 'mkd', 'mkdn', 'mkdown', 'ron', },
	['modula-2'] = { 'mod', },
	['moonscript'] = { 'moon', },
	['ocaml'] = { 'ml', 'eliom', 'eliomi', 'ml4', 'mli', 'mll', 'mly', },
	['objective-c'] = { 'm', 'h', },
	['objective-c++'] = { 'mm', },
	['oz'] = { 'oz', },
	['php'] = { 'php', 'aw', 'ctp', 'fcgi', 'inc', 'php3', 'php4', 'php5', 'phps', 'phpt', },
	['plsql'] = { 'pls', 'pck', 'pkb', 'pks', 'plb', 'plsql', 'sql', },
	['plpgsql'] = { 'sql', },
	['pascal'] = { 'pas', 'dfm', 'dpr', 'inc', 'lpr', 'pp', },
	['perl'] = { 'pl', 'al', 'cgi', 'fcgi', 'perl', 'ph', 'plx', 'pm', 'pod', 'psgi', 't', },
	['perl6'] = { '6pl', '6pm', 'nqp', 'p6', 'p6l', 'p6m', 'pl', 'pl6', 'pm', 'pm6', 't', },
	['picolisp'] = { 'l', },
	['pike'] = { 'pike', 'pmod', },
	['pony'] = { 'pony', },
	['postscript'] = { 'ps', 'eps', },
	['powershell'] = { 'ps1', 'psd1', 'psm1', },
	['prolog'] = { 'pl', 'pro', 'prolog', 'yap', },
	['python'] = { 'py', 'bzl', 'cgi', 'fcgi', 'gyp', 'lmi', 'pyde', 'pyp', 'pyt', 'pyw', 'rpy', 'tac', 'wsgi', 'xpy', },
	['racket'] = { 'rkt', 'rktd', 'rktl', 'scrbl', },
	['rebol'] = { 'reb', 'r', 'r2', 'r3', 'rebol', },
	['ruby'] = { 'rb', 'builder', 'fcgi', 'gemspec', 'god', 'irbrc', 'jbuilder', 'mspec', 'pluginspec', 'podspec', 'rabl', 'rake', 'rbuild', 'rbw', 'rbx', 'ru', 'ruby', 'thor', 'watchr', },
	['rust'] = { 'rs', 'rs.in', },
	['scss'] = { 'scss', },
	['sql'] = { 'sql', 'cql', 'ddl', 'inc', 'prc', 'tab', 'udf', 'viw', },
	['sqlpl'] = { 'sql', 'db2', },
	['scala'] = { 'scala', 'sbt', 'sc', },
	['scheme'] = { 'scm', 'sld', 'sls', 'sps', 'ss', },
	['self'] = { 'self', },
	['shell'] = { 'sh', 'bash', 'bats', 'cgi', 'command', 'fcgi', 'ksh', 'sh.in', 'tmux', 'tool', 'zsh', },
	['smalltalk'] = { 'st', 'cs', },
	['standard ml'] = { 'ML', 'fun', 'sig', 'sml', },
	['swift'] = { 'swift', },
	['tcl'] = { 'tcl', 'adp', 'tm', },
	['tex'] = { 'tex', 'aux', 'bbx', 'bib', 'cbx', 'cls', 'dtx', 'ins', 'lbx', 'ltx', 'mkii', 'mkiv', 'mkvi', 'sty', 'toc', },
	['typescript'] = { 'ts', 'tsx', },
	['vala'] = { 'vala', 'vapi', },
	['verilog'] = { 'v', 'veo', },
	['visual basic'] = { 'vb', 'bas', 'cls', 'frm', 'frx', 'vba', 'vbhtml', 'vbs', },
}

extensions.cpp    = extensions['c++']
extensions.csharp = extensions['c#']
extensions.latex  = extensions.tex
extensions.objc   = extensions['objective-c']

M.extensions = extensions

return M