nano-max-hub 0.0.1

data/rouge-5.0.0/lib/rouge/lexers/livescript.rb

@@ -0,0 +1,310 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Livescript < RegexLexer
+      tag 'livescript'
+      aliases 'ls'
+      filenames '*.ls'
+      mimetypes 'text/livescript'
+
+      title 'LiveScript'
+      desc 'LiveScript, a language which compiles to JavaScript (livescript.net)'
+
+      def self.detect?(text)
+        return text.shebang? 'lsc'
+      end
+
+      def self.declarations
+        @declarations ||= Set.new %w(const let var function class extends implements)
+      end
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          loop until for in of while break return continue switch case
+          fallthrough default otherwise when then if unless else throw try
+          catch finally new delete typeof instanceof super by from to til
+          with require do debugger import export yield
+        )
+      end
+
+      def self.constants
+        @constants ||= Javascript.constants + %w(yes no on off void)
+      end
+
+      def self.builtins
+        @builtins ||= Javascript.builtins + %w(this it that arguments)
+      end
+
+      def self.loop_control_keywords
+        @loop_control_keywords ||= Set.new %w(break continue)
+      end
+
+      id = /[$a-z_]((-(?=[a-z]))?[a-z0-9_])*/i
+      int_number = /\d[\d_]*/
+      int = /#{int_number}(e[+-]?#{int_number})?[$\w]*/ # the last class matches units
+
+      state :root do
+        rule(%r(^(?=\s|/))) { push :slash_starts_regex }
+        mixin :comments
+        mixin :whitespace
+
+        # list of words
+        rule %r/(<\[)(.*?)(\]>)/m do
+          groups Punctuation, Str, Punctuation
+        end
+
+        # function declarations
+        rule %r/!\s*function\b/, Keyword::Declaration
+        rule %r/!?[-~]>|<[-~]!?/, Keyword::Declaration
+
+        # switch arrow
+        rule %r/(=>)/, Keyword
+
+        # prototype attributes
+        rule %r/(::)(#{id})/ do
+          groups Punctuation, Name::Attribute
+          push :id
+        end
+        rule %r/(::)(#{int})/ do
+          groups Punctuation, Num::Integer
+          push :id
+        end
+
+        # instance attributes
+        rule %r/(@)(#{id})/ do
+          groups Name::Variable::Instance, Name::Attribute
+          push :id
+        end
+        rule %r/([.])(#{id})/ do
+          groups Punctuation, Name::Attribute
+          push :id
+        end
+        rule %r/([.])(\d+)/ do
+          groups Punctuation, Num::Integer
+          push :id
+        end
+        rule %r/#{id}(?=\s*:[^:=])/, Name::Attribute
+
+        # operators
+        rule %r(
+          [+][+]|--|&&|\b(and|x?or|is(nt)?|not)\b(?!-[a-zA-Z]|_)|[|][|]|
+          [.]([|&^]|<<|>>>?)[.]|\\(?=\n)|[.:]=|<<<<?|<[|]|[|]>|
+          (<<|>>|==?|!=?|[-<>+*%^/~?])=?
+        )x, Operator, :slash_starts_regex
+
+        # arguments shorthand
+        rule %r/(&)(#{id})?/ do
+          groups Name::Builtin, Name::Attribute
+        end
+
+        # switch case
+        rule %r/[|]|\bcase(?=\s)/, Keyword, :switch_underscore
+
+        rule %r/@/, Name::Variable::Instance
+        rule %r/[.]{3}/, Punctuation
+        rule %r/:/, Punctuation
+
+        # keywords
+        rule %r/#{id}/ do |m|
+          if self.class.loop_control_keywords.include? m[0]
+            token Keyword
+            push :loop_control
+            next
+          elsif self.class.keywords.include? m[0]
+            token Keyword
+          elsif self.class.constants.include? m[0]
+            token Name::Constant
+          elsif self.class.builtins.include? m[0]
+            token Name::Builtin
+          elsif self.class.declarations.include? m[0]
+            token Keyword::Declaration
+          elsif /^[A-Z]/.match(m[0]) && /[^-][a-z]/.match(m[0])
+            token Name::Class
+          else
+            token Name::Variable
+          end
+          push :id
+        end
+
+        # punctuation and brackets
+        rule %r/\](?=[!?.]|#{id})/, Punctuation, :id
+        rule %r/[{(\[;,]/, Punctuation, :slash_starts_regex
+        rule %r/[})\].]/, Punctuation
+
+        # literals
+        rule %r/#{int_number}[.]#{int}/, Num::Float
+        rule %r/0x[0-9A-Fa-f]+/, Num::Hex
+        rule %r/#{int}/, Num::Integer
+
+        # strings
+        rule %r/"""/ do
+          token Str
+          push do
+            rule %r/"""/, Str, :pop!
+            rule %r/"/, Str
+            mixin :double_strings
+          end
+        end
+
+        rule %r/'''/ do
+          token Str
+          push do
+            rule %r/'''/, Str, :pop!
+            rule %r/'/, Str
+            mixin :single_strings
+          end
+        end
+
+        rule %r/"/ do
+          token Str
+          push do
+            rule %r/"/, Str, :pop!
+            mixin :double_strings
+          end
+        end
+
+        rule %r/'/ do
+          token Str
+          push do
+            rule %r/'/, Str, :pop!
+            mixin :single_strings
+          end
+        end
+
+        # words
+        rule %r/\\\S[^\s,;\])}]*/, Str
+      end
+
+      state :code_escape do
+        rule %r(\\(
+          c[A-Z]|
+          x[0-9a-fA-F]{2}|
+          u[0-9a-fA-F]{4}|
+          u\{[0-9a-fA-F]{4}\}
+        ))x, Str::Escape
+      end
+
+      state :interpolated_expression do
+        rule %r/}/, Str::Interpol, :pop!
+        mixin :root
+      end
+
+      state :interpolation do
+        # with curly braces
+        rule %r/[#][{]/, Str::Interpol, :interpolated_expression
+        # without curly braces
+        rule %r/(#)(#{id})/ do |m|
+          groups Str::Interpol, (self.class.builtins.include? m[2]) ? Name::Builtin : Name::Variable
+        end
+      end
+
+      state :whitespace do
+        # white space and loop labels
+        rule %r/(\s+?)(?:^([^\S\n]*)(:#{id}))?/m do
+          groups Text, Text, Name::Label
+        end
+      end
+
+      state :whitespace_single_line do
+        rule %r([^\S\n]+), Text
+      end
+
+      state :slash_starts_regex do
+        mixin :comments
+        mixin :whitespace
+        mixin :multiline_regex_begin
+
+        rule %r(
+          /(\\.|[^\[/\\\n]|\[(\\.|[^\]\\\n])*\])+/ # a regex
+          ([gimy]+\b|\B)
+        )x, Str::Regex, :pop!
+
+        rule(//) { pop! }
+      end
+
+      state :multiline_regex_begin do
+        rule %r(//) do
+          token Str::Regex
+          goto :multiline_regex
+        end
+      end
+
+      state :multiline_regex_end do
+        rule %r(//([gimy]+\b|\B)), Str::Regex, :pop!
+      end
+
+      state :multiline_regex do
+        mixin :multiline_regex_end
+        mixin :regex_comment
+        mixin :interpolation
+        mixin :code_escape
+        rule %r/\\\D/, Str::Escape
+        rule %r/\\\d+/, Name::Variable
+        rule %r/./m, Str::Regex
+      end
+
+      state :regex_comment do
+        rule %r/^#(\s+.*)?$/, Comment::Single
+        rule %r/(\s+)(#)(\s+.*)?$/ do
+          groups Text, Comment::Single, Comment::Single
+        end
+      end
+
+      state :comments do
+        rule %r(/\*.*?\*/)m, Comment::Multiline
+        rule %r/#.*$/, Comment::Single
+      end
+
+      state :switch_underscore do
+        mixin :whitespace_single_line
+        rule %r/_(?=\s*=>|\s+then\b)/, Keyword
+        rule(//) { pop! }
+      end
+
+      state :loop_control do
+        mixin :whitespace_single_line
+        rule %r/#{id}(?=[);\n])/, Name::Label
+        rule(//) { pop! }
+      end
+
+      state :id do
+        rule %r/[!?]|[.](?!=)/, Punctuation
+        rule %r/[{]/ do
+          # destructuring
+          token Punctuation
+          push do
+            rule %r/[,;]/, Punctuation
+            rule %r/#{id}/, Name::Attribute
+            rule %r/#{int}/, Num::Integer
+            mixin :whitespace
+            rule %r/[}]/, Punctuation, :pop!
+          end
+        end
+        rule %r/#{id}/, Name::Attribute
+        rule %r/#{int}/, Num::Integer
+        rule(//) { goto :slash_starts_regex }
+      end
+
+      state :strings do
+        # all strings are multi-line
+        rule %r/[^#\\'"]+/m, Str
+        mixin :code_escape
+        rule %r/\\./, Str::Escape
+        rule %r/#/, Str
+      end
+
+      state :double_strings do
+        rule %r/'/, Str
+        mixin :interpolation
+        mixin :strings
+      end
+
+      state :single_strings do
+        rule %r/"/, Str
+        mixin :strings
+      end
+    end
+  end
+end

data/rouge-5.0.0/lib/rouge/lexers/llvm/keywords.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+# DO NOT EDIT
+# This file is automatically generated by `rake builtins:llvm`.
+# See tasks/builtins/llvm.rake for more info.
+
+module Rouge
+  module Lexers
+    class LLVM
+      KEYWORDS = Set.new ["aarch64_sve_vector_pcs", "aarch64_vector_pcs", "acq_rel", "acquire", "addrspace", "afn", "alias", "aliasee", "align", "alignLog2", "alignstack", "allOnes", "allocalign", "allocptr", "allocsize", "alwaysInline", "alwaysinline", "amdgpu_cs", "amdgpu_es", "amdgpu_gfx", "amdgpu_gs", "amdgpu_hs", "amdgpu_kernel", "amdgpu_ls", "amdgpu_ps", "amdgpu_vs", "any", "anyregcc", "appending", "arcp", "argmemonly", "args", "arm_aapcs_vfpcc", "arm_aapcscc", "arm_apcscc", "asm", "async", "atomic", "attributes", "available_externally", "avr_intrcc", "avr_signalcc", "bit", "bitMask", "blockaddress", "blockcount", "branchFunnel", "builtin", "byArg", "byref", "byte", "byteArray", "byval", "c", "callee", "caller", "calls", "canAutoHide", "catch", "cc", "ccc", "cfguard_checkcc", "cleanup", "cold", "coldcc", "comdat", "common", "constant", "contract", "convergent", "critical", "cxx_fast_tlscc", "datalayout", "declare", "default", "define", "dereferenceable", "dereferenceable_or_null", "disable_sanitizer_instrumentation", "distinct", "dllexport", "dllimport", "dsoLocal", "dso_local", "dso_local_equivalent", "dso_preemptable", "elementtype", "eq", "exact", "exactmatch", "extern_weak", "external", "externally_initialized", "false", "fast", "fastcc", "filter", "flags", "from", "funcFlags", "function", "gc", "ghccc", "global", "guid", "gv", "hasUnknownCall", "hash", "hhvm_ccc", "hhvmcc", "hidden", "hot", "hotness", "ifunc", "immarg", "inaccessiblemem_or_argmemonly", "inaccessiblememonly", "inalloca", "inbounds", "indir", "info", "initialexec", "inline", "inlineBits", "inlinehint", "inrange", "inreg", "insts", "intel_ocl_bicc", "inteldialect", "internal", "jumptable", "kind", "largest", "linkage", "linkonce", "linkonce_odr", "live", "local_unnamed_addr", "localdynamic", "localexec", "max", "mayThrow", "min", "minsize", "module", "monotonic", "msp430_intrcc", "mustBeUnreachable", "mustprogress", "musttail", "naked", "name", "nand", "ne", "nest", "ninf", "nnan", "noInline", "noRecurse", "noUnwind", "no_cfi", "noalias", "nobuiltin", "nocallback", "nocapture", "nocf_check", "nodeduplicate", "noduplicate", "nofree", "noimplicitfloat", "noinline", "nomerge", "none", "nonlazybind", "nonnull", "noprofile", "norecurse", "noredzone", "noreturn", "nosanitize_bounds", "nosanitize_coverage", "nosync", "notEligibleToImport", "notail", "noundef", "nounwind", "nsw", "nsz", "null", "null_pointer_is_valid", "nuw", "oeq", "offset", "oge", "ogt", "ole", "olt", "one", "opaque", "optforfuzzing", "optnone", "optsize", "ord", "param", "params", "partition", "path", "personality", "poison", "preallocated", "prefix", "preserve_allcc", "preserve_mostcc", "private", "prologue", "protected", "ptx_device", "ptx_kernel", "readNone", "readOnly", "readnone", "readonly", "reassoc", "refs", "relbf", "release", "resByArg", "returnDoesNotAlias", "returned", "returns_twice", "safestack", "samesize", "sanitize_address", "sanitize_hwaddress", "sanitize_memory", "sanitize_memtag", "sanitize_thread", "section", "seq_cst", "sge", "sgt", "shadowcallstack", "sideeffect", "signext", "single", "singleImpl", "singleImplName", "sizeM1", "sizeM1BitWidth", "sle", "slt", "source_filename", "speculatable", "speculative_load_hardening", "spir_func", "spir_kernel", "sret", "ssp", "sspreq", "sspstrong", "strictfp", "summaries", "summary", "swiftasync", "swiftcc", "swifterror", "swiftself", "swifttailcc", "sync", "syncscope", "tail", "tailcc", "target", "thread_local", "to", "triple", "true", "type", "typeCheckedLoadConstVCalls", "typeCheckedLoadVCalls", "typeIdInfo", "typeTestAssumeConstVCalls", "typeTestAssumeVCalls", "typeTestRes", "typeTests", "typeid", "typeidCompatibleVTable", "ueq", "uge", "ugt", "ule", "ult", "umax", "umin", "undef", "une", "uniformRetVal", "uniqueRetVal", "unknown", "unnamed_addr", "uno", "unordered", "unsat", "unwind", "uselistorder", "uselistorder_bb", "uwtable", "vFuncId", "vTableFuncs", "varFlags", "variable", "vcall_visibility", "virtFunc", "virtualConstProp", "visibility", "volatile", "vscale", "vscale_range", "weak", "weak_odr", "webkit_jscc", "willreturn", "win64cc", "within", "wpdRes", "wpdResolutions", "writeonly", "x", "x86_64_sysvcc", "x86_fastcallcc", "x86_intrcc", "x86_regcallcc", "x86_stdcallcc", "x86_thiscallcc", "x86_vectorcallcc", "xchg", "zeroext", "zeroinitializer"]
+      TYPES = Set.new ["bfloat", "double", "float", "fp128", "half", "label", "metadata", "ppc_fp128", "ptr", "token", "void", "x86_amx", "x86_fp80", "x86_mmx"]
+      INSTRUCTIONS = Set.new ["add", "addrspacecast", "alloca", "and", "ashr", "atomicrmw", "bitcast", "br", "call", "callbr", "catchpad", "catchret", "catchswitch", "cleanuppad", "cleanupret", "cmpxchg", "extractelement", "extractvalue", "fadd", "fcmp", "fdiv", "fence", "fmul", "fneg", "fpext", "fptosi", "fptoui", "fptrunc", "freeze", "frem", "fsub", "getelementptr", "icmp", "indirectbr", "insertelement", "insertvalue", "inttoptr", "invoke", "landingpad", "load", "lshr", "mul", "or", "phi", "ptrtoint", "resume", "ret", "sdiv", "select", "sext", "shl", "shufflevector", "sitofp", "srem", "store", "sub", "switch", "trunc", "udiv", "uitofp", "unreachable", "urem", "va_arg", "xor", "zext"]
+    end
+  end
+end

data/rouge-5.0.0/lib/rouge/lexers/llvm.rb

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class LLVM < RegexLexer
+      title "LLVM"
+      desc 'The LLVM Compiler Infrastructure (http://llvm.org/)'
+      tag 'llvm'
+
+      filenames '*.ll'
+      mimetypes 'text/x-llvm'
+
+      string = /"[^"]*?"/
+      identifier = /([-a-zA-Z$._][-a-zA-Z$._0-9]*|#{string})/
+
+      lazy do
+        require_relative 'llvm/keywords'
+      end
+
+      state :basic do
+        rule %r/;.*?$/, Comment::Single
+        rule %r/\s+/, Text
+
+        rule %r/#{identifier}\s*:/, Name::Label
+
+        rule %r/@(#{identifier}|\d+)/, Name::Variable::Global
+        rule %r/#\d+/, Name::Variable::Global
+        rule %r/(%|!)#{identifier}/, Name::Variable
+        rule %r/(%|!)\d+/, Name::Variable
+
+        rule %r/c?#{string}/, Str
+
+        rule %r/0[xX][a-fA-F0-9]+/, Num
+        rule %r/-?\d+(?:[.]\d+)?(?:[eE][-+]?\d+(?:[.]\d+)?)?/, Num
+
+        rule %r/[=<>{}\[\]()*.,!]|x/, Punctuation
+      end
+
+      state :root do
+        mixin :basic
+
+        rule %r/i[1-9]\d*/, Keyword::Type
+
+        rule %r/\w+/ do |m|
+          if TYPES.include? m[0]
+            token Keyword::Type
+          elsif INSTRUCTIONS.include? m[0]
+            token Keyword
+          elsif KEYWORDS.include? m[0]
+            token Keyword
+          else
+            token Error
+          end
+        end
+      end
+    end
+  end
+end

data/rouge-5.0.0/lib/rouge/lexers/lua/keywords.rb

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+# DO NOT EDIT
+
+# This file is automatically generated by `rake builtins:lua`.
+# See tasks/builtins/lua.rake for more info.
+
+module Rouge
+  module Lexers
+    class Lua
+      BUILTINS = {}.tap do |b|
+        b["basic"] = Set["_g", "_version", "assert", "collectgarbage", "dofile", "error", "file:close", "file:flush", "file:lines", "file:read", "file:seek", "file:setvbuf", "file:write", "getmetatable", "ipairs", "load", "loadfile", "lua_cpath", "lua_cpath_5_3", "lua_errerr", "lua_errfile", "lua_errgcmm", "lua_errmem", "lua_errrun", "lua_errsyntax", "lua_hookcall", "lua_hookcount", "lua_hookline", "lua_hookret", "lua_hooktailcall", "lua_init", "lua_init_5_3", "lua_maskcall", "lua_maskcount", "lua_maskline", "lua_maskret", "lua_maxinteger", "lua_mininteger", "lua_minstack", "lua_multret", "lua_noref", "lua_ok", "lua_opadd", "lua_opband", "lua_opbnot", "lua_opbor", "lua_opbxor", "lua_opdiv", "lua_opeq", "lua_opidiv", "lua_ople", "lua_oplt", "lua_opmod", "lua_opmul", "lua_oppow", "lua_opshl", "lua_opshr", "lua_opsub", "lua_opunm", "lua_path", "lua_path_5_3", "lua_refnil", "lua_registryindex", "lua_ridx_globals", "lua_ridx_mainthread", "lua_tboolean", "lua_tfunction", "lua_tlightuserdata", "lua_tnil", "lua_tnone", "lua_tnumber", "lua_tstring", "lua_ttable", "lua_tthread", "lua_tuserdata", "lua_use_apicheck", "lua_yield", "lual_buffersize", "luaopen_base", "luaopen_coroutine", "luaopen_debug", "luaopen_io", "luaopen_math", "luaopen_os", "luaopen_package", "luaopen_string", "luaopen_table", "luaopen_utf8", "next", "pairs", "pcall", "print", "rawequal", "rawget", "rawlen", "rawset", "select", "setmetatable", "tonumber", "tostring", "type", "xpcall"]
+        b["modules"] = Set["package.config", "package.cpath", "package.loaded", "package.loadlib", "package.path", "package.preload", "package.searchers", "package.searchpath", "require"]
+        b["coroutine"] = Set["coroutine.create", "coroutine.isyieldable", "coroutine.resume", "coroutine.running", "coroutine.status", "coroutine.wrap", "coroutine.yield"]
+        b["debug"] = Set["debug.debug", "debug.gethook", "debug.getinfo", "debug.getlocal", "debug.getmetatable", "debug.getregistry", "debug.getupvalue", "debug.getuservalue", "debug.sethook", "debug.setlocal", "debug.setmetatable", "debug.setupvalue", "debug.setuservalue", "debug.traceback", "debug.upvalueid", "debug.upvaluejoin"]
+        b["io"] = Set["io.close", "io.flush", "io.input", "io.lines", "io.open", "io.output", "io.popen", "io.read", "io.stderr", "io.stdin", "io.stdout", "io.tmpfile", "io.type", "io.write"]
+        b["math"] = Set["math.abs", "math.acos", "math.asin", "math.atan", "math.ceil", "math.cos", "math.deg", "math.exp", "math.floor", "math.fmod", "math.huge", "math.log", "math.max", "math.maxinteger", "math.min", "math.mininteger", "math.modf", "math.pi", "math.rad", "math.random", "math.randomseed", "math.sin", "math.sqrt", "math.tan", "math.tointeger", "math.type", "math.ult"]
+        b["os"] = Set["os.clock", "os.date", "os.difftime", "os.execute", "os.exit", "os.getenv", "os.remove", "os.rename", "os.setlocale", "os.time", "os.tmpname"]
+        b["string"] = Set["string.byte", "string.char", "string.dump", "string.find", "string.format", "string.gmatch", "string.gsub", "string.len", "string.lower", "string.match", "string.pack", "string.packsize", "string.rep", "string.reverse", "string.sub", "string.unpack", "string.upper"]
+        b["table"] = Set["table.concat", "table.insert", "table.move", "table.pack", "table.remove", "table.sort", "table.unpack"]
+        b["utf8"] = Set["utf8.char", "utf8.charpattern", "utf8.codepoint", "utf8.codes", "utf8.len", "utf8.offset"]
+      end
+    end
+  end
+end

data/rouge-5.0.0/lib/rouge/lexers/lua.rb

@@ -0,0 +1,186 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Lua < RegexLexer
+      title "Lua"
+      desc "Lua (http://www.lua.org)"
+      tag 'lua'
+      filenames '*.lua', '*.wlua'
+
+      mimetypes 'text/x-lua', 'application/x-lua'
+
+      option :function_highlighting, 'Whether to highlight builtin functions (default: true)'
+      option :disabled_modules, 'builtin modules to disable'
+
+      lazy auto: false do
+        require_relative 'lua/keywords'
+      end
+
+      def initialize(opts={})
+        @function_highlighting = opts.delete(:function_highlighting) { true }
+        @disabled_modules = opts.delete(:disabled_modules) { [] }
+        super(opts)
+
+        self.class.eager_load! if @function_highlighting
+      end
+
+      def self.detect?(text)
+        return true if text.shebang? 'lua'
+      end
+
+      def builtins
+        return [] unless @function_highlighting
+
+        @builtins ||= Set.new.tap do |builtins|
+          BUILTINS.each do |mod, fns|
+            next if @disabled_modules.include? mod
+            builtins.merge(fns)
+          end
+        end
+      end
+
+      state :root do
+        # lua allows a file to start with a shebang
+        rule %r(#!(.*?)$), Comment::Preproc
+        rule %r//, Text, :base
+      end
+
+      state :base do
+        rule %r(--\[(=*)\[.*?\]\1\])m, Comment::Multiline
+        rule %r(--.*$), Comment::Single
+
+        rule %r((?i)(\d*\.\d+|\d+\.\d*)(e[+-]?\d+)?'), Num::Float
+        rule %r((?i)\d+e[+-]?\d+), Num::Float
+        rule %r((?i)0x[0-9a-f]*), Num::Hex
+        rule %r(\d+), Num::Integer
+
+        rule %r(\n), Text
+        rule %r([^\S\n]), Text
+        # multiline strings
+        rule %r(\[(=*)\[.*?\]\1\])m, Str
+
+        rule %r((==|~=|<=|>=|\.\.\.|\.\.|[=+\-*/%^<>#])), Operator
+        rule %r([\[\]\{\}\(\)\.,:;]), Punctuation
+        rule %r((and|or|not)\b), Operator::Word
+
+        rule %r((break|do|else|elseif|end|for|if|in|repeat|return|then|until|while)\b), Keyword
+        rule %r((local)\b), Keyword::Declaration
+        rule %r((true|false|nil)\b), Keyword::Constant
+
+        rule %r((function)\b), Keyword, :function_name
+
+        rule %r([A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)?) do |m|
+          name = m[0]
+          if name == "gsub"
+            token Name::Builtin
+            push :gsub
+          elsif self.builtins.include?(name)
+            token Name::Builtin
+          elsif name.include?('.')
+            a, b = name.split('.', 2)
+            token Name, a
+            token Punctuation, '.'
+            token Name, b
+          else
+            token Name
+          end
+        end
+
+        rule %r('), Str::Single, :escape_sqs
+        rule %r("), Str::Double, :escape_dqs
+      end
+
+      state :function_name do
+        rule %r/\s+/, Text
+        rule %r((?:([A-Za-z_][A-Za-z0-9_]*)(\.))?([A-Za-z_][A-Za-z0-9_]*)) do
+          groups Name::Class, Punctuation, Name::Function
+          pop!
+        end
+        # inline function
+        rule %r(\(), Punctuation, :pop!
+      end
+
+      state :gsub do
+        rule %r/\)/, Punctuation, :pop!
+        rule %r/[(,]/, Punctuation
+        rule %r/\s+/, Text
+        rule %r/'/, Str::Regex, :regex_sq
+        rule %r/"/, Str::Regex, :regex_dq
+      end
+
+      state :regex_sq do
+        rule %r(') do
+          token Str::Regex
+          goto :regex_end
+        end
+
+        mixin :regex
+      end
+
+      state :regex_dq do
+        rule %r(") do
+          token Str::Regex
+          goto :regex_end
+        end
+
+        mixin :regex
+      end
+
+      state :regex do
+        rule %r(") do
+          token Str::Regex
+          goto :regex_end
+        end
+
+        rule %r/\[\^?/, Str::Escape, :regex_group
+        rule %r/\\./, Str::Escape
+        rule %r{[(][?][:=<!]}, Str::Escape
+        rule %r/[{][\d,]+[}]/, Str::Escape
+        rule %r/[()?]/, Str::Escape
+        rule %r/./, Str::Regex
+      end
+
+      state :regex_end do
+        rule %r/[$]+/, Str::Regex, :pop!
+        rule(//) { pop! }
+      end
+
+      state :regex_group do
+        rule %r(/), Str::Escape
+        rule %r/\]/, Str::Escape, :pop!
+        rule %r/(\\)(.)/ do |m|
+          groups Str::Escape, Str::Regex
+        end
+        rule %r/./, Str::Regex
+      end
+
+      state :escape_sqs do
+        mixin :string_escape
+        mixin :sqs
+      end
+
+      state :escape_dqs do
+        mixin :string_escape
+        mixin :dqs
+      end
+
+      state :string_escape do
+        rule %r(\\([abfnrtv\\"']|\d{1,3})), Str::Escape
+      end
+
+      state :sqs do
+        rule %r(\\'), Str::Escape
+        rule %r('), Str::Single, :pop!
+        rule %r([^'\\]+), Str::Single
+      end
+
+      state :dqs do
+        rule %r(\\"), Str::Escape
+        rule %r("), Str::Double, :pop!
+        rule %r([^"\\]+), Str::Double
+      end
+    end
+  end
+end