mumukit-content-type 1.11.1 → 1.12.1

data/vendor/bundle/ruby/2.7.0/gems/rouge-3.30.0/lib/rouge/lexers/stata.rb

@@ -0,0 +1,165 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Stata < RegexLexer
+      title "Stata"
+      desc "The Stata programming language (www.stata.com)"
+      tag 'stata'
+      filenames '*.do', '*.ado'
+      mimetypes 'application/x-stata', 'text/x-stata'
+
+      ###
+      # Stata reference manual is available online at: https://www.stata.com/features/documentation/
+      ###
+
+      # Partial list of common programming and estimation commands, as of Stata 16
+      # Note: not all abbreviations are included
+      KEYWORDS = %w(
+        do run include clear assert set mata log
+        by bys bysort cap capt capture char class classutil which cdir confirm new existence creturn
+        _datasignature discard di dis disp displ displa display ereturn error _estimates exit file open read write seek close query findfile fvexpand
+        gettoken java home heapmax java_heapmax icd9 icd9p icd10 icd10cm icd10pcs initialize javacall levelsof
+        tempvar tempname tempfile macro shift uniq dups retokenize clean sizeof posof
+        makecns matcproc marksample mark markout markin svymarkout matlist
+        accum define dissimilarity eigenvalues get rowjoinbyname rownames score svd symeigen dir list ren rename
+        more pause plugin call postfile _predict preserve restore program define drop end python qui quietly noi noisily _return return _rmcoll rmsg _robust
+        serset locale_functions locale_ui signestimationsample checkestimationsample sleep syntax sysdir adopath adosize
+        tabdisp timer tokenize trace unab unabcmd varabbrev version viewsource
+        window fopen fsave manage menu push stopbox
+        net from cd link search install sj stb ado update uninstall pwd ssc ls
+        using insheet outsheet mkmat svmat sum summ summarize
+        graph gr_edit twoway histogram kdensity spikeplot
+        mi miss missing var varname order compress append
+        gen gene gener genera generat generate egen replace duplicates
+        estimates nlcom lincom test testnl predict suest
+        _regress reg regr regre regres regress probit logit ivregress logistic svy gmm ivprobit ivtobit
+        bsample assert codebook collapse compare contract copy count cross datasignature d ds desc describe destring tostring
+        drawnorm edit encode decode erase expand export filefilter fillin format frame frget frlink gsort
+        import dbase delimited excel fred haver sas sasxport5 sasxport8 spss infile infix input insobs inspect ipolate isid
+        joinby label language labelbook lookfor memory mem merge mkdir mvencode notes obs odbc order outfile
+        pctile xtile _pctile putmata range recast recode rename group reshape rm rmdir sample save saveold separate shell snapshot sort split splitsample stack statsby sysuse
+        type unicode use varmanage vl webuse xpose zipfile
+        number keep tab table tabulate stset stcox tsset xtset
+      )
+
+      # Complete list of functions by name, as of Stata 16
+      PRIMITIVE_FUNCTIONS = %w(
+        abbrev abs acos acosh age age_frac asin asinh atan atan2 atanh autocode
+        betaden binomial binomialp binomialtail binormal birthday bofd byteorder
+        c _caller cauchy cauchyden cauchytail Cdhms ceil char chi2 chi2den chi2tail Chms
+        chop cholesky clip Clock clock clockdiff cloglog Cmdyhms Cofc cofC Cofd cofd coleqnumb
+        collatorlocale collatorversion colnfreeparms colnumb colsof comb cond corr cos cosh
+        daily date datediff datediff_frac day det dgammapda dgammapdada dgammapdadx dgammapdxdx dhms
+        diag diag0cnt digamma dofb dofC dofc dofh dofm dofq dofw dofy dow doy dunnettprob e el epsdouble
+        epsfloat exp expm1 exponential exponentialden exponentialtail
+        F Fden fileexists fileread filereaderror filewrite float floor fmtwidth frval _frval Ftail
+        fammaden gammap gammaptail get hadamard halfyear halfyearly has_eprop hh hhC hms hofd hours
+        hypergeometric hypergeometricp
+        I ibeta ibetatail igaussian igaussianden igaussiantail indexnot inlist inrange int inv invbinomial invbinomialtail
+        invcauchy invcauchytail invchi2 invchi2tail invcloglog invdunnettprob invexponential invexponentialtail invF
+        invFtail invgammap invgammaptail invibeta invibetatail invigaussian invigaussiantail invlaplace invlaplacetail
+        invlogistic invlogistictail invlogit invnbinomial invnbinomialtail invnchi2 invnchi2tail invnF invnFtail invnibeta invnormal invnt invnttail
+        invpoisson invpoissontail invsym invt invttail invtukeyprob invweibull invweibullph invweibullphtail invweibulltail irecode islepyear issymmetric
+        J laplace laplaceden laplacetail ln ln1m ln1p lncauchyden lnfactorial lngamma lnigammaden lnigaussianden lniwishartden lnlaplaceden lnmvnormalden
+        lnnormal lnnormalden lnnormalden lnnormalden lnwishartden log log10 log1m log1p logistic logisticden logistictail logit
+        matmissing matrix matuniform max maxbyte maxdouble maxfloat maxint maxlong mdy mdyhms mi min minbyte mindouble minfloat minint minlong minutes
+        missing mm mmC mod mofd month monthly mreldif msofhours msofminutes msofseconds
+        nbetaden nbinomial nbinomialp nbinomialtail nchi2 nchi2den nchi2tail nextbirthday nextleapyear nF nFden nFtail nibeta
+        normal normalden npnchi2 npnF npnt nt ntden nttail nullmat
+        plural poisson poissonp poissontail previousbirthday previousleapyear qofd quarter quarterly r rbeta rbinomial rcauchy rchi2 recode
+        real regexm regexr regexs reldif replay return rexponential rgamma rhypergeometric rigaussian rlaplace rlogistic rnormal
+        round roweqnumb rownfreeparms rownumb rowsof rpoisson rt runiform runiformint rweibull rweibullph
+        s scalar seconds sign sin sinh smallestdouble soundex soundex_nara sqrt ss ssC strcat strdup string stritrim strlen strlower
+        strltrim strmatch strofreal strpos strproper strreverse strrpos strrtrim strtoname strtrim strupper subinstr subinword substr sum sweep
+        t tan tanh tC tc td tden th tin tm tobytes tq trace trigamma trunc ttail tukeyprob tw twithin
+        uchar udstrlen udsubstr uisdigit uisletter uniform ustrcompare ustrcompareex ustrfix ustrfrom ustrinvalidcnt ustrleft ustrlen ustrlower
+        ustrltrim ustrnormalize ustrpos ustrregexm ustrregexra ustrregexrf ustrregexs ustrreverse ustrright ustrrpos ustrrtrim ustrsortkey
+        ustrsortkeyex ustrtitle ustrto ustrtohex ustrtoname ustrtrim ustrunescape ustrupper ustrword ustrwordcount usubinstr usubstr
+        vec vecdiag week weekly weibull weibullden weibullph weibullphden weibullphtail weibulltail wofd word wordbreaklocale wordcount
+        year yearly yh ym yofd yq yw
+      )
+
+      # Note: types `str1-str2045` handled separately below
+      def self.type_keywords
+        @type_keywords ||= Set.new %w(byte int long float double str strL numeric string integer scalar matrix local global numlist varlist newlist)
+      end
+
+      # Stata commands used with braces. Includes all valid abbreviations for 'forvalues'.
+      def self.reserved_keywords
+        @reserved_keywords ||= Set.new %w(if else foreach forv forva forval forvalu forvalue forvalues to while in of continue break nobreak)
+      end
+
+      ###
+      # Lexer state and rules
+      ###
+      state :root do
+
+        # Pre-processor commands: #
+        rule %r/^\s*#.*$/, Comment::Preproc
+
+        # Hashbang comments: *!
+        rule %r/^\*!.*$/, Comment::Hashbang
+
+        # Single-line comment: *
+        rule %r/^\s*\*.*$/, Comment::Single
+
+        # Keywords: recognize only when they are the first word
+        rule %r/^\s*(#{KEYWORDS.join('|')})\b/, Keyword
+
+        # Whitespace. Classify `\n` as `Text` to avoid interference with `Comment` and `Keyword` above
+        rule(/[ \t]+/, Text::Whitespace)
+        rule(/[\n\r]+/, Text)
+
+        # In-line comment: //
+        rule %r/\/\/.*?$/, Comment::Single
+
+        # Multi-line comment: /* and */
+        rule %r(/(\\\n)?[*].*?[*](\\\n)?/)m, Comment::Multiline
+
+        # Strings indicated by compound double-quotes (`""') and double-quotes ("")
+        rule %r/`"(\\.|.)*?"'/, Str::Double
+        rule %r/"(\\.|.)*?"/, Str::Double
+
+        # Format locals (`') and globals ($) as strings
+        rule %r/`(\\.|.)*?'/, Str::Double
+        rule %r/(?<!\w)\$\w+/, Str::Double
+
+        # Display formats
+        rule %r/\%\S+/, Name::Property
+
+        # Additional string types: str1-str2045
+        rule %r/\bstr(204[0-5]|20[0-3][0-9]|[01][0-9][0-9][0-9]|[0-9][0-9][0-9]|[0-9][0-9]|[1-9])\b/, Keyword::Type
+
+        # Only recognize primitive functions when they are actually used as a function call, i.e. followed by an opening parenthesis
+        # `Name::Builtin` would be more logical, but is not usually highlighted, so use `Name::Function` instead
+        rule %r/\b(#{PRIMITIVE_FUNCTIONS.join('|')})(?=\()/, Name::Function
+
+        # Matrix operator `..` (declare here instead of with other operators, in order to avoid conflict with numbers below)
+        rule %r/\.\.(?=.*\])/, Operator
+
+        # Numbers
+        rule %r/[+-]?(\d+([.]\d+)?|[.]\d+)([eE][+-]?\d+)?/, Num
+
+        # Factor variable and time series operators
+        rule %r/\b[ICOicoLFDSlfds]\w*\./, Operator
+        rule %r/\b[ICOicoLFDSlfds]\w*(?=\(.*\)\.)/, Operator
+
+        rule %r/\w+/ do |m|
+          if self.class.reserved_keywords.include? m[0]
+            token Keyword::Reserved
+          elsif self.class.type_keywords.include? m[0]
+            token Keyword::Type
+          else
+            token Name
+          end
+        end
+
+        rule %r/[\[\]{}();,]/, Punctuation
+
+        rule %r([-<>?*+'^/\\!#.=~:&|]), Operator
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/rouge-3.30.0/lib/rouge/lexers/supercollider.rb

@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class SuperCollider < RegexLexer
+      tag 'supercollider'
+      filenames '*.sc', '*.scd'
+
+      title "SuperCollider"
+      desc 'A cross-platform interpreted programming language for sound synthesis, algorithmic composition, and realtime performance'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          var arg classvar const super this
+        )
+      end
+
+      # these aren't technically keywords, but we treat
+      # them as such because it makes things clearer 99%
+      # of the time
+      def self.reserved
+        @reserved ||= Set.new %w(
+          case do for forBy loop if while new newCopyArgs
+        )
+      end
+
+      def self.constants
+        @constants ||= Set.new %w(
+          true false nil inf thisThread
+          thisMethod thisFunction thisProcess
+          thisFunctionDef currentEnvironment
+          topEnvironment
+        )
+      end
+
+      state :whitespace do
+        rule %r/\s+/m, Text
+      end
+
+      state :comments do
+        rule %r(//.*?$), Comment::Single
+        rule %r(/[*]) do
+          token Comment::Multiline
+          push :nested_comment
+        end
+      end
+
+      state :nested_comment do
+        rule %r(/[*]), Comment::Multiline, :nested_comment
+        rule %r([*]/), Comment::Multiline, :pop!
+        rule %r([^*/]+)m, Comment::Multiline
+        rule %r/./, Comment::Multiline
+      end
+
+      state :root do
+        mixin :whitespace
+        mixin :comments
+
+        rule %r/[\-+]?0[xX]\h+/, Num::Hex
+
+        # radix float
+        rule %r/[\-+]?\d+r[0-9a-zA-Z]*(\.[0-9A-Z]*)?/, Num::Float
+
+        # normal float
+        rule %r/[\-+]?((\d+(\.\d+)?([eE][\-+]?\d+)?(pi)?)|pi)/, Num::Float
+
+        rule %r/[\-+]?\d+/, Num::Integer
+
+        rule %r/\$(\\.|.)/, Str::Char
+
+        rule %r/"([^\\"]|\\.)*"/, Str
+
+        # symbols (single-quote notation)
+        rule %r/'([^\\']|\\.)*'/, Str::Other
+
+        # symbols (backslash notation)
+        rule %r/\\\w+/, Str::Other
+
+        # symbol arg
+        rule %r/[A-Za-z_]\w*:/, Name::Label
+
+        rule %r/[A-Z]\w*/, Name::Class
+
+        # primitive
+        rule %r/_\w+/, Name::Function
+
+        # main identifiers section
+        rule %r/[a-z]\w*/ do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+          elsif self.class.constants.include? m[0]
+            token Keyword::Constant
+          elsif self.class.reserved.include? m[0]
+            token Keyword::Reserved
+          else
+            token Name
+          end
+        end
+
+        # environment variables
+        rule %r/~\w+/, Name::Variable::Global
+
+        rule %r/[\{\}()\[\];,\.]/, Punctuation
+
+        # operators. treat # (array unpack) as an operator
+        rule %r/[\+\-\*\/&\|%<>=]+/, Operator
+        rule %r/[\^:#]/, Operator
+
+        # treat curry argument as a special operator
+        rule %r/\b_\b/, Name::Builtin
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/rouge-3.30.0/lib/rouge/lexers/swift.rb

@@ -0,0 +1,186 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Swift < RegexLexer
+      tag 'swift'
+      filenames '*.swift'
+
+      title "Swift"
+      desc 'Multi paradigm, compiled programming language developed by Apple for iOS and OS X development. (developer.apple.com/swift)'
+
+      id_head = /_|(?!\p{Mc})\p{Alpha}|[^\u0000-\uFFFF]/
+      id_rest = /[\p{Alnum}_]|[^\u0000-\uFFFF]/
+      id = /#{id_head}#{id_rest}*/
+
+      keywords = Set.new %w(
+        await break case continue default do else fallthrough if in for return switch where while try catch throw guard defer repeat
+
+        as dynamicType is new super self Self Type __COLUMN__ __FILE__ __FUNCTION__ __LINE__
+
+        associativity async didSet get infix inout isolated mutating none nonmutating operator override postfix precedence prefix set unowned weak willSet throws rethrows precedencegroup
+
+        #available #colorLiteral #column #else #elseif #endif #error #file #fileLiteral #function #if #imageLiteral #line #selector #sourceLocation #warning
+      )
+
+      declarations = Set.new %w(
+        actor class deinit enum convenience extension final func import init internal lazy let nonisolated optional private protocol public required static struct subscript typealias var dynamic indirect associatedtype open fileprivate some
+      )
+
+      constants = Set.new %w(
+        true false nil
+      )
+
+      start { push :bol }
+
+      # beginning of line
+      state :bol do
+        rule %r/#.*/, Comment::Preproc
+
+        mixin :inline_whitespace
+
+        rule(//) { pop! }
+      end
+
+      state :inline_whitespace do
+        rule %r/\s+/m, Text
+        mixin :has_comments
+      end
+
+      state :whitespace do
+        rule %r/\n+/m, Text, :bol
+        rule %r(\/\/.*?$), Comment::Single, :bol
+        mixin :inline_whitespace
+      end
+
+      state :has_comments do
+        rule %r(/[*]), Comment::Multiline, :nested_comment
+      end
+
+      state :nested_comment do
+        mixin :has_comments
+        rule %r([*]/), Comment::Multiline, :pop!
+        rule %r([^*/]+)m, Comment::Multiline
+        rule %r/./, Comment::Multiline
+      end
+
+      state :root do
+        mixin :whitespace
+        
+        rule %r/\$(([1-9]\d*)?\d)/, Name::Variable
+
+        rule %r{[()\[\]{}:;,?\\]}, Punctuation
+        rule %r([-/=+*%<>!&|^.~]+), Operator
+        rule %r/@?"/, Str, :dq
+        rule %r/'(\\.|.)'/, Str::Char
+        rule %r/(\d+(?:_\d+)*\*|(?:\d+(?:_\d+)*)*\.\d+(?:_\d)*)(e[+-]?\d+(?:_\d)*)?/i, Num::Float
+        rule %r/\d+e[+-]?[0-9]+/i, Num::Float
+        rule %r/0o?[0-7]+(?:_[0-7]+)*/, Num::Oct
+        rule %r/0x[0-9A-Fa-f]+(?:_[0-9A-Fa-f]+)*((\.[0-9A-F]+(?:_[0-9A-F]+)*)?p[+-]?\d+)?/, Num::Hex
+        rule %r/0b[01]+(?:_[01]+)*/, Num::Bin
+        rule %r{[\d]+(?:_\d+)*}, Num::Integer
+
+        rule %r/@#{id}/, Keyword::Declaration
+
+        rule %r/(private|internal)(\([ ]*)(\w+)([ ]*\))/ do |m|
+          if m[3] == 'set'
+            token Keyword::Declaration
+          else
+            groups Keyword::Declaration, Keyword::Declaration, Error, Keyword::Declaration
+          end
+        end
+
+        rule %r/(unowned\([ ]*)(\w+)([ ]*\))/ do |m|
+          if m[2] == 'safe' || m[2] == 'unsafe'
+            token Keyword::Declaration
+          else
+            groups Keyword::Declaration, Error, Keyword::Declaration
+          end
+        end
+
+        rule %r/#available\([^)]+\)/, Keyword::Declaration
+
+        rule %r/(#(?:selector|keyPath)\()([^)]+?(?:[(].*?[)])?)(\))/ do
+          groups Keyword::Declaration, Name::Function, Keyword::Declaration
+        end
+
+        rule %r/#(line|file|column|function|dsohandle)/, Keyword::Declaration
+
+        rule %r/(let|var)\b(\s*)(#{id})/ do
+          groups Keyword, Text, Name::Variable
+        end
+
+        rule %r/(let|var)\b(\s*)([(])/ do
+          groups Keyword, Text, Punctuation
+          push :tuple
+        end
+
+        rule %r/(?!\b(if|while|for|private|internal|unowned|switch|case)\b)\b#{id}(?=(\?|!)?\s*[(])/ do |m|
+          if m[0] =~ /^[[:upper:]]/
+            token Keyword::Type
+          else
+            token Name::Function
+          end
+        end
+
+        rule %r/as[?!]?(?=\s)/, Keyword
+        rule %r/try[!]?(?=\s)/, Keyword
+
+        rule %r/(#?(?!default)(?![[:upper:]])#{id})(\s*)(:)/ do
+          groups Name::Variable, Text, Punctuation
+        end
+
+        rule id do |m|
+          if keywords.include? m[0]
+            token Keyword
+          elsif declarations.include? m[0]
+            token Keyword::Declaration
+          elsif constants.include? m[0]
+            token Keyword::Constant
+          elsif m[0] =~ /^[[:upper:]]/
+            token Keyword::Type
+          else
+            token Name
+          end
+        end
+
+        rule %r/(`)(#{id})(`)/ do
+          groups Punctuation, Name::Variable, Punctuation
+        end
+      end
+
+      state :tuple do
+        rule %r/(#{id})/, Name::Variable
+        rule %r/(`)(#{id})(`)/ do
+            groups Punctuation, Name::Variable, Punctuation
+        end
+        rule %r/,/, Punctuation
+        rule %r/[(]/, Punctuation, :push
+        rule %r/[)]/, Punctuation, :pop!
+        mixin :inline_whitespace
+      end
+
+      state :dq do
+        rule %r/\\[\\0tnr'"]/, Str::Escape
+        rule %r/\\[(]/, Str::Escape, :interp
+        rule %r/\\u\{\h{1,8}\}/, Str::Escape
+        rule %r/[^\\"]+/, Str
+        rule %r/"""/, Str, :pop!
+        rule %r/"/, Str, :pop!
+      end
+
+      state :interp do
+        rule %r/[(]/, Punctuation, :interp_inner
+        rule %r/[)]/, Str::Escape, :pop!
+        mixin :root
+      end
+
+      state :interp_inner do
+        rule %r/[(]/, Punctuation, :push
+        rule %r/[)]/, Punctuation, :pop!
+        mixin :root
+      end
+    end
+  end
+end