nano-max-hub 0.0.1

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

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class OpenTypeFeatureFile < RegexLexer
+      title "OpenType Feature File"
+      desc "Feature specifications for an OpenType font (adobe-type-tools.github.io/afdko)"
+      tag 'opentype_feature_file'
+      aliases 'fea', 'opentype', 'opentypefeature'
+      filenames '*.fea'
+
+      def self.keywords
+        @keywords ||= %w(
+          Ascender Attach AxisValue CapHeight CaretOffset CodePageRange
+          DesignAxis Descender ElidedFallbackName ElidedFallbackNameID
+          ElidableAxisValueName FeatUILabelNameID FeatUITooltipTextNameID
+          FontRevision FSType GlyphClassDef HorizAxis.BaseScriptList
+          HorizAxis.BaseTagList HorizAxis.MinMax IgnoreBaseGlyphs
+          IgnoreLigatures IgnoreMarks LigatureCaretByDev LigatureCaretByIndex
+          LigatureCaretByPos LineGap MarkAttachClass MarkAttachmentType NULL
+          OlderSiblingFontAttribute Panose ParamUILabelNameID RightToLeft
+          SampleTextNameID TypoAscender TypoDescender TypoLineGap UnicodeRange
+          UseMarkFilteringSet Vendor VertAdvanceY VertAxis.BaseScriptList
+          VertAxis.BaseTagList VertAxis.MinMax VertOriginY VertTypoAscender
+          VertTypoDescender VertTypoLineGap WeightClass WidthClass XHeight
+
+          anchorDef anchor anonymous anon by contour cursive device enumerate
+          enum exclude_dflt featureNames feature flag from ignore include_dflt
+          include languagesystem language location lookupflag lookup markClass
+          mark nameid name parameters position pos required reversesub rsub
+          script sizemenuname substitute subtable sub table useExtension
+          valueRecordDef winAscent winDescent
+        )
+      end
+
+
+      identifier = %r/[a-z_][a-z0-9\/_.-]*/i
+
+      state :root do
+        rule %r/\s+/m, Text::Whitespace
+        rule %r/#.*$/, Comment
+
+        # feature <tag>
+        rule %r/(anonymous|anon|feature|lookup|table)((?:\s)+)/ do
+          groups Keyword, Text
+          push :featurename
+        end
+        # } <tag> ;
+        rule %r/(\})((?:\s))/ do
+          groups Punctuation, Text
+          push :featurename
+        end
+        # solve include( ../path)
+        rule %r/include\b/i, Keyword, :includepath
+
+        rule %r/[\-\[\]\/(){},.:;=%*<>']/, Punctuation
+
+        rule %r/`.*?/, Str::Backtick
+        rule %r/\"/, Str, :strings
+        rule %r/\\[^.*\s]+/i, Str::Escape
+
+        # classes, start with @<nameOfClass>
+        rule %r/@#{identifier}/, Name::Class
+
+        # using negative lookbehind so we don't match property names
+        rule %r/(?<!\.)#{identifier}/ do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+          else
+            token Name
+          end
+        end
+
+        rule identifier, Name
+        rule %r/(?:0x|\\)[0-9A-Fa-f]+/, Num::Hex
+        rule %r/-?\d+/, Num::Integer
+      end
+
+      state :featurename do
+        rule identifier, Name::Function, :pop!
+      end
+
+      state :includepath do
+        rule %r/\s+/, Text::Whitespace
+        rule %r/\)/, Punctuation, :pop!
+        rule %r/\(/, Punctuation
+        rule %r/[^\s()]+/, Str
+      end
+
+      state :strings do
+        rule %r/"/, Str, :pop!
+        rule %r/[^"%\n]+/, Str
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class P4 < RegexLexer
+      tag 'p4'
+      title 'P4'
+      desc 'The P4 programming language'
+      filenames '*.p4'
+      mimetypes 'text/x-p4'
+
+      def self.keywords
+        @keywords ||= %w(
+          abstract action actions apply const default default_action else enum
+          entries extern exit if in inout key list out package packet_in
+          packet_out return size select switch this transition tuple type
+          typedef
+        )
+      end
+
+      def self.operators
+        @operators ||= %w(
+          \|\+\| \|-\| \? \& \&\&\& < > << >> \* \| ~ \^ - \+ /
+          \# \. = != <= >= \+\+
+        )
+      end
+
+      def self.decls
+        @decls ||= %w(
+          control header header_union parser state struct table
+          value_set
+        )
+      end
+
+      def self.builtins
+        @builtins ||= %w(
+          bit bool error extract int isValid setValid setInvalid match_kind
+          string varbit verify void
+        )
+      end
+
+      state :whitespace do
+        rule %r/\s+/m, Text
+      end
+
+      state :comment do
+        rule %r((//).*$\n?), Comment::Single
+        rule %r/\/\*(?:(?!\*\/).)*\*\//m, Comment::Multiline
+      end
+
+      state :number do
+        rule %r/([0-9]+[sw])?0[oO][0-7_]+/, Num
+        rule %r/([0-9]+[sw])?0[xX][0-9a-fA-F_]+/, Num
+        rule %r/([0-9]+[sw])?0[bB][01_]+/, Num
+        rule %r/([0-9]+[sw])?0[dD][0-9_]+/, Num
+        rule %r/([0-9]+[sw])?[0-9_]+/, Num
+      end
+
+      id = /[\p{XID_Start}_]\p{XID_Continue}*/
+      string_element  = /\\"|[^"]/x
+
+      state :root do
+        mixin :whitespace
+        mixin :comment
+
+        rule %r/#\s*#{id}/, Comment::Preproc
+        rule %r/\b(?:#{P4.keywords.join('|')})\b/, Keyword
+        rule %r/\b(?:#{P4.decls.join('|')})\b/, Keyword::Declaration
+        rule %r/\b(?:#{P4.builtins.join('|')})\b/, Name::Builtin
+        rule %r/\b#{id}_[th]\b/x, Name::Class
+        rule %r/(?:#{P4.operators.join('|')})/x, Operator
+        rule %r/[(){}\[\]<>,:;\.]/, Punctuation
+        mixin :number
+        rule %r/@#{id}/x, Name::Label
+        rule %r/#{id}/x, Text
+        rule %r/"(?: #{string_element} )*"/x, Str::String
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Pascal < RegexLexer
+      tag 'pascal'
+      title "Pascal"
+      desc 'a procedural programming language commonly used as a teaching language.'
+      filenames '*.pas', '*.lpr', '*.pp'
+
+      mimetypes 'text/x-pascal'
+
+      id = /@?[_a-z]\w*/i
+
+      keywords = %w(
+        absolute abstract all and and_then array as asm assembler attribute
+        begin bindable case class const constructor delay destructor div do
+        downto else end except exit export exports external far file finalization
+        finally for forward function goto if implementation import in inc index
+        inherited initialization inline interface interrupt is label library
+        message mod module near nil not object of on only operator or or_else
+        otherwise out overload override packed pascal pow private procedure program
+        property protected public published qualified raise read record register
+        repeat resident resourcestring restricted safecall segment set shl shr
+        stdcall stored string then threadvar to try type unit until uses value var
+        view virtual while with write writeln xor
+      )
+
+      keywords_type = %w(
+        ansichar ansistring bool boolean byte bytebool cardinal char comp currency
+        double dword extended int64 integer iunknown longbool longint longword pansichar
+        pansistring pbool pboolean pbyte pbytearray pcardinal pchar pcomp pcurrency
+        pdate pdatetime pdouble pdword pextended phandle pint64 pinteger plongint plongword
+        pointer ppointer pshortint pshortstring psingle psmallint pstring pvariant pwidechar
+        pwidestring pword pwordarray pwordbool real real48 shortint shortstring single
+        smallint string tclass tdate tdatetime textfile thandle tobject ttime variant
+        widechar widestring word wordbool
+      )
+
+      state :whitespace do
+        # Spaces
+        rule %r/\s+/m, Text
+        # // Comments
+        rule %r((//).*$\n?), Comment::Single
+        # -- Comments
+        rule %r((--).*$\n?), Comment::Single
+        # (* Comments *)
+        rule %r(\(\*.*?\*\))m, Comment::Multiline
+        # { Comments }
+        rule %r(\{.*?\})m, Comment::Multiline
+      end
+
+      state :root do
+        mixin :whitespace
+
+        rule %r{((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)(L|l|UL|ul|u|U|F|f|ll|LL|ull|ULL)?}, Num
+        rule %r/\$[0-9A-Fa-f]+/, Num::Hex
+        rule %r{[~!@#\$%\^&\*\(\)\+`\-={}\[\]:;<>\?,\.\/\|\\]}, Punctuation
+        rule %r{'([^']|'')*'}, Str
+        rule %r/(true|false|nil)\b/i, Name::Builtin
+        rule %r/\b(#{keywords.join('|')})\b/i, Keyword
+        rule %r/\b(#{keywords_type.join('|')})\b/i, Keyword::Type
+        rule id, Name
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+# vim: set ts=2 sw=2 et:
+
+# PDF = Portable Document Format page description language
+# As defined by ISO 32000-2:2020 including resolved errata from https://pdf-issues.pdfa.org/
+#
+# The PDF syntax is also known as "COS" and can be used with FDF (Forms Data Field) files as
+# per ISO 32000-2:2020 clause 12.7.8.
+#
+# This is a token-based parser ONLY! It is intended to syntax highlight full or partial fragments
+# of nicely written hand-written PDF syntax in documentation such as ISO specifications. It is NOT
+# intended to cope with real-world PDFs that will contain arbitrary binary data (that form invalid
+# UTF-8 sequences and generate "ArgumentError: invalid byte sequence in UTF-8" Ruby errors) and
+# other types of malformations or syntax errors.
+#
+# Author: Peter Wyatt, CTO, PDF Association. 2024
+#
+module Rouge
+  module Lexers
+    class Pdf < RegexLexer
+      title "PDF"
+      desc "PDF - Portable Document Format (ISO 32000)"
+      tag 'pdf'
+      aliases "fdf", 'cos'
+      filenames '*.pdf', '*.fdf'
+      mimetypes 'application/pdf', 'application/fdf' # IANA registered media types
+
+      # PDF and FDF files must start with "%PDF-x.y" or "%FDF-x.y"
+      # where x is the single digit major version and y is the single digit minor version.
+      # For simplicity as a syntax highlighter, assumes occurs at start of a line.
+      def self.detect?(text)
+        return true if /\A%(P|F)DF-\d\.\d/.match?(text)
+      end
+
+      # PDF Delimiters (ISO 32000-2:2020, Table 1 and Table 2).
+      # Ruby whitespace "\s" is /[ \t\r\n\f\v]/ which does not include NUL (ISO 32000-2:2020, Table 1).
+      # PDF also support 2 character EOL sequences.
+
+      state :root do
+        # Start-of-file header comment is special (comment is up to EOL)
+        rule %r/^%(P|F)DF-\d\.\d.*$/, Comment::Preproc
+
+        # End-of-file marker comment is special (comment is up to EOL)
+        rule %r/^%%EOF.*$/, Comment::Preproc
+
+        # PDF only has single-line comments: from "%" to EOL
+        rule %r/%.*$/, Comment::Single
+
+        # PDF Boolean and null object keywords
+        rule %r/(false|true|null)/, Keyword::Constant
+
+        # PDF Dictionary and array object start and end tokens
+        rule %r/(<<|>>|\[|\])/, Punctuation
+
+        # PDF Hex string - can contain whitespace and span multiple lines.
+        # This rule must be after "<<"/">>"
+        rule %r/<[0-9A-Fa-f\s]*>/m, Str::Other
+
+        # PDF literal strings are complex (multi-line, escapes, etc.). Use separate state machine.
+        rule %r/\(/, Str, :stringliteral
+
+        # PDF Name objects - can be empty (i.e., nothing after "/").
+        # No special processing required for 2-digit hex codes that start with "#".
+        rule %r/\/[^\(\)<>\[\]\/%\s]*/, Name::Other
+
+        # PDF objects and stream (no checking of object ID)
+        # Note that object number and generation numbers do not have sign.
+        rule %r/\d+\s\d+\sobj/, Keyword::Declaration
+        rule %r/endstream|endobj|stream/, Keyword::Declaration
+
+        # PDF conventional file layout keywords
+        rule %r/startxref|trailer|xref/, Keyword::Declaration
+
+        # PDF cross reference section entries (20 bytes including EOL).
+        # Explicit single SPACE separators.
+        rule %r/^\d{10} \d{5} (n|f)\s*$/, Keyword::Namespace
+
+        # PDF Indirect reference (lax, allows zero as the object number).
+        # Requires terminating delimiter lookahead to disambiguate from "RG" operator
+        rule %r/\d+\s\d+\sR(?=[\(\)<>\[\]\/%\s])/, Name::Decorator
+
+        # PDF Real object
+        rule %r/(\-|\+)?([0-9]+\.?|[0-9]*\.[0-9]+|[0-9]+\.[0-9]*)/, Num::Float
+
+        # PDF Integer object
+        rule %r/(\-|\+)?[0-9]+/, Num::Integer
+
+        # A run of non-delimiters is most likely a PDF content stream
+        # operator (ISO 32000-2:2020, Annex A).
+        rule %r/[^\(\)<>\[\]\/%\s]+/, Operator::Word
+
+        # Whitespace (except inside strings and comments) is ignored = /[ \t\r\n\f\v]/.
+        # Ruby doesn't include NUL as whitespace (vs ISO 32000-2:2020 Table 1)
+        rule %r/\s+/, Text::Whitespace
+      end
+
+      # PDF literal string. See ISO 32000-2:2020 clause 7.3.4.2 and Table 3
+      state :stringliteral do
+        rule %r/\(/, Str, :stringliteral             # recursive for internal bracketed strings
+        rule %r/\\\(/, Str::Escape, :stringliteral   # recursive for internal escaped bracketed strings
+        rule %r/\)/, Str, :pop!
+        rule %r/\\\)/, Str::Escape, :pop!
+        rule %r/\\([0-7]{3}|n|r|t|b|f|\\)/, Str::Escape
+        rule %r/[^\(\)\\]+/, Str
+      end
+    end
+  end
+end

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

@@ -0,0 +1,251 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Perl < RegexLexer
+      title "Perl"
+      desc "The Perl scripting language (perl.org)"
+
+      tag 'perl'
+      aliases 'pl'
+
+      filenames '*.pl', '*.pm', '*.t'
+      mimetypes 'text/x-perl', 'application/x-perl'
+
+      def self.detect?(text)
+        return true if text.shebang? 'perl'
+      end
+
+      keywords = %w(
+        case continue do else elsif for foreach if last my next our
+        redo reset then unless until while use print new BEGIN CHECK
+        INIT END return
+      )
+
+      builtins = %w(
+        abs accept alarm atan2 bind binmode bless caller chdir chmod
+        chomp chop chown chr chroot close closedir connect continue cos
+        crypt dbmclose dbmopen defined delete die dump each endgrent
+        endhostent endnetent endprotoent endpwent endservent eof eval
+        exec exists exit exp fcntl fileno flock fork format formline getc
+        getgrent getgrgid getgrnam gethostbyaddr gethostbyname gethostent
+        getlogin getnetbyaddr getnetbyname getnetent getpeername
+        getpgrp getppid getpriority getprotobyname getprotobynumber
+        getprotoent getpwent getpwnam getpwuid getservbyname getservbyport
+        getservent getsockname getsockopt glob gmtime goto grep hex
+        import index int ioctl join keys kill last lc lcfirst length
+        link listen local localtime log lstat map mkdir msgctl msgget
+        msgrcv msgsnd my next no oct open opendir ord our pack package
+        pipe pop pos printf prototype push quotemeta rand read readdir
+        readline readlink readpipe recv redo ref rename require reverse
+        rewinddir rindex rmdir scalar seek seekdir select semctl semget
+        semop send setgrent sethostent setnetent setpgrp setpriority
+        setprotoent setpwent setservent setsockopt shift shmctl shmget
+        shmread shmwrite shutdown sin sleep socket socketpair sort splice
+        split sprintf sqrt srand stat study substr symlink syscall sysopen
+        sysread sysseek system syswrite tell telldir tie tied time times
+        tr truncate uc ucfirst umask undef unlink unpack unshift untie
+        utime values vec wait waitpid wantarray warn write
+      )
+
+      re_tok = Str::Regex
+
+      state :balanced_regex do
+        rule %r(/(\\[\\/]|[^/])*/[egimosx]*)m, re_tok, :pop!
+        rule %r(!(\\[\\!]|[^!])*![egimosx]*)m, re_tok, :pop!
+        rule %r(\\(\\\\|[^\\])*\\[egimosx]*)m, re_tok, :pop!
+        rule %r({(\\[\\}]|[^}])*}[egimosx]*), re_tok, :pop!
+        rule %r(<(\\[\\>]|[^>])*>[egimosx]*), re_tok, :pop!
+        rule %r(\[(\\[\\\]]|[^\]])*\][egimosx]*), re_tok, :pop!
+        rule %r[\((\\[\\\)]|[^\)])*\)[egimosx]*], re_tok, :pop!
+        rule %r(@(\\[\\@]|[^@])*@[egimosx]*), re_tok, :pop!
+        rule %r(%(\\[\\%]|[^%])*%[egimosx]*), re_tok, :pop!
+        rule %r(\$(\\[\\\$]|[^\$])*\$[egimosx]*), re_tok, :pop!
+      end
+
+      state :root do
+        rule %r/#.*/, Comment::Single
+        rule %r/^=[a-zA-Z0-9]+\s+.*?\n=cut/m, Comment::Multiline
+        rule %r/(?:#{keywords.join('|')})\b/, Keyword
+
+        rule %r/(format)(\s+)([a-zA-Z0-9_]+)(\s*)(=)(\s*\n)/ do
+          groups Keyword, Text, Name, Text, Punctuation, Text
+
+          push :format
+        end
+
+        rule %r/(?:eq|lt|gt|le|ge|ne|not|and|or|cmp)\b/, Operator::Word
+
+        # substitution/transliteration: balanced delimiters
+        rule %r((?:s|tr|y){(\\\\|\\}|[^}])*}\s*), re_tok, :balanced_regex
+        rule %r((?:s|tr|y)<(\\\\|\\>|[^>])*>\s*), re_tok, :balanced_regex
+        rule %r((?:s|tr|y)\[(\\\\|\\\]|[^\]])*\]\s*), re_tok, :balanced_regex
+        rule %r[(?:s|tr|y)\((\\\\|\\\)|[^\)])*\)\s*], re_tok, :balanced_regex
+
+        # substitution/transliteration: arbitrary non-whitespace delimiters
+        rule %r((?:s|tr|y)\s*([^\w\s])((\\\\|\\\1)|[^\1])*?\1((\\\\|\\\1)|[^\1])*?\1[msixpodualngcr]*)m, re_tok
+        rule %r((?:s|tr|y)\s+(\w)((\\\\|\\\1)|[^\1])*?\1((\\\\|\\\1)|[^\1])*?\1[msixpodualngcr]*)m, re_tok
+
+        # matches: common case, m-optional
+        rule %r(m?/(\\\\|\\/|[^/\n])*/[msixpodualngc]*), re_tok
+        rule %r(m(?=[/!\\{<\[\(@%\$])), re_tok, :balanced_regex
+
+        # arbitrary non-whitespace delimiters
+        rule %r(m\s*([^\w\s])((\\\\|\\\1)|[^\1])*?\1[msixpodualngc]*)m, re_tok
+        rule %r(m\s+(\w)((\\\\|\\\1)|[^\1])*?\1[msixpodualngc]*)m, re_tok
+
+        rule %r(((?<==~)|(?<=\())\s*/(\\\\|\\/|[^/])*/[msixpodualngc]*),
+          re_tok, :balanced_regex
+
+        rule %r/\s+/, Text
+
+        rule(/(?=[a-z_]\w*(\s*#.*\n)*\s*=>)/i) { push :fat_comma }
+
+        rule %r/(?:#{builtins.join('|')})\b/, Name::Builtin
+        rule %r/((__(DIE|WARN)__)|(DATA|STD(IN|OUT|ERR)))\b/,
+          Name::Builtin::Pseudo
+
+        rule %r/<<([\'"]?)([a-zA-Z_][a-zA-Z0-9_]*)\1;?\n.*?\n\2\n/m, Str
+
+        rule %r/(__(END|DATA)__)\b/, Comment::Preproc, :end_part
+        rule %r/\$\^[ADEFHILMOPSTWX]/, Name::Variable::Global
+        rule %r/\$[\\"'\[\]&`+*.,;=%~?@$!<>(^\|\/_-](?!\w)/, Name::Variable::Global
+        rule %r/[$@%&*][$@%&*#_]*(?=[a-z{\[;])/i, Name::Variable, :varname
+
+        rule %r/[-+\/*%=<>&^\|!\\~]=?/, Operator
+
+        rule %r/0_?[0-7]+(_[0-7]+)*/, Num::Oct
+        rule %r/0x[0-9A-Fa-f]+(_[0-9A-Fa-f]+)*/, Num::Hex
+        rule %r/0b[01]+(_[01]+)*/, Num::Bin
+        rule %r/(\d*(_\d*)*\.\d+(_\d*)*|\d+(_\d*)*\.\d+(_\d*)*)(e[+-]?\d+)?/i,
+          Num::Float
+        rule %r/\d+(_\d*)*e[+-]?\d+(_\d*)*/i, Num::Float
+        rule %r/\d+(_\d+)*/, Num::Integer
+
+        rule %r/'/, Punctuation, :sq
+        rule %r/"/, Punctuation, :dq
+        rule %r/`/, Punctuation, :bq
+        rule %r/<([^\s>]+)>/, re_tok
+        rule %r/(q|qq|qw|qr|qx)\{/, Str::Other, :cb_string
+        rule %r/(q|qq|qw|qr|qx)\(/, Str::Other, :rb_string
+        rule %r/(q|qq|qw|qr|qx)\[/, Str::Other, :sb_string
+        rule %r/(q|qq|qw|qr|qx)</, Str::Other, :lt_string
+        rule %r/(q|qq|qw|qr|qx)(\W)(.|\n)*?\2/, Str::Other
+
+        rule %r/package\s+/, Keyword, :modulename
+        rule %r/sub\s+/, Keyword, :funcname
+        rule %r/\[\]|\*\*|::|<<|>>|>=|<=|<=>|={3}|!=|=~|!~|&&?|\|\||\.{1,3}/,
+          Operator
+        rule %r/[()\[\]:;,<>\/?{}]/, Punctuation
+        rule(/(?=\w)/) { push :name }
+      end
+
+      state :format do
+        rule %r/\.\n/, Str::Interpol, :pop!
+        rule %r/.*?\n/, Str::Interpol
+      end
+
+      state :fat_comma do
+        rule %r/#.*/, Comment::Single
+        rule %r/\w+/, Str
+        rule %r/\s+/, Text
+        rule %r/=>/, Operator, :pop!
+      end
+
+      state :name_common do
+        rule %r/\w+::/, Name::Namespace
+        rule %r/[\w:]+/, Name::Variable, :pop!
+      end
+
+      state :varname do
+        rule %r/\s+/, Text
+        rule %r/[{\[]/, Punctuation, :pop! # hash syntax
+        rule %r/[),]/, Punctuation, :pop! # arg specifier
+        rule %r/[;]/, Punctuation, :pop! # postfix
+        mixin :name_common
+      end
+
+      state :name do
+        mixin :name_common
+        rule %r/[A-Z_]+(?=[^a-zA-Z0-9_])/, Name::Constant, :pop!
+        rule(/(?=\W)/) { pop! }
+      end
+
+      state :modulename do
+        rule %r/[a-z_]\w*/i, Name::Namespace, :pop!
+      end
+
+      state :funcname do
+        rule %r/[a-zA-Z_]\w*[!?]?/, Name::Function
+        rule %r/\s+/, Text
+
+        # argument declaration
+        rule %r/(\([$@%]*\))(\s*)/ do
+          groups Punctuation, Text
+        end
+
+        rule %r/.*?{/, Punctuation, :pop!
+        rule %r/;/, Punctuation, :pop!
+      end
+
+      state :sq do
+        rule %r/\\[\\']/, Str::Escape
+        rule %r/[^\\']+/, Str::Single
+        rule %r/'/, Punctuation, :pop!
+        rule %r/\\/, Str::Single
+      end
+
+      state :dq do
+        mixin :string_intp
+        rule %r/\\[\\tnrabefluLUE"$@]/, Str::Escape
+        rule %r/\\0\d{2}/, Str::Escape
+        rule %r/\\o\{\d+\}/, Str::Escape
+        rule %r/\\x\h{2}/, Str::Escape
+        rule %r/\\x\{\h+\}/, Str::Escape
+        rule %r/\\c./, Str::Escape
+        rule %r/\\N\{[^\}]+\}/, Str::Escape
+        rule %r/[^\\"]+?/, Str::Double
+        rule %r/"/, Punctuation, :pop!
+        rule %r/\\/, Str::Escape
+      end
+
+      state :bq do
+        mixin :string_intp
+        rule %r/\\[\\tnr`]/, Str::Escape
+        rule %r/[^\\`]+?/, Str::Backtick
+        rule %r/`/, Punctuation, :pop!
+      end
+
+      [[:cb, '\{', '\}'],
+       [:rb, '\(', '\)'],
+       [:sb, '\[', '\]'],
+       [:lt, '<',  '>']].each do |name, open, close|
+        tok = Str::Other
+        state :"#{name}_string" do
+          rule %r/\\[#{open}#{close}\\]/, tok
+          rule %r/\\/, tok
+          rule(/#{open}/) { token tok; push }
+          rule %r/#{close}/, tok, :pop!
+          rule %r/[^#{open}#{close}\\]+/, tok
+        end
+      end
+
+      state :in_interp do
+        rule %r/}/, Str::Interpol, :pop!
+        rule %r/\s+/, Text
+        rule %r/[a-z_]\w*/i, Str::Interpol
+      end
+
+      state :string_intp do
+        rule %r/[$@][{]/, Str::Interpol, :in_interp
+        rule %r/[$@][a-z_]\w*/i, Str::Interpol
+      end
+
+      state :end_part do
+        # eat the rest of the stream
+        rule %r/.+/m, Comment::Preproc, :pop!
+      end
+    end
+  end
+end