packages feed

skylighting-core 0.14.7 → 0.15

raw patch · 71 files changed

+23094/−4092 lines, 71 filesdep ~basePVP ok

version bump matches the API change (PVP)

Dependency ranges changed: base

API changes (from Hackage documentation)

- Skylighting.Types: [cLineBeginContext] :: Context -> ![ContextSwitch]
- Skylighting.Types: [rWeakDeliminators] :: Rule -> Set Char
+ Skylighting.Regex: matchRegexWithGroups :: IntMap Regex -> Regex -> ByteString -> Maybe (ByteString, IntMap (Int, Int))
+ Skylighting.Regex: reMinimal :: RE -> Bool
+ Skylighting.Types: [rWordDelimiters] :: Rule -> Set Char
- Skylighting.Regex: MatchCaptured :: !Int -> Regex
+ Skylighting.Regex: MatchCaptured :: !Int -> !Bool -> Regex
- Skylighting.Regex: compileRE :: RE -> Either String Regex
+ Skylighting.Regex: compileRE :: RE -> Either String (Regex, IntMap Regex)
- Skylighting.Regex: compileRegex :: Bool -> ByteString -> Either String Regex
+ Skylighting.Regex: compileRegex :: Bool -> Bool -> ByteString -> Either String Regex
- Skylighting.Regex: pattern RE :: ByteString -> Bool -> RE
+ Skylighting.Regex: pattern RE :: ByteString -> Bool -> Bool -> RE
- Skylighting.Types: Context :: !Text -> !Text -> ![Rule] -> !TokenType -> ![ContextSwitch] -> ![ContextSwitch] -> ![ContextSwitch] -> !Bool -> ![ContextSwitch] -> !Bool -> Context
+ Skylighting.Types: Context :: !Text -> !Text -> ![Rule] -> !TokenType -> ![ContextSwitch] -> ![ContextSwitch] -> !Bool -> ![ContextSwitch] -> !Bool -> Context
- Skylighting.Types: LineContinue :: Matcher
+ Skylighting.Types: LineContinue :: !Char -> Matcher

Files

changelog.md view
@@ -1,5 +1,278 @@ # Revision history for skylighting and skylighting-core +## 0.15++  * New syntaxes: sparql (#212), sas (#213), mermaid, desktop,+    elixir-eex, elixir-heex, abnf, asciidoc, cabal, cobol, context,+    csv, haml, idl, jinja, jira, k, logfile, meson, nginx, ninja,+    ocamllex, ocamlyacc, q, quarto, rdoc, rmarkdown, rtf, textile,+    todo, vue.++  * Update syntax definitions from upstream: bash, cmake, cpp,+    crystal, dot, elixir, haskell, markdown, nix, ocaml, orgmode,+    perl, php, powershell, python, qml, raku, rust,+    spdx-comments, tcsh, typst, yaml, zig, zsh.++  * Allow multiple contexts separated by `!` (#208).+    This is an upstream KDE change.++  * Bump min base version to 4.18.++  * Regex: don't hang on bounded repetition with min > max.+    `atmost` recursed without a guard for negative counts, so a pattern+    like `a{3,1}` made the compiler loop forever building an infinite+    regex. Reject the quantifier and fall back to interpreting it as a+    literal, consistent with how other invalid quantifiers (`a{}`, `a{3`)+    are handled.++  * Regex: don't hang on lazy quantifiers in lookbehinds.+    Previously lazy quantifier inside a lookbehind (e.g. `(?<=a+?b)`) hung.++  * Regex: don't hang on subroutine recursion that consumes no input.+    Previously a pattern like `x|(?R)` recursed forever.++  * Regex: fix `lastCharOffset` for multibyte UTF-8 characters.+    This bug resulted in failure of lookbehinds and word boundary+    checks after non-ASCII characters.++  * Regex: don't let `(?i:...)` leak out of its group.+    Previously, in `/(?i:a)b/` the trailing `b` was also matched+    case-insensitively.++  * Regex: fix `[[:graph:]]`, `[[:word:]]`, and add `[[:digit:]]`.++  * Regex: find nested capturing groups for subroutine calls.+    Previously, calls like `(?2)` in `/((a)b)(?2)/` were+    silently ignored (matching the empty string).++  * Regex: apply case-insensitivity to classes, escapes, backreferences.+    Case-insensitive matching was previously only applied to plain literal+    characters, not character classes and escaped literals. Now:++    + `pRegexCharClass` takes the case-sensitivity flag and, when+      insensitive, matches a character if any of its case variants is in+      the class (negated classes exclude all case variants, as in PCRE).+    + Escaped literals like \x61 match case-insensitively when+      insensitivity is in effect.+    + The matcher compares captured text character by character with+      case folding (correct even when the case variants have different+      UTF-8 encodings).+    + [API change] `MatchCaptured` has a new argument place;+      `MatchCaptured !Int !Bool`, where the Bool records the case+      sensitivity in effect at its position.++  * Regex: linearize `{m,n}` expansion and cap repeat counts.+    Previously `r{m,n}` was expanded to produce an AST quadratic in+    n-m, which also made matching quadratic: matching `[ab]{0,800}`+    against 800 characters took ~31 ms.  We now use+    a nested-optional encoding, `r(r(r)?)?`, which is linear; the same+    match takes ~0.3 ms. In addition, repeat counts larger than+    65535 (the limit PCRE2 uses) are no longer treated as+    quantifiers; like other invalid quantifier syntax, they fall+    back to a literal interpretation. Previously `x{100000000}`+    would eagerly build a hundred-million-node regex.++  * Regex: treat unmatched `]` outside a character class as a literal.+    This the behavior of PCRE2 (used by KSyntaxHighlighting via+    QRegularExpression). Previously we treated this as a parse error,+    which caused failures in several current KDE syntax definitions.++  * Regex: parse `\0` octal escapes with up to two digits, as in PCRE.+    `\0` previously required exactly three following octal digits.++  * Regex: support `\G` (assert position of match start).+    Because our matcher is always anchored at the start of+    the input it is given, this is exactly AssertBeginning.++  * Regex: support `\gN` and `\g{N}` backreferences.++  * Regex: support inline modifiers like `(?i)` without a colon.++  * Regex: support `\h` and `\H` (horizontal whitespace).++  * Regex: support `\A` (start of subject).+    Since matching is always anchored at the start of the input we are+    given, `\A` is equivalent to AssertBeginning.++  * Regex: allow an empty first alternative, as in `(?:|a)`.+    As in PCRE, an empty alternative matches the empty string.  Empty+    alternatives other than the first were already supported.++  * Regex: support `\b` (backspace) inside character classes.++  * Regex: support atomic groups `(?>...)`.++  * Regex: leftmost-first (PCRE) match semantics instead of longest-match.++    + Alternation is now leftmost-first, and alternatives are tried in+      source order (a fold in the compiler used to reverse them, which+      was harmless under longest-match).+    + Possessive quantifiers and atomic groups commit to the first match+      in backtracking order, fixing the divergence from PCRE.+      `(?>a|ab)c` now fails on "abc".+    + Lookahead/lookbehind assertions are atomic and keep only the first+      match's captures, so `d(?=(a|ab))` captures "a", as in PCRE.+    - Lazy quantifiers are compiled to forms that prefer fewer+      repetitions instead of being special-cased in the matcher; the old+      special case could commit to a short prefix and miss valid longer+      continuations.+    - Repetition loops terminate via a seen-state set.++  * Regex: fix subroutine calls to groups with multi-digit numbers.++  * Regex: after `(?|...)`, resume group numbering after the max group.++  * Regex: allow a leading literal `]` in a character class to start a range.+    As in PCRE, `[]-a]` is the range from `]` to `a`; previously it was parsed+    as the three literals.++  * Regex: support `\pL`, `\P{...}`, `\PL`, and `\p{^...}`.++  * Regex: make Eq Match consistent with Ord.++  * Regex: Raise compile errors for stray quantifiers and unsupported flags.++    + a quantifier with nothing to repeat.+    + a quantifier after an anchor or word-boundary assertion.+    + `{m,n}` with m > n.+    + repeat counts over 65535.+    + inline flags we do not implement.++  * Regex: Support minimal= (inverted greediness) on RegExpr rules.++    + `compileRegex` takes a new Bool parameter for minimal matching+      [API change], and `pSuffix` swaps the greedy and lazy variant+      s of a quantifier when it is set.+    + The inline flag `(?U)` (and `(?-U)`, `(?U:...))`, which toggles the+      same option in PCRE, is now supported.+    + RE has a new `reMinimal` field [API change], which+      Skylighting.Parser sets from the `minimal` attribute on+      RegExpr elements.++  * Support the char attribute on LineContinue. [API change]+    The LineContinue constructor of Matcher now carries the character.++  * Fix case-sensitivity defaults to match KDE.++    + Rules (RegExpr, StringDetect, WordDetect, DetectChar, etc.) now+      default to case-sensitive matching regardless of the language+      element's `casesensitive` attribute.+    + The default case sensitivity of keyword lists is given by the+      `casesensitive` attribute on the language element, and may be+      overridden by the `casesensitive` attribute on general > keywords.+    + An `insensitive` attribute on a keyword rule itself now overrides+      the keyword list's case sensitivity, but only when the attribute+      is actually present.++    Behavior verified against KSyntaxHighlighting's definition.cpp and+    highlightingdata.cpp.++  * Honor `additionalDeliminator`/`weakDeliminator` on rules.++    + Keyword rules fold rule-level `additionalDeliminator` and+      `weakDeliminator` into their delimiter set, so e.g. Lua's+      special variables rule (additionalDeliminator=".") matches+      nil in nil.x even though the general keywords element makes+      `.` a weak delimiter.+    + Rule gains an `rAdditionalDeliminators` field [API change],+      and both it and `rWeakDeliminators` now also incorporate+      the general > keywords delimiter modifications, applied+      before the rule-level ones as in KDE.  Both sets are consulted+      by WordDetect, Int, Float, HlCHex, and HlCOct: a weak delimiter+      counts as a word character and an additional delimiter does+      not, with weak delimiters taking precedence.+    + WordDetect now uses KDE's boundary conditions: a delimiter (or+      line edge) must precede the word or be its first character, and+      must follow the word or be its last character.  The leading+      check also prevents WordDetect from matching in the middle of+      a word.++  * Match KDE semantics for Int, Float, HlCOct, HlCHex rules [API change]++    + These rules match only if the *preceding* character is a word+      delimiter (or the match is at the start of the line); nothing is+      required of the following character.  Previously we used a+      two-sided `\w`-based word boundary check.+    + None of these rules consume a leading sign.  Previously Int,+      HlCOct, HlCHex consumed an optional '-', and Float an optional+      '+' or '-'.+    + Int matches decimal digits only (no hex or octal forms).+    + HlCOct matches C-style octals: '0' followed by octal digits.+      Previously we required a "0o" prefix (and, due to a bug, actually+      matched the hex form, so HlCOct never matched real octals).+    + Float requires a '.', so "5e2" is not a Float; the exponent is+      all-or-nothing (an incomplete exponent like "1.5e+" matches just+      "1.5"); and there is no check on what follows the match, so+      "1.2.3" matches "1.2".++    Since all four rules (and keyword and WordDetect) now need+    only a single effective delimiter set, we replace the+    `rWeakDeliminators` and `rAdditionalDeliminators` fields on+    Rule with a single `rWordDelimiters` field [API change].++  * Match KDE line-loop semantics.++    + Remove `cLineBeginContext` from Context [API change] and the+      `lineBeginContext` attribute from the parser.  KDE no longer+      has this feature, no bundled syntax definition uses it.+    + Column and `firstNonspaceColumn` now restart on every physical line.+      A line continuation only suppresses the previous line's+      `lineEndContext`; it no longer carries the previous line's column+      state into the next line.+    + `lineEmptyContext` defaults to `lineEndContext` when unspecified or+      `#stay` (KDE context.cpp, see kde bug 405903).+    + An empty line now applies the `lineEmptyContext` switches of+      successive top contexts until `#stay`, and does not apply+      `lineEndContext` separately.+    + `checkLineEnd` likewise applies lineEndContext switches of successive+      top contexts until `#stay`.+    + Guard against endless loops from broken syntax definitions, as KDE+      does: the empty-line and line-end context-switch loops and rule+      matching without consuming input are limited to 1024 iterations+      without progress, after which highlighting of the line is aborted.++  * Cache capturing groups in RE alongside the compiled regex.+    Previously, matchRegex called extractCapturingGroups on every+    invocation. Now the RE smart constructor extracts the+    capturing groups once at compile time and caches them+    alongside the compiled Regex. The tokenizer uses the cached groups+    for static rules. For dynamic rules the groups are recomputed+    after `subDynamic`, since the substitution rewrites the AST.++    + compileRE now returns Either String (Regex, IntMap Regex) [API change].+    + New function matchRegexWithGroups [API change] takes precomputed groups;+      matchRegex keeps its old behavior for external callers.++  * Resolve keywords at load time, not on every tokenize call.++    + `tokenize` no longer resolves keywords; it assumes keyword lists in+      the syntax map have already been resolved into word sets.  This is+      the case for the bundled syntax definitions (which are generated+      via loadSyntaxesFromDir) and for definitions loaded with the+      functions in Skylighting.Loader.+    - `loadValidSyntaxesFromDir` now resolves keywords, fixing an+      inconsistency with `loadSyntaxesFromDir` (which already did).+    - The skylighting CLI resolves keywords in syntaxes added with+      `--definition`.+    - Users who build a SyntaxMap by hand from `parseSyntaxDefinition`+      output must now apply resolveKeywords themselves; tokenizing with+      an unresolved keyword list yields a clear "Keyword with unresolved+      list" error.++  * Minor performance improvements in matchers and syntax lookup.++    + `detect2Chars`: compare decoded characters directly (like+      detectChar) instead of allocating a two-character Text and+      encoding it to a ByteString on every attempt.+    + `wordDetect`, `stringDetect`: in the case-sensitive case, compare+      bytes with a prefix check instead of walking and decoding a+      prefix of the input into Text on every attempt.+    + `syntaxByName`: don't rebuild the entire syntax map with lowercased+      keys on every lookup; try an exact lookup first and fall back to+      a linear scan.+    + `syntaxByShortName`: lowercase the query once instead of once per+      map entry.+ ## 0.14.7    * Update xml syntax definitions: agda, apache, bash, c, clojure,
skylighting-core.cabal view
@@ -1,5 +1,5 @@ name:                skylighting-core-version:             0.14.7+version:             0.15 synopsis:            syntax highlighting library description:         Skylighting is a syntax highlighting library.                      It derives its tokenizers from XML syntax@@ -113,7 +113,7 @@                        Regex.KDE.Compile                        Regex.KDE.Match   other-extensions:    CPP-  build-depends:       base >= 4.8 && < 5.0,+  build-depends:       base >= 4.18 && < 5,                        mtl,                        transformers,                        text,@@ -147,7 +147,7 @@   type:           exitcode-stdio-1.0   main-is:        test-skylighting.hs   hs-source-dirs: test-  build-depends:  base >= 4.8 && < 5.0,+  build-depends:  base >= 4.8 && < 5,                   tasty,                   tasty-golden,                   tasty-hunit,@@ -185,7 +185,7 @@   Default-Language: Haskell2010  executable skylighting-extract-  build-depends:       base >= 4.8 && < 5.0,+  build-depends:       base >= 4.8 && < 5,                        skylighting-core,                        filepath,                        text,
src/Regex/KDE.hs view
@@ -1,6 +1,7 @@ {-# LANGUAGE OverloadedStrings #-} module Regex.KDE- (Regex(..), compileRegex, matchRegex, testRegex, isWordChar)+ (Regex(..), compileRegex, matchRegex, matchRegexWithGroups,+  extractCapturingGroups, testRegex, isWordChar)   where  import Regex.KDE.Regex@@ -15,7 +16,7 @@ testRegex caseSensitive re s =   let bs = U.fromString s       toSlice (off,len) = U.toString $ B.take len $ B.drop off bs-   in case compileRegex caseSensitive (U.fromString re) of+   in case compileRegex caseSensitive False (U.fromString re) of         Right r ->           case matchRegex r bs of             Nothing -> Nothing
src/Regex/KDE/Compile.hs view
@@ -25,12 +25,18 @@ -- It is described here: https://doc.qt.io/qt-6/qregexp.html  -- | Compile a UTF-8 encoded ByteString as a Regex.  If the first--- parameter is True, then the Regex will be case sensitive.-compileRegex :: Bool -> ByteString -> Either String Regex-compileRegex caseSensitive bs =+-- parameter is True, then the Regex will be case sensitive.  If the+-- second parameter is True, quantifiers are minimal (lazy) rather+-- than greedy by default, and the @?@ modifier makes them greedy+-- instead of lazy -- this corresponds to PCRE's UNGREEDY option+-- (QRegularExpression's InvertedGreedinessOption, set by+-- @minimal="1"@ in KDE syntax definitions).+compileRegex :: Bool -> Bool -> ByteString -> Either String Regex+compileRegex caseSensitive minimal bs =   let !res = parseOnly (evalStateT parser RState{                                             rsCurrentCaptureNumber = 0,-                                            rsCaseSensitive = caseSensitive })+                                            rsCaseSensitive = caseSensitive,+                                            rsMinimal = minimal })                        (decodeUtf8With lenientDecode bs)    in res  where@@ -44,7 +50,8 @@ data RState =   RState   { rsCurrentCaptureNumber :: Int-  , rsCaseSensitive :: Bool }+  , rsCaseSensitive :: Bool+  , rsMinimal :: Bool }   deriving (Show)  type RParser = StateT RState Parser@@ -52,8 +59,12 @@ pRegex :: RParser Regex pRegex =   option MatchNull $-  foldr MatchAlt-    <$> pAltPart+  -- earlier alternatives must be the left operands of MatchAlt, since+  -- the matcher prefers them, as in PCRE.  The first alternative may+  -- be empty, as in (?:|a); as in PCRE, an empty alternative matches+  -- the empty string:+  (\x xs -> foldr1 MatchAlt (x:xs))+    <$> (pAltPart <|> pure mempty)     <*> many (lift (char '|') *> (pAltPart <|> pure mempty))  pAltPart :: RParser Regex@@ -66,30 +77,58 @@ pParenthesized :: RParser Regex pParenthesized = do   _ <- lift (char '(')-  -- pcrepattern says: A group that starts with (?| resets the capturing-  -- parentheses numbers in each alternative.-  resetCaptureNumbers <- option False (True <$ lift (string "?|"))-  (modifier, stModifier) <--              if resetCaptureNumbers-                 then return (id, id)-                 else lift (char '?' *> pGroupModifiers)-                    <|> do modify (\st -> st{-                                      rsCurrentCaptureNumber =-                                             rsCurrentCaptureNumber st + 1})-                           num <- gets rsCurrentCaptureNumber-                           pure (MatchCapture num, id)-  currentCaptureNumber <- gets rsCurrentCaptureNumber-  contents <- option MatchNull $ withStateT stModifier $-    foldr MatchAlt-      <$> pAltPart-      <*> many (lift (char '|') *>-            ((when resetCaptureNumbers-                  (modify (\st ->-                        st{ rsCurrentCaptureNumber = currentCaptureNumber }))-               >> pAltPart) <|> pure mempty))-  _ <- lift (char ')')-  return $ modifier contents+  pInlineModifiers <|> do+    -- pcrepattern says: A group that starts with (?| resets the capturing+    -- parentheses numbers in each alternative.+    resetCaptureNumbers <- option False (True <$ lift (string "?|"))+    (modifier, stModifier) <-+                if resetCaptureNumbers+                   then return (id, id)+                   else lift (char '?' *> pGroupModifiers)+                      <|> do modify (\st -> st{+                                        rsCurrentCaptureNumber =+                                               rsCurrentCaptureNumber st + 1})+                             num <- gets rsCurrentCaptureNumber+                             pure (MatchCapture num, id)+    currentCaptureNumber <- gets rsCurrentCaptureNumber+    -- modifiers like (?i: or (?U: are scoped to the group, so save the+    -- current flags and restore them after the closing parenthesis:+    oldCaseSensitive <- gets rsCaseSensitive+    oldMinimal <- gets rsMinimal+    modify stModifier+    contents <- do+      x <- pAltPart <|> pure mempty+      n0 <- gets rsCurrentCaptureNumber+      let pNextAlt = do+            _ <- lift (char '|')+            when resetCaptureNumbers $+              modify (\st ->+                       st{ rsCurrentCaptureNumber = currentCaptureNumber })+            y <- pAltPart <|> pure mempty+            n <- gets rsCurrentCaptureNumber+            pure (y, n)+      rest <- many pNextAlt+      -- with (?|, numbering after the group resumes after the highest+      -- group number used in any alternative, as in PCRE:+      when resetCaptureNumbers $+        modify (\st ->+                 st{ rsCurrentCaptureNumber = maximum (n0 : map snd rest) })+      pure (foldr1 MatchAlt (x : map fst rest))+    _ <- lift (char ')')+    modify $ \st -> st{ rsCaseSensitive = oldCaseSensitive+                      , rsMinimal = oldMinimal }+    return $ modifier contents +-- Inline modifiers like (?i) or (?-i), without a colon, apply from+-- this point to the end of the enclosing group (or pattern).  The+-- state change persists after the closing parenthesis; the enclosing+-- group's save/restore of rsCaseSensitive provides the scoping.+pInlineModifiers :: RParser Regex+pInlineModifiers = do+  stModifier <- lift $ char '?' *> pRegexModifier <* char ')'+  modify stModifier+  return MatchNull+ pGroupModifiers :: Parser (Regex -> Regex, RState -> RState) pGroupModifiers =   (do stmod <- pRegexModifier -- (?i:@@ -100,33 +139,55 @@         ((AssertPositive dir, id) <$ char '=') <|>           ((AssertNegative dir, id) <$ char '!')    <|>-     do c <- digit-        return (\_ -> Subroutine (ord c - 48), id)+     do ds <- many1 digit+        case readMay ds of+          Just !n -> return (\_ -> Subroutine n, id)+          Nothing -> fail "not a number"    <|>      do void $ char 'R'         return  (\_ -> Subroutine 0, id)+   <|> -- atomic group (?>...): no backtracking into the group+     ((Possessive, id) <$ char '>')  pRegexModifier :: Parser (RState -> RState) pRegexModifier = do-  -- "adlupimnsx-imnsx"-  -- i = 105  - = 45-  ons <- many $ satisfy (inClass "adlupimnsx")+  -- Of PCRE's inline flags we implement i and U (ungreedy).  We also+  -- accept m and s, which are no-ops for us: subjects are single+  -- lines, so there are no newlines for (?s) to let . match or for+  -- (?m) to change the meaning of ^ and $.  Flags that would change+  -- semantics we don't implement (x, n, ...) are rejected, causing a+  -- compile error, as unknown flags do in PCRE.  Turning flags *off*+  -- is always safe, since only i and U are ever on.+  ons <- many $ satisfy (inClass "imsU")   offs <- option [] $ char '-' *>-                      many (satisfy (inClass "imnsx"))+                      many (satisfy (inClass "imnsxU"))   pure $ \st -> st{     rsCaseSensitive =       if 'i' `elem` ons && 'i' `notElem` offs          then False          else ('i' `elem` offs) || rsCaseSensitive st+  , rsMinimal =+      if 'U' `elem` ons && 'U' `notElem` offs+         then True+         else ('U' `notElem` offs) && rsMinimal st   }  pSuffix :: Regex -> RParser Regex+-- a quantifier after an anchor or word-boundary assertion is a+-- compile error in PCRE ("quantifier does not follow a repeatable+-- item").  We get the same effect by leaving the quantifier+-- unconsumed: *, +, and ? are rejected by pRegexChar as special, and+-- { is rejected there when it begins a valid quantifier.+pSuffix re@AssertBeginning = pure re+pSuffix re@AssertEnd = pure re+pSuffix re@AssertWordBoundary = pure re pSuffix re = option re $ do   w <- lift $ satisfy (inClass "*+?{")-  (case w of-    '*'  -> return $ MatchAlt (MatchSome re) MatchNull-    '+'  -> return $ MatchSome re-    '?'  -> return $ MatchAlt re MatchNull+  case w of+    '*'  -> withModifier (MatchAlt (MatchSome re) MatchNull)+                         (MatchAlt MatchNull (Lazy (MatchSome re)))+    '+'  -> withModifier (MatchSome re) (Lazy (MatchSome re))+    '?'  -> withModifier (MatchAlt re MatchNull) (MatchAlt MatchNull re)     '{'  -> do       minn <- lift $         option Nothing $ readMay . T.unpack <$> A.takeWhile isDigit@@ -134,24 +195,64 @@                        (readMay . T.unpack <$> A.takeWhile isDigit)       _ <- lift $ char '}'       case (minn, maxn) of-          (Nothing, Nothing) -> mzero-          (Just n, Nothing)  -> return $! atleast n re-          (Nothing, Just n)  -> return $! atmost n re-          (Just m, Just n)   -> return $! between m n re-    _   -> fail "pSuffix encountered impossible byte") >>=-             lift . pQuantifierModifier+          _ | maybe False (> maxRepeat) minn ||+              maybe False (> maxRepeat) maxn+                             -> mzero -- the unconsumed {..} then causes a+                                      -- parse error via pRegexChar, as in+                                      -- PCRE ("number too big in {}+                                      -- quantifier")+          (Nothing, Nothing) -> mzero -- {} and {,} are literal+          (Just n, Nothing)  -> withModifier (atleast n re) (atleastLazy n re)+          (Nothing, Just n)  -> withModifier (atmost n re) (atmostLazy n re)+          (Just m, Just n)+            | m > n          -> mzero -- e.g. a{3,1}: the unconsumed {..}+                                      -- then causes a parse error via+                                      -- pRegexChar, as in PCRE ("numbers+                                      -- out of order in {} quantifier")+            | otherwise      -> withModifier (between m n re)+                                             (betweenLazy m n re)+    _   -> fail "pSuffix encountered impossible byte"  where-   atmost 0 _ = MatchNull-   atmost n r = MatchAlt (mconcat (replicate n r)) (atmost (n-1) r)+   -- A lazy quantifier prefers fewer repetitions, which is expressed+   -- by putting the empty alternative first; Lazy itself is only ever+   -- applied to MatchSome (the matcher relies on this).  A possessive+   -- quantifier commits to the preferred match of the greedy version.+   -- In minimal (ungreedy) mode the roles of the bare quantifier and+   -- the ? modifier are swapped, as with PCRE's UNGREEDY option;+   -- possessive quantifiers are unaffected.+   withModifier :: Regex -> Regex -> RParser Regex+   withModifier greedy lazy = do+     minimal <- gets rsMinimal+     let (bare, questioned) = if minimal+                                 then (lazy, greedy)+                                 else (greedy, lazy)+     lift $ (Possessive greedy <$ char '+') <|> (questioned <$ char '?')+            <|> pure bare +   -- repeat counts larger than this (the limit PCRE2 uses) are not+   -- treated as quantifiers:+   maxRepeat = 65535 :: Int++   -- nest the optional matches -- r(r(r)?)? -- so that the size of+   -- the compiled regex is linear, not quadratic, in n:+   atmost n r+     | n <= 0 = MatchNull+     | otherwise = MatchAlt (r <> atmost (n - 1) r) MatchNull++   atmostLazy n r+     | n <= 0 = MatchNull+     | otherwise = MatchAlt MatchNull (r <> atmostLazy (n - 1) r)+    between 0 n r = atmost n r    between m n r = mconcat (replicate m r) <> atmost (n - m) r +   betweenLazy 0 n r = atmostLazy n r+   betweenLazy m n r = mconcat (replicate m r) <> atmostLazy (n - m) r+    atleast n r = mconcat (replicate n r) <> MatchAlt (MatchSome r) MatchNull -pQuantifierModifier :: Regex -> Parser Regex-pQuantifierModifier re = option re $-  (Possessive re <$ char '+') <|> (Lazy re <$ char '?')+   atleastLazy n r = mconcat (replicate n r) <>+                     MatchAlt MatchNull (Lazy (MatchSome r))  pRegexChar :: RParser Regex pRegexChar = do@@ -165,52 +266,98 @@                 Just !n -> return $ MatchDynamic n                 Nothing -> fail "not a number")             <|> return (MatchChar (== '%'))-    '\\' -> lift pRegexEscapedChar+    '\\' -> lift $ pRegexEscapedChar caseSensitive     '$'  -> return AssertEnd     '^'  -> return AssertBeginning-    '['  -> lift pRegexCharClass+    '['  -> lift $ pRegexCharClass caseSensitive+    '{'  -> do+      -- if this { begins a valid quantifier, there is nothing for it+      -- to repeat, which is a compile error in PCRE ("quantifier does+      -- not follow a repeatable item"); the same happens with a+      -- quantifier that pSuffix declined to consume (out-of-order or+      -- too-big repeat counts, which are also compile errors in PCRE):+      isQuantifier <- lift $ option False (True <$ pQuantifierShape)+      if isQuantifier+         then fail "quantifier does not follow a repeatable item"+         else return $ MatchChar (== '{')     _ | isSpecial w -> mzero       | otherwise -> return $!             MatchChar $ if caseSensitive                            then (== w)                            else (\d -> toLower d == toLower w) -pRegexEscapedChar :: Parser Regex-pRegexEscapedChar = do+-- The forms {m}, {m,}, {m,n}, and {,n} are quantifiers (PCRE also+-- recognizes {,n} as of 10.43); anything else beginning with { --+-- e.g. {}, {,}, {b}, or an unclosed {2 -- is a sequence of literal+-- characters.  Assumes the initial { has already been consumed.+pQuantifierShape :: Parser ()+pQuantifierShape = do+  _ <- (A.takeWhile1 isDigit <* option ',' (char ',' <* A.takeWhile isDigit))+        <|> (char ',' *> A.takeWhile1 isDigit)+  void $ char '}'++pRegexEscapedChar :: Bool -> Parser Regex+pRegexEscapedChar caseSensitive = do   c <- A.anyChar   (case c of     'b' -> return AssertWordBoundary     'B' -> return $ AssertNegative Forward AssertWordBoundary+    -- PCRE's \G asserts the position at which the match attempt+    -- started.  Since matching is always anchored at the start of+    -- the input we are given, that is the same as AssertBeginning:+    'G' -> return AssertBeginning+    -- PCRE's \A asserts the start of the subject.  Since matching is+    -- always anchored at the start of the input we are given, that is+    -- also the same as AssertBeginning:+    'A' -> return AssertBeginning     '{' -> do -- captured pattern: \1 \2 \{12}               ds <- many1 digit               _ <- char '}'               case readMay ds of-                Just !n -> return $ MatchCaptured n+                Just !n -> return $ MatchCaptured n caseSensitive                 Nothing -> fail "not a number"+    'g' -> do -- PCRE backreference syntax: \g1 \g{12}+              ds <- (char '{' *> many1 digit <* char '}') <|> many1 digit+              case readMay ds of+                Just !n -> return $ MatchCaptured n caseSensitive+                Nothing -> fail "not a number"     'd' -> return $ MatchChar isDigit     'D' -> return $ MatchChar (not . isDigit)     's' -> return $ MatchChar isSpace     'S' -> return $ MatchChar (not . isSpace)+    'h' -> return $ MatchChar isHorizSpace+    'H' -> return $ MatchChar (not . isHorizSpace)     'w' -> return $ MatchChar isWordChar     'W' -> return $ MatchChar (not . isWordChar)     'p' -> MatchChar <$> pUnicodeCharClass-    _ | isDigit c ->-       return $! MatchCaptured (ord c - ord '0')-      | otherwise -> mzero) <|> (MatchChar . (==) <$> pEscaped c)+    'P' -> MatchChar . (not .) <$> pUnicodeCharClass+    _ | isDigit c, c /= '0' -> -- \0 is an octal escape, not a backreference+       return $! MatchCaptured (ord c - ord '0') caseSensitive+      | otherwise -> mzero) <|> (matchLiteralChar <$> pEscaped c)+ where+   matchLiteralChar d = MatchChar $+     if caseSensitive+        then (== d)+        else \x -> toLower x == toLower d  pEscaped :: Char -> Parser Char pEscaped c =   case c of     '\\' -> return c     'a' -> return '\a'+    -- \b means backspace inside a character class (outside one, it is+    -- a word boundary assertion handled by pRegexEscapedChar):+    'b' -> return '\b'     'f' -> return '\f'     'n' -> return '\n'     'r' -> return '\r'     't' -> return '\t'     'v' -> return '\v'-    '0' -> do -- \0ooo matches octal ooo-      ds <- A.take 3-      case readMay ("'\\o" ++ T.unpack ds ++ "'") of+    '0' -> do -- \0 followed by up to two octal digits (as in PCRE)+      ds <- A.scan (0 :: Int) (\s w -> if s < 2 && isOctDigit w+                                          then Just (s + 1)+                                          else Nothing)+      case readMay ("'\\o0" ++ T.unpack ds ++ "'") of         Just x  -> return x         Nothing -> fail "invalid octal character escape"     _ | c >= '1' && c <= '7' -> do@@ -236,8 +383,8 @@     _ | isPunctuation c || isSymbol c || isSpace c -> return c       | otherwise -> fail $ "invalid escape \\" ++ [c] -pRegexCharClass :: Parser Regex-pRegexCharClass = do+pRegexCharClass :: Bool -> Parser Regex+pRegexCharClass caseSensitive = do   negated <- option False $ True <$ char '^'   let getEscapedClass = do         _ <- char '\\'@@ -245,6 +392,8 @@          <|> (not . isDigit <$ char 'D')          <|> (isSpace <$ char 's')          <|> (not . isSpace <$ char 'S')+         <|> (isHorizSpace <$ char 'h')+         <|> (not . isHorizSpace <$ char 'H')          <|> (isWordChar <$ char 'w')          <|> (not . isWordChar <$ char 'W')   let getPosixClass = do@@ -256,7 +405,8 @@              <|> ((\c -> isSpace c && c `notElem` ['\n','\r','\f','\v']) <$                    string "blank")              <|> (isControl <$ string "cntrl")-             <|> ((\c -> isPrint c || isSpace c) <$ string "graph:")+             <|> (isDigit <$ string "digit")+             <|> ((\c -> isPrint c && not (isSpace c)) <$ string "graph")              <|> (isLower <$ string "lower")              <|> (isUpper <$ string "upper")              <|> (isPrint <$ string "print")@@ -264,7 +414,7 @@              <|> (isSpace <$ string "space")              <|> ((\c -> isAlphaNum c ||                          generalCategory c == ConnectorPunctuation)-                   <$ string "word:")+                   <$ string "word")              <|> (isHexDigit <$ string "xdigit")         _ <- string ":]"         return $! if localNegated then not . res else res@@ -278,20 +428,36 @@         void $ A.string "\\Q"         cs <- manyTill anyChar (A.string "\\E")         return $! \c -> any (== c) cs-  brack <- option [] $ [(==']')] <$ char ']'+  -- a ] in first position is a literal; it may also be the start of+  -- a range, as in []-a]:+  brack <- option [] $ do+    _ <- char ']'+    (do d <- char '-' *> getC+        return [\x -> x >= ']' && x <= d])+      <|> return [(== ']')]   fs <- many (getQELiteral <|> getEscapedClass <|> getPosixClass <|> getCRange-              <|> (A.string "\\p" *> pUnicodeCharClass))+              <|> (A.string "\\p" *> pUnicodeCharClass)+              <|> (A.string "\\P" *> ((not .) <$> pUnicodeCharClass)))   void $ char ']'   let f c = any ($ c) $ brack ++ fs+  -- for case-insensitive matching, a character matches (or, if+  -- negated, is excluded) if any of its case variants matches:+  let f' c | caseSensitive = f c+           | otherwise = f c || f (toLower c) || f (toUpper c)   return $! MatchChar $ if negated-                           then not . f-                           else f+                           then not . f'+                           else f' --- character class \p{Lo}; we assume \p is already parsed+-- character class \p{Lo}, \p{^Lo}, or \pL; we assume \p is already+-- parsed pUnicodeCharClass :: Parser (Char -> Bool) pUnicodeCharClass = do-  ds <- char '{' *> A.takeWhile (/= '}') <* char '}'-  return $+  (negated, ds) <-+    (char '{' *> ((,) <$> option False (True <$ char '^')+                      <*> (A.takeWhile (/= '}') <* char '}')))+     <|> ((,) False . T.singleton <$> satisfy isAlpha)+  let neg = if negated then (not .) else id+  return $ neg $     (case ds of       "Lu" -> (== UppercaseLetter)       "Ll" -> (== LowercaseLetter)@@ -343,6 +509,14 @@       _    -> const False) . generalCategory  +-- PCRE's \h matches this fixed list of horizontal whitespace+-- characters (which is not the same as Unicode category Zs):+isHorizSpace :: Char -> Bool+isHorizSpace c =+  c == '\t' || c == ' ' || c == '\xA0' || c == '\x1680' || c == '\x180E' ||+  (c >= '\x2000' && c <= '\x200A') || c == '\x202F' || c == '\x205F' ||+  c == '\x3000'+ isSpecial :: Char -> Bool isSpecial '\\' = True isSpecial '?'  = True@@ -350,7 +524,9 @@ isSpecial '+'  = True -- isSpecial '{' = True -- this is okay except in suffixes isSpecial '[' = True-isSpecial ']' = True+-- an unmatched ] is treated as a literal (as in PCRE), so it is+-- not included here; the ] terminating a character class is consumed+-- by pRegexCharClass: isSpecial '%' = True isSpecial '(' = True isSpecial ')' = True
src/Regex/KDE/Match.hs view
@@ -5,13 +5,18 @@ {-# LANGUAGE BinaryLiterals #-} module Regex.KDE.Match  ( matchRegex+ , matchRegexWithGroups+ , extractCapturingGroups  ) where  import qualified Data.ByteString as B import Data.ByteString (ByteString) import qualified Data.ByteString.UTF8 as U+import Data.Char (toLower) import qualified Data.Set as Set import Data.Set (Set)+import Data.Bits (shiftL, (.|.))+import Data.Word (Word8) import Regex.KDE.Regex import qualified Data.IntMap.Strict as M #if !MIN_VERSION_base(4,11,0)@@ -21,20 +26,72 @@ -- Note that all matches are from the beginning of the string. -- The ^ anchor is implicit at the beginning of the regex. +-- To reproduce PCRE's leftmost-first (backtracking) semantics in a+-- set-based matcher, every match carries a path recording the choices+-- made to reach it: 0 for taking the left branch of an alternation or+-- continuing a greedy repetition, 1 for the right branch or ending+-- the repetition (for lazy repetitions the loop codes are reversed).+-- Comparing paths lexicographically gives the order in which a+-- backtracking matcher like PCRE would find the matches, so the+-- preferred match is always the one with the smallest path.++-- A sequence of binary choices, packed into an Integer (most recent+-- choice in the least significant bit) together with its length.+-- Compared lexicographically as a bit sequence, with a proper prefix+-- ordered before its extensions.+data Path = Path !Integer !Int+  deriving (Show, Eq)++instance Ord Path where+  compare (Path i1 l1) (Path i2 l2) =+    compare (i1 `shiftL` max 0 (l2 - l1)) (i2 `shiftL` max 0 (l1 - l2))+      <> compare l1 l2++emptyPath :: Path+emptyPath = Path 0 0++pathSnoc :: Path -> Word8 -> Path+pathSnoc (Path i l) b = Path ((i `shiftL` 1) .|. fromIntegral b) (l + 1)+ data Match =    Match { matchBytes    :: !ByteString          , matchOffset   :: !Int          , matchCaptures :: !(M.IntMap (Int, Int))                                   -- starting offset, length in bytes-         } deriving (Show, Eq)+         , matchPath     :: !Path+         } deriving (Show) --- preferred matches are <=+-- consistent with Ord (which ignores matchBytes, since all matches+-- in a given run share it):+instance Eq Match where+  m1 == m2 = compare m1 m2 == EQ++-- preferred matches are <=; the path (priority) is decisive, and the+-- other comparisons only make the order total: instance Ord Match where-  m1 <= m2-    | matchOffset m1 > matchOffset m2 = True-    | matchOffset m1 < matchOffset m2 = False-    | otherwise = matchCaptures m1 >= matchCaptures m2+  compare m1 m2 =+    compare (matchPath m1) (matchPath m2) <>+    compare (matchOffset m1) (matchOffset m2) <>+    compare (matchCaptures m1) (matchCaptures m2) +-- the state of a match, disregarding its priority+stateKey :: Match -> (Int, M.IntMap (Int, Int))+stateKey m = (matchOffset m, matchCaptures m)++-- append a choice to the path of every match+addChoice :: Word8 -> Set Match -> Set Match+addChoice !b = Set.map (\m -> m{ matchPath = pathSnoc (matchPath m) b })++-- Discard any match whose state coincides with that of a preferred+-- (smaller-path) match: their futures are identical, and a+-- backtracking matcher would explore the preferred one first.+dedup :: Set Match -> Set Match+dedup = snd . Set.foldl' step (Set.empty, Set.empty)+ where+  step (!seen, !out) m+    | stateKey m `Set.member` seen = (seen, out)+    | otherwise = (Set.insert (stateKey m) seen, Set.insert m out)+ mapMatching :: (Match -> Match) -> Set Match -> Set Match mapMatching f = Set.filter ((>= 0) . matchOffset) . Set.map f @@ -42,22 +99,28 @@ sizeLimit :: Int sizeLimit = 2000 --- prune matches if it gets out of hand+-- prune matches if it gets out of hand, keeping preferred matches prune :: Set Match -> Set Match prune ms = if Set.size ms > sizeLimit               then Set.take sizeLimit ms               else ms --- first argument is a map of capturing groups, needed for Subroutine.-exec :: M.IntMap Regex -> Direction -> Regex -> Set Match -> Set Match+-- first argument: the set of subroutine calls (group number, offset)+-- currently being evaluated -- used to prevent infinite recursion --+-- and a map of capturing groups, needed for Subroutine.+exec :: (Set (Int, Int), M.IntMap Regex)+     -> Direction -> Regex -> Set Match -> Set Match exec _ _ MatchNull = id-exec cgs dir (Lazy re) = -- note: the action is below under Concat-  exec cgs dir (MatchConcat (Lazy re) MatchNull)+exec cgs dir (Lazy (MatchSome re)) = someLoop cgs dir re 1 0+exec cgs dir (Lazy re) = -- Lazy is only applied to MatchSome (see Compile)+  exec cgs dir re exec cgs dir (Possessive re) =-  foldr-    (\elt s -> case Set.lookupMin (exec cgs dir re (Set.singleton elt)) of-                 Nothing -> s-                 Just m  -> Set.insert m s)+  -- commit to the first match (in backtracking order) of re; its+  -- internal choices are forgotten, so the path is reset:+  Set.foldl'+    (\s m -> case Set.lookupMin (exec cgs dir re (Set.singleton m)) of+               Nothing -> s+               Just m' -> Set.insert m'{ matchPath = matchPath m } s)     mempty exec cgs dir (MatchDynamic n) = -- if this hasn't been replaced, match literal   exec cgs dir (MatchChar (== '%') <>@@ -65,11 +128,16 @@ exec _ _ AssertEnd = Set.filter (\m -> matchOffset m == B.length (matchBytes m)) exec _ _ AssertBeginning = Set.filter (\m -> matchOffset m == 0) exec cgs _ (AssertPositive dir regex) =-  Set.unions . Set.map-    (\m -> Set.map (\m' -> -- we keep captures but not matches-                            m'{ matchBytes = matchBytes m,-                               matchOffset = matchOffset m })-           $ exec cgs dir regex (Set.singleton m))+  -- assertions are atomic: only the captures of the first match (in+  -- backtracking order) of the assertion are kept, as in PCRE:+  Set.foldl'+    (\s m -> case Set.lookupMin (exec cgs dir regex (Set.singleton m)) of+               Nothing -> s+               Just m' -> Set.insert+                            m'{ matchBytes = matchBytes m+                              , matchOffset = matchOffset m+                              , matchPath = matchPath m } s)+    mempty exec cgs _ (AssertNegative dir regex) =   Set.filter (\m -> null (exec cgs dir regex (Set.singleton m))) exec _ _ AssertWordBoundary = Set.filter atWordBoundary@@ -94,22 +162,7 @@         _                -> m{ matchOffset = -1 } exec cgs dir (MatchConcat (MatchConcat r1 r2) r3) =   exec cgs dir (MatchConcat r1 (MatchConcat r2 r3))-exec cgs Forward (MatchConcat (Lazy r1) r2) =-  Set.foldl Set.union mempty . Set.map-    (\m ->-      let ms1 = exec cgs Forward r1 (Set.singleton m)-       in if Set.null ms1-             then ms1-             else go ms1)- where-  go ms = case Set.lookupMax ms of   -- find shortest match-            Nothing -> Set.empty-            Just m' ->-              let s' = exec cgs Forward r2 (Set.singleton m')-               in if Set.null s'-                     then go (Set.delete m' ms)-                     else s'-exec cgs Forward (MatchConcat r1 r2) = -- TODO longest match first+exec cgs Forward (MatchConcat r1 r2) =   \ms ->     let ms1 = exec cgs Forward r1 ms      in if Set.null ms1@@ -117,14 +170,9 @@            else exec cgs Forward r2 (prune ms1) exec cgs Backward (MatchConcat r1 r2) =   exec cgs Backward r1 . exec cgs Backward r2-exec cgs dir (MatchAlt r1 r2) = \ms -> exec cgs dir r1 ms <> exec cgs dir r2 ms-exec cgs dir (MatchSome re) = go- where-  go ms = case exec cgs dir re ms of-            ms' | Set.null ms' -> Set.empty-                | ms' == ms    -> ms-                | otherwise    -> let ms'' = prune ms'-                                   in ms'' <> go ms''+exec cgs dir (MatchAlt r1 r2) = \ms ->+  dedup $ exec cgs dir r1 (addChoice 0 ms) <> exec cgs dir r2 (addChoice 1 ms)+exec cgs dir (MatchSome re) = someLoop cgs dir re 0 1 exec cgs dir (MatchCapture i re) =   Set.foldr Set.union Set.empty .    Set.map (\m ->@@ -134,26 +182,69 @@       let len = matchOffset m' - matchOffset m       in  m'{ matchCaptures = M.insert i (matchOffset m, len)                                   (matchCaptures m') }-exec _ dir (MatchCaptured n) = mapMatching matchCaptured+exec _ dir (MatchCaptured n caseSensitive) = mapMatching matchCaptured  where    matchCaptured m =      case M.lookup n (matchCaptures m) of        Just (offset, len) ->               let capture = B.take len $ B.drop offset $ matchBytes m               in  case dir of-                     Forward | B.isPrefixOf capture-                                 (B.drop (matchOffset m) (matchBytes m))+                     Forward+                       | caseSensitive+                       , B.isPrefixOf capture+                           (B.drop (matchOffset m) (matchBytes m))                         -> m{ matchOffset = matchOffset m + B.length capture }-                     Backward | B.isSuffixOf capture-                                 (B.take (matchOffset m) (matchBytes m))+                       | not caseSensitive+                       , Just len' <- ciPrefixLength (U.toString capture)+                             (B.drop (matchOffset m) (matchBytes m))+                        -> m{ matchOffset = matchOffset m + len' }+                     Backward+                       | caseSensitive+                       , B.isSuffixOf capture+                           (B.take (matchOffset m) (matchBytes m))                         -> m{ matchOffset = matchOffset m - B.length capture }+                       | not caseSensitive+                       , Just off' <- ciSuffixOffset+                             (reverse (U.toString capture))+                             (matchBytes m) (matchOffset m)+                        -> m{ matchOffset = off' }                      _  -> m{ matchOffset = -1 }        Nothing -> m{ matchOffset = -1 }-exec cgs dir (Subroutine i) =+exec (active, cgs) dir (Subroutine i) =   case M.lookup i cgs of     Nothing -> id  -- ignore references to nonexistent groups-    Just re' -> exec cgs dir re'+    Just re' -> \ms ->+      -- A subroutine that calls itself again without having consumed+      -- any input can never make progress: block re-entry at the same+      -- offset so that zero-progress recursion (e.g. `x|(?R)`) fails+      -- instead of looping forever.+      dedup $ Set.unions+        [ exec (Set.insert (i, matchOffset m) active, cgs) dir re'+            (Set.singleton m)+        | m <- Set.toList ms+        , (i, matchOffset m) `Set.notMember` active ] +-- Match one or more repetitions of a regex.  contB is the path code+-- appended when continuing with another repetition, stopB the one+-- appended when stopping: 0/1 for greedy, 1/0 for lazy repetitions,+-- so that the paths order the results the way a backtracking matcher+-- would find them.+someLoop :: (Set (Int, Int), M.IntMap Regex) -> Direction -> Regex+         -> Word8 -> Word8 -> Set Match -> Set Match+someLoop cgs dir re !contB !stopB = \ms0 ->+  let ms1 = dedup $ exec cgs dir re ms0  -- first, obligatory repetition+   in go (Set.map stateKey ms1) ms1+ where+  go !seen ms+    | Set.null ms = Set.empty+    | otherwise =+        let ms' = dedup $ prune $ exec cgs dir re (addChoice contB ms)+            -- Drop matches that revisit an already-seen state: they+            -- have no new futures, and this guarantees termination+            -- when an iteration can match the empty string.+            new = Set.filter (\m -> stateKey m `Set.notMember` seen) ms'+         in addChoice stopB ms <> go (seen <> Set.map stateKey new) new+ atWordBoundary :: Match -> Bool atWordBoundary m =   case lastCharOffset (matchBytes m) (matchOffset m) of@@ -163,46 +254,86 @@         (cur:next:_) -> isWordChar cur /= isWordChar next         _ -> True +-- If the characters of the first argument match the beginning of the+-- bytestring case-insensitively, return the length in bytes of the+-- matching prefix.+ciPrefixLength :: String -> ByteString -> Maybe Int+ciPrefixLength [] _ = Just 0+ciPrefixLength (c:cs) bs =+  case U.decode bs of+    Just (d, n) | toLower d == toLower c ->+      (n +) <$> ciPrefixLength cs (B.drop n bs)+    _ -> Nothing++-- If the characters of the first argument (reversed) match the+-- characters just before the given offset case-insensitively, return+-- the offset at which the match begins.+ciSuffixOffset :: String -> ByteString -> Int -> Maybe Int+ciSuffixOffset [] _ off = Just off+ciSuffixOffset (c:cs) bs off =+  case lastCharOffset bs off of+    Just off' | Just (d, _) <- U.decode (B.drop off' bs)+              , toLower d == toLower c -> ciSuffixOffset cs bs off'+    _ -> Nothing++-- Return the offset of the start of the (UTF-8 encoded) character+-- that ends at (i.e., whose last byte is just before) offset n. lastCharOffset :: ByteString -> Int -> Maybe Int lastCharOffset _ 0 = Nothing-lastCharOffset _ 1 = Just 0-lastCharOffset bs n =-  case B.index bs (n - 2) of-    w | w <  0b10000000 -> Just (n - 1)-      | w >= 0b11000000 -> Just (n - 1)-      | otherwise -> lastCharOffset bs (n - 1)+lastCharOffset bs n = go (n - 1)+ where+  go !k+    | k <= 0 = Just 0+    | isContinuationByte (B.index bs k) = go (k - 1)+    | otherwise = Just k+  isContinuationByte w = w >= 0b10000000 && w < 0b11000000  -- | Match a Regex against a (presumed UTF-8 encoded) ByteString, -- returning the matched text and a map of (offset, size) -- pairs for captures.  Note that all matches are from the--- beginning of the string (a @^@ anchor is implicit).  Note--- also that to avoid pathological performance in certain cases,--- the matcher is limited to considering 2000 possible matches--- at a time; when that threshold is reached, it discards--- smaller matches.  Hence certain regexes may incorrectly fail to--- match: e.g. @a*a{3000}$@ on a string of 3000 @a@s.+-- beginning of the string (a @^@ anchor is implicit).  As in+-- PCRE, the match returned is the first one that a backtracking+-- matcher would find (leftmost alternatives are preferred), which+-- is not necessarily the longest.  Note also that to avoid+-- pathological performance in certain cases, the matcher is limited+-- to considering 2000 possible matches at a time; when that+-- threshold is reached, it discards lower-priority matches.  Hence+-- certain regexes may incorrectly fail to match: e.g. @a*a{3000}$@+-- on a string of 3000 @a@s. matchRegex :: Regex            -> ByteString            -> Maybe (ByteString, M.IntMap (Int, Int))-matchRegex re bs =-  let capturingGroups = extractCapturingGroups re-  in  toResult <$> Set.lookupMin-               (exec capturingGroups Forward re-                  (Set.singleton (Match bs 0 M.empty)))+matchRegex re = matchRegexWithGroups (extractCapturingGroups re) re++-- | Like 'matchRegex', but takes the map of capturing groups (as+-- computed by 'extractCapturingGroups') as an argument, so that it+-- can be computed once per regex instead of once per match.  (The+-- map is only consulted for regexes containing subroutine calls+-- like @(?1)@ or @(?R)@.)+matchRegexWithGroups :: M.IntMap Regex+                     -> Regex+                     -> ByteString+                     -> Maybe (ByteString, M.IntMap (Int, Int))+matchRegexWithGroups capturingGroups re bs =+  toResult <$> Set.lookupMin+             (exec (Set.empty, capturingGroups) Forward re+                (Set.singleton (Match bs 0 M.empty emptyPath)))  where    toResult m = (B.take (matchOffset m) (matchBytes m), (matchCaptures m)) +-- | Extract the capturing groups of a regex, numbered as in the+-- regex, with the whole regex at key 0. extractCapturingGroups :: Regex -> M.IntMap Regex-extractCapturingGroups regex = M.singleton 0 regex <>-  case regex of-    MatchSome re -> extractCapturingGroups re-    MatchAlt re1 re2 ->-      extractCapturingGroups re1 <> extractCapturingGroups re2-    MatchConcat re1 re2 ->-      extractCapturingGroups re1 <> extractCapturingGroups re2-    MatchCapture i re -> M.singleton i re-    AssertPositive _ re -> extractCapturingGroups re-    AssertNegative _ re -> extractCapturingGroups re-    Possessive re -> extractCapturingGroups re-    Lazy re -> extractCapturingGroups re-    _ -> mempty+extractCapturingGroups regex = M.insert 0 regex (go regex)+ where+  -- Note: left-biased union means that with (?|...), which reuses+  -- group numbers, the first alternative's group wins.+  go (MatchSome re) = go re+  go (MatchAlt re1 re2) = go re1 <> go re2+  go (MatchConcat re1 re2) = go re1 <> go re2+  go (MatchCapture i re) = M.insert i re (go re)+  go (AssertPositive _ re) = go re+  go (AssertNegative _ re) = go re+  go (Possessive re) = go re+  go (Lazy re) = go re+  go _ = mempty
src/Regex/KDE/Regex.hs view
@@ -22,7 +22,7 @@   MatchAlt !Regex !Regex |   MatchConcat !Regex !Regex |   MatchCapture !Int !Regex |-  MatchCaptured !Int |+  MatchCaptured !Int !Bool | -- group number, case sensitivity   AssertWordBoundary |   AssertBeginning |   AssertEnd |@@ -43,7 +43,8 @@             ")"   show (MatchCapture i re) = "(MatchCapture " <> show i <> " " <>                 show re <> ")"-  show (MatchCaptured n) = "(MatchCaptured " <> show n <> ")"+  show (MatchCaptured n cs) = "(MatchCaptured " <> show n <> " " <>+                show cs <> ")"   show AssertWordBoundary = "AssertWordBoundary"   show AssertBeginning = "AssertBeginning"   show AssertEnd = "AssertEnd"
src/Skylighting/Core.hs view
@@ -39,13 +39,17 @@ -- | Lookup a syntax by full name (case insensitive). syntaxByName :: SyntaxMap -> Text -> Maybe Syntax syntaxByName syntaxmap name =-  Map.lookup (Text.toLower name) (Map.mapKeys Text.toLower syntaxmap)+  Map.lookup name syntaxmap `mplus`  -- fast path for exact match+    listToMaybe [s | (k, s) <- Map.toList syntaxmap+                   , Text.toLower k == lcname ]+ where lcname = Text.toLower name  -- | Lookup a syntax by short name (case insensitive). syntaxByShortName :: SyntaxMap -> Text -> Maybe Syntax syntaxByShortName syntaxmap name = listToMaybe   [s | s <- Map.elems syntaxmap-     , Text.toLower (sShortname s) == Text.toLower name ]+     , Text.toLower (sShortname s) == lcname ]+ where lcname = Text.toLower name  -- | Lookup syntax by (in order) full name (case insensitive), -- short name (case insensitive), extension.
src/Skylighting/Loader.hs view
@@ -64,7 +64,9 @@ -- SyntaxMap will be made up of only the files that could successfully be loaded -- and parsed. loadValidSyntaxesFromDir :: FilePath -> IO (LoadErrMap, SyntaxMap)-loadValidSyntaxesFromDir path = foldM go (mempty, mempty) =<< syntaxFiles path+loadValidSyntaxesFromDir path = do+    (errMap, sm) <- foldM go (mempty, mempty) =<< syntaxFiles path+    return (errMap, M.map (resolveKeywords sm) sm)   where     go (errMap, syntaxMap) file =       loadSyntaxFromFile file >>= \case
src/Skylighting/Parser.hs view
@@ -80,7 +80,10 @@                            _       -> defaultVal  -- | Parses a file containing a Kate XML syntax definition--- into a 'Syntax' description.+-- into a 'Syntax' description.  Note that the resulting 'Syntax'+-- must be processed with 'resolveKeywords' (once the full syntax+-- map is assembled) before it can be used for tokenizing; the+-- functions in Skylighting.Loader do this automatically. parseSyntaxDefinition :: FilePath -> IO (Either String Syntax) parseSyntaxDefinition fp = do   bs <- BL.readFile fp@@ -146,7 +149,7 @@    let itemDatas = getItemData hlEl -  let defKeywordAttr = getKeywordAttrs rootEl+  let defKeywordAttr = getKeywordAttrs casesensitive rootEl    let contextEls = getElementsNamed "contexts" hlEl >>=                    getElementsNamed "context"@@ -154,7 +157,7 @@   let syntaxname = getAttrValue "name" rootEl    contexts <- mapM-    (getContext casesensitive syntaxname itemDatas lists defKeywordAttr)+    (getContext syntaxname itemDatas lists defKeywordAttr)     contextEls    startingContext <- case contexts of@@ -216,24 +219,35 @@            | otherwise -> (T.drop 2 y, x)  getParser :: Monad m-          => Bool -> Text -> ItemData -> M.Map Text [ListItem] -> KeywordAttr+          => Text -> ItemData -> M.Map Text [ListItem] -> KeywordAttr           -> Text -> Element -> ExceptT String m Rule-getParser casesensitive syntaxname itemdatas lists kwattr cattr el = do+getParser syntaxname itemdatas lists kwattr cattr el = do   let name = nameLocalName . elementName $ el   let attribute = getAttrValue "attribute" el   let context = getAttrValue "context" el   let char0 = readChar $ getAttrValue "char" el   let char1 = readChar $ getAttrValue "char1" el   let str' = getAttrValue "String" el-  let insensitive = vBool (not casesensitive) $ getAttrValue "insensitive" el+  -- rules default to case-sensitive matching; the language's+  -- casesensitive attribute applies only to keyword lists (as in KDE):+  let insensitive = vBool False $ getAttrValue "insensitive" el   let includeAttrib = vBool False $ getAttrValue "includeAttrib" el   let weakDelim = Set.fromList $ T.unpack $ getAttrValue "weakDeliminator" el+  let additionalDelim = Set.fromList $ T.unpack $+                          getAttrValue "additionalDeliminator" el+  -- In KDE the word delimiters of a rule are the language's word+  -- delimiters (standard delimiters as modified by additionalDeliminator+  -- and weakDeliminator on general > keywords, which we get from+  -- kwattr), further modified by the additionalDeliminator and+  -- weakDeliminator attributes on the rule itself:+  let ruleDelims = Set.union (keywordDelims kwattr) additionalDelim+                     Set.\\ weakDelim   let lookahead = vBool False $ getAttrValue "lookAhead" el   let firstNonSpace = vBool False $ getAttrValue "firstNonSpace" el   let column' = getAttrValue "column" el   let dynamic = vBool False $ getAttrValue "dynamic" el-  children <- mapM (getParser casesensitive-                    syntaxname itemdatas lists kwattr attribute)+  let minimal = vBool False $ getAttrValue "minimal" el+  children <- mapM (getParser syntaxname itemdatas lists kwattr attribute)                   [e | NodeElement e <- elementNodes el ]   let tildeRegex = name == "RegExpr" && T.take 1 str' == "^"   let str = if tildeRegex then T.drop 1 str' else str'@@ -242,11 +256,13 @@                   else either (\_ -> Nothing) (Just . fst) $                          TR.decimal column'   let re = RegExpr RE{ reString = TE.encodeUtf8 str-                     , reCaseSensitive = not insensitive }+                     , reCaseSensitive = not insensitive+                     , reMinimal = minimal }+  let contextSwitches = parseContextSwitches syntaxname context   let (incsyntax, inccontext) =-          case T.breakOn "##" context of-                (_,x) | T.null x -> (syntaxname, context)-                (cont, lang)     -> (T.drop 2 lang, cont)+        case contextSwitches of+          (Push (s,c) : _)  -> (s,c)+          _ -> error "IncludeRules doesn't specify a syntax and context"   matcher <- case name of                  "DetectChar" -> return $ DetectChar char0                  "Detect2Chars" -> return $ Detect2Chars char0 char1@@ -255,34 +271,50 @@                  "StringDetect" -> return $ StringDetect str                  "WordDetect" -> return $ WordDetect str                  "RegExpr" -> return $ re-                 "keyword" -> return $ Keyword kwattr (Left str)+                 -- an insensitive attribute on the keyword rule itself+                 -- (if present) overrides the case sensitivity of the+                 -- keyword list, and additionalDeliminator and+                 -- weakDeliminator attributes adjust its delimiters+                 -- (as in KDE):+                 "keyword" -> return $+                   let kwattr' = if M.member (String.fromString "insensitive")+                                      (elementAttributes el)+                                    then kwattr{ keywordCaseSensitive =+                                                   not insensitive }+                                    else kwattr+                    in Keyword kwattr'{ keywordDelims = ruleDelims }+                               (Left str)                  "Int" -> return $ Int                  "Float" -> return $ Float                  "HlCOct" -> return $ HlCOct                  "HlCHex" -> return $ HlCHex                  "HlCStringChar" -> return $ HlCStringChar                  "HlCChar" -> return $ HlCChar-                 "LineContinue" -> return $ LineContinue+                 -- KDE uses the first character of the char attribute,+                 -- or backslash if it is absent or empty:+                 "LineContinue" -> return $ LineContinue $+                    case T.uncons (getAttrValue "char" el) of+                      Just (c, _) -> c+                      Nothing     -> '\\'                  "IncludeRules" -> return $                    IncludeRules (incsyntax, inccontext)                  "DetectSpaces" -> return $ DetectSpaces                  "DetectIdentifier" -> return $ DetectIdentifier                  _ -> throwError $ "Unknown element " ++ T.unpack name -  let contextSwitch = if name == "IncludeRules"-                         then []  -- is this right?-                         else parseContextSwitch incsyntax inccontext   return $ Rule{ rMatcher = matcher                , rAttribute = fromMaybe NormalTok $                     if T.null attribute                        then M.lookup cattr itemdatas                        else M.lookup attribute itemdatas                , rIncludeAttribute = includeAttrib-               , rWeakDeliminators = weakDelim+               , rWordDelimiters = ruleDelims                , rDynamic = dynamic                , rCaseSensitive = not insensitive                , rChildren = children-               , rContextSwitch = contextSwitch+               , rContextSwitch = if name == "IncludeRules"+                                     then []+                                     else contextSwitches                , rLookahead = lookahead                , rFirstNonspace = firstNonSpace                , rColumn = column@@ -290,25 +322,22 @@   getContext :: Monad m-           => Bool-           -> Text+           => Text            -> ItemData            -> M.Map Text [ListItem]            -> KeywordAttr            -> Element            -> ExceptT String m Context-getContext casesensitive syntaxname itemDatas lists kwattr el = do+getContext syntaxname itemDatas lists kwattr el = do   let name = getAttrValue "name" el   let attribute = getAttrValue "attribute" el   let lineEmptyContext = getAttrValue "lineEmptyContext" el   let lineEndContext = getAttrValue "lineEndContext" el-  let lineBeginContext = getAttrValue "lineBeginContext" el   let fallthrough = vBool False $ getAttrValue "fallthrough" el   let fallthroughContext = getAttrValue "fallthroughContext" el   let dynamic = vBool False $ getAttrValue "dynamic" el -  parsers <- mapM (getParser casesensitive-                    syntaxname itemDatas lists kwattr attribute)+  parsers <- mapM (getParser syntaxname itemDatas lists kwattr attribute)                   [e | NodeElement e <- elementNodes el ]    return $ Context {@@ -316,15 +345,19 @@           , cSyntax = syntaxname           , cRules = parsers           , cAttribute = fromMaybe NormalTok $ M.lookup attribute itemDatas+            -- lineEmptyContext defaults to lineEndContext when it is+            -- unspecified or #stay; this avoids skipping empty lines+            -- after a line continuation character (KDE context.cpp,+            -- Context::resolveContexts, see kde bug 405903):           , cLineEmptyContext =-               parseContextSwitch syntaxname lineEmptyContext+               case parseContextSwitches syntaxname lineEmptyContext of+                 [] -> parseContextSwitches syntaxname lineEndContext+                 cs -> cs           , cLineEndContext =-               parseContextSwitch syntaxname lineEndContext-          , cLineBeginContext =-               parseContextSwitch syntaxname lineBeginContext+               parseContextSwitches syntaxname lineEndContext           , cFallthrough = fallthrough           , cFallthroughContext =-               parseContextSwitch syntaxname fallthroughContext+               parseContextSwitches syntaxname fallthroughContext           , cDynamic = dynamic           } @@ -334,33 +367,41 @@     | e <- (getElementsNamed "itemDatas" el >>= getElementsNamed "itemData")   ] -getKeywordAttrs :: Element -> KeywordAttr-getKeywordAttrs el =+-- The default case sensitivity of keyword lists is given by the+-- casesensitive attribute on the language element, and may be+-- overridden by the casesensitive attribute on general > keywords:+getKeywordAttrs :: Bool -> Element -> KeywordAttr+getKeywordAttrs casesensitive el =   case (getElementsNamed "general" el >>= getElementsNamed "keywords") of-     []    -> defaultKeywordAttr+     []    -> defaultKeywordAttr{ keywordCaseSensitive = casesensitive }      (x:_) ->        let weakDelim = T.unpack $ getAttrValue "weakDeliminator" x            additionalDelim = T.unpack $ getAttrValue "additionalDeliminator" x         in KeywordAttr { keywordCaseSensitive =-                             vBool True $ getAttrValue "casesensitive" x+                             vBool casesensitive $ getAttrValue "casesensitive" x                        , keywordDelims = Set.union standardDelims                            (Set.fromList additionalDelim)                              Set.\\ Set.fromList weakDelim } -parseContextSwitch :: Text -> Text -> [ContextSwitch]-parseContextSwitch syntaxname t =+parseContextSwitches :: Text -> Text -> [ContextSwitch]+parseContextSwitches syntaxname t =   if T.null t || t == "#stay"      then []      else        case T.stripPrefix "#pop" t of-         Just rest -> Pop : parseContextSwitch syntaxname rest-         Nothing   ->-           let (othersyntax, contextname) =-                  splitContext (T.dropWhile (=='!') t)-               syntaxname' = if T.null othersyntax-                                then syntaxname-                                else othersyntax-            in [Push (syntaxname', contextname)]+          Just rest ->+            Pop : parseContextSwitches syntaxname rest+          Nothing ->+            -- a sequence of contexts separated by !; in+            -- A!B!C, C is the top of the stack.+            let cs = filter (not . T.null) $ T.split (== '!') t+                toContext x =+                  let (othersyntax, contextname) = splitContext x+                      syntaxname' = if T.null othersyntax+                                       then syntaxname+                                       else othersyntax+                   in (syntaxname', contextname)+            in map (Push . toContext) cs  type ItemData = M.Map Text TokenType
src/Skylighting/Regex.hs view
@@ -8,10 +8,11 @@ module Skylighting.Regex (                 Regex(..)               , RE-              , pattern RE, reCaseSensitive, reString+              , pattern RE, reCaseSensitive, reMinimal, reString               , compileRE               , compileRegex               , matchRegex+              , matchRegexWithGroups               , testRegex               , isWordChar               ) where@@ -21,6 +22,7 @@ import qualified Data.ByteString.Base64 as Base64 import qualified Data.ByteString.Char8 as BS import Data.Data+import qualified Data.IntMap.Strict as M import qualified Data.Text as Text import qualified Data.Text.Encoding as TE #if !MIN_VERSION_base(4,13,0)@@ -34,25 +36,33 @@ data RE = RE'{     _reString        :: BS.ByteString   , _reCaseSensitive :: Bool-  , _reCompiled      :: Either String Regex+  , _reMinimal       :: Bool+  , _reCompiled      :: Either String (Regex, M.IntMap Regex) } deriving Typeable --- We define a smart constructor which also holds the compiled regex, to avoid--- recompiling each time we tokenize.+-- We define a smart constructor which also holds the compiled regex+-- and its capturing groups, to avoid recomputing them each time we+-- tokenize.  {-# COMPLETE RE #-}-pattern RE :: BS.ByteString -> Bool  -> RE-pattern RE {reString, reCaseSensitive} <- RE' reString reCaseSensitive _ where-  RE str caseSensitive = RE' str caseSensitive (compileRegex caseSensitive str)+pattern RE :: BS.ByteString -> Bool -> Bool -> RE+pattern RE {reString, reCaseSensitive, reMinimal} <-+  RE' reString reCaseSensitive reMinimal _ where+  RE str caseSensitive minimal =+    RE' str caseSensitive minimal+        (fmap (\r -> (r, extractCapturingGroups r))+              (compileRegex caseSensitive minimal str))  -- Unfortunately this means we need to derive all the instances ourselves.  instance Show RE where-  showsPrec d (RE str caseSensitive) = showParen (d > 10) -    $ showString "RE {reString = " +  showsPrec d (RE str caseSensitive minimal) = showParen (d > 10)+    $ showString "RE {reString = "     . showsPrec 11 str     . showString ", reCaseSensitive = "     . showsPrec 11 caseSensitive+    . showString ", reMinimal = "+    . showsPrec 11 minimal     . showString "}"  instance Read RE where@@ -66,11 +76,15 @@     Ident "reCaseSensitive" <- lexP     Punc "=" <- lexP     caseSensitive <- readPrec+    Punc "," <- lexP+    Ident "reMinimal" <- lexP+    Punc "=" <- lexP+    minimal <- readPrec     Punc "}" <- lexP-    pure (RE str caseSensitive)+    pure (RE str caseSensitive minimal) -toComparisonKey :: RE -> (BS.ByteString, Bool)-toComparisonKey (RE x y) = (x, y)+toComparisonKey :: RE -> (BS.ByteString, Bool, Bool)+toComparisonKey (RE x y z) = (x, y, z)  instance Eq RE where   x == y = toComparisonKey x == toComparisonKey y@@ -84,22 +98,24 @@ tyRE   = mkDataType "Skylighting.Regex.RE" [conRE]  instance Data RE where-  gfoldl k z (RE s c) = z RE `k` s `k` c-  gunfold k z _ = k (k (z RE))+  gfoldl k z (RE s c m) = z RE `k` s `k` c `k` m+  gunfold k z _ = k (k (k (z RE)))   toConstr _ = conRE   dataTypeOf _ = tyRE  instance Binary RE where-  put (RE x y) = put x >> put y-  get = RE <$> get <*> get+  put (RE x y z) = put x >> put y >> put z+  get = RE <$> get <*> get <*> get  instance ToJSON RE where   toJSON re = object [ "reString"        .= encodeToText (reString re)-                     , "reCaseSensitive" .= reCaseSensitive re ]+                     , "reCaseSensitive" .= reCaseSensitive re+                     , "reMinimal"       .= reMinimal re ] instance FromJSON RE where   parseJSON = withObject "RE" $ \v ->     RE <$> ((v .: "reString") >>= decodeFromText)        <*> v .: "reCaseSensitive"+       <*> v .:? "reMinimal" .!= False  -- functions to marshall bytestrings to text @@ -109,5 +125,7 @@ decodeFromText :: (Monad m, MonadFail m) => Text.Text -> m BS.ByteString decodeFromText = either fail return . Base64.decode . TE.encodeUtf8 -compileRE :: RE -> Either String Regex+-- | The compiled regex and its capturing groups (cached in the+-- 'RE' by the smart constructor).+compileRE :: RE -> Either String (Regex, M.IntMap Regex) compileRE = _reCompiled
src/Skylighting/Tokenizer.hs view
@@ -34,7 +34,6 @@ import Debug.Trace import Skylighting.Regex import Skylighting.Types-import Skylighting.Parser (resolveKeywords) import Data.List.NonEmpty (NonEmpty((:|)), (<|), toList) #if !MIN_VERSION_base(4,11,0) import Data.Semigroup@@ -56,6 +55,9 @@   , column              :: Int   , lineContinuation    :: Bool   , firstNonspaceColumn :: Maybe Int+  , loopCounter         :: Int+    -- ^ number of consecutive rule-matching iterations without+    -- consuming any input; used to guard against endless loops }  -- | Configuration options for 'tokenize'.@@ -137,20 +139,23 @@                                       z            -> z)  -- | Tokenize some text using 'Syntax'.+-- Note that the syntax definitions are assumed to have their+-- keyword lists already resolved into word sets (as is the case+-- for the bundled syntax definitions and for definitions loaded+-- with the functions in Skylighting.Loader).  If you construct a+-- syntax map yourself from syntaxes parsed with+-- 'Skylighting.Parser.parseSyntaxDefinition', apply+-- 'Skylighting.Parser.resolveKeywords' to each syntax first. tokenize :: TokenizerConfig -> Syntax -> Text -> Either String [SourceLine] tokenize config syntax inp =   eitherStack >>= \(!stack) ->-    case runTokenizerM action-            config{ syntaxMap = Map.map (resolveKeywords (syntaxMap config))-                                          (syntaxMap config) }-            (startingState stack) of+    case runTokenizerM action config (startingState stack) of        (_, Success ls) -> Right ls        (_, Error e)    -> Left e        (_, Failure)    -> Left "Could not tokenize code"   where     action = mapM tokenizeLine (zip (BS.lines (encodeUtf8 inp)) [1..])-    eitherStack = case lookupContext (sStartingContext syntax)-                         (resolveKeywords (syntaxMap config) syntax) of+    eitherStack = case lookupContext (sStartingContext syntax) syntax of                     Just c  -> Right $ ContextStack ((c, Captures mempty) :| [])                     Nothing -> Left "No starting context specified"     startingState stack =@@ -162,6 +167,7 @@                     , column = 0                     , lineContinuation = False                     , firstNonspaceColumn = Nothing+                    , loopCounter = 0                     }  info :: String -> TokenizerM ()@@ -240,35 +246,86 @@  tokenizeLine :: (ByteString, Int) -> TokenizerM [Token] tokenizeLine (!ln, !linenum) = do-  modify $ \st -> st{ input = ln, endline = BS.null ln, prevChar = '\n' }-  cur <- currentContext-  lineCont <- gets lineContinuation-  if lineCont-     then modify $ \st -> st{ lineContinuation = False }-     else do-       let !mbFirstNonspace = BS.findIndex (not . isSpace) $! ln-       modify $ \st -> st{ column = 0-                         , firstNonspaceColumn = mbFirstNonspace }-       doContextSwitches (cLineBeginContext cur)+  -- column and firstNonspaceColumn restart on every physical line;+  -- a line continuation only suppresses the previous line's+  -- lineEndContext (KDE abstracthighlighter.cpp, highlightLine).+  let !mbFirstNonspace = BS.findIndex (not . isSpace) $! ln+  modify $ \st -> st{ input = ln+                    , endline = BS.null ln+                    , prevChar = '\n'+                    , lineContinuation = False+                    , column = 0+                    , firstNonspaceColumn = mbFirstNonspace+                    , loopCounter = 0 }   if BS.null ln-     then doContextSwitches (cLineEmptyContext cur)-     else doContextSwitches (cLineBeginContext cur)-  ts <- normalizeHighlighting . catMaybes <$> many getToken-  eol <- gets endline-  if eol      then do-       currentContext >>= checkLineEnd-       return ts-     else do  -- fail if we haven't consumed whole line-       col <- gets column-       throwError $ "Could not match anything at line " ++-         show linenum ++ " column " ++ show col+       -- Empty lines get only the lineEmptyContext switches (which+       -- default to the lineEndContext switches), applied for+       -- successive top contexts until #stay; the lineEndContext is+       -- not applied separately (KDE abstracthighlighter.cpp).+       handleEmptyLine loopLimit+       return []+     else do+       ts <- normalizeHighlighting . catMaybes <$> many getToken+       eol <- gets endline+       if eol+          then do+            checkLineEnd+            return ts+          else do  -- fail if we haven't consumed whole line+            col <- gets column+            throwError $ "Could not match anything at line " +++              show linenum ++ " column " ++ show col +-- | Limit on iterations that make no progress, to avoid endless+-- loops with broken syntax definitions, as in KDE's+-- abstracthighlighter.cpp.+loopLimit :: Int+loopLimit = 1024++-- | Apply line-empty context switches for successive top contexts+-- until a context with no switches (#stay) is on top, guarding+-- against endless loops (KDE abstracthighlighter.cpp, highlightLine).+handleEmptyLine :: Int -> TokenizerM ()+handleEmptyLine counter = do+  cur <- currentContext+  case cLineEmptyContext cur of+    [] -> return ()  -- #stay+    switches+      | counter <= 0 -> info $ "Endless switch context transitions " +++          "for line empty context, aborting highlighting of line."+      | otherwise -> do+          before <- gets (fmap fst . unContextStack . contextStack)+          doContextSwitches switches+          after <- gets (fmap fst . unContextStack . contextStack)+          -- if the stack is unchanged (e.g. #pop of the initial+          -- context), stop:+          when (before /= after) $ handleEmptyLine (counter - 1)+ getToken :: TokenizerM (Maybe Token) getToken = do   inp <- gets input   gets endline >>= guard . not   !context <- currentContext+  counter <- gets loopCounter+  if counter > loopLimit+     -- too many iterations without consuming input (e.g. a cycle of+     -- context switches): abort highlighting of this line, giving+     -- the rest of it the context's attribute, as in KDE's+     -- abstracthighlighter.cpp.+     then do+       info "Endless state transitions, aborting highlighting of line."+       t <- decodeBS inp+       modify $ \st -> st{ input = BS.empty+                         , endline = True+                         , prevChar = Text.last t+                         , column = column st + Text.length t }+       return $ Just (cAttribute context, t)+     else getToken' context inp counter++getToken' :: Context -> ByteString -> Int -> TokenizerM (Maybe Token)+getToken' context inp counter = do+  modify $ \st -> st{ loopCounter = counter + 1 }   msum (map (\r -> tryRule r inp) (cRules context)) <|>      case cFallthroughContext context of            [] | cFallthrough context -> Nothing <$ doContextSwitches [Pop]@@ -289,7 +346,8 @@   modify $ \st -> st{ input = rest,                       endline = BS.null rest,                       prevChar = Text.last t,-                      column = column st + numchars }+                      column = column st + numchars,+                      loopCounter = 0 }  -- input was consumed: progress   return t  tryRule :: Rule -> ByteString -> TokenizerM (Maybe Token)@@ -313,6 +371,7 @@   modify $ \st -> st{ captures = Captures mempty }    let attr = rAttribute rule+  let delims = rWordDelimiters rule   mbtok <- case rMatcher rule of                 DetectChar c -> withAttr attr $ detectChar (rDynamic rule) c inp                 Detect2Chars c d -> withAttr attr $@@ -320,12 +379,12 @@                 AnyChar cs -> withAttr attr $ anyChar cs inp                 RangeDetect c d -> withAttr attr $ rangeDetect c d inp                 RegExpr re -> withAttr attr $ regExpr (rDynamic rule) re inp-                Int -> withAttr attr $ parseInt inp-                HlCOct -> withAttr attr $ parseOct inp-                HlCHex -> withAttr attr $ parseHex inp+                Int -> withAttr attr $ parseInt delims inp+                HlCOct -> withAttr attr $ parseOct delims inp+                HlCHex -> withAttr attr $ parseHex delims inp                 HlCStringChar -> withAttr attr $ parseCStringChar inp                 HlCChar -> withAttr attr $ parseCChar inp-                Float -> withAttr attr $ parseFloat inp+                Float -> withAttr attr $ parseFloat delims inp                 Keyword _kwattr (Left listname) ->                   throwError $ "Keyword with unresolved list " <> show listname                 Keyword kwattr (Right kws) ->@@ -335,8 +394,8 @@                                                  s inp                 WordDetect s -> withAttr attr $                                     wordDetect (rCaseSensitive rule)-                                      (rWeakDeliminators rule) s inp-                LineContinue -> withAttr attr $ lineContinue inp+                                      delims s inp+                LineContinue c -> withAttr attr $ lineContinue c inp                 DetectSpaces -> withAttr attr $ detectSpaces inp                 DetectIdentifier -> withAttr attr $ detectIdentifier inp                 IncludeRules cname -> includeRules@@ -350,17 +409,23 @@                  Nothing -> return Nothing                  Just (tt, s)                    | rLookahead rule -> do-                     (oldinput, oldendline, oldprevChar, oldColumn) <-+                     (oldinput, oldendline, oldprevChar, oldColumn,+                      oldLoopCounter) <-                          case oldstate of                               Nothing -> throwError                                     "oldstate not saved with lookahead rule"                               Just st -> return                                     (input st, endline st,-                                     prevChar st, column st)+                                     prevChar st, column st,+                                     loopCounter st)+                     -- restore loopCounter too: a lookahead match makes+                     -- no progress, so it must not reset the+                     -- endless-loop guard (takeChars reset it):                      modify $ \st -> st{ input = oldinput                                        , endline = oldendline                                        , prevChar = oldprevChar-                                       , column = oldColumn }+                                       , column = oldColumn+                                       , loopCounter = oldLoopCounter }                      return Nothing                    | otherwise -> do                      case mbchildren of@@ -381,24 +446,34 @@      then return Nothing      else return $ Just (tt, res) -wordDetect :: Bool -> Set.Set Char -> Text -> ByteString -> TokenizerM Text-wordDetect caseSensitive weakDelims s inp = do-  -- Removed the next line because KDE seems to allow-  -- \n<DOCTYPE! to match \b<DOCTYPE!/b:-  -- wordBoundary weakDelims inp-  t <- decodeBS $ UTF8.take (Text.length s) inp-  -- we assume here that the case fold will not change length,-  -- which is safe for ASCII keywords and the like...-  guard $ if caseSensitive-             then s == t-             else mk s == mk t+wordDetect :: Bool -> Set.Set Char -> Text -> ByteString+           -> TokenizerM Text+wordDetect caseSensitive delims s inp = do+  t <- if caseSensitive+          then do -- fast path: compare bytes without decoding+            guard $ encodeUtf8 s `BS.isPrefixOf` inp+            return s+          else do+            t <- decodeBS $ UTF8.take (Text.length s) inp+            -- we assume here that the case fold will not change length,+            -- which is safe for ASCII keywords and the like...+            guard $ mk s == mk t+            return t   guard $ not (Text.null t)+  let isDelim = (`Set.member` delims)+  -- KDE requires a word delimiter (or start of line) before the+  -- word, or as its first character (this is why \n<DOCTYPE!+  -- matches \b<DOCTYPE!/b):+  prev <- gets prevChar+  guard $ isDelim prev || isDelim (Text.head t)   let c = Text.last t   let rest = UTF8.drop (Text.length s) inp   let d = case UTF8.uncons rest of                Nothing    -> '\n'                Just (x,_) -> x-  guard $ isWordBoundary weakDelims c d+  -- ... and a word delimiter (or end of line) after the word, or+  -- as its last character:+  guard $ isDelim d || isDelim c   takeChars (Text.length t)  stringDetect :: Bool -> Bool -> Text -> ByteString -> TokenizerM Text@@ -409,12 +484,14 @@           info $ "Dynamic string: " ++ show dynStr           return dynStr         else return s-  t <- decodeBS $ UTF8.take (Text.length s') inp-  -- we assume here that the case fold will not change length,-  -- which is safe for ASCII keywords and the like...-  guard $ if caseSensitive-             then s' == t-             else mk s' == mk t+  if caseSensitive+     then -- fast path: compare bytes without decoding+          guard $ encodeUtf8 s' `BS.isPrefixOf` inp+     else do+       t <- decodeBS $ UTF8.take (Text.length s') inp+       -- we assume here that the case fold will not change length,+       -- which is safe for ASCII keywords and the like...+       guard $ mk s' == mk t   takeChars (Text.length s')  subDynamicText :: Text -> TokenizerM Text@@ -463,17 +540,29 @@                     (Just (NormalTok, xs), Just attr) -> Just (attr, xs)                     _                                 -> mbtok -checkLineEnd :: Context -> TokenizerM ()-checkLineEnd c = do-  unless (null (cLineEndContext c)) $ do-    eol <- gets endline-    info $ "checkLineEnd for " ++ show (cName c) ++ " eol = " ++ show eol ++ " cLineEndContext = " ++ show (cLineEndContext c)-    when eol $ do-      lineCont' <- gets lineContinuation-      unless lineCont' $ do-        doContextSwitches (cLineEndContext c)-        c' <- currentContext-        unless (c == c') $ checkLineEnd c'+-- | Apply line-end context switches for successive top contexts+-- until a context with no switches (#stay) is on top, guarding+-- against endless loops (KDE abstracthighlighter.cpp, highlightLine).+checkLineEnd :: TokenizerM ()+checkLineEnd = do+  lineCont' <- gets lineContinuation+  unless lineCont' $ go loopLimit+ where+  go counter = do+    c <- currentContext+    unless (null (cLineEndContext c)) $+      if counter <= 0+         then info $ "Endless switch context transitions " +++                "for line end context, aborting highlighting of line."+         else do+           info $ "checkLineEnd for " ++ show (cName c) +++                  " cLineEndContext = " ++ show (cLineEndContext c)+           before <- gets (fmap fst . unContextStack . contextStack)+           doContextSwitches (cLineEndContext c)+           after <- gets (fmap fst . unContextStack . contextStack)+           -- if the stack is unchanged (e.g. #pop of the initial+           -- context), stop:+           when (before /= after) $ go (counter - 1)  detectChar :: Bool -> Char -> ByteString -> TokenizerM Text detectChar dynamic c inp = do@@ -500,9 +589,12 @@   d' <- if dynamic && d >= '0' && d <= '9'            then getDynamicChar d            else return d-  if (encodeUtf8 (Text.pack [c',d'])) `BS.isPrefixOf` inp-     then takeChars 2-     else mzero+  case UTF8.uncons inp of+    Just (x, rest) | x == c' ->+      case UTF8.uncons rest of+        Just (y, _) | y == d' -> takeChars 2+        _ -> mzero+    _ -> mzero  rangeDetect :: Char -> Char -> ByteString -> TokenizerM Text rangeDetect c d inp = do@@ -534,9 +626,9 @@                                      not (isAlphaNum d || d == '_')) t)     _ -> mzero -lineContinue :: ByteString -> TokenizerM Text-lineContinue inp = do-  if inp == "\\"+lineContinue :: Char -> ByteString -> TokenizerM Text+lineContinue c inp = do+  if inp == UTF8.fromString [c]      then do        modify $ \st -> st{ lineContinuation = True }        takeChars 1@@ -552,16 +644,20 @@ regExpr dynamic re inp = do   -- return $! traceShowId $! (reStr, inp)   let reStr = reString re-  when (BS.take 2 reStr == "\\b") $ wordBoundary mempty inp-  regex <- case compileRE re of+  when (BS.take 2 reStr == "\\b") $ wordBoundary inp+  (regex, groups) <- case compileRE re of             Right r  -> return r             Left e   -> throwError $               "Error compiling regex " ++               UTF8.toString reStr ++ ": " ++ e-  regex' <- if dynamic-               then subDynamic regex-               else return regex-  case matchRegex regex' inp of+  mbmatch <- if dynamic+                then do+                  regex' <- subDynamic regex+                  -- the capturing groups have to be recomputed after+                  -- dynamic substitution (matchRegex does this):+                  return $ matchRegex regex' inp+                else return $ matchRegexWithGroups groups regex inp+  case mbmatch of         Just (matchedBytes, capts) -> do           unless (null capts) $             modify $ \st -> st{ captures = Captures $@@ -572,19 +668,27 @@ toSlice :: ByteString -> (Int, Int) -> ByteString toSlice bs (off, len) = BS.take len $ BS.drop off bs -wordBoundary :: Set.Set Char -> ByteString -> TokenizerM ()-wordBoundary weakDelims inp = do+wordBoundary :: ByteString -> TokenizerM ()+wordBoundary inp = do   case UTF8.uncons inp of        Nothing -> return ()        Just (d, _) -> do          c <- gets prevChar-         guard $ isWordBoundary weakDelims c d+         guard $ isWordBoundary c d -isWordBoundary :: Set.Set Char -> Char -> Char -> Bool-isWordBoundary weakDelims c d =-  (isWordChar c || c `Set.member` weakDelims) /=-  (isWordChar d || d `Set.member` weakDelims)+isWordBoundary :: Char -> Char -> Bool+isWordBoundary c d = isWordChar c /= isWordChar d +-- In KDE, Int, Float, HlCOct, and HlCHex rules match only if the+-- preceding character is a word delimiter (or we are at the start+-- of the line, which we detect via prevChar == '\n', since '\n'+-- is always a delimiter).  Nothing is required of the character+-- following the match.+precededByWordDelim :: Set.Set Char -> TokenizerM ()+precededByWordDelim delims = do+  c <- gets prevChar+  guard $ c `Set.member` delims+ decodeBS :: ByteString -> TokenizerM Text decodeBS bs = case decodeUtf8' bs of                     Left _ -> throwError ("ByteString " ++@@ -661,74 +765,65 @@   pCStringChar <|> () <$ A.satisfy (\c -> c /= '\'' && c /= '\\')   () <$ A.char '\'' -parseInt :: ByteString -> TokenizerM Text-parseInt inp = do-  wordBoundary mempty inp-  case A.parseOnly (A.match (pHex <|> pOct <|> pDec)) inp of+-- Like KDE's Int rule: a sequence of one or more decimal digits.+-- No sign, and no hex or octal forms.+parseInt :: Set.Set Char -> ByteString -> TokenizerM Text+parseInt delims inp = do+  precededByWordDelim delims+  case A.parseOnly (A.match (void $ A.takeWhile1 (A.inClass "0-9"))) inp of        Left _      -> mzero        Right (r,_) -> takeChars (BS.length r) -- assumes ascii -pDec :: A.Parser ()-pDec = do-  mbMinus-  void $ A.takeWhile1 (A.inClass "0-9")--parseOct :: ByteString -> TokenizerM Text-parseOct inp = do-  wordBoundary mempty inp-  case A.parseOnly (A.match pHex) inp of+-- Like KDE's HlCOct rule: a C-style octal, 0 followed by one or+-- more octal digits.  No sign, and no "0o" prefix.+parseOct :: Set.Set Char -> ByteString -> TokenizerM Text+parseOct delims inp = do+  precededByWordDelim delims+  case A.parseOnly (A.match pOct) inp of        Left _      -> mzero        Right (r,_) -> takeChars (BS.length r) -- assumes ascii  pOct :: A.Parser () pOct = do-  mbMinus   _ <- A.char '0'-  _ <- A.satisfy (A.inClass "Oo")   _ <- A.takeWhile1 (A.inClass "0-7")   return () -parseHex :: ByteString -> TokenizerM Text-parseHex inp = do-  wordBoundary mempty inp+-- Like KDE's HlCHex rule: 0x or 0X followed by one or more hex+-- digits.  No sign.+parseHex :: Set.Set Char -> ByteString -> TokenizerM Text+parseHex delims inp = do+  precededByWordDelim delims   case A.parseOnly (A.match pHex) inp of        Left _      -> mzero        Right (r,_) -> takeChars (BS.length r) -- assumes ascii  pHex :: A.Parser () pHex = do-  mbMinus   _ <- A.char '0'   _ <- A.satisfy (A.inClass "Xx")   _ <- A.takeWhile1 (A.inClass "0-9a-fA-F")   return () -mbMinus :: A.Parser ()-mbMinus = (() <$ A.char '-') <|> return ()--mbPlusMinus :: A.Parser ()-mbPlusMinus = () <$ A.satisfy (A.inClass "+-") <|> return ()--parseFloat :: ByteString -> TokenizerM Text-parseFloat inp = do-  wordBoundary mempty inp+-- Like KDE's Float rule: optional digits, a mandatory '.', and+-- optional digits (at least one digit is required on one side of+-- the dot), followed by an optional exponent (e or E, an optional+-- sign, and digits); if the exponent is not complete, the match+-- ends before the e/E.  No leading sign, and "5e2" is not a Float.+parseFloat :: Set.Set Char -> ByteString -> TokenizerM Text+parseFloat delims inp = do+  precededByWordDelim delims   case A.parseOnly (A.match pFloat) inp of        Left _      -> mzero        Right (r,_) -> takeChars (BS.length r)  -- assumes all ascii   where pFloat :: A.Parser ()         pFloat = do-          let digits = A.takeWhile1 (A.inClass "0-9")-          mbPlusMinus-          before <- A.option False $ True <$ digits-          dot <- A.option False $ True <$ A.satisfy (A.inClass ".")-          after <- A.option False $ True <$ digits-          e <- A.option False $ True <$ (A.satisfy (A.inClass "Ee") >>-                                         mbPlusMinus >> digits)-          mbnext <- A.peekChar-          case mbnext of-               Nothing -> return ()-               Just c  -> guard (not $ A.inClass "." c)-          guard $ (before && not dot && e)     -- 5e2-               || (before && dot && (after || not e)) -- 5.2e2 or 5.2 or 5.-               || (not before && dot && after) -- .23 or .23e2+          before <- A.takeWhile (A.inClass "0-9")+          _ <- A.char '.'+          after <- A.takeWhile (A.inClass "0-9")+          guard $ not (BS.null before && BS.null after)+          A.option () $ do+            _ <- A.satisfy (A.inClass "Ee")+            _ <- A.option '+' (A.satisfy (A.inClass "+-"))+            void $ A.takeWhile1 (A.inClass "0-9")
src/Skylighting/Types.hs view
@@ -109,7 +109,7 @@   | HlCHex   | HlCStringChar   | HlCChar-  | LineContinue+  | LineContinue !Char   | IncludeRules !ContextName   | DetectSpaces   | DetectIdentifier@@ -130,7 +130,7 @@     rMatcher          :: !Matcher   , rAttribute        :: !TokenType   , rIncludeAttribute :: !Bool-  , rWeakDeliminators :: Set.Set Char+  , rWordDelimiters   :: Set.Set Char   , rDynamic          :: !Bool   , rCaseSensitive    :: !Bool   , rChildren         :: ![Rule]@@ -178,7 +178,6 @@   , cAttribute          :: !TokenType   , cLineEmptyContext   :: ![ContextSwitch]   , cLineEndContext     :: ![ContextSwitch]-  , cLineBeginContext   :: ![ContextSwitch]   , cFallthrough        :: !Bool   , cFallthroughContext :: ![ContextSwitch]   , cDynamic            :: !Bool
test/expected/abc.haskell.native view
@@ -103,7 +103,9 @@   , ( OtherTok , "=" )   , ( NormalTok , " " )   , ( FunctionTok , "mapM_" )-  , ( NormalTok , " (\\w " )+  , ( NormalTok , " (" )+  , ( OperatorTok , "\\" )+  , ( NormalTok , "w " )   , ( OtherTok , "->" )   , ( NormalTok , " " )   , ( FunctionTok , "print" )
test/test-skylighting.hs view
@@ -103,12 +103,14 @@                 testCase ("regex " <>                            (Text.unpack $ TE.decodeUtf8 regex) <> " in "                            <> sFilename syn)-             $ case compileRegex True regex of+             $ case compileRegex True False regex of                  Right _ -> assertBool "regex does not compile" True                  Left e -> assertFailure ("regex does not compile: " <> show e))                          $ getRegexesFromSyntax syn))         syntaxes     , testGroup "Regex module" $ map regexTest regexTests+    , testGroup "Regex module compile errors" $+        map regexErrorTest regexErrorTests     , testGroup "Regression tests" $       let perl = maybe (error "could not find Perl syntax") id                              (lookupSyntax "Perl" sMap)@@ -119,7 +121,21 @@           bash  = maybe (error "could not find bash syntax") id                              (lookupSyntax "bash" sMap)           c    = maybe (error "could not find C syntax") id-                             (lookupSyntax "c" sMap) in+                             (lookupSyntax "c" sMap)+          dosbat = maybe (error "could not find MS-DOS Batch syntax") id+                             (lookupSyntax "MS-DOS Batch" sMap)+          cmake = maybe (error "could not find CMake syntax") id+                             (lookupSyntax "CMake" sMap)+          lua = maybe (error "could not find Lua syntax") id+                             (lookupSyntax "Lua" sMap)+          awk = maybe (error "could not find AWK syntax") id+                             (lookupSyntax "AWK" sMap)+          glsl = maybe (error "could not find GLSL syntax") id+                             (lookupSyntax "GLSL" sMap)+          makefile = maybe (error "could not find Makefile syntax") id+                             (lookupSyntax "Makefile" sMap)+          markdown = maybe (error "could not find Markdown syntax") id+                             (lookupSyntax "Markdown" sMap) in       [ testCase "perl NUL case" $ Right              [[(OtherTok,"s\NULb\NUL")               ,(StringTok,"c")@@ -195,6 +211,40 @@              @=? tokenize defConfig bash                      "f() {\n    echo > f\n}\n" +      , testCase "LineContinue with char attribute (dosbat ^)" $ Right+          [ [ ( BuiltInTok , "echo" )+            , ( NormalTok , " foo " )+            , ( SpecialCharTok , "^" ) ]+          , [ ( NormalTok , "bar" ) ] ]+             @=? tokenize defConfig dosbat "echo foo ^\nbar"++      , testCase "keyword rule insensitive attribute (cmake)" $ Right+          [ [ ( ControlFlowTok , "if" )+            , ( NormalTok , "(" )+            , ( OtherTok , "YES" )+            , ( NormalTok , ")" ) ]+          , [ ( ControlFlowTok , "if" )+            , ( NormalTok , "(" )+            , ( OtherTok , "yes" )+            , ( NormalTok , ")" ) ] ]+             @=? tokenize defConfig cmake "if(YES)\nif(yes)"++      , testCase "keyword rule additionalDeliminator attribute (lua)" $ Right+          [ [ ( VariableTok , "a" )+            , ( NormalTok , " " )+            , ( OperatorTok , "=" )+            , ( NormalTok , " " )+            , ( KeywordTok , "nil" )+            , ( OperatorTok , "." )+            , ( VariableTok , "x" ) ] ]+             @=? tokenize defConfig lua "a = nil.x"++      , testCase "Int respects general weakDeliminator (awk)" $ Right+          [ [ ( NormalTok , "x" )+            , ( OperatorTok , "@" )+            , ( NormalTok , "5" ) ] ]+             @=? tokenize defConfig awk "x@5"+       , testCase "C floating-point literal (#174)" $ Right           [ [ ( DataTypeTok , "double")             , ( NormalTok , " x " )@@ -205,9 +255,104 @@              @=? tokenize defConfig c                      "double x = 0.5;\n" +      -- HlCOct matches C-style octals (0 followed by octal digits);+      -- HlCHex matches 0x followed by hex digits:+      , testCase "HlCOct and HlCHex rules (glsl)" $ Right+          [ [ ( NormalTok , "x " )+            , ( OperatorTok , "=" )+            , ( NormalTok , " " )+            , ( BaseNTok , "0755" )+            , ( OperatorTok , ";" ) ]+          , [ ( NormalTok , "y " )+            , ( OperatorTok , "=" )+            , ( NormalTok , " " )+            , ( BaseNTok , "0x1F" )+            , ( OperatorTok , ";" ) ] ]+             @=? tokenize defConfig glsl "x = 0755;\ny = 0x1F;"++      -- As in KDE, the Float rule requires a '.', so 5e2 is matched+      -- by Int (leaving e2 unmatched), and an incomplete exponent is+      -- excluded from the match:+      , testCase "Float rule requires dot; exponent all-or-nothing (glsl)" $+          Right+          [ [ ( NormalTok , "x " )+            , ( OperatorTok , "=" )+            , ( NormalTok , " " )+            , ( DecValTok , "5" )+            , ( NormalTok , "e2" )+            , ( OperatorTok , ";" ) ]+          , [ ( NormalTok , "y " )+            , ( OperatorTok , "=" )+            , ( NormalTok , " " )+            , ( FloatTok , "1.5" )+            , ( NormalTok , "e" )+            , ( OperatorTok , "+;" ) ] ]+             @=? tokenize defConfig glsl "x = 5e2;\ny = 1.5e+;"++      -- As in KDE, Int and Float rules do not consume a leading sign:+      , testCase "Int does not include leading minus (glsl)" $ Right+          [ [ ( NormalTok , "x " )+            , ( OperatorTok , "=" )+            , ( NormalTok , " " )+            , ( OperatorTok , "-" )+            , ( DecValTok , "15" )+            , ( OperatorTok , ";" ) ] ]+             @=? tokenize defConfig glsl "x = -15;"++      -- As in KDE, column and firstNonspaceColumn restart on every+      -- physical line; a line continuation only suppresses the+      -- previous line's lineEndContext.  So the column="0" Target+      -- rule applies to "bar" on the continuation line:+      , testCase "column restarts after LineContinue (makefile)" $ Right+          [ [ ( DecValTok , "foo " )+            , ( CharTok , "\\" ) ]+          , [ ( DecValTok , "bar:" )+            , ( DataTypeTok , " baz" ) ] ]+             @=? tokenize defConfig makefile "foo \\\nbar: baz"++      -- As in KDE, an empty line applies the lineEmptyContext+      -- switches of successive top contexts until #stay (and+      -- lineEmptyContext defaults to lineEndContext).  Here the empty+      -- line pops blockquote and then enters Normal Text's+      -- lineEmptyContext (find-code-block), so the indented line+      -- becomes a code block:+      , testCase "empty line applies successive lineEmptyContexts (markdown)" $+          Right+          [ [ ( AttributeTok , "> quote" ) ]+          , []+          , [ ( InformationTok , "    code" ) ] ]+             @=? tokenize defConfig markdown "> quote\n\n    code"++      -- A zero-progress cycle of context switches driven by a+      -- lookahead rule must trigger the endless-loop guard (as in+      -- KDE), aborting the line instead of hanging; in particular a+      -- lookahead match must not reset the loop counter:+      , testCase "zero-progress lookahead loop aborts line" $+          Right [ [ ( NormalTok, "xy" ) ] ]+             @=? tokenize defConfig{ syntaxMap =+                    addSyntaxDefinition loopSyntax (syntaxMap defConfig) }+                  loopSyntax "xy"       ]     ] +-- | A syntax definition with a zero-progress loop: a lookahead rule+-- pushes a context that immediately pops back via fallthrough.+loopSyntax :: Syntax+loopSyntax = either error id $ parseSyntaxDefinitionFromText "loop.xml" $+     "<language name=\"Loop\" version=\"1\" kateversion=\"5.0\""+  <> " section=\"Other\" extensions=\"\">"+  <> "<highlighting><contexts>"+  <> "<context name=\"start\" attribute=\"Normal Text\""+  <> " lineEndContext=\"#stay\">"+  <> "<AnyChar lookAhead=\"1\" context=\"other\" String=\"x\"/>"+  <> "</context>"+  <> "<context name=\"other\" attribute=\"Normal Text\""+  <> " lineEndContext=\"#stay\" fallthroughContext=\"#pop\">"+  <> "</context>"+  <> "</contexts><itemDatas>"+  <> "<itemData name=\"Normal Text\" defStyleNum=\"dsNormal\"/>"+  <> "</itemDatas></highlighting></language>"+ compareValues :: FilePath -> Text -> Text -> IO (Maybe String) compareValues referenceFile expected actual =    if expected == actual@@ -301,7 +446,8 @@   , ("abc|ab$", "abd", Nothing)   , ("[\\x50-\\x51]*", "PQR", Just ("PQ", []))   , ("[\\x{2019}]*", "\x2019PQR", Just ("\x2019", []))-  , ("(?:ab)*|a.*", "abababa", Just ("abababa", []))+  , ("(?:ab)*|a.*", "abababa", Just ("ababab", []))+    -- leftmost-first: first alternative matches, so second is never tried   , ("a[b-e]*", "abcdefg", Just ("abcde", []))   , ("a[b-e\\n-]*", "abcde\nb-bcfg", Just ("abcde\nb-bc", []))   , ("^\\s+\\S+\\s+$", "   abc  ", Just ("   abc  ", []))@@ -344,11 +490,226 @@   , ("([abc](?1)*)", "abcd", Just ("abc", [(1,"abc")]))   , ("(x(?1)*)", "xxxxy", Just ("xxxx", [(1,"xxxx")]))   , ("a|\\((?0)\\)", "(((a)))", Just ("(((a)))", []))-  , ("([abc](x(?1))*)", "axbxcc", Just ("axbxc", [(1,"axbxc"),(2,"xc")]))-    -- note: pcre gives insetad (2, "xbxc") -- I don't understand why+  , ("([abc](x(?1))*)", "axbxcc", Just ("axbxc", [(1,"axbxc"),(2,"xbxc")]))+    -- group 2's last iteration is "xbxc": the recursion (?1) inside it+    -- matches "bxc", and inner iterations' captures are overwritten   , ("[\\p{Nd}]", "33", Just ("3", []))   , ("\\p{N}", "33", Just ("3", []))+    -- {m,n} with m > n is a compile error (see regexErrorTests; it+    -- used to send the compiler into an infinite loop, and later was+    -- treated as a literal)+    -- lazy quantifiers in lookbehinds used to hang the matcher:+  , ("ab(?<=a+?b)c", "abc", Just ("abc", []))+  , ("ab(?<=a+?)c", "abc", Nothing)+    -- recursive subroutine calls that consume no input used to hang;+    -- now re-entering a subroutine at the same offset just fails:+  , ("x|(?R)", "x", Just ("x", []))+  , ("a|(?R)(?R)", "aa", Just ("a", []))+    -- leftmost-first: the first alternative succeeds on "a"+    -- backward matching (lookbehind, \b) after multibyte characters+    -- used to land inside a UTF-8 sequence:+  , ("\x00e9(?<=\x00e9)x", "\x00e9x", Just ("\x00e9x", []))+  , ("\x00e9\\bx", "\x00e9x", Nothing)+  , ("\x2019(?<=\x2019)x", "\x2019x", Just ("\x2019x", []))+  , ("\x00e9(?<!\x00e9)x", "\x00e9x", Nothing)+    -- (?i:...) is scoped to the group; it used to leak to the rest+    -- of the pattern:+  , ("(?i:a)b", "Ab", Just ("Ab", []))+  , ("(?i:a)b", "AB", Nothing)+  , ("x(?i:a(?-i:b)c)y", "xAbCy", Just ("xAbCy", []))+  , ("x(?i:a(?-i:b)c)y", "xABCy", Nothing)+    -- [[:graph:]] and [[:word:]] used to be unparseable (and graph+    -- meant "print"):+  , ("[[:graph:]]+", "ab cd", Just ("ab", []))+  , ("[[:word:]]+", "a_b-c", Just ("a_b", []))+  , ("[^[:graph:]]", " a", Just (" ", []))+  , ("[[:alpha:][:digit:]]+", "ab1 x", Just ("ab1", []))+    -- subroutine calls to groups nested inside other groups used to+    -- be silently ignored (matching the empty string):+  , ("((a)b)(?2)", "aba", Just ("aba", [(1,"ab"),(2,"a")]))+  , ("((a)b)(?2)", "abx", Nothing)+    -- character classes, escaped literals, and backreferences used+    -- to ignore case-insensitivity:+  , ("(?i:[abc]+)d", "aBcd", Just ("aBcd", []))+  , ("(?i:[a-z]+)!", "aBcD!", Just ("aBcD!", []))+  , ("(?i:[^a]+)", "xA", Just ("x", []))+  , ("(?i:\\x61+)", "aA", Just ("aA", []))+  , ("(?i:(ab)\\1)", "abAB", Just ("abAB", [(1,"ab")]))+  , ("(ab)\\1", "abAB", Nothing)+    -- {m,n} expansion is now linear in n; behavior is unchanged:+  , ("a{0,3}b", "aaab", Just ("aaab", []))+  , ("a{0,3}b", "aaaab", Nothing)+  , ("a{2,4}c", "aaaac", Just ("aaaac", []))+  , ("a{2,4}c", "aaaaac", Nothing)+  , ("[ab]{0,800}", replicate 800 'a', Just (replicate 800 'a', []))+    -- repeat counts over 65535 are compile errors (see+    -- regexErrorTests)+    -- an unmatched ] outside a character class is a literal, as in+    -- PCRE (used, e.g., by mermaid.xml and apparmor.xml):+  , ("a]b", "a]b", Just ("a]b", []))+  , ("\\d{1,3}]", "42]x", Just ("42]", []))+  , ("[ab]]", "b]", Just ("b]", []))+    -- a class is terminated by the first unescaped ] even if that+    -- yields a stray ] later (as in PCRE):+  , ("[^|{}[]", "a", Just ("a", []))+  , ("[^|{}[]", "[", Nothing)+    -- \0 takes up to two further octal digits, as in PCRE+    -- (\041 = '!', \042 = '"'); it is octal, not a backreference:+  , ("[\\041-\\043]", "\"", Just ("\"", []))+  , ("\\041", "!!", Just ("!", []))+  , ("a\\0b", "a\NULb", Just ("a\NULb", []))+  , ("[\\0]", "\NULx", Just ("\NUL", []))+    -- a third digit is not consumed (\0101 is \b followed by 1):+  , ("\\0101", "\b1", Just ("\b1", []))+    -- \G asserts the position where the match attempt started;+    -- since our matches are anchored, a leading \G is always true+    -- and a \G after consuming input always fails:+  , ("\\G\\d{4}-\\d{2}", "2024-01x", Just ("2024-01", []))+  , ("a\\Gb", "ab", Nothing)+    -- \g1 and \g{1} are PCRE syntax for backreferences:+  , ("(ab)\\g1", "ababx", Just ("abab", [(1,"ab")]))+  , ("(a)(b)\\g2\\g1", "abba", Just ("abba", [(1,"a"),(2,"b")]))+  , ("(ab)c\\g{1}", "abcabx", Just ("abcab", [(1,"ab")]))+  , ("([_*]{1,2})x\\g1", "**x**", Just ("**x**", [(1,"**")]))+  , ("([_*]{1,2})x\\g1", "**x*", Nothing)+    -- inline modifiers without a colon, like (?i), apply from that+    -- point to the end of the enclosing group (as in PCRE):+  , ("(?i)ab", "AB", Just ("AB", []))+  , ("A(?i)B", "aB", Nothing)+  , ("A(?i)B", "Ab", Just ("Ab", []))+  , ("x(?:(?i)a)Y", "xAY", Just ("xAY", []))+  , ("x(?:(?i)a)Y", "xAy", Nothing)+  , ("(a(?i)b|c)", "C", Just ("C", [(1,"C")]))+  , ("(?i)A(?-i)B", "aB", Just ("aB", []))+  , ("(?i)A(?-i)B", "Ab", Nothing)+    -- \h and \H match horizontal whitespace (and its complement):+  , ("a\\hb", "a b", Just ("a b", []))+  , ("a\\hb", "a\tb", Just ("a\tb", []))+  , ("a\\hb", "a\xa0\&b", Just ("a\xa0\&b", []))+  , ("\\h", "\x180e", Just ("\x180e", []))+  , ("a\\hb", "a\nb", Nothing)+  , ("a\\Hb", "axb", Just ("axb", []))+  , ("a\\Hb", "a b", Nothing)+  , ("[\\h]", "\xa0", Just ("\xa0", []))+  , ("[^\\h]+", "ab cd", Just ("ab", []))+    -- \A asserts the start of the subject:+  , ("\\Aab", "abc", Just ("ab", []))+  , ("a\\Ab", "ab", Nothing)+    -- an empty first alternative matches the empty string:+  , ("(?:|abc)x", "x", Just ("x", []))+  , ("(?:|abc)x", "abcx", Just ("abcx", []))+  , ("(?:\\d\\d(?:|[DT]\\d\\d))y", "12y", Just ("12y", []))+  , ("(?:\\d\\d(?:|[DT]\\d\\d))y", "12T34y", Just ("12T34y", []))+  , ("(?<=|)z\\d", "z4", Just ("z4", []))+    -- inside a character class, \b means backspace:+  , ("[\\b]", "\b", Just ("\b", []))+  , ("[\\b+-]x", "\bx", Just ("\bx", []))+  , ("[\\b+-]x", "+x", Just ("+x", []))+  , ("[\\b+-]x", "bx", Nothing)+    -- atomic groups (?>...):+  , ("(?>ab|a)c", "abc", Just ("abc", []))+  , ("(?>ab|a)c", "ac", Just ("ac", []))+  , ("(?>a+)ab", "aaab", Nothing)+  , ("x(?>)y", "xy", Just ("xy", []))+  , ("(?>a|ab)c", "abc", Nothing)+  , ("(?>(a|ab)c)", "abc", Just ("abc", [(1,"ab")]))+    -- alternation is leftmost-first, not longest-match (as in PCRE):+  , ("a|ab", "ab", Just ("a", []))+  , ("(a|ab)c?", "abc", Just ("a", [(1,"a")]))+  , ("(?=(a|ab))", "ab", Just ("", [(1,"a")]))+    -- lazy quantifiers match as little as possible:+  , ("a+?b", "aaab", Just ("aaab", []))+  , ("a*?b", "aaab", Just ("aaab", []))+  , ("(a+?)ab", "aaab", Just ("aaab", [(1,"aa")]))+    -- subroutine calls to groups with multi-digit numbers:+  , ("(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)x(?12)", "abcdefghijklxl",+      Just ("abcdefghijklxl",+            [(1,"a"),(2,"b"),(3,"c"),(4,"d"),(5,"e"),(6,"f"),(7,"g"),+             (8,"h"),(9,"i"),(10,"j"),(11,"k"),(12,"l")]))+  , ("(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)x(?12)", "abcdefghijklxa", Nothing)+    -- numbering after (?|...) resumes after the highest group number+    -- used in any alternative:+  , ("(?|(a)(b)|(c))(d)\\2", "abdb",+      Just ("abdb", [(1,"a"),(2,"b"),(3,"d")]))+  , ("(?|(a)(b)|(c))(d)\\2", "cdd", Nothing)+    -- a ] in first position in a character class is a literal, and+    -- may be the start of a range:+  , ("[]-a]+", "^_`", Just ("^_`", []))+  , ("[]-a]+", "b", Nothing)+  , ("[]-]+", "]-]", Just ("]-]", []))+  , ("[]-]+", "^", Nothing)+  , ("[^]-a]+", "bz!", Just ("bz!", []))+  , ("[^]-a]+", "^", Nothing)+  , ("[]a-]+", "a]-", Just ("a]-", []))+    -- \pL is short for \p{L}; \P is the complement of \p:+  , ("\\pL+", "ab\x3a3\&9", Just ("ab\x3a3", []))+  , ("\\pN", "9", Just ("9", []))+  , ("\\pN", "a", Nothing)+  , ("\\PL+", "9!", Just ("9!", []))+  , ("\\P{L}+", "9!a", Just ("9!", []))+  , ("\\p{^L}+", "9!a", Just ("9!", []))+  , ("[\\pL]+", "ab9", Just ("ab", []))+  , ("[\\PL]+", "9!a", Just ("9!", []))+  , ("[\\P{N}]+", "a!9", Just ("a!", []))+  , ("[^\\PL]+", "ab9", Just ("ab", []))+    -- {,n} is a quantifier (as in PCRE 10.43+), but {,} and {b} are+    -- literal:+  , ("a{,2}", "aaa", Just ("aa", []))+  , ("a{,}", "a{,}", Just ("a{,}", []))+  , ("a{b}", "a{b}", Just ("a{b}", []))+    -- (?s) and (?m) are accepted (and are no-ops on our single-line+    -- subjects):+  , ("(?s)a.b", "axb", Just ("axb", []))+  , ("(?m)^ab", "ab", Just ("ab", []))+  , ("(?ims)ab", "AB", Just ("AB", []))+    -- (?U) makes quantifiers minimal by default and ? makes them+    -- greedy (PCRE's UNGREEDY option, QRegularExpression's+    -- InvertedGreedinessOption, minimal="1" in KDE syntax files):+  , ("(?U)a+", "aaa", Just ("a", []))+  , ("(?U)a+?", "aaa", Just ("aaa", []))+  , ("(?U)a*b", "aabb", Just ("aab", []))+  , ("(?U)a?", "a", Just ("", []))+  , ("(?U)a{2,4}", "aaaaa", Just ("aa", []))+  , ("(?U)a{2,4}?", "aaaaa", Just ("aaaa", []))+  , ("(?U)a{2}", "aaa", Just ("aa", []))+  , ("(?U)a*+b", "aab", Just ("aab", [])) -- possessive is unaffected+  , ("(?U)<(.*)>", "<x><y>", Just ("<x>", [(1, "x")]))+  , ("(?U:a+)a", "aaa", Just ("aa", []))+  , ("((?U)a+)(a+)", "aaaa", Just ("aaaa", [(1, "a"), (2, "aaa")]))+  , ("(?iU)ab+", "ABBB", Just ("AB", []))+  , ("(?U)(?-U)a+", "aaa", Just ("aaa", []))   ]++-- these should fail to compile, as they do in PCRE ("quantifier does+-- not follow a repeatable item", "numbers out of order in {}+-- quantifier", "number too big in {} quantifier", or an unsupported+-- inline flag):+regexErrorTests :: [String]+regexErrorTests =+  [ "{2}"+  , "({2})"+  , "a|{2}"+  , "a{2}{3}"+  , "a+{2}"+  , "{,2}"+  , "a{3,1}"+  , "x{70000}"+  , "a{2,70000}"+  , "^{2}"+  , "^*a"+  , "a$*"+  , "\\b+a"+  , "(?x)a b"+  , "(?n)(a)b"+  , "(?u)a"+  ]++regexErrorTest :: String -> TestTree+regexErrorTest re =+  testCase ("/" ++ re ++ "/") $+    case compileRegex True False (TE.encodeUtf8 (Text.pack re)) of+      Left _  -> return ()+      Right _ -> assertFailure "regex compiled, but an error was expected"   vividize :: Diff Text -> Text
+ xml/abnf.xml view
@@ -0,0 +1,175 @@+<?xml version="1.0" encoding="UTF-8"?>+<!DOCTYPE language [+  <!ENTITY rulename "[[:alpha:]_][-\w]*">+]>+<!--+  SPDX-FileCopyrightText: 2026 Jonathan Poelen <jonathan.poelen@gmail.com>+  SPDX-License-Identifier: MIT++  https://www.rfc-editor.org/rfc/rfc5234 (Augmented BNF for Syntax Specifications: ABNF)+  https://www.rfc-editor.org/rfc/rfc7405 (Case-Sensitive String Support in ABNF)+-->+<language+  name="ABNF"+  section="Sources"+  version="1"+  kateversion="5.79"+  extensions="*.abnf"+  mimetype="text/x-abnf"+  author="Jonathan Poelen (jonathan.poelen@gmail.com)"+  indenter="normal"+  license="MIT"+>+  <highlighting>++    <list name="core rules">+      <item>ALPHA</item>+      <item>BIT</item>+      <item>CHAR</item>+      <item>CR</item>+      <item>CRLF</item>+      <item>CTL</item>+      <item>DIGIT</item>+      <item>DQUOTE</item>+      <item>HEXDIG</item>+      <item>HTAB</item>+      <item>LF</item>+      <item>LWSP</item>+      <item>OCTET</item>+      <item>SP</item>+      <item>VCHAR</item>+      <item>WSP</item>+    </list>++    <contexts>+      <context attribute="Normal Text" name="Normal" fallthroughContext="Elements">+        <DetectSpaces/>++        <StringDetect String=";" attribute="Comment" context="Comment"/>+        <StringDetect String="=" attribute="New Rule Operator" context="Elements"/>+        <RegExpr attribute="New Rule" String="&rulename;(?=\s*=)" context="SetRule"/>+      </context>++      <context attribute="Normal Text" name="SetRule">+        <DetectSpaces/>+        <StringDetect String="=" attribute="New Rule Operator" context="#pop!Elements"/>+      </context>++      <context attribute="Normal Text" name="Elements" lineEndContext="#pop">+        <DetectSpaces/>++        <AnyChar String="/" attribute="Alternation"/>+        <!-- other than '*' as extension -->+        <AnyChar String="*+?!#$&amp;@^~" attribute="Operator"/>++        <StringDetect String=";" attribute="Comment" context="#pop!Comment"/>++        <AnyChar String="()" attribute="Group"/>+        <AnyChar String="[]" attribute="Option"/>++        <!-- do not use <Int> to colorize %b012DIGIT+                                          ~~~~        special char+                                              ~       Integer+                                               ~~~~~  Rule+        -->+        <AnyChar String="0123456789" attribute="Integer"/>++        <DetectChar attribute="String" context="DQuote" char="&quot;"/>++        <StringDetect String="%b" attribute="Numeric Base" context="NumBin"/>+        <StringDetect String="%d" attribute="Numeric Base" context="NumDec"/>+        <StringDetect String="%x" attribute="Numeric Base" context="NumHex"/>++        <StringDetect String="%i" attribute="Case Sensitivity"/>+        <StringDetect String="%s" attribute="Case Sensitivity"/>++        <DetectChar char="&lt;" attribute="Prose" context="Prose"/>++        <keyword attribute="Core Rule" String="core rules" weakDeliminator="-"/>+        <RegExpr attribute="Rule Name" String="&rulename;"/>++        <!-- extension -->+        <DetectChar lookAhead="1" context="Escape" char="\"/>+      </context>+++      <!-- ;... -->+      <context name="Comment" attribute="Comment" lineEndContext="#pop">+        <DetectSpaces/>+        <IncludeRules context="##Comments"/>+        <DetectIdentifier/>+      </context>+++      <!-- "..." -->+      <context name="DQuote" attribute="String">+        <DetectChar attribute="String" context="#pop" char="&quot;"/>+      </context>+++      <!-- %b### -->+      <context name="NumBin" attribute="Numeric Value" lineEndContext="#pop" fallthroughContext="#pop">+        <AnyChar attribute="Numeric Value" String="01"/>+        <IncludeRules context="NumCommon"/>+      </context>+      <!-- %d### -->+      <context name="NumDec" attribute="Numeric Value" lineEndContext="#pop" fallthroughContext="#pop">+        <AnyChar attribute="Numeric Value" String="0123456789"/>+        <IncludeRules context="NumCommon"/>+      </context>+      <!-- %h### -->+      <context name="NumHex" attribute="Numeric Value" lineEndContext="#pop" fallthroughContext="#pop">+        <AnyChar attribute="Numeric Value" String="0123456789abcdefABCDEF"/>+        <IncludeRules context="NumCommon"/>+      </context>++      <context name="NumCommon" attribute="Numeric Value">+        <AnyChar attribute="Concatenation" String="."/>+        <AnyChar attribute="Range" String="-"/>+      </context>+++      <!-- <...> -->+      <context name="Prose" attribute="Prose" lineEndContext="#pop">+        <DetectChar char="&gt;" attribute="Prose" context="#pop"/>+      </context>+++      <!-- \w, etc -->+      <context attribute="String" lineEndContext="#stay" name="Escape">+        <HlCStringChar attribute="String Char" context="#pop"/>+        <RegExpr attribute="String Char" context="#pop" String="\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|\\[a-zA-Z]\b"/>+        <DetectChar context="#pop" char="\"/>+      </context>++    </contexts>+    <itemDatas>+      <itemData name="Normal Text" defStyleNum="dsNormal" spellChecking="0"/>+      <itemData name="Alternation" defStyleNum="dsControlFlow" spellChecking="0"/>+      <itemData name="Comment" defStyleNum="dsComment" spellChecking="1"/>+      <itemData name="New Rule" defStyleNum="dsKeyword" spellChecking="0"/>+      <itemData name="New Rule Operator" defStyleNum="dsVariable" spellChecking="0"/>+      <itemData name="Integer" defStyleNum="dsDecVal" spellChecking="0"/>+      <itemData name="Rule Name" defStyleNum="dsNormal" spellChecking="0"/>+      <itemData name="Core Rule" defStyleNum="dsPreprocessor" spellChecking="0"/>+      <itemData name="Operator" defStyleNum="dsOperator" bold="true" spellChecking="0"/>+      <itemData name="Group" defStyleNum="dsInformation" spellChecking="0"/>+      <itemData name="Option" defStyleNum="dsConstant" spellChecking="0"/>+      <itemData name="Case Sensitivity" defStyleNum="dsFunction" spellChecking="0"/>+      <itemData name="Numeric Base" defStyleNum="dsFunction" spellChecking="0"/>+      <itemData name="Numeric Value" defStyleNum="dsSpecialString" spellChecking="0"/>+      <itemData name="String" defStyleNum="dsString" spellChecking="0"/>+      <itemData name="String Char" defStyleNum="dsSpecialChar" spellChecking="0"/>+      <itemData name="Prose" defStyleNum="dsDataType" spellChecking="1"/>+      <itemData name="Concatenation" defStyleNum="dsFunction" spellChecking="0"/>+      <itemData name="Range" defStyleNum="dsFunction" spellChecking="0"/>+    </itemDatas>+  </highlighting>+  <general>+    <comments>+      <comment name="singleLine" start=";"/>+    </comments>+    <folding indentationsensitive="true"/>+  </general>+</language>+<!-- kate: replace-tabs on; indent-width 2; -->
+ xml/asciidoc.xml view
@@ -0,0 +1,640 @@+<?xml version="1.0" encoding="UTF-8"?>+<!DOCTYPE language [+    <!-- alphabetic -->+    <!ENTITY alp "a-zA-Z">+    <!-- alphanumeric -->+    <!ENTITY aln "&alp;0-9">+    <!ENTITY id "\w[\w-]+">+    <!-- percent symbol, needs to be encoded inside an entity definition -->+    <!ENTITY perc "&#x0025;">++    <!ENTITY admonition_names "CAUTION|IMPORTANT|NOTE|TIP|WARNING">++    <!-- regular expression parts to identify anchors -->+    <!ENTITY anchor_mid "&id;(?:,.+?)?">+    <!ENTITY anchor_phrase "#\S(?:.*?\S)?#">++    <!-- block delimiters -->+    <!ENTITY block_dels_comment "/{4,}">+    <!ENTITY block_dels_normal "={4,}|_{4,}|\*{4,}|-{2}|&quot;{2}">+    <!ENTITY block_dels_pass "\+{4,}">+    <!ENTITY block_dels_verbatim "`{3}|-{4,}|\.{4,}">+    <!-- postfix/trailing part of block name -->+    <!ENTITY block_name_post "(?:[#&perc;].+)?\s*(?:,.*)?\]\s*$">+    <!-- block end delimiter, dynamic matching: "^%1\s*$" -->+    <!ENTITY block_end_del "^&perc;1\s*$">++    <!-- unicode character reference, decimal and hexadecimal -->+    <!ENTITY char_ref "&amp;#(?:\d{2,4}|x[\da-fA-F]{2,4});">++    <!-- email - inline -->+    <!ENTITY email "\w[\w.&perc;+-]*@[&aln;][&aln;.-]*\.[&alp;]{2,4}\b">++    <!-- link macro and mailto: -->+    <!ENTITY link_mailto "(?:link|mailto):[^:\s\[][^\s\[]*\[(?:\]|.*?[^\\]\])">++    <!-- macro -->+    <!ENTITY macro "(?:anchor|xref):&id;\[.*?\]|(?:btn|footnote(?:ref)?|kbd):\[.*?\]|pass:\w*\[.*?\]|(?:icon|image|menu):[^:].*?\[.*?\]|toc::\[\]">++    <!ENTITY list_marker "(?:\S.+::(?=\s|$)|(?:(?:\.+|\d+\.)|(?:-|\*+)(?:\s+\[[*x ]\])?)(?=\s+\S))">++    <!ENTITY table_option_delimiter "(?:(?:\d*\.)?\d+\+|\d+\*)?(?:[&lt;&gt;^]?\.?[&lt;&gt;^])?[adehlmsv]?\|">++    <!-- parts to build regular expressions to identify quoted (formatted) text+         E.g. emphasized, marked, strong. -->+    <!-- prefix/leading part -->+    <!ENTITY quoted_pre "(?&lt;=^|[^\w;:}])">+    <!ENTITY quoted_pre_pass "(?&lt;=^|\W)">+    <!-- central part -->+    <!ENTITY quoted "\S(?:.*?\S)??">+    <!-- postfix/trailing part -->+    <!ENTITY quoted_post "(?=\W|$)">+]>+<language author="Andreas Gratzer" extensions="*.ad;*.adoc;*.asciidoc" kateversion="5.0" mimetype="text/asciidoc" name="AsciiDoc" license="MIT" section="Markup" version="9">+    <highlighting>+        <list name="macro">+            <item>anchor</item>+            <item>btn</item>+            <item>footnote</item>+            <item>footnoteref</item>+            <item>icon</item>+            <item>image</item>+            <item>indexterm</item>+            <item>indexterm2</item>+            <item>kbd</item>+            <item>menu</item>+            <item>pass</item>+            <item>toc</item>+            <item>xref</item>+        </list>++        <contexts>+            <context name="start" attribute="Normal" lineEndContext="#stay" fallthrough="1" fallthroughContext="R section block">+                <!-- section title level 0 to 5 -->+                <RegExpr String="^(?:={1,6}|#{1,6})\s+(?=\S)" lookAhead="1" context="dispatch section main title" column="0"/>+                <IncludeRules context="R section inline"/>+            </context>++            <!-- attribute value definition, may span multiple lines -->+            <context name="attribute value" attribute="Normal" lineEndContext="#stay" lineEmptyContext="#pop">+                <!-- line with continuation -->+                <RegExpr String=".*?(?=\s+(?:\+\s+)?\\\s*$)" attribute="Attribute Value" context="continuation"/>+                <!-- line without continuation, terminates value definition -->+                <RegExpr String=".*" attribute="Attribute Value" context="#pop"/>+            </context>+            <!-- inline attribute value definition -->+            <context name="attribute value inline" attribute="Attribute Value" lineEndContext="#stay">+                <!-- the leading `:` is part of the definition syntax and should not be highlighted as value -->+                <DetectChar char=":" attribute="Attribute" context="attribute value inline L2"/>+                <DetectChar char="}" attribute="Attribute" context="#pop"/>+            </context>+            <context name="attribute value inline L2" attribute="Attribute Value" lineEndContext="#stay">+                <DetectChar char="}" attribute="Attribute" context="#pop#pop"/>+            </context>++            <!-- backlash, may function as an escape -->+            <context name="backlash" attribute="Normal" lineEndContext="#stay" fallthrough="true" fallthroughContext="#pop">+                <!-- attribute usage+                     formatted/quoted text+                     replacement of apostrophe+                     table separator (default)+                     anchor, consuming leading char will make anchor matches fail+                     cross reference+                     indexterm, consuming leading char will make matches fail+                -->+                <!-- replacement (besides apostrophe -->+                <Detect2Chars char="&lt;" char1="-" attribute="Normal" context="#pop"/>+                <Detect2Chars char="&lt;" char1="=" attribute="Normal" context="#pop"/>+                <AnyChar String="_#`+*~^'|{[&lt;(" attribute="Normal" context="#pop"/>+                <Detect2Chars char="-" char1="-" attribute="Normal" context="#pop"/>+                <Detect2Chars char="-" char1="&gt;" attribute="Normal" context="#pop"/>+                <Detect2Chars char="=" char1="&gt;" attribute="Normal" context="#pop"/>+                <StringDetect String="..." attribute="Normal" context="#pop"/>+                <!-- email - inline, needs to be ordered after mailto: -->+                <!-- link and mailto macros, note that ftp, irc, http(s) don't match with leading `\` anyway -->+                <RegExpr String="&email;|&link_mailto;|&char_ref;" attribute="Normal" context="#pop"/>+                <!-- macro -->+                <keyword String="macro" attribute="Normal" context="#pop"/>+            </context>++            <context name="block title" attribute="Block Title" lineEndContext="#pop">+                <IncludeRules context="R title"/>+            </context>++            <context name="comment" attribute="Comment" lineEndContext="#stay" lineEmptyContext="#pop">+                <DetectSpaces attribute="Comment"/>+                <RegExpr String="^(&block_dels_comment;)\s*$" attribute="Comment" context="#pop!comment delimited" beginRegion="comment" column="0"/>+                <IncludeRules context="R anchor"/>+                <IncludeRules context="R block title"/>+                <IncludeRules context="##Comments"/>+                <DetectIdentifier attribute="Comment"/>+            </context>+            <context name="comment delimited" attribute="Comment" lineEndContext="#stay">+                <DetectSpaces attribute="Comment"/>+                <RegExpr String="&block_end_del;" dynamic="true" attribute="Comment" context="#pop" endRegion="comment" column="0"/>+                <IncludeRules context="##Comments" />+                <DetectIdentifier attribute="Comment"/>+            </context>+            <context name="comment single-line" attribute="Comment" lineEndContext="#pop">+                <DetectSpaces attribute="Comment"/>+                <IncludeRules context="##Comments" />+                <DetectIdentifier attribute="Comment"/>+            </context>++            <!-- continuation, both for normal text and attribute value definition+                 The allowed pattern must already by validated.+                 Here only the possible characters are highlighted. -->+            <context name="continuation" attribute="Normal" lineEndContext="#pop">+                <AnyChar String="+\" attribute="Control"/>+            </context>++            <context name="main title" attribute="Main Title" lineEndContext="#pop!section L0">+                <IncludeRules context="R title"/>+            </context>++            <context name="normal" attribute="Normal" lineEndContext="#stay" lineEmptyContext="#pop">+                <RegExpr String="^(-{2}|&block_dels_normal;)\s*$" attribute="Delimiter" context="#pop!normal delimited" beginRegion="block" column="0"/>+                <IncludeRules context="R block title"/>+                <!-- shared rules includes anchor rules, so we do not need to include that separately -->+                <IncludeRules context="R shared"/>+                <IncludeRules context="R normal"/>+            </context>+            <context name="normal delimited" attribute="Normal" lineEndContext="#stay">+                <RegExpr String="&block_end_del;" dynamic="true" attribute="Delimiter" context="#pop" endRegion="block" column="0"/>+                <IncludeRules context="R admonition"/>+                <IncludeRules context="R block"/>+                <!-- shared rules includes anchor rules, so we do not need to include that separately -->+                <IncludeRules context="R shared"/>+                <IncludeRules context="R normal"/>+            </context>++            <context name="passthrough" attribute="Passthrough" lineEndContext="#stay" lineEmptyContext="#pop">+                <DetectSpaces attribute="Passthrough"/>+                <IncludeRules context="R include"/>+                <DetectIdentifier attribute="Passthrough"/>+                <RegExpr String="^(&block_dels_pass;)\s*$" attribute="Delimiter" context="#pop!passthrough delimited" beginRegion="block" column="0"/>+                <IncludeRules context="R anchor"/>+                <IncludeRules context="R block title"/>+            </context>+            <context name="passthrough delimited" attribute="Passthrough" lineEndContext="#stay">+                <RegExpr String="&block_end_del;" dynamic="true" attribute="Delimiter" context="#pop" endRegion="block" column="0"/>+                <IncludeRules context="R include"/>+            </context>++            <context name="dispatch section main title" attribute="Normal" lineEndContext="#stay">+                <IncludeRules context="dispatch section title L1-5"/>+                <!-- main title, first level 0 section title -->+                <AnyChar String="=#" attribute="Main Title" context="#pop!main title" beginRegion="section" column="0"/>+            </context>++            <context name="dispatch section title L0-5" attribute="Normal" lineEndContext="#stay">+                <IncludeRules context="dispatch section title L1-5"/>+                <AnyChar String="=#" attribute="Section Title" context="#pop!section title L0" beginRegion="section" endRegion="section" column="0"/>+            </context>+            <context name="dispatch section title L1-5" attribute="Normal" lineEndContext="#stay">+                <IncludeRules context="dispatch section title L2-5"/>+                <Detect2Chars char="=" char1="=" attribute="Section Title" context="#pop!section title L1" beginRegion="section" column="0"/>+                <Detect2Chars char="#" char1="#" attribute="Section Title" context="#pop!section title L1" beginRegion="section" column="0"/>+            </context>+            <context name="dispatch section title L2-5" attribute="Normal" lineEndContext="#stay">+                <IncludeRules context="dispatch section title L3-5"/>+                <StringDetect String="===" attribute="Section Title" context="#pop!section title L2" beginRegion="section" column="0"/>+                <StringDetect String="###" attribute="Section Title" context="#pop!section title L2" beginRegion="section" column="0"/>+            </context>+            <context name="dispatch section title L3-5" attribute="Normal" lineEndContext="#stay">+                <IncludeRules context="dispatch section title L4-5"/>+                <StringDetect String="====" attribute="Section Title" context="#pop!section title L3" beginRegion="section" column="0"/>+                <StringDetect String="####" attribute="Section Title" context="#pop!section title L3" beginRegion="section" column="0"/>+            </context>+            <context name="dispatch section title L4-5" attribute="Normal" lineEndContext="#stay">+                <IncludeRules context="dispatch section title L5"/>+                <StringDetect String="=====" attribute="Section Title" context="#pop!section title L4" beginRegion="section" column="0"/>+                <StringDetect String="#####" attribute="Section Title" context="#pop!section title L4" beginRegion="section" column="0"/>+            </context>+            <context name="dispatch section title L5" attribute="Normal" lineEndContext="#stay">+                <StringDetect String="======" attribute="Section Title" context="#pop!section title L5" beginRegion="section" column="0"/>+                <StringDetect String="######" attribute="Section Title" context="#pop!section title L5" beginRegion="section" column="0"/>+            </context>++            <context name="section L0" attribute="Normal" lineEndContext="#stay" fallthrough="1" fallthroughContext="R section block">+                <RegExpr String="^(?:={1,6}|#{1,6})\s+(?=\S)" lookAhead="1" context="dispatch section title L0-5" column="0"/>+                <IncludeRules context="section L5"/>+            </context>++            <context name="section L1" attribute="Normal" lineEndContext="#stay" fallthrough="1" fallthroughContext="R section block">+                <RegExpr String="^(?:={3,6}|#{3,6})\s+(?=\S)" lookAhead="1" context="dispatch section title L2-5" column="0"/>+                <IncludeRules context="section L5"/>+            </context>++            <context name="section L2" attribute="Normal" lineEndContext="#stay" fallthrough="1" fallthroughContext="R section block">+                <RegExpr String="^(?:={4,6}|#{4,6})\s+(?=\S)" lookAhead="1" context="dispatch section title L3-5" column="0"/>+                <IncludeRules context="section L5"/>+            </context>++            <context name="section L3" attribute="Normal" lineEndContext="#stay" fallthrough="1" fallthroughContext="R section block">+                <RegExpr String="^(?:={5,6}|#{5,6})\s+(?=\S)" lookAhead="1" context="dispatch section title L4-5" column="0"/>+                <IncludeRules context="section L5"/>+            </context>++            <context name="section L4" attribute="Normal" lineEndContext="#stay" fallthrough="1" fallthroughContext="R section block">+                <RegExpr String="^(?:={6}|#{6})\s+(?=\S)" lookAhead="1" context="dispatch section title L5" column="0"/>+                <IncludeRules context="section L5"/>+            </context>++            <context name="section L5" attribute="Normal" lineEndContext="#stay" fallthrough="1" fallthroughContext="R section block">+                <RegExpr String="^(?:={1,6}|#{1,6})\s+\S" lookAhead="1" context="#pop" endRegion="section" column="0"/>+                <IncludeRules context="R section inline"/>+            </context>++            <context name="section title L0" attribute="Section Title" lineEndContext="#pop">+                <IncludeRules context="R title"/>+            </context>++            <context name="section title L1" attribute="Section Title" lineEndContext="#pop!section L1">+                <IncludeRules context="R title"/>+            </context>++            <context name="section title L2" attribute="Section Title" lineEndContext="#pop!section L2">+                <IncludeRules context="R title"/>+            </context>++            <context name="section title L3" attribute="Section Title" lineEndContext="#pop!section L3">+                <IncludeRules context="R title"/>+            </context>++            <context name="section title L4" attribute="Section Title" lineEndContext="#pop!section L4">+                <IncludeRules context="R title"/>+            </context>++            <context name="section title L5" attribute="Section Title" lineEndContext="#pop!section L5">+                <IncludeRules context="R title"/>+            </context>++            <context name="table" attribute="Normal" lineEndContext="#stay">+                <RegExpr String="&block_end_del;" dynamic="true" attribute="Delimiter" context="#pop" endRegion="block" column="0"/>+                <!-- `|` with prefix for alignment, style etc. -->+                <RegExpr String="(?&lt;=^|\s)&table_option_delimiter;" attribute="Delimiter"/>+                <!-- simple `|` without alignment, style etc. -->+                <DetectChar char="|" attribute="Delimiter"/>+                <IncludeRules context="R shared"/>+                <IncludeRules context="R normal"/>+            </context>++            <context name="verbatim" attribute="Verbatim" lineEndContext="#stay">+                <RegExpr String="^(-{2}|&block_dels_verbatim;)\s*$" attribute="Delimiter" context="#pop!verbatim delimited" beginRegion="block" column="0"/>+                <IncludeRules context="R anchor"/>+                <RegExpr String="^(\[\w+[^,\]]*(,[^,\]]*)*\]\s*)+$" attribute="Preprocessor" column="0"/>+                <IncludeRules context="R block title"/>+                <IncludeRules context="R comment"/>+                <IncludeRules context="R include"/>+                <RegExpr String="^.*" attribute="Verbatim" context="#pop!verbatim paragraph" column="0"/>+            </context>+            <context name="verbatim delimited" attribute="Verbatim" lineEndContext="#stay">+                <RegExpr String="&block_end_del;" dynamic="true" attribute="Delimiter" context="#pop" endRegion="block" column="0"/>+                <IncludeRules context="R include"/>+            </context>+            <context name="verbatim paragraph" attribute="Verbatim" lineEndContext="#stay" lineEmptyContext="#pop">+                <IncludeRules context="R include"/>+            </context>++            <!-- contexts to be used for IncludeRules only -->++            <context name="R normal" attribute="Normal" lineEndContext="#stay">+                <!-- Regex which allows to quickly consume text that is not+                    - macro+                    - continuation+                    - index term+                    - link+                    - replacement+                    - preprocessor+                    - formatted text+                    - table delimiter++                maanchor:anchor-id[Macro Anchor]+                ^ Normal+                  ^ Macro++                bla__bla__bla+                ^ Normal+                   ^ Emphasized+                          ^ Normal++                For some reason, Asciidoctor recognizes emails with leading : or / but does not render them as link++                /example@mail.com+                ^ Normal++                example@mail.com+                ^ Link+                -->+                <RegExpr String="([:/]&email;|(?!&macro;|link:|mailto:|(?:ftp|https?|irc)://|&char_ref;|indexterm2?:\[.+?\]|[\\+|\[{~^]|__|##|\([CR]\)|\(TM\)|\.\.\.|&lt;[-=&lt;]|--|->|=>|``\*?_?|\*\*_?|\(\(|\s+[[+]|\s&table_option_delimiter;|(?&lt;=[^&alp;;:}])_|&quoted_pre;(`\*?_?|\*_?|#)|(?&lt;=[&alp;])'(?=[&alp;])|&email;).)++" attribute="Normal"/>+            </context>++            <context name="R admonition" attribute="Normal" lineEndContext="#stay">+                <!-- admonition - simple form, block form is part of block rules -->+                <RegExpr String="^(?:&admonition_names;):(?=\s+\S)" attribute="Preprocessor" context="normal" column="0"/>+            </context>++            <context name="R anchor" attribute="Normal" lineEndContext="#stay">+                <!-- shorthand form at line start -->+                <!-- bibliographic anchor -->+                <!-- normal form -->+                <!-- shorthand form inline -->+                <RegExpr String="^\[#&anchor_mid;\](?:&anchor_phrase;|\s*$)|\[{3}&anchor_mid;\]{3}|\[{2}&anchor_mid;\]{2}|(?&lt;=\S\s)\s*\[\s*#&anchor_mid;\s*\]&anchor_phrase;" attribute="Anchor"/>+            </context>++            <context name="R attribute" attribute="Normal" lineEndContext="#stay">+                <!-- attribute definition without value / unset attribute -->+                <RegExpr String="^:!?&id;!?:$" attribute="Attribute" column="0"/>+                <!-- attribute definition with value -->+                <RegExpr String="^:!?&id;!?:\s(?=\S)" attribute="Attribute" context="attribute value" column="0"/>+                <!-- attribute inline definition -->+                <RegExpr String="\{set:&id;(?=(?::.*)?\})" minimal="true" attribute="Attribute" context="attribute value inline"/>+                <IncludeRules context="R attribute usage"/>+            </context>++            <context name="R attribute usage" attribute="Normal" lineEndContext="#stay">+                <RegExpr String="\{&id;\}" attribute="Attribute"/>+            </context>++            <context name="R block" attribute="Normal" lineEndContext="#stay">+                <IncludeRules context="R block title"/>+                <IncludeRules context="R block without title"/>+            </context>++            <context name="R block without title" attribute="Normal" lineEndContext="#stay">+                <!-- name matching -->+                <RegExpr String="^\[(?:&admonition_names;)&block_name_post;|^\[(?:example|quote|sidebar|verse)&block_name_post;" attribute="Preprocessor" context="normal" column="0"/>+                <RegExpr String="^\[(?:pass|stem)&block_name_post;" attribute="Preprocessor" context="passthrough" column="0"/>+                <RegExpr String="^\[(?:listing|literal|source)&block_name_post;" attribute="Preprocessor" context="verbatim" column="0"/>++                <!-- delimiter matching -->+                <RegExpr String="^(&block_dels_normal;)\s*$" attribute="Delimiter" context="normal delimited" beginRegion="block" column="0"/>+                <RegExpr String="^(&block_dels_pass;)\s*$" attribute="Delimiter" context="passthrough delimited" beginRegion="block" column="0"/>+                <RegExpr String="^(\|={3,})\s*$" attribute="Delimiter" context="table" beginRegion="block" column="0"/>+                <RegExpr String="^(&block_dels_verbatim;)\s*$" attribute="Delimiter" context="verbatim delimited" beginRegion="block" column="0"/>+            </context>++            <context name="R block title" attribute="Normal" lineEndContext="#stay">+                <!-- not more than 3 leading dots followed by a non-dot, otherwise it would conflict with the delimited literal block -->+                <RegExpr String="^\.{1,3}(?=[^\.\s])" attribute="Block Title" context="block title" column="0"/>+            </context>++            <context name="R comment" attribute="Normal" lineEndContext="#stay">+                <!-- comment - multi-line, named block -->+                <RegExpr String="^\[comment&block_name_post;" attribute="Preprocessor" context="comment" column="0"/>+                <!-- comment - multi-line, delimited block -->+                <RegExpr String="^(&block_dels_comment;)\s*$" attribute="Comment" context="comment delimited" beginRegion="comment" column="0"/>+                <!-- comment - single line -->+                <RegExpr String="^/{2}(?:[^/]|$)" attribute="Comment" context="comment single-line" column="0"/>+            </context>++            <context name="R formatted" attribute="Normal" lineEndContext="#stay">+                <!-- custom style, e.g. [underline]#underlined text# -->+                <RegExpr String="(?&lt;=^|\W)\[[^\]]+?\]([#_`*]{1,2})&quoted;\g1&quoted_post;" attribute="Preprocessor"/>++                <!-- combined highlighting must be ordered before simple highlighting -->++                <!-- emphasized monospaced strong unconstrained - must be ordered before constrained -->+                <!-- emphasized monospaced strong - constrained must be ordered after unconstrained -->+                <RegExpr String="`{2}\*_.*?_\*`{2}|&quoted_pre;`\*_&quoted;_\*`&quoted_post;" attribute="Emphasized Monospaced Strong"/>++                <!-- emphasized strong unconstrained - must be ordered before constrained -->+                <!-- emphasized strong constrained - must be ordered after unconstrained -->+                <RegExpr String="\*{2}_.*?_\*{2}|&quoted_pre;\*_&quoted;_\*&quoted_post;" attribute="Emphasized Strong"/>++                <!-- monospaced strong unconstrained - must be ordered before constrained -->+                <!-- monospaced strong constrained - must be ordered after unconstrained -->+                <RegExpr String="`{2}\*.*?\*`{2}|&quoted_pre;`\*&quoted;\*`&quoted_post;" attribute="Monospaced Strong"/>++                <!-- emphasized monospaced unconstrained - must be ordered before constrained -->+                <!-- emphasized monospaced constrained - must be ordered after unconstrained -->+                <RegExpr String="`{2}_.*?_`{2}|&quoted_pre;`_&quoted;_`&quoted_post;" attribute="Emphasized Monospaced"/>++                <!-- strong unconstrained - must be ordered before constrained -->+                <!-- strong constrained - must be ordered after unconstrained -->+                <RegExpr String="\*{2}[^*].*?\*{2}|&quoted_pre;\*&quoted;\*&quoted_post;" attribute="Strong"/>++                <!-- emphasized unconstrained - must be ordered before constrained -->+                <!-- emphasized constrained - must be ordered after unconstrained+                     Can't use &quoted_pre; as that excludes \w which excludes `_` too. -->+                <RegExpr String="_{2}[^_].*?_{2}|(?&lt;=^|[^&alp;;:}])_&quoted;_&quoted_post;" attribute="Emphasized"/>++                <IncludeRules context="R marked"/>+                <IncludeRules context="R monospaced"/>++                <!-- subscript -->+                <RegExpr String="~\S+~" minimal="true" attribute="Subscript"/>+                <!-- superscript -->+                <RegExpr String="\^\S+\^" minimal="true" attribute="Superscript"/>+            </context>++            <context name="R include" attribute="Normal" lineEndContext="#stay">+                <RegExpr String="^include::.*\[.*?\](?=\s*$)" attribute="Preprocessor" column="0"/>+            </context>++            <context name="R macro" attribute="Normal" lineEndContext="#stay">+                <RegExpr String="&macro;" attribute="Preprocessor"/>+            </context>++            <context name="R marked" attribute="Normal" lineEndContext="#stay">+                <!-- marked unconstrained - must be ordered before constrained -->+                <!-- marked constrained - must be ordered after unconstrained -->+                <RegExpr String="#{2}.+?#{2}|&quoted_pre;#&quoted;#&quoted_post;" attribute="Marked"/>+            </context>++            <context name="R monospaced" attribute="Normal" lineEndContext="#stay">+                <!-- monospaced unconstrained - must be ordered before constrained -->+                <!-- monospaced constrained - must be ordered after unconstrained -->+                <RegExpr String="`{2}[^`].*?`{2}|&quoted_pre;`&quoted;`&quoted_post;" attribute="Monospaced"/>+            </context>++            <!-- replacements -->+            <context name="R replacement" attribute="Normal" lineEndContext="#stay">+                <!-- copyright -->+                <StringDetect String="(C)" attribute="Replacement"/>+                <!-- registered -->+                <StringDetect String="(R)" attribute="Replacement"/>+                <!-- trademark -->+                <StringDetect String="(TM)" attribute="Replacement"/>+                <!-- apostrophe, only when between alphabetic characters -->+                <RegExpr String="(?&lt;=[&alp;])'(?=[&alp;])" attribute="Replacement"/>+                <!-- ellipses -->+                <StringDetect String="..." attribute="Replacement"/>+                <!-- mdash -->+                <Detect2Chars char="-" char1="-" attribute="Replacement"/>+                <!-- left single arrow -->+                <Detect2Chars char="&lt;" char1="-" attribute="Replacement"/>+                <!-- right single arrow -->+                <Detect2Chars char="-" char1="&gt;" attribute="Replacement"/>+                <!-- left double arrow -->+                <Detect2Chars char="&lt;" char1="=" attribute="Replacement"/>+                <!-- right double arrow -->+                <Detect2Chars char="=" char1="&gt;" attribute="Replacement"/>+                <!-- unicode character reference -->+                <RegExpr String="&char_ref;" attribute="Replacement"/>+            </context>++            <context name="R section inline" attribute="Normal" lineEndContext="#stay">+                <!-- literal paragraph started by a line with leading spaces -->+                <RegExpr String="^\s+(?!&list_marker;)\S.*" attribute="Verbatim" context="verbatim paragraph" column="0"/>+                <IncludeRules context="R block"/>+                <IncludeRules context="R anchor"/>+                <IncludeRules context="R comment"/>+                <IncludeRules context="R media"/>+                <IncludeRules context="R preprocessor"/>+                <IncludeRules context="R horizontal rules and page break"/>+            </context>++            <!-- first line of a section block -->+            <context name="R section block" attribute="Normal" lineEndContext="#pop!section block continuation" lineEmptyContext="#pop">+                <IncludeRules context="R callout"/>+                <RegExpr String="^\+\s*$" attribute="Control" context="#pop" column="0"/>+                <IncludeRules context="R admonition"/>+                <IncludeRules context="R block"/>+                <IncludeRules context="R shared"/>+                <IncludeRules context="R empty"/>+                <IncludeRules context="R normal"/>+            </context>++            <!-- callout as being used below a source code block -->+            <context name="R callout" attribute="Normal" lineEndContext="#stay" lineEmptyContext="#pop">+                <RegExpr String="^&lt;(?:\.|\d+)&gt;(?=\s+\S)" attribute="Callout" context="#pop!callout" column="0"/>+            </context>+            <context name="callout" attribute="Normal" lineEndContext="#stay" lineEmptyContext="#pop">+                <IncludeRules context="R callout"/>+                <IncludeRules context="section block continuation"/>+            </context>++            <!-- line 2 and following of a section block -->+            <context name="section block continuation" attribute="Normal" lineEndContext="#stay" lineEmptyContext="#pop">+                <RegExpr String="^\+\s*$" attribute="Control" context="#pop" column="0"/>+                <IncludeRules context="R block without title"/>+                <IncludeRules context="R shared"/>+                <IncludeRules context="R empty"/>+                <IncludeRules context="R normal"/>+            </context>++            <context name="R empty" attribute="Normal" lineEndContext="#stay">+                <RegExpr String="^\s+$" attribute="Normal" context="#pop" column="0"/>+            </context>++            <context name="R shared" attribute="Normal" lineEndContext="#stay">+                <!-- the escaped forms must be ordered before the not escaped forms -->+                <DetectChar char="\" attribute="Normal" context="backlash"/>++                <!-- passthrough - inline, must be ordered before other rules+                     The macro form pass: is part of "R macro" context -->+                <RegExpr String="&quoted_pre_pass;(\+{1,3})&quoted;\g1&quoted_post;" attribute="Passthrough"/>++                <IncludeRules context="R anchor"/>+                <IncludeRules context="R attribute"/>+                <IncludeRules context="R comment"/>+                <IncludeRules context="R include"/>+                <IncludeRules context="R macro"/>++                <!-- counter and counter2 -->+                <RegExpr String="\{counter2?:\s*&id;\s*(?::\s*(?:\d+|[&alp;])\s*)?\}" minimal="true" attribute="Attribute"/>++                <!-- horizontal rules and page break -->+                <!-- to enable highlighting of the horizontal rules using "- - -" or "* * *",+                     keep this before the checklist and unnumbered list definition -->+                <IncludeRules context="R horizontal rules and page break"/>++                <!-- cross reference -->+                <RegExpr String="&lt;&lt;[^&lt;\s].*?&gt;&gt;" attribute="Link"/>++                <!-- index term -->+                <RegExpr String="\({3}.+?\){3}|\({2}.+?\){2}|indexterm2?:\[.+?\]" attribute="Preprocessor"/>++                <!-- marker for description list -->+                <!-- marker for numbered list -->+                <!-- marker for checklist and bulleted/unnumbered list+                     To enable highlighting of the horizontal rules using "- - -" or "* * *",+                     keep this after the horizontal rules definition -->+                <RegExpr String="^\s*&list_marker;" attribute="List Marker" column="0"/>++                <!-- media - block format -->+                <IncludeRules context="R media"/>++                <!-- links -->+                <RegExpr String="(?&lt;=^|[\s\[\]();&lt;&gt;])(?:ftp|https?|irc)://[^\s\[]*?(?:\[\]|\[.*?[^\\]\]|(?=(?:[\[\]]|[\.,;:]??(?:\s|$))))|&link_mailto;|&email;" attribute="Link"/>++                <!-- preprocessor -->+                <!-- general meta data attribute list - must be ordered after other rules matching for lines of the form of [some content] -->+                <IncludeRules context="R preprocessor"/>++                <!-- continuation `+`, both at end of line and on a line on its own -->+                <RegExpr String="(?:^|\s)\s*\+\s*$" lookAhead="true" attribute="Normal" context="continuation"/>++                <!-- formatted/quoted must be ordered after unnumbered list -->+                <IncludeRules context="R formatted"/>+                <!-- replacements are done only if nothing else matched -->+                <IncludeRules context="R replacement"/>+            </context>++            <context name="R media" attribute="Normal" lineEndContext="#stay">+                <RegExpr String="^(?:audio|image|video)::.*\[.*?\](?=\s*$)" attribute="Preprocessor" column="0"/>+            </context>++            <context name="R preprocessor" attribute="Normal" lineEndContext="#stay">+                <RegExpr String="^ifn?def::&id;(?:[,\+]&id;)*\[.*\]|^ifeval::\[.*\]|^endif::(?:&id;)?\[\]|^\[[^\s\[].*\](?=\s*$)" attribute="Preprocessor" column="0"/>+            </context>++            <context name="R horizontal rules and page break" attribute="Normal" lineEndContext="#stay">+                <RegExpr String="^(?:'{3}|-{3}|\*{3}|- - -|\* \* \*|&lt;{3})\s*$" attribute="Control" column="0"/>+            </context>++            <!-- common rules for main title, section title, block title -->+            <context name="R title" attribute="Normal" lineEndContext="#stay">+                <DetectSpaces/>+                <DetectIdentifier/>+                <!-- the escaped forms must be ordered before the not escaped forms -->+                <DetectChar char="\" attribute="Section Title" context="backlash"/>+                <IncludeRules context="R anchor"/>+                <IncludeRules context="R attribute usage"/>+                <IncludeRules context="R marked"/>+                <IncludeRules context="R monospaced"/>+            </context>+        </contexts>++        <itemDatas>+            <itemData name="Anchor" defStyleNum="dsFunction"/>+            <itemData name="Attribute" defStyleNum="dsVariable"/>+            <itemData name="Attribute Value" defStyleNum="dsVariable" italic="true"/>+            <itemData name="Block Title" defStyleNum="dsString" italic="true"/>+            <itemData name="Callout" defStyleNum="dsNormal" bold="true" underline="true"/>+            <itemData name="Comment" defStyleNum="dsComment"/>+            <itemData name="Control" defStyleNum="dsControlFlow" bold="true" underline="true"/>+            <itemData name="Delimiter" defStyleNum="dsPreprocessor" bold="true"/>+            <itemData name="Emphasized" defStyleNum="dsNormal" italic="true"/>+            <itemData name="Emphasized Monospaced" defStyleNum="dsDocumentation" italic="true"/>+            <itemData name="Emphasized Monospaced Strong" defStyleNum="dsDocumentation" bold="true" italic="true"/>+            <itemData name="Emphasized Strong" defStyleNum="dsNormal" bold="true" italic="true"/>+            <itemData name="Link" defStyleNum="dsVariable" underline="true"/>+            <itemData name="List Marker" defStyleNum="dsNormal" bold="true"/>+            <itemData name="Main Title" defStyleNum="dsNormal" bold="true"/>+            <itemData name="Marked" defStyleNum="dsFloat"/>+            <itemData name="Monospaced" defStyleNum="dsDocumentation"/>+            <itemData name="Monospaced Strong" defStyleNum="dsDocumentation" bold="true"/>+            <itemData name="Normal" defStyleNum="dsNormal"/>+            <itemData name="Passthrough" defStyleNum="dsSpecialString"/>+            <itemData name="Preprocessor" defStyleNum="dsPreprocessor"/>+            <itemData name="Replacement" defStyleNum="dsNormal" bold="true" underline="true"/>+            <itemData name="Section Title" defStyleNum="dsString" bold="true"/>+            <itemData name="Strong" defStyleNum="dsNormal" bold="true"/>+            <itemData name="Subscript" defStyleNum="dsNormal" underline="true"/>+            <itemData name="Superscript" defStyleNum="dsNormal" bold="true" underline="true"/>+            <itemData name="Verbatim" defStyleNum="dsDocumentation"/>+        </itemDatas>+    </highlighting>++    <general>+        <comments>+            <comment name="singleLine" start="//"/>+            <comment name="multiLine" start="////" end="////" region="comment"/>+        </comments>+        <keywords casesensitive="1"/>+    </general>+</language>+<!-- kate: replace-tabs on; tab-width 4; indent-width 4; -->
xml/bash.xml view
@@ -71,11 +71,11 @@  <language     name="Bash"-    version="54"+    version="58"     kateversion="5.79"     section="Scripts"-    extensions="*.sh;*.bash;*.ebuild;*.eclass;*.exlib;*.exheres-0;.bashrc;.bash_profile;.bash_login;.profile;PKGBUILD;APKBUILD"-    mimetype="application/x-shellscript"+    extensions="*.sh;*.bash;*.ebuild;*.eclass;*.exlib;*.exheres-0;.bashrc;.bash_profile;.bash_login;.profile;.envrc;PKGBUILD;APKBUILD"+    mimetype="application/x-shellscript;text/x-shellscript"     casesensitive="1"     author="Wilbert Berendsen (wilbert@kde.nl)"     license="LGPL"@@ -669,10 +669,12 @@         <Detect2Chars attribute="Parameter Expansion" context="#pop!VarBraceStart" char="$" char1="{"/>         <StringDetect context="#pop!ExprDblParenSubstOrSubstCommand" String="$((" lookAhead="1"/>         <Detect2Chars attribute="Parameter Expansion" context="#pop!SubstCommand" char="$" char1="(" beginRegion="subshell"/>+        <!-- The old format $[exp] is undocumented, deprecated+        and will be removed in upcoming versions of bash. -->       </context>       <context attribute="Command" lineEndContext="#pop#pop" name="DispatchStringVariables">         <Detect2Chars attribute="String SingleQ" context="#pop!StringEsc" char="$" char1="'"/>-        <Detect2Chars attribute="String Transl." context="#pop!StringDQ" char="$" char1="&quot;"/>+        <Detect2Chars attribute="String Transl." context="#pop!StringTrDQ" char="$" char1="&quot;"/>       </context>       <context attribute="Command" lineEndContext="#pop#pop" name="DispatchVarnameVariables">         <RegExpr attribute="Dollar Prefix" context="#pop!VarNamePrefixedWithDollar" String="\$(?=&varname;|[*@#?$!0-9-])"/>@@ -1227,7 +1229,7 @@       <context attribute="String DoubleQ" lineEndContext="#stay" name="StringDQDispatchVariables">         <IncludeRules context="DispatchSubstVariables"/>         <IncludeRules context="DispatchVarnameVariables"/>-        <DetectChar attribute="String DoubleQ" context="#pop" char="$"/>+        <DetectChar context="#pop" char="$"/>       </context>       <context attribute="String DoubleQ" lineEndContext="#pop" name="StringDQEscape">         <Detect2Chars attribute="String Escape" context="#pop" char="\" char1="&quot;"/>@@ -1235,9 +1237,19 @@         <Detect2Chars attribute="String Escape" context="#pop" char="\" char1="`"/>         <Detect2Chars attribute="String Escape" context="#pop" char="\" char1="$"/>         <LineContinue attribute="String Escape" context="#pop"/>-        <DetectChar attribute="String DoubleQ" context="#pop" char="\"/>+        <DetectChar context="#pop" char="\"/>       </context> +      <!-- StringTrDQ consumes anything till $", substitutes vars and expressions -->+      <context attribute="String Transl." lineEndContext="#stay" name="StringTrDQ">+        <DetectSpaces attribute="String Transl."/>+        <DetectIdentifier attribute="String Transl."/>+        <DetectChar attribute="String Transl." context="#pop" char="&quot;"/>+        <DetectChar context="StringDQEscape" char="\" lookAhead="1"/>+        <DetectChar context="StringDQDispatchVariables" char="$" lookAhead="1"/>+        <DetectChar attribute="Backquote" context="RegularBackq" char="`"/>+      </context>+       <!-- RegularBackq consumes anything till ` -->       <context attribute="Normal Text" lineEndContext="#stay" name="RegularBackq" fallthroughContext="Command">         <DetectChar attribute="Backquote" context="#pop" char="`"/>@@ -1276,15 +1288,15 @@       </context>        <!-- VarBraceStart is called as soon as ${ is encoutered -->-      <context attribute="Variable" lineEndContext="SubstBraceCommand" name="VarBraceStart" fallthroughContext="#pop!VarBrace">+      <context attribute="Variable" lineEndContext="#pop!SubstBraceCommand" name="VarBraceStart" fallthroughContext="#pop!VarBrace">         <!-- '${!}' as process ID variable, not a Parameter Expansion -->         <StringDetect context="#pop!VarBrace" String="!}" lookAhead="1"/>         <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarBracePrefix" char="!"/>         <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarBrace" char="#"/>         <!-- Bash-5.3: ${ cmd; } -->-        <DetectSpaces attribute="Normal Text" context="SubstBraceCommand"/>+        <DetectSpaces attribute="Normal Text" context="#pop!SubstBraceCommand"/>         <!-- Bash-5.3: ${|cmd;} -->-        <DetectChar attribute="Control" context="SubstBraceCommand" char="|"/>+        <DetectChar attribute="Control" context="#pop!SubstBraceCommand" char="|"/>       </context>        <!-- SubstBraceCommand is called after a '${ ' are '${|' are encountered -->@@ -1934,7 +1946,7 @@   </highlighting>   <general>     <comments>-      <comment name="singleLine" start="#"/>+      <comment name="singleLine" start="#" position="afterwhitespace"/>     </comments>     <keywords casesensitive="1" weakDeliminator="_&weakDeliminatorSymbols;" additionalDeliminator="`"/>   </general>
+ xml/cabal.xml view
@@ -0,0 +1,398 @@+<?xml version="1.0" encoding="UTF-8"?>+<!DOCTYPE language [+  <!ENTITY version "(?&lt;![-+@$\w.])[0-9]+(\.[0-9]+)*">+  <!ENTITY noversion "[0-9.]+">+]>+<language name="Cabal" section="Configuration" version="1" kateversion="5.62"+          extensions="*.cabal;cabal.config;cabal.project;cabal.project.freeze;cabal.project.local"+          author="Jonathan Poelen (jonathan.poelen@gmail.com)" license="MIT">+  <highlighting>++<list name="conditional">+  <item>if</item>+  <item>elif</item>+  <item>else</item>+</list>++<list name="function">+  <item>os</item>+  <item>arche</item>+  <item>impl</item>+  <item>flag</item>+</list>++<list name="category">+	<item>executable</item>+	<item>library</item>+	<item>benchmark</item>+	<item>test-suite</item>+	<item>source-repository</item>+	<item>flag</item>+  <item>foreign-library</item>+	<item>custom-setup</item>+	<item>common</item>+</list>++<list name="constant">+  <item>True</item>+  <item>False</item>+</list>++<list name="stmt">+  <item>asm-options</item>+  <item>asm-sources</item>+  <item>author</item>+  <item>autogen-includes</item>+  <item>autogen-modules</item>+  <item>branch</item>+  <item>bug-reports</item>+  <item>build-depends</item>+  <item>build-tool-depends</item>+  <item>build-tools</item>+  <item>build-type</item>+  <item>buildable</item>+  <item>c-sources</item>+  <item>cabal-version</item>+  <item>category</item>+  <item>cc-options</item>+  <item>cmm-options</item>+  <item>cmm-sources</item>+  <item>copyright</item>+  <item>cpp-options</item>+  <item>cxx-options</item>+  <item>cxx-sources</item>+  <item>data-dir</item>+  <item>data-files</item>+  <item>default-extensions</item>+  <item>default-language</item>+  <item>default</item>+  <item>description</item>+  <item>executable</item>+  <item>exposed-modules</item>+  <item>exposed</item>+  <item>extensions</item>+  <item>extra-bundled-libraries</item>+  <item>extra-doc-files</item>+  <item>extra-dynamic-library-flavours</item>+  <item>extra-framework-dirs</item>+  <item>extra-ghci-libraries</item>+  <item>extra-lib-dirs-static</item>+  <item>extra-lib-dirs</item>+  <item>extra-libraries-static</item>+  <item>extra-libraries</item>+  <item>extra-library-flavours</item>+  <item>extra-source-files</item>+  <item>extra-tmp-files</item>+  <item>frameworks</item>+  <item>ghc-options</item>+  <item>ghc-prof-options</item>+  <item>ghc-shared-options</item>+  <item>ghcjs-options</item>+  <item>ghcjs-prof-options</item>+  <item>ghcjs-shared-options</item>+  <item>homepage</item>+  <item>hs-source-dir</item>+  <item>hs-source-dirs</item>+  <item>hugs-options</item>+  <item>import</item>+  <item>include-dirs</item>+  <item>includes</item>+  <item>install-includes</item>+  <item>js-sources</item>+  <item>ld-options</item>+  <item>lib-version-info</item>+  <item>lib-version-linux</item>+  <item>license-file</item>+  <item>license</item>+  <item>location</item>+  <item>main-is</item>+  <item>maintainer</item>+  <item>manual</item>+  <item>mixins</item>+  <item>mod-def-file</item>+  <item>module</item>+  <item>name</item>+  <item>nhc98-options</item>+  <item>options</item>+  <item>other-extensions</item>+  <item>other-language</item>+  <item>other-languages</item>+  <item>other-modules</item>+  <item>package-url</item>+  <item>pkgconfig-depends</item>+  <item>reexported-modules</item>+  <item>scope</item>+  <item>setup-depends</item>+  <item>signatures</item>+  <item>stability</item>+  <item>subdir</item>+  <item>synopsis</item>+  <item>tag</item>+  <item>test-module</item>+  <item>tested-with</item>+  <item>type</item>+  <item>version</item>+  <item>virtual-modules</item>+</list>++<list name="language">+  <item>Haskell98</item>+  <item>Haskell2010</item>+</list>++<list name="compiler">+  <item>ghc</item>+  <item>nhc</item>+  <item>yhc</item>+  <item>hugs</item>+  <item>hbc</item>+  <item>helium</item>+  <item>jhc</item>+  <item>lhc</item>+</list>++<list name="build-type">+  <item>simple</item>+  <item>custom</item>+  <item>configure</item>+</list>++<list name="default-extensions">+  <include>language_pragmas##Haskell</include>+</list>++<contexts>+  <context name="Normal" attribute="Normal Text" lineEndContext="#stay">+    <DetectSpaces attribute="Normal Text"/>+    <StringDetect attribute="Comment" context="Comment" String="--"/>+    <WordDetect attribute="Statement" context="stmtVersion" String="version" insensitive="1"/>+    <WordDetect attribute="Statement" context="stmtVersion" String="cabal-version" insensitive="1"/>+    <WordDetect attribute="Statement" context="stmtBuildType" String="build-type" insensitive="1"/>+    <WordDetect attribute="Statement" context="stmtTestWith" String="tested-with" insensitive="1"/>+    <WordDetect attribute="Statement" context="stmtLicenseFile" String="license-file" insensitive="1"/>+    <WordDetect attribute="Statement" context="stmtLicense" String="license" insensitive="1"/>+    <WordDetect attribute="Statement" context="stmtMaintainer" String="maintainer" insensitive="1"/>+    <WordDetect attribute="Statement" context="stmtAuthor" String="author" insensitive="1"/>+    <WordDetect attribute="Statement" context="stmtName" String="name" insensitive="1"/>+    <WordDetect attribute="Statement" context="stmtDescription" String="description" insensitive="1"/>+    <WordDetect attribute="Statement" context="stmtCopyright" String="copyright" insensitive="1"/>+    <WordDetect attribute="Statement" context="stmtHomepage" String="homepage" insensitive="1"/>+    <WordDetect attribute="Statement" context="stmtBugReports" String="bug-reports" insensitive="1"/>+    <keyword attribute="Statement" context="stmt" String="stmt"/>+    <keyword attribute="Category" context="category" String="category"/>+    <keyword attribute="Conditional" context="conditional" String="conditional"/>+    <RegExpr attribute="Other Statement" context="stmt" String="[-\w]+"/>+  </context>++  <context name="Comment" attribute="Comment" lineEndContext="#pop">+    <DetectSpaces attribute="Comment"/>+    <IncludeRules context="##Comments"/>+    <DetectIdentifier attribute="Comment"/>+  </context>++  <context name="category" attribute="Category Title" lineEndContext="#pop">+    <StringDetect attribute="Comment" context="#pop!Comment" String="--"/>+  </context>++  <context name="stmt" attribute="Normal Text" lineEndContext="#pop!stmt2" fallthroughContext="#pop!stmt2">+    <DetectSpaces attribute="Normal Text"/>+    <StringDetect attribute="Symbol Separator" String=":" context="#pop!stmt2"/>+  </context>+  <context name="stmt2" attribute="Normal Text" lineEndContext="stmtContinuation">+    <IncludeRules context="findStmt"/>+    <RegExpr attribute="Normal Text" String="[-\w.]+\s*"/>+  </context>++  <context name="findOperator" attribute="Normal Text" lineEndContext="#stay">+    <StringDetect attribute="Operator" String="!"/>+    <StringDetect attribute="Operator" String="||"/>+    <StringDetect attribute="Operator" String="&amp;&amp;"/>+  </context>++  <context name="findStmt" attribute="Normal Text" lineEndContext="#stay">+    <DetectSpaces attribute="Normal Text"/>+    <IncludeRules context="findOperator"/>+    <StringDetect attribute="Comment" context="Comment" String="--"/>+    <StringDetect attribute="Version Operator" String="==" context="versionOp"/>+    <StringDetect attribute="Version Operator" String=">=" context="versionOp"/>+    <StringDetect attribute="Version Operator" String="&lt;=" context="versionOp"/>+    <StringDetect attribute="Version Operator" String="^>=" context="versionOp"/>+    <AnyChar attribute="Version Operator" String="&lt;>" context="versionOp"/>+    <AnyChar String="=^" context="versionOp" lookAhead="1"/>+    <keyword attribute="Constant" String="constant"/>+    <keyword attribute="Language" String="language"/>+  </context>++  <context name="versionOp" attribute="Error" lineEndContext="#pop" fallthroughContext="#pop">+    <DetectSpaces attribute="Normal Text"/>+    <AnyChar attribute="Error" String="=^!&lt;>"/>+    <DetectChar attribute="Normal Text" context="#pop!versionOpList" char="{"/>+    <RegExpr attribute="Version" String="&version;" context="#pop"/>+    <RegExpr attribute="Error" String="&noversion;" context="#pop"/>+  </context>+  <context name="versionOpList" attribute="Error" lineEndContext="#pop" fallthroughContext="#pop">+    <DetectSpaces attribute="Normal Text"/>+    <DetectChar attribute="Normal Text" char=","/>+    <DetectChar attribute="Normal Text" context="#pop" char="}"/>+    <StringDetect attribute="Comment" context="Comment" String="--"/>+    <IncludeRules context="findVersion"/>+  </context>+  <context name="findVersion" attribute="Normal Text" lineEndContext="#pop">+    <RegExpr attribute="Version" String="&version;"/>+    <RegExpr attribute="Error" String="&noversion;"/>+  </context>++  <context name="stmtContinuation" attribute="Normal Text" lineEndContext="#stay" fallthroughContext="#pop">+    <RegExpr attribute="Normal Text" String="^\s*[a-zA-Z]+[-0-9a-zA-Z]*\s*:|^\s*(if|else|elif|executable|library|benchmark|test-suite|source-repository|flag|foreign-library|custom-setup|common)(?![-\w])" lookAhead="1" context="#pop#pop" insensitive="1"/>+  </context>++  <context name="stmtVersion" attribute="Error" lineEndContext="#pop" fallthroughContext="#pop!version">+    <DetectSpaces attribute="Normal Text"/>+    <DetectChar attribute="Symbol Separator" char=":" context="#pop!version"/>+  </context>+  <context name="version" attribute="Normal Text" lineEndContext="stmtContinuation">+    <DetectSpaces attribute="Normal Text"/>+    <StringDetect attribute="Comment" context="Comment" String="--"/>+    <IncludeRules context="findVersion"/>+  </context>++  <context name="stmtBuildType" attribute="Normal Text" lineEndContext="#pop" fallthroughContext="stmtContinuation">+    <DetectSpaces attribute="Normal Text"/>+    <DetectChar attribute="Symbol Separator" char=":"/>+    <StringDetect attribute="Comment" context="Comment" String="--"/>+    <keyword attribute="Built Type" String="build-type"/>+  </context>++  <context name="stmtTestWith" attribute="Normal Text" lineEndContext="#pop!testWith" fallthroughContext="#pop!testWith">+    <DetectSpaces attribute="Normal Text"/>+    <StringDetect attribute="Symbol Separator" String=":" context="#pop!testWith"/>+  </context>+  <context name="testWith" attribute="Normal Text" lineEndContext="stmtContinuation">+    <IncludeRules context="findStmt"/>+    <keyword attribute="Compiler" String="compiler"/>+    <RegExpr attribute="Error" String="[-\w.]+"/>+  </context>++  <context name="stmtLicense" attribute="License" lineEndContext="#pop!license" fallthroughContext="#pop!license">+    <DetectSpaces attribute="Normal Text"/>+    <StringDetect attribute="Symbol Separator" String=":" context="#pop!license"/>+  </context>+  <context name="license" attribute="License" lineEndContext="stmtContinuation">+    <StringDetect attribute="Comment" context="Comment" String="--"/>+  </context>++  <context name="stmtLicenseFile" attribute="License File" lineEndContext="#pop!licenseFile" fallthroughContext="#pop!licenseFile">+    <DetectSpaces attribute="Normal Text"/>+    <StringDetect attribute="Symbol Separator" String=":" context="#pop!licenseFile"/>+  </context>+  <context name="licenseFile" attribute="License File" lineEndContext="stmtContinuation">+    <StringDetect attribute="Comment" context="Comment" String="--"/>+  </context>++  <context name="stmtMaintainer" attribute="Maintainer" lineEndContext="#pop!maintainer" fallthroughContext="#pop!maintainer">+    <DetectSpaces attribute="Normal Text"/>+    <StringDetect attribute="Symbol Separator" String=":" context="#pop!maintainer"/>+  </context>+  <context name="maintainer" attribute="Maintainer" lineEndContext="stmtContinuation">+    <StringDetect attribute="Comment" context="Comment" String="--"/>+  </context>++  <context name="stmtAuthor" attribute="Author" lineEndContext="#pop!author" fallthroughContext="#pop!author">+    <DetectSpaces attribute="Normal Text"/>+    <StringDetect attribute="Symbol Separator" String=":" context="#pop!author"/>+  </context>+  <context name="author" attribute="Author" lineEndContext="stmtContinuation">+    <StringDetect attribute="Comment" context="Comment" String="--"/>+  </context>++  <context name="stmtName" attribute="Name" lineEndContext="#pop!name" fallthroughContext="#pop!name">+    <DetectSpaces attribute="Normal Text"/>+    <StringDetect attribute="Symbol Separator" String=":" context="#pop!name"/>+  </context>+  <context name="name" attribute="Name" lineEndContext="stmtContinuation">+    <StringDetect attribute="Comment" context="Comment" String="--"/>+  </context>++  <context name="stmtDescription" attribute="Description" lineEndContext="#pop!description" fallthroughContext="#pop!description">+    <DetectSpaces attribute="Normal Text"/>+    <StringDetect attribute="Symbol Separator" String=":" context="#pop!description"/>+  </context>+  <context name="description" attribute="Description" lineEndContext="stmtContinuation">+    <StringDetect attribute="Comment" context="Comment" String="--"/>+  </context>++  <context name="stmtCopyright" attribute="Copyright" lineEndContext="#pop!copyright" fallthroughContext="#pop!copyright">+    <DetectSpaces attribute="Normal Text"/>+    <StringDetect attribute="Symbol Separator" String=":" context="#pop!copyright"/>+  </context>+  <context name="copyright" attribute="Copyright" lineEndContext="stmtContinuation">+    <StringDetect attribute="Comment" context="Comment" String="--"/>+  </context>++  <context name="stmtHomepage" attribute="Homepage" lineEndContext="#pop!homepage" fallthroughContext="#pop!homepage">+    <DetectSpaces attribute="Normal Text"/>+    <StringDetect attribute="Symbol Separator" String=":" context="#pop!homepage"/>+  </context>+  <context name="homepage" attribute="Homepage" lineEndContext="stmtContinuation">+    <StringDetect attribute="Comment" context="Comment" String="--"/>+  </context>++  <context name="stmtBugReports" attribute="Bug Reports" lineEndContext="#pop!bugReports" fallthroughContext="#pop!bugReports">+    <DetectSpaces attribute="Normal Text"/>+    <StringDetect attribute="Symbol Separator" String=":" context="#pop!bugReports"/>+  </context>+  <context name="bugReports" attribute="Bug Reports" lineEndContext="stmtContinuation">+    <StringDetect attribute="Comment" context="Comment" String="--"/>+  </context>++  <context name="conditional" attribute="Normal Text" lineEndContext="#pop">+    <DetectSpaces attribute="Normal Text"/>+    <AnyChar attribute="Symbol" String="()"/>+    <IncludeRules context="findOperator"/>+    <StringDetect attribute="Comment" context="#pop!Comment" String="--"/>+    <keyword attribute="Function" String="function" insensitive="0"/>+    <keyword attribute="Constant" String="constant"/>+    <DetectIdentifier attribute="Normal Text"/>+  </context>++</contexts>++<itemDatas>+  <itemData name="Normal Text" defStyleNum="dsNormal" spellChecking="0"/>+  <itemData name="Comment" defStyleNum="dsComment"/>+  <itemData name="Category" defStyleNum="dsKeyword" spellChecking="0"/>+  <itemData name="Category Title" defStyleNum="dsAttribute" spellChecking="0"/>+  <itemData name="Statement" defStyleNum="dsDataType" spellChecking="0"/>+  <itemData name="Other Statement" defStyleNum="dsPreprocessor" spellChecking="0"/>+  <itemData name="Name" defStyleNum="dsVerbatimString" spellChecking="0"/>+  <itemData name="Author" defStyleNum="dsString" spellChecking="0"/>+  <itemData name="Homepage" defStyleNum="dsSpecialString" spellChecking="0"/>+  <itemData name="Description" defStyleNum="dsVerbatimString" spellChecking="0"/>+  <itemData name="Maintainer" defStyleNum="dsString" spellChecking="0"/>+  <itemData name="Bug Reports" defStyleNum="dsSpecialString" spellChecking="0"/>+  <itemData name="Copyright" defStyleNum="dsString" spellChecking="0"/>+  <itemData name="License" defStyleNum="dsString" spellChecking="0"/>+  <itemData name="License File" defStyleNum="dsString" spellChecking="0"/>+  <itemData name="Built Type" defStyleNum="dsKeyword" spellChecking="0"/>+  <itemData name="Operator" defStyleNum="dsOperator" spellChecking="0"/>+  <itemData name="Version Operator" defStyleNum="dsOperator" spellChecking="0"/>+  <itemData name="Symbol" defStyleNum="dsNormal" spellChecking="0"/>+  <itemData name="Symbol Separator" defStyleNum="dsNormal" spellChecking="0"/>+  <itemData name="Version" defStyleNum="dsDecVal" spellChecking="0"/>+  <itemData name="Constant" defStyleNum="dsConstant" spellChecking="0"/>+  <itemData name="Language" defStyleNum="dsConstant" spellChecking="0"/>+  <itemData name="Function" defStyleNum="dsFunction" spellChecking="0"/>+  <itemData name="Conditional" defStyleNum="dsControlFlow" spellChecking="0"/>+  <itemData name="Compiler" defStyleNum="dsConstant" spellChecking="0"/>+  <itemData name="Error" defStyleNum="dsError" spellChecking="0"/>+</itemDatas>++  </highlighting>+  <general>+    <comments>+      <comment name="singleLine" start="--"/>+    </comments>+    <keywords casesensitive="0" weakDeliminator="-"/>+  </general>+</language>+<!-- kate: space-indent on; indent-width 2; replace-tabs on; -->
xml/cmake.xml view
@@ -7,15 +7,15 @@   <!ENTITY tgt_name_re "[A-Za-z0-9_\.\+\-]+"> ]> <!---    This file is part of KDE's kate project.+  This file is part of KDE's kate project. -    SPDX-FileCopyrightText: 2004 Alexander Neundorf <neundorf@kde.org>-    SPDX-FileCopyrightText: 2005 Dominik Haumann <dhdev@gmx.de>-    SPDX-FileCopyrightText: 2007, 2008, 2013, 2014 Matthew Woehlke <mw_triad@users.sourceforge.net>-    SPDX-FileCopyrightText: 2013-2015, 2017-2025 Alex Turbov <i.zaufi@gmail.com>+  SPDX-FileCopyrightText: 2004 Alexander Neundorf <neundorf@kde.org>+  SPDX-FileCopyrightText: 2005 Dominik Haumann <dhdev@gmx.de>+  SPDX-FileCopyrightText: 2007, 2008, 2013, 2014 Matthew Woehlke <mw_triad@users.sourceforge.net>+  SPDX-FileCopyrightText: 2013-2015, 2017-2025 Alex Turbov <i.zaufi@gmail.com> -    SPDX-License-Identifier: LGPL-2.0-or-later- -->+  SPDX-License-Identifier: LGPL-2.0-or-later+-->  <!-- ***** THIS FILE WAS GENERATED BY A SCRIPT - DO NOT EDIT *****   $ cd data/generators@@ -24,7 +24,7 @@  <language     name="CMake"-    version="54"+    version="61"     kateversion="5.62"     section="Other"     extensions="CMakeLists.txt;*.cmake;*.cmake.in"@@ -38,6 +38,7 @@     <list name="commands">         <item>block</item>         <item>break</item>+        <item>cmake_diagnostic</item>         <item>cmake_host_system_information</item>         <item>cmake_language</item>         <item>cmake_minimum_required</item>@@ -101,8 +102,10 @@         <item>aux_source_directory</item>         <item>build_command</item>         <item>cmake_file_api</item>+        <item>cmake_instrumentation</item>         <item>create_test_sourcelist</item>         <item>define_property</item>+        <item>discover_tests</item>         <item>enable_language</item>         <item>enable_testing</item>         <item>export</item>@@ -155,9 +158,33 @@       <item>SCOPE_FOR</item>     </list>     <list name="block_sargs">+      <item>DIAGNOSTICS</item>       <item>POLICIES</item>       <item>VARIABLES</item>     </list>+    <list name="cmake_diagnostic_nargs">+      <item>DEMOTE</item>+      <item>GET</item>+      <item>NO_RECURSE</item>+      <item>POP</item>+      <item>PROMOTE</item>+      <item>PUSH</item>+      <item>RECURSE</item>+      <item>SET</item>+    </list>+    <list name="cmake_diagnostic_sargs">+      <item>CMD_AUTHOR</item>+      <item>CMD_DEPRECATED</item>+      <item>CMD_EXPERIMENTAL</item>+      <item>CMD_INSTALL_ABSOLUTE_DESTINATION</item>+      <item>CMD_POLICY</item>+      <item>CMD_UNINITIALIZED</item>+      <item>CMD_UNUSED_CLI</item>+      <item>FATAL_ERROR</item>+      <item>IGNORE</item>+      <item>SEND_ERROR</item>+      <item>WARN</item>+    </list>     <list name="cmake_host_system_information_nargs">       <item>ERROR_VARIABLE</item>       <item>QUERY</item>@@ -193,6 +220,7 @@       <item>HOST</item>       <item>HOSTNAME</item>       <item>IS_64BIT</item>+      <item>LOCALE_CHARSET</item>       <item>MSYSTEM_PREFIX</item>       <item>NUMBER_OF_LOGICAL_CORES</item>       <item>NUMBER_OF_PHYSICAL_CORES</item>@@ -215,6 +243,7 @@       <item>DIRECTORY</item>       <item>EVAL</item>       <item>EXIT</item>+      <item>EXPAND</item>       <item>GET_CALL</item>       <item>GET_CALL_IDS</item>       <item>GET_MESSAGE_LOG_LEVEL</item>@@ -222,6 +251,7 @@       <item>ID_VAR</item>       <item>SET_DEPENDENCY_PROVIDER</item>       <item>SUPPORTED_METHODS</item>+      <item>TRACE</item>     </list>     <list name="cmake_language_sargs">       <item>FETCHCONTENT_MAKEAVAILABLE_SERIAL</item>@@ -232,6 +262,7 @@       <item>VERSION</item>     </list>     <list name="cmake_parse_arguments_nargs">+      <item>PARSE_ARGN</item>       <item>PARSE_ARGV</item>     </list>     <list name="cmake_path_nargs">@@ -281,13 +312,18 @@     <list name="cmake_pkg_config_nargs">       <item>ALLOW_SYSTEM_INCLUDES</item>       <item>ALLOW_SYSTEM_LIBS</item>+      <item>BIND_PC_REQUIRES</item>       <item>DISABLE_UNINSTALLED</item>       <item>ENV_MODE</item>       <item>EXACT</item>       <item>EXTRACT</item>+      <item>IMPORT</item>+      <item>NAME</item>       <item>PC_LIBDIR</item>       <item>PC_PATH</item>       <item>PC_SYSROOT_DIR</item>+      <item>POPULATE</item>+      <item>PREFIX</item>       <item>QUIET</item>       <item>REQUIRED</item>       <item>STRICTNESS</item>@@ -334,6 +370,7 @@       <item>AND</item>       <item>COMMAND</item>       <item>DEFINED</item>+      <item>DIAGNOSTIC</item>       <item>EQUAL</item>       <item>EXISTS</item>       <item>GREATER</item>@@ -373,6 +410,8 @@       <item>ECHO_ERROR_VARIABLE</item>       <item>ECHO_OUTPUT_VARIABLE</item>       <item>ENCODING</item>+      <item>ENVIRONMENT</item>+      <item>ENVIRONMENT_MODIFICATION</item>       <item>ERROR_FILE</item>       <item>ERROR_QUIET</item>       <item>ERROR_STRIP_TRAILING_WHITESPACE</item>@@ -505,6 +544,7 @@       <item>STATUS</item>       <item>STRINGS</item>       <item>TARGET</item>+      <item>THREADS</item>       <item>TIMEOUT</item>       <item>TIMESTAMP</item>       <item>TLS_CAINFO</item>@@ -528,6 +568,7 @@       <item>BZip2</item>       <item>CRLF</item>       <item>DOS</item>+      <item>Deflate</item>       <item>FILE</item>       <item>FUNCTION</item>       <item>GROUP_EXECUTE</item>@@ -536,11 +577,14 @@       <item>GZip</item>       <item>IGNORED</item>       <item>LF</item>+      <item>LZMA</item>+      <item>LZMA2</item>       <item>None</item>       <item>OPTIONAL</item>       <item>OWNER_EXECUTE</item>       <item>OWNER_READ</item>       <item>OWNER_WRITE</item>+      <item>PPMd</item>       <item>PROCESS</item>       <item>REQUIRED</item>       <item>SETGID</item>@@ -684,6 +728,7 @@       <item>CACHE</item>       <item>DEFINED</item>       <item>DIRECTORY</item>+      <item>FILE_SET</item>       <item>FULL_DOCS</item>       <item>GLOBAL</item>       <item>INSTALL</item>@@ -696,6 +741,7 @@       <item>VARIABLE</item>     </list>     <list name="include_nargs">+      <item>NO_DIAGNOSTIC_SCOPE</item>       <item>NO_POLICY_SCOPE</item>       <item>OPTIONAL</item>       <item>RESULT_VARIABLE</item>@@ -706,8 +752,10 @@     </list>     <list name="list_nargs">       <item>APPEND</item>+      <item>APPLY</item>       <item>AT</item>       <item>CASE</item>+      <item>COMPARATOR</item>       <item>COMPARE</item>       <item>EXCLUDE</item>       <item>FILTER</item>@@ -723,6 +771,7 @@       <item>OUTPUT_VARIABLE</item>       <item>POP_BACK</item>       <item>POP_FRONT</item>+      <item>PREDICATE</item>       <item>PREPEND</item>       <item>REGEX</item>       <item>REMOVE_AT</item>@@ -791,6 +840,7 @@       <item>APPEND_STRING</item>       <item>CACHE</item>       <item>DIRECTORY</item>+      <item>FILE_SET</item>       <item>GLOBAL</item>       <item>INSTALL</item>       <item>PROPERTY</item>@@ -827,6 +877,7 @@       <item>FIND</item>       <item>GENEX_STRIP</item>       <item>GET</item>+      <item>GET_RAW</item>       <item>GREATER</item>       <item>GREATER_EQUAL</item>       <item>HEX</item>@@ -843,7 +894,9 @@       <item>NAME</item>       <item>NAMESPACE</item>       <item>NOTEQUAL</item>+      <item>PARTIAL_EQUAL</item>       <item>PREPEND</item>+      <item>QUOTE</item>       <item>RANDOM</item>       <item>RANDOM_SEED</item>       <item>REGEX</item>@@ -861,6 +914,7 @@       <item>SHA3_384</item>       <item>SHA3_512</item>       <item>SHA512</item>+      <item>STRING_ENCODE</item>       <item>STRIP</item>       <item>SUBSTRING</item>       <item>TIMESTAMP</item>@@ -960,6 +1014,20 @@       <item>QUERY</item>       <item>TOOLCHAINS</item>     </list>+    <list name="cmake_instrumentation_nargs">+      <item>API_VERSION</item>+      <item>CALLBACK</item>+      <item>CUSTOM_CONTENT</item>+      <item>DATA_VERSION</item>+      <item>HOOKS</item>+      <item>OPTIONS</item>+    </list>+    <list name="cmake_instrumentation_sargs">+      <item>BOOL</item>+      <item>JSON</item>+      <item>LIST</item>+      <item>STRING</item>+    </list>     <list name="create_test_sourcelist_nargs">       <item>EXTRA_INCLUDE</item>       <item>FUNCTION</item>@@ -977,6 +1045,17 @@       <item>TEST</item>       <item>VARIABLE</item>     </list>+    <list name="discover_tests_nargs">+      <item>COMMAND</item>+      <item>COMMAND_EXPAND_LISTS</item>+      <item>CONFIGURATIONS</item>+      <item>DISCOVERY_ARGS</item>+      <item>DISCOVERY_MATCH</item>+      <item>DISCOVERY_PROPERTIES</item>+      <item>TEST_ARGS</item>+      <item>TEST_NAME</item>+      <item>TEST_PROPERTIES</item>+    </list>     <list name="enable_language_nargs">       <item>OPTIONAL</item>     </list>@@ -986,6 +1065,7 @@       <item>ASM_MARMASM</item>       <item>ASM_MASM</item>       <item>ASM_NASM</item>+      <item>ASM_POASM</item>       <item>C</item>       <item>CSharp</item>       <item>CUDA</item>@@ -1002,16 +1082,34 @@     <list name="export_nargs">       <item>ANDROID_MK</item>       <item>APPEND</item>+      <item>APPENDIX</item>       <item>AUTO</item>+      <item>COMPAT_VERSION</item>+      <item>CXX_MODULES_DIRECTORY</item>+      <item>DEFAULT_CONFIGURATIONS</item>+      <item>DEFAULT_LICENSE</item>+      <item>DEFAULT_TARGETS</item>+      <item>DESCRIPTION</item>       <item>ENABLED</item>       <item>EXPORT</item>       <item>EXPORT_LINK_INTERFACE_LIBRARIES</item>       <item>FILE</item>+      <item>FORMAT</item>+      <item>HOMEPAGE_URL</item>+      <item>LICENSE</item>+      <item>LOWER_CASE_FILE</item>       <item>NAMESPACE</item>+      <item>NO_PROJECT_METADATA</item>       <item>PACKAGE_DEPENDENCY</item>+      <item>PACKAGE_INFO</item>+      <item>PACKAGE_URL</item>+      <item>PROJECT</item>+      <item>SBOM</item>       <item>SETUP</item>       <item>TARGET</item>       <item>TARGETS</item>+      <item>VERSION</item>+      <item>VERSION_SCHEMA</item>       <item>XCFRAMEWORK_LOCATION</item>     </list>     <list name="get_source_file_property_nargs">@@ -1032,11 +1130,18 @@       <item>TYPE</item>     </list>     <list name="install_nargs">+      <item>APPENDIX</item>       <item>ARCHIVE</item>       <item>BUNDLE</item>       <item>CODE</item>+      <item>COMPAT_VERSION</item>       <item>COMPONENT</item>       <item>CONFIGURATIONS</item>+      <item>CXX_MODULES_DIRECTORY</item>+      <item>DEFAULT_CONFIGURATIONS</item>+      <item>DEFAULT_LICENSE</item>+      <item>DEFAULT_TARGETS</item>+      <item>DESCRIPTION</item>       <item>DESTINATION</item>       <item>DIRECTORIES</item>       <item>DIRECTORY</item>@@ -1052,17 +1157,24 @@       <item>FILES_MATCHING</item>       <item>FILE_PERMISSIONS</item>       <item>FILE_SET</item>+      <item>FORMAT</item>       <item>FRAMEWORK</item>+      <item>HOMEPAGE_URL</item>       <item>IMPORTED_RUNTIME_ARTIFACTS</item>       <item>INCLUDES</item>       <item>LIBRARY</item>+      <item>LICENSE</item>+      <item>LOWER_CASE_FILE</item>       <item>MESSAGE_NEVER</item>       <item>NAMELINK_COMPONENT</item>       <item>NAMELINK_ONLY</item>       <item>NAMELINK_SKIP</item>       <item>NAMESPACE</item>+      <item>NO_PROJECT_METADATA</item>       <item>OBJECTS</item>       <item>OPTIONAL</item>+      <item>PACKAGE_INFO</item>+      <item>PACKAGE_URL</item>       <item>PATTERN</item>       <item>PERMISSIONS</item>       <item>POST_EXCLUDE_FILES</item>@@ -1073,6 +1185,7 @@       <item>PRE_INCLUDE_REGEXES</item>       <item>PRIVATE_HEADER</item>       <item>PROGRAMS</item>+      <item>PROJECT</item>       <item>PUBLIC_HEADER</item>       <item>REGEX</item>       <item>RENAME</item>@@ -1080,10 +1193,13 @@       <item>RUNTIME</item>       <item>RUNTIME_DEPENDENCIES</item>       <item>RUNTIME_DEPENDENCY_SET</item>+      <item>SBOM</item>       <item>SCRIPT</item>       <item>TARGETS</item>       <item>TYPE</item>       <item>USE_SOURCE_PERMISSIONS</item>+      <item>VERSION</item>+      <item>VERSION_SCHEMA</item>     </list>     <list name="install_sargs">       <item>BIN</item>@@ -1127,14 +1243,17 @@       <item>READ_WITH_PREFIX</item>     </list>     <list name="project_nargs">+      <item>COMPAT_VERSION</item>       <item>DESCRIPTION</item>       <item>HOMEPAGE_URL</item>       <item>LANGUAGES</item>+      <item>SPDX_LICENSE</item>       <item>VERSION</item>     </list>     <list name="project_sargs">       <item>ASM</item>       <item>ASM-ATT</item>+      <item>ASM_MARMASM</item>       <item>ASM_MASM</item>       <item>ASM_NASM</item>       <item>C</item>@@ -1285,6 +1404,7 @@     <list name="target_sources_sargs">       <item>CXX_MODULES</item>       <item>HEADERS</item>+      <item>SOURCES</item>     </list>     <list name="try_compile_nargs">       <item>BINARY_DIR</item>@@ -1338,6 +1458,9 @@       <item>FLAGS</item>       <item>NUMBER_ERRORS</item>       <item>NUMBER_WARNINGS</item>+      <item>PARALLEL_LEVEL</item>+      <item>PRESET</item>+      <item>PRESETS_FILE</item>       <item>PROJECT_NAME</item>       <item>RETURN_VALUE</item>       <item>TARGET</item>@@ -1347,6 +1470,8 @@       <item>BUILD</item>       <item>CAPTURE_CMAKE_ERROR</item>       <item>OPTIONS</item>+      <item>PRESET</item>+      <item>PRESETS_FILE</item>       <item>QUIET</item>       <item>RETURN_VALUE</item>       <item>SOURCE</item>@@ -1362,6 +1487,7 @@     <list name="ctest_memcheck_nargs">       <item>APPEND</item>       <item>BUILD</item>+      <item>CAPTURE_CMAKE_ERROR</item>       <item>DEFECT_COUNT</item>       <item>END</item>       <item>EXCLUDE</item>@@ -1371,11 +1497,17 @@       <item>EXCLUDE_LABEL</item>       <item>INCLUDE</item>       <item>INCLUDE_LABEL</item>+      <item>OUTPUT_JUNIT</item>       <item>PARALLEL_LEVEL</item>+      <item>PRESET</item>+      <item>PRESETS_FILE</item>       <item>QUIET</item>+      <item>REPEAT</item>+      <item>RESOURCE_SPEC_FILE</item>       <item>RETURN_VALUE</item>       <item>SCHEDULE_RANDOM</item>       <item>START</item>+      <item>STOP_ON_FAILURE</item>       <item>STOP_TIME</item>       <item>STRIDE</item>       <item>TEST_LOAD</item>@@ -1416,9 +1548,13 @@       <item>INCLUDE</item>       <item>INCLUDE_FROM_FILE</item>       <item>INCLUDE_LABEL</item>+      <item>OUTPUT_JUNIT</item>       <item>PARALLEL_LEVEL</item>+      <item>PRESET</item>+      <item>PRESETS_FILE</item>       <item>QUIET</item>       <item>REPEAT</item>+      <item>RESOURCE_SPEC_FILE</item>       <item>RETURN_VALUE</item>       <item>SCHEDULE_RANDOM</item>       <item>START</item>@@ -1433,9 +1569,12 @@       <item>UNTIL_PASS</item>     </list>     <list name="ctest_update_nargs">+      <item>CAPTURE_CMAKE_ERROR</item>       <item>QUIET</item>       <item>RETURN_VALUE</item>       <item>SOURCE</item>+      <item>VERSION_ONLY</item>+      <item>VERSION_OVERRIDE</item>     </list>     <list name="ctest_upload_nargs">       <item>CAPTURE_CMAKE_ERROR</item>@@ -1494,6 +1633,7 @@     <list name="check_type_size_nargs">       <item>BUILTIN_TYPES_ONLY</item>       <item>LANGUAGE</item>+      <item>RESULT_VARIABLE</item>     </list>     <list name="cmake_add_fortran_subdirectory_nargs">       <item>ARCHIVE_DIR</item>@@ -1520,8 +1660,11 @@     <list name="write_basic_package_version_file_sargs">       <item>AnyNewerVersion</item>       <item>ExactVersion</item>+      <item>SameFullVersion</item>       <item>SameMajorVersion</item>       <item>SameMinorVersion</item>+      <item>SamePatchVersion</item>+      <item>SemanticVersion</item>     </list>     <list name="generate_apple_platform_selection_file_nargs">       <item>INSTALL_DESTINATION</item>@@ -1662,6 +1805,15 @@       <item>TARBALL</item>       <item>TARBALL_COMPRESSION</item>     </list>+    <list name="ctest_coverage_collect_gcov_sargs">+      <item>BZIP2</item>+      <item>FROM_EXT</item>+      <item>GZIP</item>+      <item>LZMA</item>+      <item>LZMA2</item>+      <item>XZ</item>+      <item>ZSTD</item>+    </list>     <list name="ExternalData_Add_Target_nargs">       <item>SHOW_PROGRESS</item>     </list>@@ -1676,6 +1828,8 @@       <item>CMAKE_CACHE_ARGS</item>       <item>CMAKE_CACHE_DEFAULT_ARGS</item>       <item>CMAKE_COMMAND</item>+      <item>CMAKE_EP_GIT_CLONE_RETRY_COUNT</item>+      <item>CMAKE_EP_GIT_CLONE_RETRY_DELAY</item>       <item>CMAKE_GENERATOR</item>       <item>CMAKE_GENERATOR_INSTANCE</item>       <item>CMAKE_GENERATOR_PLATFORM</item>@@ -1981,6 +2135,7 @@       <item>ENTRY_POINT</item>       <item>GENERATE_NATIVE_HEADERS</item>       <item>INCLUDE_JARS</item>+      <item>INCLUDE_MODULES</item>       <item>INSTALL</item>       <item>MANIFEST</item>       <item>NAMESPACE</item>@@ -2035,15 +2190,18 @@       <item>WINDOWTITLE</item>     </list>     <list name="swig_add_library_nargs">+      <item>DEBUG_POSTFIX</item>       <item>LANGUAGE</item>-      <item>MODULE</item>       <item>NO_PROXY</item>       <item>OUTFILE_DIR</item>       <item>OUTPUT_DIR</item>-      <item>SHARED</item>       <item>SOURCES</item>-      <item>STATIC</item>       <item>TYPE</item>+    </list>+    <list name="swig_add_library_sargs">+      <item>MODULE</item>+      <item>SHARED</item>+      <item>STATIC</item>       <item>USE_BUILD_SHARED_LIBS</item>     </list>     <list name="squish_add_test_nargs">@@ -2156,6 +2314,7 @@       <item>MODULE</item>       <item>SHARED</item>       <item>STATIC</item>+      <item>USE_SABI</item>       <item>WITH_SOABI</item>     </list>     <list name="Subversion_WC_INFO_nargs">@@ -2213,6 +2372,7 @@       <item>Boost_USE_MULTITHREADED</item>       <item>Boost_USE_RELEASE_LIBS</item>       <item>Boost_USE_STATIC_LIBS</item>+      <item>Boost_USE_STATIC_RUNTIME</item>       <item>Boost_USE_STLPORT</item>       <item>Boost_USE_STLPORT_DEPRECATED_NATIVE_IOSTREAMS</item>       <item>Boost_VERSION_COUNT</item>@@ -2257,6 +2417,9 @@       <item>CMAKE_AR</item>       <item>CMAKE_ARCHIVE_OUTPUT_DIRECTORY</item>       <item>CMAKE_ARGC</item>+      <item>CMAKE_AUTOGEN_BETTER_GRAPH_MULTI_CONFIG</item>+      <item>CMAKE_AUTOGEN_COMMAND_LINE_LENGTH_MAX</item>+      <item>CMAKE_AUTOGEN_INTERMEDIATE_DIR_STRATEGY</item>       <item>CMAKE_AUTOGEN_ORIGIN_DEPENDS</item>       <item>CMAKE_AUTOGEN_PARALLEL</item>       <item>CMAKE_AUTOGEN_USE_SYSTEM_INCLUDE</item>@@ -2264,6 +2427,8 @@       <item>CMAKE_AUTOMOC</item>       <item>CMAKE_AUTOMOC_DEPEND_FILTERS</item>       <item>CMAKE_AUTOMOC_EXECUTABLE</item>+      <item>CMAKE_AUTOMOC_INCLUDE_DIRECTORIES</item>+      <item>CMAKE_AUTOMOC_MACRO_NAMES</item>       <item>CMAKE_AUTOMOC_MOC_OPTIONS</item>       <item>CMAKE_AUTOMOC_PATH_PREFIX</item>       <item>CMAKE_AUTORCC</item>@@ -2276,7 +2441,6 @@       <item>CMAKE_BINARY_DIR</item>       <item>CMAKE_BUILD_RPATH</item>       <item>CMAKE_BUILD_RPATH_USE_ORIGIN</item>-      <item>CMAKE_BUILD_TOOL</item>       <item>CMAKE_BUILD_TYPE</item>       <item>CMAKE_BUILD_WITH_INSTALL_NAME_DIR</item>       <item>CMAKE_BUILD_WITH_INSTALL_RPATH</item>@@ -2322,13 +2486,18 @@       <item>CMAKE_CURRENT_LIST_FILE</item>       <item>CMAKE_CURRENT_LIST_LINE</item>       <item>CMAKE_CURRENT_SOURCE_DIR</item>+      <item>CMAKE_CXX_COMPILE_BMI</item>       <item>CMAKE_CXX_COMPILE_FEATURES</item>       <item>CMAKE_CXX_EXTENSIONS</item>       <item>CMAKE_CXX_LINK_NO_PIE_SUPPORTED</item>       <item>CMAKE_CXX_LINK_PIE_SUPPORTED</item>+      <item>CMAKE_CXX_MODULE_BMI_ONLY_FLAG</item>+      <item>CMAKE_CXX_MODULE_MAP_FLAG</item>+      <item>CMAKE_CXX_MODULE_MAP_FORMAT</item>       <item>CMAKE_CXX_SCAN_FOR_MODULES</item>       <item>CMAKE_CXX_STANDARD</item>       <item>CMAKE_CXX_STANDARD_REQUIRED</item>+      <item>CMAKE_CXX_STDLIB_MODULES_JSON</item>       <item>CMAKE_C_COMPILE_FEATURES</item>       <item>CMAKE_C_EXTENSIONS</item>       <item>CMAKE_C_LINK_NO_PIE_SUPPORTED</item>@@ -2370,6 +2539,7 @@       <item>CMAKE_EXTRA_SHARED_LIBRARY_SUFFIXES</item>       <item>CMAKE_FIND_APPBUNDLE</item>       <item>CMAKE_FIND_DEBUG_MODE</item>+      <item>CMAKE_FIND_DEBUG_MODE_NO_IMPLICIT_CONFIGURE_LOG</item>       <item>CMAKE_FIND_FRAMEWORK</item>       <item>CMAKE_FIND_FRAMEWORK_EXTRA_LOCATIONS</item>       <item>CMAKE_FIND_LIBRARY_CUSTOM_LIB_SUFFIX</item>@@ -2384,6 +2554,7 @@       <item>CMAKE_FIND_PACKAGE_SORT_ORDER</item>       <item>CMAKE_FIND_PACKAGE_TARGETS_GLOBAL</item>       <item>CMAKE_FIND_PACKAGE_WARN_NO_MODULE</item>+      <item>CMAKE_FIND_REQUIRED</item>       <item>CMAKE_FIND_ROOT_PATH</item>       <item>CMAKE_FIND_ROOT_PATH_MODE_INCLUDE</item>       <item>CMAKE_FIND_ROOT_PATH_MODE_LIBRARY</item>@@ -2505,6 +2676,7 @@       <item>CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_NO_WARNINGS</item>       <item>CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_SKIP</item>       <item>CMAKE_INSTALL_UCRT_LIBRARIES</item>+      <item>CMAKE_INTERMEDIATE_DIR_STRATEGY</item>       <item>CMAKE_INTERPROCEDURAL_OPTIMIZATION</item>       <item>CMAKE_ISPC_HEADER_DIRECTORY</item>       <item>CMAKE_ISPC_HEADER_SUFFIX</item>@@ -2613,11 +2785,13 @@       <item>CMAKE_POSITION_INDEPENDENT_CODE</item>       <item>CMAKE_PREFIX_PATH</item>       <item>CMAKE_PROGRAM_PATH</item>+      <item>CMAKE_PROJECT_COMPAT_VERSION</item>       <item>CMAKE_PROJECT_DESCRIPTION</item>       <item>CMAKE_PROJECT_HOMEPAGE_URL</item>       <item>CMAKE_PROJECT_INCLUDE</item>       <item>CMAKE_PROJECT_INCLUDE_BEFORE</item>       <item>CMAKE_PROJECT_NAME</item>+      <item>CMAKE_PROJECT_SPDX_LICENSE</item>       <item>CMAKE_PROJECT_TOP_LEVEL_INCLUDES</item>       <item>CMAKE_PROJECT_VERSION</item>       <item>CMAKE_PROJECT_VERSION_MAJOR</item>@@ -2633,6 +2807,7 @@       <item>CMAKE_REQUIRED_LINK_OPTIONS</item>       <item>CMAKE_REQUIRED_QUIET</item>       <item>CMAKE_ROOT</item>+      <item>CMAKE_RULE_MESSAGES</item>       <item>CMAKE_RUNTIME_OUTPUT_DIRECTORY</item>       <item>CMAKE_SCRIPT_MODE_FILE</item>       <item>CMAKE_SHARED_LIBRARY_ENABLE_EXPORTS</item>@@ -2647,6 +2822,7 @@       <item>CMAKE_SKIP_INSTALL_ALL_DEPENDENCY</item>       <item>CMAKE_SKIP_INSTALL_RPATH</item>       <item>CMAKE_SKIP_INSTALL_RULES</item>+      <item>CMAKE_SKIP_LINTING</item>       <item>CMAKE_SKIP_RPATH</item>       <item>CMAKE_SKIP_TEST_ALL_DEPENDENCY</item>       <item>CMAKE_SOURCE_DIR</item>@@ -2679,7 +2855,10 @@       <item>CMAKE_Swift_LANGUAGE_VERSION</item>       <item>CMAKE_Swift_MODULE_DIRECTORY</item>       <item>CMAKE_Swift_NUM_THREADS</item>+      <item>CMAKE_Swift_SEPARATE_MODULE_EMISSION</item>+      <item>CMAKE_TARGET_MESSAGES</item>       <item>CMAKE_TASKING_TOOLSET</item>+      <item>CMAKE_TEST_BUILD_DEPENDS</item>       <item>CMAKE_TEST_LAUNCHER</item>       <item>CMAKE_THREAD_LIBS_INIT</item>       <item>CMAKE_THREAD_PREFER_PTHREAD</item>@@ -2691,12 +2870,15 @@       <item>CMAKE_TWEAK_VERSION</item>       <item>CMAKE_UNITY_BUILD</item>       <item>CMAKE_UNITY_BUILD_BATCH_SIZE</item>+      <item>CMAKE_UNITY_BUILD_RELOCATABLE</item>+      <item>CMAKE_UNITY_BUILD_UNIQUE_ID</item>       <item>CMAKE_USER_MAKE_RULES_OVERRIDE</item>       <item>CMAKE_USE_PTHREADS_INIT</item>       <item>CMAKE_USE_SPROC_INIT</item>       <item>CMAKE_USE_WIN32_THREADS_INIT</item>       <item>CMAKE_VERBOSE_MAKEFILE</item>       <item>CMAKE_VERIFY_INTERFACE_HEADER_SETS</item>+      <item>CMAKE_VERIFY_PRIVATE_HEADER_SETS</item>       <item>CMAKE_VERSION</item>       <item>CMAKE_VISIBILITY_INLINES_HIDDEN</item>       <item>CMAKE_VS_DEBUGGER_COMMAND</item>@@ -2734,7 +2916,6 @@       <item>CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION</item>       <item>CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION_MAXIMUM</item>       <item>CMAKE_VS_WINRT_BY_DEFAULT</item>-      <item>CMAKE_WARN_DEPRECATED</item>       <item>CMAKE_WARN_ON_ABSOLUTE_INSTALL_DESTINATION</item>       <item>CMAKE_WATCOM_RUNTIME_LIBRARY</item>       <item>CMAKE_WIN32_EXECUTABLE</item>@@ -2771,10 +2952,26 @@       <item>CMAKE_XCODE_SCHEME_ZOMBIE_OBJECTS</item>       <item>CMAKE_XCODE_XCCONFIG</item>       <item>CPACK_ABSOLUTE_DESTINATION_FILES</item>+      <item>CPACK_APPIMAGE_COMPRESSOR</item>+      <item>CPACK_APPIMAGE_DESKTOP_FILE</item>+      <item>CPACK_APPIMAGE_EXCLUDE_FILE</item>+      <item>CPACK_APPIMAGE_GUESS_UPDATE_INFORMATION</item>+      <item>CPACK_APPIMAGE_MKSQUASHFS_OPTIONS</item>+      <item>CPACK_APPIMAGE_NO_APPSTREAM</item>+      <item>CPACK_APPIMAGE_PATCHELF_EXECUTABLE</item>+      <item>CPACK_APPIMAGE_RUNTIME_FILE</item>+      <item>CPACK_APPIMAGE_SIGN</item>+      <item>CPACK_APPIMAGE_SIGN_KEY</item>+      <item>CPACK_APPIMAGE_TOOL_EXECUTABLE</item>+      <item>CPACK_APPIMAGE_UPDATE_INFORMATION</item>       <item>CPACK_ARCHIVE_COMPONENT_INSTALL</item>+      <item>CPACK_ARCHIVE_COMPRESSION_LEVEL</item>+      <item>CPACK_ARCHIVE_ENCODING</item>       <item>CPACK_ARCHIVE_FILE_EXTENSION</item>       <item>CPACK_ARCHIVE_FILE_NAME</item>+      <item>CPACK_ARCHIVE_GID</item>       <item>CPACK_ARCHIVE_THREADS</item>+      <item>CPACK_ARCHIVE_UID</item>       <item>CPACK_BUILD_SOURCE_DIRS</item>       <item>CPACK_BUNDLE_APPLE_CERT_APP</item>       <item>CPACK_BUNDLE_APPLE_CODESIGN_FILES</item>@@ -2794,12 +2991,14 @@       <item>CPACK_COMPONENTS_ALL</item>       <item>CPACK_COMPONENTS_GROUPING</item>       <item>CPACK_COMPONENT_INCLUDE_TOPLEVEL_DIRECTORY</item>+      <item>CPACK_COMPRESSION_LEVEL</item>       <item>CPACK_CREATE_DESKTOP_LINKS</item>       <item>CPACK_CUSTOM_INSTALL_VARIABLES</item>       <item>CPACK_CYGWIN_BUILD_SCRIPT</item>       <item>CPACK_CYGWIN_PATCH_FILE</item>       <item>CPACK_CYGWIN_PATCH_NUMBER</item>       <item>CPACK_DEBIAN_ARCHIVE_TYPE</item>+      <item>CPACK_DEBIAN_COMPRESSION_LEVEL</item>       <item>CPACK_DEBIAN_COMPRESSION_TYPE</item>       <item>CPACK_DEBIAN_DEBUGINFO_PACKAGE</item>       <item>CPACK_DEBIAN_ENABLE_COMPONENT_DEPENDS</item>@@ -2937,6 +3136,7 @@       <item>CPACK_NSIS_BRANDING_TEXT_TRIM_POSITION</item>       <item>CPACK_NSIS_COMPRESSOR</item>       <item>CPACK_NSIS_CONTACT</item>+      <item>CPACK_NSIS_CRC_CHECK</item>       <item>CPACK_NSIS_CREATE_ICONS_EXTRA</item>       <item>CPACK_NSIS_DELETE_ICONS_EXTRA</item>       <item>CPACK_NSIS_DISPLAY_NAME</item>@@ -2951,6 +3151,7 @@       <item>CPACK_NSIS_FINISH_TITLE</item>       <item>CPACK_NSIS_FINISH_TITLE_3LINES</item>       <item>CPACK_NSIS_HELP_LINK</item>+      <item>CPACK_NSIS_IGNORE_COMPONENTS_PAGE</item>       <item>CPACK_NSIS_IGNORE_LICENSE_PAGE</item>       <item>CPACK_NSIS_INSTALLED_ICON_NAME</item>       <item>CPACK_NSIS_INSTALLER_MUI_ICON_CODE</item>@@ -2994,6 +3195,7 @@       <item>CPACK_NUGET_PACKAGE_TAGS</item>       <item>CPACK_NUGET_PACKAGE_TFMS</item>       <item>CPACK_NUGET_PACKAGE_TITLE</item>+      <item>CPACK_NUGET_SYMBOL_PACKAGE</item>       <item>CPACK_OBJCOPY_EXECUTABLE</item>       <item>CPACK_OBJDUMP_EXECUTABLE</item>       <item>CPACK_OUTPUT_CONFIG_FILE</item>@@ -3072,6 +3274,7 @@       <item>CPACK_RPM_PACKAGE_CONFLICTS</item>       <item>CPACK_RPM_PACKAGE_DEBUG</item>       <item>CPACK_RPM_PACKAGE_DESCRIPTION</item>+      <item>CPACK_RPM_PACKAGE_ENHANCES</item>       <item>CPACK_RPM_PACKAGE_EPOCH</item>       <item>CPACK_RPM_PACKAGE_GROUP</item>       <item>CPACK_RPM_PACKAGE_LICENSE</item>@@ -3089,6 +3292,7 @@       <item>CPACK_RPM_PACKAGE_SOURCES</item>       <item>CPACK_RPM_PACKAGE_SUGGESTS</item>       <item>CPACK_RPM_PACKAGE_SUMMARY</item>+      <item>CPACK_RPM_PACKAGE_SUPPLEMENTS</item>       <item>CPACK_RPM_PACKAGE_URL</item>       <item>CPACK_RPM_PACKAGE_VENDOR</item>       <item>CPACK_RPM_PACKAGE_VERSION</item>@@ -3145,12 +3349,14 @@       <item>CTEST_BINARY_DIRECTORY</item>       <item>CTEST_BUILD_COMMAND</item>       <item>CTEST_BUILD_NAME</item>+      <item>CTEST_BUILD_PRESET</item>       <item>CTEST_BZR_COMMAND</item>       <item>CTEST_BZR_UPDATE_OPTIONS</item>       <item>CTEST_CHANGE_ID</item>       <item>CTEST_CHECKOUT_COMMAND</item>       <item>CTEST_CONFIGURATION_TYPE</item>       <item>CTEST_CONFIGURE_COMMAND</item>+      <item>CTEST_CONFIGURE_PRESET</item>       <item>CTEST_COVERAGE_COMMAND</item>       <item>CTEST_COVERAGE_EXTRA_FLAGS</item>       <item>CTEST_CURL_OPTIONS</item>@@ -3198,16 +3404,21 @@       <item>CTEST_P4_COMMAND</item>       <item>CTEST_P4_OPTIONS</item>       <item>CTEST_P4_UPDATE_OPTIONS</item>+      <item>CTEST_PRESET</item>+      <item>CTEST_PRESETS_FILE</item>       <item>CTEST_RESOURCE_SPEC_FILE</item>       <item>CTEST_RUN_CURRENT_SCRIPT</item>       <item>CTEST_SITE</item>       <item>CTEST_SOURCE_DIRECTORY</item>       <item>CTEST_SUBMIT_INACTIVITY_TIMEOUT</item>+      <item>CTEST_SUBMIT_PARTS</item>       <item>CTEST_SUBMIT_URL</item>       <item>CTEST_SVN_COMMAND</item>       <item>CTEST_SVN_OPTIONS</item>       <item>CTEST_SVN_UPDATE_OPTIONS</item>+      <item>CTEST_TEST_COVERAGE_TOOL</item>       <item>CTEST_TEST_LOAD</item>+      <item>CTEST_TEST_PRESET</item>       <item>CTEST_TEST_TIMEOUT</item>       <item>CTEST_TLS_VERIFY</item>       <item>CTEST_TLS_VERSION</item>@@ -3246,6 +3457,7 @@       <item>ExternalData_CUSTOM_LOCATION</item>       <item>ExternalData_HTTPHEADERS</item>       <item>ExternalData_LINK_CONTENT</item>+      <item>ExternalData_LINK_MODE</item>       <item>ExternalData_NO_SYMLINKS</item>       <item>ExternalData_OBJECT_STORES</item>       <item>ExternalData_SERIES_MATCH</item>@@ -3254,6 +3466,7 @@       <item>ExternalData_SERIES_PARSE_PREFIX</item>       <item>ExternalData_SERIES_PARSE_SUFFIX</item>       <item>ExternalData_SOURCE_ROOT</item>+      <item>ExternalData_STATE_ROOT</item>       <item>ExternalData_TIMEOUT_ABSOLUTE</item>       <item>ExternalData_TIMEOUT_INACTIVITY</item>       <item>ExternalData_URL_TEMPLATES</item>@@ -3401,6 +3614,7 @@       <item>LTTNGUST_HAS_TRACEF</item>       <item>LTTNGUST_HAS_TRACELOG</item>       <item>LUALATEX_COMPILER</item>+      <item>LibXml2_USE_STATIC_LIBS</item>       <item>Libinput_COMPILE_OPTIONS</item>       <item>MAKEINDEX_COMPILER</item>       <item>MATLAB_ADDITIONAL_VERSIONS</item>@@ -3514,11 +3728,13 @@       <item>PNG_DEFINITIONS</item>       <item>PNG_LIBRARY</item>       <item>PROJECT_BINARY_DIR</item>+      <item>PROJECT_COMPAT_VERSION</item>       <item>PROJECT_DESCRIPTION</item>       <item>PROJECT_HOMEPAGE_URL</item>       <item>PROJECT_IS_TOP_LEVEL</item>       <item>PROJECT_NAME</item>       <item>PROJECT_SOURCE_DIR</item>+      <item>PROJECT_SPDX_LICENSE</item>       <item>PROJECT_VERSION</item>       <item>PROJECT_VERSION_MAJOR</item>       <item>PROJECT_VERSION_MINOR</item>@@ -3576,6 +3792,7 @@       <item>Python3_FIND_STRATEGY</item>       <item>Python3_FIND_UNVERSIONED_NAMES</item>       <item>Python3_FIND_VIRTUALENV</item>+      <item>Python3_FREE_THREADED</item>       <item>Python3_INTERPRETER</item>       <item>Python3_INTERPRETER_ID</item>       <item>Python3_LINK_OPTIONS</item>@@ -3667,7 +3884,6 @@       <item>wxWidgets_DEFINITIONS_DEBUG</item>       <item>wxWidgets_EXCLUDE_COMMON_LIBRARIES</item>       <item>wxWidgets_USE_DEBUG</item>-      <item>wxWidgets_USE_FILE</item>       <item>wxWidgets_USE_STATIC</item>       <item>wxWidgets_USE_UNICODE</item>       <item>wxWidgets_USE_UNIVERSAL</item>@@ -3676,24 +3892,31 @@     <list name="deprecated-or-internal-variables">       <item>CMAKE_AUTOMOC_RELAXED_MODE</item>       <item>CMAKE_BACKWARDS_COMPATIBILITY</item>+      <item>CMAKE_BUILD_TOOL</item>       <item>CMAKE_COMPILER_IS_GNUCC</item>       <item>CMAKE_COMPILER_IS_GNUCXX</item>       <item>CMAKE_COMPILER_IS_GNUG77</item>       <item>CMAKE_ENABLE_EXPORTS</item>+      <item>CMAKE_ERROR_DEPRECATED</item>       <item>CMAKE_EXTRA_GENERATOR</item>       <item>CMAKE_FILES_DIRECTORY</item>       <item>CMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY</item>       <item>CMAKE_FIND_PACKAGE_NO_SYSTEM_PACKAGE_REGISTRY</item>+      <item>CMAKE_FIND_USE_CMAKE_PACKAGE_REGISTRY</item>       <item>CMAKE_HOME_DIRECTORY</item>       <item>CMAKE_INTERNAL_PLATFORM_ABI</item>       <item>CMAKE_IOS_INSTALL_COMBINED</item>       <item>CMAKE_NOT_USING_CONFIG_FLAGS</item>+      <item>CMAKE_OBJCOPY</item>       <item>CMAKE_OBJDUMP</item>+      <item>CMAKE_READELF</item>+      <item>CMAKE_STRIP</item>       <item>CMAKE_SUPPRESS_DEVELOPER_ERRORS</item>       <item>CMAKE_SUPPRESS_DEVELOPER_WARNINGS</item>       <item>CMAKE_SYSTEM_ARCH</item>       <item>CMAKE_USE_RELATIVE_PATHS</item>       <item>CMAKE_VS_INTEL_Fortran_PROJECT_VERSION</item>+      <item>CMAKE_WARN_DEPRECATED</item>       <item>CPACK_INSTALL_PREFIX</item>       <item>CPACK_INSTALL_SCRIPT</item>       <item>CPACK_PACKAGE_CONTACT</item>@@ -3703,6 +3926,8 @@       <item>CTEST_CVS_CHECKOUT</item>       <item>CTEST_SCP_COMMAND</item>       <item>CTEST_TRIGGER_SITE</item>+      <item>LIBXML2_FOUND</item>+      <item>LIBXML2_VERSION_STRING</item>       <item>MSVC10</item>       <item>MSVC11</item>       <item>MSVC12</item>@@ -3712,6 +3937,7 @@       <item>MSVC71</item>       <item>MSVC80</item>       <item>MSVC90</item>+      <item>wxWidgets_USE_FILE</item>     </list>      <list name="environment-variables">@@ -3721,12 +3947,14 @@       <item>CFLAGS</item>       <item>CMAKE_APPBUNDLE_PATH</item>       <item>CMAKE_APPLE_SILICON_PROCESSOR</item>+      <item>CMAKE_AUTOGEN_INTERMEDIATE_DIR_STRATEGY</item>       <item>CMAKE_BUILD_PARALLEL_LEVEL</item>       <item>CMAKE_BUILD_TYPE</item>       <item>CMAKE_COLOR_DIAGNOSTICS</item>       <item>CMAKE_CONFIGURATION_TYPES</item>       <item>CMAKE_CONFIG_TYPE</item>       <item>CMAKE_CROSSCOMPILING_EMULATOR</item>+      <item>CMAKE_DISABLE_PRECOMPILE_HEADERS</item>       <item>CMAKE_EXPORT_BUILD_DATABASE</item>       <item>CMAKE_EXPORT_COMPILE_COMMANDS</item>       <item>CMAKE_FRAMEWORK_PATH</item>@@ -3737,6 +3965,7 @@       <item>CMAKE_INCLUDE_PATH</item>       <item>CMAKE_INSTALL_MODE</item>       <item>CMAKE_INSTALL_PREFIX</item>+      <item>CMAKE_INTERMEDIATE_DIR_STRATEGY</item>       <item>CMAKE_LIBRARY_PATH</item>       <item>CMAKE_MAXIMUM_RECURSION_DEPTH</item>       <item>CMAKE_MSVCIDE_RUN_PATH</item>@@ -3896,6 +4125,7 @@       <item>AUTOMOC_COMPILER_PREDEFINES</item>       <item>AUTOMOC_DEPEND_FILTERS</item>       <item>AUTOMOC_EXECUTABLE</item>+      <item>AUTOMOC_INCLUDE_DIRECTORIES</item>       <item>AUTOMOC_MACRO_NAMES</item>       <item>AUTOMOC_MOC_OPTIONS</item>       <item>AUTOMOC_PATH_PREFIX</item>@@ -3986,6 +4216,11 @@       <item>IMPORTED</item>       <item>IMPORTED_COMMON_LANGUAGE_RUNTIME</item>       <item>IMPORTED_CONFIGURATIONS</item>+      <item>IMPORTED_CXX_MODULES_COMPILE_DEFINITIONS</item>+      <item>IMPORTED_CXX_MODULES_COMPILE_FEATURES</item>+      <item>IMPORTED_CXX_MODULES_COMPILE_OPTIONS</item>+      <item>IMPORTED_CXX_MODULES_INCLUDE_DIRECTORIES</item>+      <item>IMPORTED_CXX_MODULES_LINK_LIBRARIES</item>       <item>IMPORTED_GLOBAL</item>       <item>IMPORTED_IMPLIB</item>       <item>IMPORTED_LIBNAME</item>@@ -4002,6 +4237,8 @@       <item>IMPORT_SUFFIX</item>       <item>INCLUDE_DIRECTORIES</item>       <item>INSTALL_NAME_DIR</item>+      <item>INSTALL_OBJECT_NAME_STRATEGY</item>+      <item>INSTALL_OBJECT_ONLY_USE_DESTINATION</item>       <item>INSTALL_REMOVE_ENVIRONMENT_RPATH</item>       <item>INSTALL_RPATH</item>       <item>INSTALL_RPATH_USE_LINK_PATH</item>@@ -4089,6 +4326,7 @@       <item>PRECOMPILE_HEADERS_REUSE_FROM</item>       <item>PREFIX</item>       <item>PRIVATE_HEADER</item>+      <item>PRIVATE_HEADER_SETS_TO_VERIFY</item>       <item>PROJECT_LABEL</item>       <item>PUBLIC_HEADER</item>       <item>RESOURCE</item>@@ -4098,9 +4336,11 @@       <item>RUNTIME_OUTPUT_DIRECTORY</item>       <item>RUNTIME_OUTPUT_NAME</item>       <item>SKIP_BUILD_RPATH</item>+      <item>SKIP_LINTING</item>       <item>SOURCES</item>       <item>SOURCE_DIR</item>       <item>SOVERSION</item>+      <item>SPDX_LICENSE</item>       <item>STATIC_LIBRARY_FLAGS</item>       <item>STATIC_LIBRARY_OPTIONS</item>       <item>SUFFIX</item>@@ -4110,6 +4350,8 @@       <item>Swift_LANGUAGE_VERSION</item>       <item>Swift_MODULE_DIRECTORY</item>       <item>Swift_MODULE_NAME</item>+      <item>Swift_PACKAGE_NAME</item>+      <item>Swift_SEPARATE_MODULE_EMISSION</item>       <item>TEST_LAUNCHER</item>       <item>TRANSITIVE_COMPILE_PROPERTIES</item>       <item>TRANSITIVE_LINK_PROPERTIES</item>@@ -4118,9 +4360,11 @@       <item>UNITY_BUILD_BATCH_SIZE</item>       <item>UNITY_BUILD_CODE_AFTER_INCLUDE</item>       <item>UNITY_BUILD_CODE_BEFORE_INCLUDE</item>+      <item>UNITY_BUILD_FILENAME_PREFIX</item>       <item>UNITY_BUILD_MODE</item>       <item>UNITY_BUILD_UNIQUE_ID</item>       <item>VERIFY_INTERFACE_HEADER_SETS</item>+      <item>VERIFY_PRIVATE_HEADER_SETS</item>       <item>VERSION</item>       <item>VISIBILITY_INLINES_HIDDEN</item>       <item>VS_CONFIGURATION_TYPE</item>@@ -4200,6 +4444,56 @@       <item>XCODE_XCCONFIG</item>       <item>XCTEST</item>     </list>+    <list name="fileset-properties">+      <item>BASE_DIRS</item>+      <item>COMPILE_DEFINITIONS</item>+      <item>COMPILE_OPTIONS</item>+      <item>CXX_SCAN_FOR_MODULES</item>+      <item>INCLUDE_DIRECTORIES</item>+      <item>INDEPENDENT_FILES</item>+      <item>INTERFACE_COMPILE_DEFINITIONS</item>+      <item>INTERFACE_COMPILE_OPTIONS</item>+      <item>INTERFACE_INCLUDE_DIRECTORIES</item>+      <item>INTERFACE_SOURCES</item>+      <item>JOB_POOL_COMPILE</item>+      <item>SCOPE</item>+      <item>SKIP_LINTING</item>+      <item>SKIP_PRECOMPILE_HEADERS</item>+      <item>SKIP_UNITY_BUILD_INCLUSION</item>+      <item>SOURCES</item>+      <item>TYPE</item>+    </list>+    <list name="test-properties">+      <item>ATTACHED_FILES</item>+      <item>ATTACHED_FILES_ON_FAIL</item>+      <item>COST</item>+      <item>DEPENDS</item>+      <item>DISABLED</item>+      <item>ENVIRONMENT</item>+      <item>ENVIRONMENT_MODIFICATION</item>+      <item>FAIL_REGULAR_EXPRESSION</item>+      <item>FIXTURES_CLEANUP</item>+      <item>FIXTURES_REQUIRED</item>+      <item>FIXTURES_SETUP</item>+      <item>GENERATED_RESOURCE_SPEC_FILE</item>+      <item>LABELS</item>+      <item>MEASUREMENT</item>+      <item>PASS_REGULAR_EXPRESSION</item>+      <item>PROCESSORS</item>+      <item>PROCESSOR_AFFINITY</item>+      <item>REQUIRED_FILES</item>+      <item>RESOURCE_GROUPS</item>+      <item>RESOURCE_LOCK</item>+      <item>RUN_SERIAL</item>+      <item>SKIP_REGULAR_EXPRESSION</item>+      <item>SKIP_RETURN_CODE</item>+      <item>TIMEOUT</item>+      <item>TIMEOUT_AFTER_MATCH</item>+      <item>TIMEOUT_SIGNAL_GRACE_PERIOD</item>+      <item>TIMEOUT_SIGNAL_NAME</item>+      <item>WILL_FAIL</item>+      <item>WORKING_DIRECTORY</item>+    </list>     <list name="source-properties">       <item>ABSTRACT</item>       <item>AUTORCC_OPTIONS</item>@@ -4214,12 +4508,15 @@       <item>GENERATED</item>       <item>HEADER_FILE_ONLY</item>       <item>INCLUDE_DIRECTORIES</item>+      <item>INSTALL_OBJECT_NAME</item>+      <item>JOB_POOL_COMPILE</item>       <item>KEEP_EXTENSION</item>       <item>LABELS</item>       <item>LANGUAGE</item>       <item>LOCATION</item>       <item>MACOSX_PACKAGE_LOCATION</item>       <item>OBJECT_DEPENDS</item>+      <item>OBJECT_NAME</item>       <item>OBJECT_OUTPUTS</item>       <item>SKIP_AUTOGEN</item>       <item>SKIP_AUTOMOC</item>@@ -4254,37 +4551,6 @@       <item>XCODE_FILE_ATTRIBUTES</item>       <item>XCODE_LAST_KNOWN_FILE_TYPE</item>     </list>-    <list name="test-properties">-      <item>ATTACHED_FILES</item>-      <item>ATTACHED_FILES_ON_FAIL</item>-      <item>COST</item>-      <item>DEPENDS</item>-      <item>DISABLED</item>-      <item>ENVIRONMENT</item>-      <item>ENVIRONMENT_MODIFICATION</item>-      <item>FAIL_REGULAR_EXPRESSION</item>-      <item>FIXTURES_CLEANUP</item>-      <item>FIXTURES_REQUIRED</item>-      <item>FIXTURES_SETUP</item>-      <item>GENERATED_RESOURCE_SPEC_FILE</item>-      <item>LABELS</item>-      <item>MEASUREMENT</item>-      <item>PASS_REGULAR_EXPRESSION</item>-      <item>PROCESSORS</item>-      <item>PROCESSOR_AFFINITY</item>-      <item>REQUIRED_FILES</item>-      <item>RESOURCE_GROUPS</item>-      <item>RESOURCE_LOCK</item>-      <item>RUN_SERIAL</item>-      <item>SKIP_REGULAR_EXPRESSION</item>-      <item>SKIP_RETURN_CODE</item>-      <item>TIMEOUT</item>-      <item>TIMEOUT_AFTER_MATCH</item>-      <item>TIMEOUT_SIGNAL_GRACE_PERIOD</item>-      <item>TIMEOUT_SIGNAL_NAME</item>-      <item>WILL_FAIL</item>-      <item>WORKING_DIRECTORY</item>-    </list>     <list name="cache-properties">       <item>ADVANCED</item>       <item>HELPSTRING</item>@@ -4310,13 +4576,17 @@       <item>AND</item>       <item>OR</item>       <item>NOT</item>-      <item>STREQUAL</item>       <item>EQUAL</item>       <item>VERSION_LESS</item>       <item>VERSION_GREATER</item>       <item>VERSION_EQUAL</item>       <item>VERSION_LESS_EQUAL</item>       <item>VERSION_GREATER_EQUAL</item>+      <item>STREQUAL</item>+      <item>STRLESS</item>+      <item>STRGREATER</item>+      <item>STRLESS_EQUAL</item>+      <item>STRGREATER_EQUAL</item>       <item>LOWER_CASE</item>       <item>UPPER_CASE</item>       <item>MAKE_C_IDENTIFIER</item>@@ -4365,12 +4635,29 @@       <item>LINK_ONLY</item>       <item>DEVICE_LINK</item>       <item>HOST_LINK</item>+      <item>C_COMPILER_LINKER_ID</item>+      <item>CXX_COMPILER_LINKER_ID</item>+      <item>CUDA_COMPILER_LINKER_ID</item>+      <item>OBJC_COMPILER_LINKER_ID</item>+      <item>OBJCXX_COMPILER_LINKER_ID</item>+      <item>Fortran_COMPILER_LINKER_ID</item>+      <item>HIP_COMPILER_LINKER_ID</item>+      <item>C_COMPILER_LINKER_FRONTEND_VARIANT</item>+      <item>CXX_COMPILER_LINKER_FRONTEND_VARIANT</item>+      <item>CUDA_COMPILER_LINKER_FRONTEND_VARIANT</item>+      <item>OBJC_COMPILER_LINKER_FRONTEND_VARIANT</item>+      <item>OBJCXX_COMPILER_LINKER_FRONTEND_VARIANT</item>+      <item>Fortran_COMPILER_LINKER_FRONTEND_VARIANT</item>+      <item>HIP_COMPILER_LINKER_FRONTEND_VARIANT</item>+      <item>SOURCE_EXISTS</item>+      <item>SOURCE_PROPERTY</item>+      <item>FILE_SET_EXISTS</item>+      <item>FILE_SET_PROPERTY</item>       <item>TARGET_EXISTS</item>       <item>TARGET_NAME_IF_EXISTS</item>       <item>TARGET_NAME</item>-      <item>TARGET_PROPERTY</item>-      <item>TARGET_OBJECTS</item>       <item>TARGET_POLICY</item>+      <item>TARGET_PROPERTY</item>       <item>TARGET_FILE</item>       <item>TARGET_FILE_BASE_NAME</item>       <item>TARGET_FILE_PREFIX</item>@@ -4389,18 +4676,35 @@       <item>TARGET_LINKER_FILE_SUFFIX</item>       <item>TARGET_LINKER_FILE_NAME</item>       <item>TARGET_LINKER_FILE_DIR</item>+      <item>TARGET_LINKER_LIBRARY_FILE</item>+      <item>TARGET_LINKER_LIBRARY_FILE_BASE_NAME</item>+      <item>TARGET_LINKER_LIBRARY_FILE_PREFIX</item>+      <item>TARGET_LINKER_LIBRARY_FILE_SUFFIX</item>+      <item>TARGET_LINKER_LIBRARY_FILE_NAME</item>+      <item>TARGET_LINKER_LIBRARY_FILE_DIR</item>+      <item>TARGET_LINKER_IMPORT_FILE</item>+      <item>TARGET_LINKER_IMPORT_FILE_BASE_NAME</item>+      <item>TARGET_LINKER_IMPORT_FILE_PREFIX</item>+      <item>TARGET_LINKER_IMPORT_FILE_SUFFIX</item>+      <item>TARGET_LINKER_IMPORT_FILE_NAME</item>+      <item>TARGET_LINKER_IMPORT_FILE_DIR</item>       <item>TARGET_SONAME_FILE</item>       <item>TARGET_SONAME_FILE_NAME</item>       <item>TARGET_SONAME_FILE_DIR</item>+      <item>TARGET_SONAME_IMPORT_FILE</item>+      <item>TARGET_SONAME_IMPORT_FILE_NAME</item>+      <item>TARGET_SONAME_IMPORT_FILE_DIR</item>       <item>TARGET_PDB_FILE</item>       <item>TARGET_PDB_FILE_BASE_NAME</item>       <item>TARGET_PDB_FILE_NAME</item>       <item>TARGET_PDB_FILE_DIR</item>-      <item>TARGET_BUNDLE_DIR_NAME</item>       <item>TARGET_BUNDLE_DIR</item>+      <item>TARGET_BUNDLE_DIR_NAME</item>       <item>TARGET_BUNDLE_CONTENT_DIR</item>+      <item>TARGET_OBJECTS</item>       <item>TARGET_RUNTIME_DLLS</item>       <item>TARGET_RUNTIME_DLL_DIRS</item>+      <item>TARGET_INTERMEDIATE_DIR</item>       <item>INSTALL_INTERFACE</item>       <item>BUILD_INTERFACE</item>       <item>BUILD_LOCAL_INTERFACE</item>@@ -4412,6 +4716,27 @@       <item>SEMICOLON</item>       <item>QUOTE</item>     </list>+    <list name="genex-STRING-subcommands">+      <item>LENGTH</item>+      <item>SUBSTRING</item>+      <item>FIND</item>+      <item>MATCH</item>+      <item>JOIN</item>+      <item>ASCII</item>+      <item>TIMESTAMP</item>+      <item>RANDOM</item>+      <item>UUID</item>+      <item>REPLACE</item>+      <item>APPEND</item>+      <item>PREPEND</item>+      <item>TOLOWER</item>+      <item>TOUPPER</item>+      <item>STRIP</item>+      <item>QUOTE</item>+      <item>HEX</item>+      <item>HASH</item>+      <item>MAKE_C_IDENTIFIER</item>+    </list>     <list name="genex-LIST-subcommands">       <item>LENGTH</item>       <item>GET</item>@@ -4554,7 +4879,6 @@       <item>Boost</item>       <item>Bullet</item>       <item>BZip2</item>-      <item>CABLE</item>       <item>Coin3D</item>       <item>CUDAToolkit</item>       <item>Cups</item>@@ -4573,7 +4897,6 @@       <item>FLTK2</item>       <item>Fontconfig</item>       <item>Freetype</item>-      <item>GCCXML</item>       <item>Gettext</item>       <item>GIF</item>       <item>Git</item>@@ -4735,6 +5058,8 @@       <item>CPackWIX</item>       <item>GetPrerequisites</item>       <item>TestBigEndian</item>+      <item>FindGCCXML</item>+      <item>FindCABLE</item>     </list>      @@ -4764,6 +5089,7 @@         <DetectSpaces/>         <WordDetect String="block" insensitive="true" attribute="Command" context="block_ctx" beginRegion="block"/>         <WordDetect String="break" insensitive="true" attribute="Control Flow" context="break_ctx"/>+        <WordDetect String="cmake_diagnostic" insensitive="true" attribute="Command" context="cmake_diagnostic_ctx"/>         <WordDetect String="cmake_host_system_information" insensitive="true" attribute="Command" context="cmake_host_system_information_ctx"/>         <WordDetect String="cmake_language" insensitive="true" attribute="Command" context="cmake_language_ctx"/>         <WordDetect String="cmake_minimum_required" insensitive="true" attribute="Command" context="cmake_minimum_required_ctx"/>@@ -4827,8 +5153,10 @@         <WordDetect String="aux_source_directory" insensitive="true" attribute="Command" context="function_ctx"/>         <WordDetect String="build_command" insensitive="true" attribute="Command" context="build_command_ctx"/>         <WordDetect String="cmake_file_api" insensitive="true" attribute="Command" context="cmake_file_api_ctx"/>+        <WordDetect String="cmake_instrumentation" insensitive="true" attribute="Command" context="cmake_instrumentation_ctx"/>         <WordDetect String="create_test_sourcelist" insensitive="true" attribute="Command" context="create_test_sourcelist_ctx"/>         <WordDetect String="define_property" insensitive="true" attribute="Command" context="define_property_ctx"/>+        <WordDetect String="discover_tests" insensitive="true" attribute="Command" context="discover_tests_ctx"/>         <WordDetect String="enable_language" insensitive="true" attribute="Command" context="enable_language_ctx"/>         <WordDetect String="enable_testing" insensitive="true" attribute="Command" context="function_ctx"/>         <WordDetect String="export" insensitive="true" attribute="Command" context="export_ctx"/>@@ -5038,6 +5366,7 @@         <WordDetect String="protobuf_generate_python" insensitive="true" attribute="CMake Provided Function/Macro" context="function_ctx"/>         <WordDetect String="protobuf_generate" insensitive="true" attribute="CMake Provided Function/Macro" context="protobuf_generate_ctx"/>         <WordDetect String="Python_add_library" insensitive="true" attribute="CMake Provided Function/Macro" context="Python_add_library_ctx"/>+        <WordDetect String="Python3_add_library" insensitive="true" attribute="CMake Provided Function/Macro" context="Python_add_library_ctx"/>         <WordDetect String="Subversion_WC_INFO" insensitive="true" attribute="CMake Provided Function/Macro" context="Subversion_WC_INFO_ctx"/>         <WordDetect String="Subversion_WC_LOG" insensitive="true" attribute="CMake Provided Function/Macro" context="function_ctx"/>         <WordDetect String="xctest_add_bundle" insensitive="true" attribute="CMake Provided Function/Macro" context="function_ctx"/>@@ -5065,6 +5394,17 @@         <DetectSpaces/>         <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>       </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="cmake_diagnostic_ctx">+        <DetectChar attribute="Normal Text" context="cmake_diagnostic_ctx_op" char="("/>+        <DetectChar attribute="Normal Text" context="#pop" char=")"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="cmake_diagnostic_ctx_op">+        <DetectSpaces/>+        <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>+        <keyword attribute="Named Args" context="#stay" String="cmake_diagnostic_nargs"/>+        <keyword attribute="Special Args" context="#stay" String="cmake_diagnostic_sargs"/>+        <IncludeRules context="User Function Args"/>+      </context>       <context attribute="Normal Text" lineEndContext="#stay" name="cmake_host_system_information_ctx">         <DetectChar attribute="Normal Text" context="cmake_host_system_information_ctx_op" char="("/>         <DetectChar attribute="Normal Text" context="#pop" char=")"/>@@ -5161,10 +5501,18 @@         <DetectSpaces/>         <DetectChar attribute="Normal Text" context="elseif_ctx_op_nested" char="("/>         <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>-        <WordDetect String="TARGET" attribute="Named Args" context="Target Name"/>+        <WordDetect String="TARGET" attribute="Named Args" context="elseif_tgts"/>+        <StringDetect attribute="Cache Variable Substitution" context="CacheVarSubst" String="CACHE{"/>         <keyword attribute="Named Args" context="#stay" String="elseif_nargs"/>         <IncludeRules context="User Function Args"/>       </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="elseif_tgts">+        <DetectSpaces/>+        <keyword attribute="Named Args" context="#pop" String="elseif_nargs" lookAhead="true"/>+        <IncludeRules context="Detect Aliased Targets"/>+        <IncludeRules context="Detect Targets"/>+        <IncludeRules context="User Function Opened"/>+      </context>       <context attribute="Normal Text" lineEndContext="#stay" name="elseif_ctx_op_nested">         <DetectSpaces/>         <DetectChar attribute="Normal Text" context="#pop" char=")"/>@@ -5297,10 +5645,12 @@       <context attribute="Normal Text" lineEndContext="#stay" name="get_property_ctx_op">         <DetectSpaces/>         <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>+        <WordDetect String="TARGET" attribute="Named Args" context="get_property_tgts"/>         <keyword attribute="Named Args" context="#stay" String="get_property_nargs"/>         <keyword attribute="Property" context="#stay" String="cache-properties"/>         <keyword attribute="Property" context="#stay" String="directory-properties"/>         <IncludeRules context="Detect More directory-properties"/>+        <keyword attribute="Property" context="#stay" String="fileset-properties"/>         <keyword attribute="Property" context="#stay" String="global-properties"/>         <IncludeRules context="Detect More global-properties"/>         <keyword attribute="Property" context="#stay" String="install-properties"/>@@ -5311,6 +5661,13 @@         <keyword attribute="Property" context="#stay" String="test-properties"/>         <IncludeRules context="User Function Args"/>       </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="get_property_tgts">+        <DetectSpaces/>+        <keyword attribute="Named Args" context="#pop" String="get_property_nargs" lookAhead="true"/>+        <IncludeRules context="Detect Aliased Targets"/>+        <IncludeRules context="Detect Targets"/>+        <IncludeRules context="User Function Opened"/>+      </context>       <context attribute="Normal Text" lineEndContext="#stay" name="if_ctx">         <DetectChar attribute="Normal Text" context="if_ctx_op" char="("/>         <DetectChar attribute="Normal Text" context="#pop" char=")"/>@@ -5319,7 +5676,8 @@         <DetectSpaces/>         <DetectChar attribute="Normal Text" context="if_ctx_op_nested" char="("/>         <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>-        <WordDetect String="TARGET" attribute="Named Args" context="Target Name"/>+        <WordDetect String="TARGET" attribute="Named Args" context="elseif_tgts"/>+        <StringDetect attribute="Cache Variable Substitution" context="CacheVarSubst" String="CACHE{"/>         <keyword attribute="Named Args" context="#stay" String="elseif_nargs"/>         <IncludeRules context="User Function Args"/>       </context>@@ -5425,6 +5783,7 @@         <keyword attribute="Property" context="#stay" String="cache-properties"/>         <keyword attribute="Property" context="#stay" String="directory-properties"/>         <IncludeRules context="Detect More directory-properties"/>+        <keyword attribute="Property" context="#stay" String="fileset-properties"/>         <keyword attribute="Property" context="#stay" String="global-properties"/>         <IncludeRules context="Detect More global-properties"/>         <keyword attribute="Property" context="#stay" String="install-properties"/>@@ -5442,10 +5801,12 @@       <context attribute="Normal Text" lineEndContext="#stay" name="set_property_ctx_op">         <DetectSpaces/>         <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>+        <WordDetect String="TARGET" attribute="Named Args" context="set_property_tgts"/>         <keyword attribute="Named Args" context="#stay" String="set_property_nargs"/>         <keyword attribute="Property" context="#stay" String="cache-properties"/>         <keyword attribute="Property" context="#stay" String="directory-properties"/>         <IncludeRules context="Detect More directory-properties"/>+        <keyword attribute="Property" context="#stay" String="fileset-properties"/>         <keyword attribute="Property" context="#stay" String="global-properties"/>         <IncludeRules context="Detect More global-properties"/>         <keyword attribute="Property" context="#stay" String="install-properties"/>@@ -5456,6 +5817,13 @@         <keyword attribute="Property" context="#stay" String="test-properties"/>         <IncludeRules context="User Function Args"/>       </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="set_property_tgts">+        <DetectSpaces/>+        <keyword attribute="Named Args" context="#pop" String="set_property_nargs" lookAhead="true"/>+        <IncludeRules context="Detect Aliased Targets"/>+        <IncludeRules context="Detect Targets"/>+        <IncludeRules context="User Function Opened"/>+      </context>       <context attribute="Normal Text" lineEndContext="#stay" name="set_ctx">         <DetectChar attribute="Normal Text" context="set_ctx_op" char="("/>         <DetectChar attribute="Normal Text" context="#pop" char=")"/>@@ -5463,6 +5831,7 @@       <context attribute="Normal Text" lineEndContext="#stay" name="set_ctx_op">         <DetectSpaces/>         <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>+        <StringDetect attribute="Cache Variable Substitution" context="CacheVarSubst" String="CACHE{"/>         <keyword attribute="Named Args" context="#stay" String="set_nargs"/>         <keyword attribute="Special Args" context="#stay" String="set_sargs"/>         <IncludeRules context="User Function Args"/>@@ -5484,6 +5853,7 @@       <context attribute="Normal Text" lineEndContext="#stay" name="unset_ctx_op">         <DetectSpaces/>         <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>+        <StringDetect attribute="Cache Variable Substitution" context="CacheVarSubst" String="CACHE{"/>         <keyword attribute="Named Args" context="#stay" String="unset_nargs"/>         <IncludeRules context="User Function Args"/>       </context>@@ -5495,7 +5865,8 @@         <DetectSpaces/>         <DetectChar attribute="Normal Text" context="while_ctx_op_nested" char="("/>         <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>-        <WordDetect String="TARGET" attribute="Named Args" context="Target Name"/>+        <WordDetect String="TARGET" attribute="Named Args" context="elseif_tgts"/>+        <StringDetect attribute="Cache Variable Substitution" context="CacheVarSubst" String="CACHE{"/>         <keyword attribute="Named Args" context="#stay" String="elseif_nargs"/>         <IncludeRules context="User Function Args"/>       </context>@@ -5514,10 +5885,17 @@         <DetectSpaces/>         <DetectChar attribute="Normal Text" context="add_custom_command_ctx_op_nested" char="("/>         <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>-        <WordDetect String="TARGET" attribute="Named Args" context="Target Name"/>+        <WordDetect String="TARGET" attribute="Named Args" context="add_custom_command_tgts"/>         <keyword attribute="Named Args" context="#stay" String="add_custom_command_nargs"/>         <IncludeRules context="User Function Args"/>       </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="add_custom_command_tgts">+        <DetectSpaces/>+        <keyword attribute="Named Args" context="#pop" String="add_custom_command_nargs" lookAhead="true"/>+        <IncludeRules context="Detect Aliased Targets"/>+        <IncludeRules context="Detect Targets"/>+        <IncludeRules context="User Function Opened"/>+      </context>       <context attribute="Normal Text" lineEndContext="#stay" name="add_custom_command_ctx_op_nested">         <DetectSpaces/>         <DetectChar attribute="Normal Text" context="#pop" char=")"/>@@ -5529,11 +5907,11 @@         <DetectChar attribute="Normal Text" context="add_custom_target_ctx_op_tgt_first" char="("/>         <DetectChar attribute="Normal Text" context="#pop" char=")"/>       </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="add_custom_target_ctx_op_tgt_first">+      <context attribute="Normal Text" lineEndContext="#stay" name="add_custom_target_ctx_op_tgt_first" fallthroughContext="add_custom_target_ctx_op">         <DetectSpaces/>         <RegExpr attribute="Aliased Targets" context="add_custom_target_ctx_op" String="&tgt_name_re;::&tgt_name_re;(?:\:\:&tgt_name_re;)*"/>         <RegExpr attribute="Targets" context="add_custom_target_ctx_op" String="&tgt_name_re;"/>-        <IncludeRules context="User Function Opened"/>+        <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>       </context>       <context attribute="Normal Text" lineEndContext="#stay" name="add_custom_target_ctx_op">         <DetectSpaces/>@@ -5563,11 +5941,11 @@         <DetectChar attribute="Normal Text" context="add_executable_ctx_op_tgt_first" char="("/>         <DetectChar attribute="Normal Text" context="#pop" char=")"/>       </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="add_executable_ctx_op_tgt_first">+      <context attribute="Normal Text" lineEndContext="#stay" name="add_executable_ctx_op_tgt_first" fallthroughContext="add_executable_ctx_op">         <DetectSpaces/>         <RegExpr attribute="Aliased Targets" context="add_executable_ctx_op" String="&tgt_name_re;::&tgt_name_re;(?:\:\:&tgt_name_re;)*"/>         <RegExpr attribute="Targets" context="add_executable_ctx_op" String="&tgt_name_re;"/>-        <IncludeRules context="User Function Opened"/>+        <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>       </context>       <context attribute="Normal Text" lineEndContext="#stay" name="add_executable_ctx_op">         <DetectSpaces/>@@ -5579,19 +5957,26 @@         <DetectChar attribute="Normal Text" context="add_library_ctx_op_tgt_first" char="("/>         <DetectChar attribute="Normal Text" context="#pop" char=")"/>       </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="add_library_ctx_op_tgt_first">+      <context attribute="Normal Text" lineEndContext="#stay" name="add_library_ctx_op_tgt_first" fallthroughContext="add_library_ctx_op">         <DetectSpaces/>         <RegExpr attribute="Aliased Targets" context="add_library_ctx_op" String="&tgt_name_re;::&tgt_name_re;(?:\:\:&tgt_name_re;)*"/>         <RegExpr attribute="Targets" context="add_library_ctx_op" String="&tgt_name_re;"/>-        <IncludeRules context="User Function Opened"/>+        <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>       </context>       <context attribute="Normal Text" lineEndContext="#stay" name="add_library_ctx_op">         <DetectSpaces/>         <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>-        <WordDetect String="ALIAS" attribute="Named Args" context="Target Name"/>+        <WordDetect String="ALIAS" attribute="Named Args" context="add_library_tgts"/>         <keyword attribute="Named Args" context="#stay" String="add_library_nargs"/>         <IncludeRules context="User Function Args"/>       </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="add_library_tgts">+        <DetectSpaces/>+        <keyword attribute="Named Args" context="#pop" String="add_library_nargs" lookAhead="true"/>+        <IncludeRules context="Detect Aliased Targets"/>+        <IncludeRules context="Detect Targets"/>+        <IncludeRules context="User Function Opened"/>+      </context>       <context attribute="Normal Text" lineEndContext="#stay" name="add_subdirectory_ctx">         <DetectChar attribute="Normal Text" context="add_subdirectory_ctx_op" char="("/>         <DetectChar attribute="Normal Text" context="#pop" char=")"/>@@ -5627,10 +6012,17 @@       <context attribute="Normal Text" lineEndContext="#stay" name="build_command_ctx_op">         <DetectSpaces/>         <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>-        <WordDetect String="TARGET" attribute="Named Args" context="Target Name"/>+        <WordDetect String="TARGET" attribute="Named Args" context="build_command_tgts"/>         <keyword attribute="Named Args" context="#stay" String="build_command_nargs"/>         <IncludeRules context="User Function Args"/>       </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="build_command_tgts">+        <DetectSpaces/>+        <keyword attribute="Named Args" context="#pop" String="build_command_nargs" lookAhead="true"/>+        <IncludeRules context="Detect Aliased Targets"/>+        <IncludeRules context="Detect Targets"/>+        <IncludeRules context="User Function Opened"/>+      </context>       <context attribute="Normal Text" lineEndContext="#stay" name="cmake_file_api_ctx">         <DetectChar attribute="Normal Text" context="cmake_file_api_ctx_op" char="("/>         <DetectChar attribute="Normal Text" context="#pop" char=")"/>@@ -5641,6 +6033,17 @@         <keyword attribute="Named Args" context="#stay" String="cmake_file_api_nargs"/>         <IncludeRules context="User Function Args"/>       </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="cmake_instrumentation_ctx">+        <DetectChar attribute="Normal Text" context="cmake_instrumentation_ctx_op" char="("/>+        <DetectChar attribute="Normal Text" context="#pop" char=")"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="cmake_instrumentation_ctx_op">+        <DetectSpaces/>+        <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>+        <keyword attribute="Named Args" context="#stay" String="cmake_instrumentation_nargs"/>+        <keyword attribute="Special Args" context="#stay" String="cmake_instrumentation_sargs"/>+        <IncludeRules context="User Function Args"/>+      </context>       <context attribute="Normal Text" lineEndContext="#stay" name="create_test_sourcelist_ctx">         <DetectChar attribute="Normal Text" context="create_test_sourcelist_ctx_op" char="("/>         <DetectChar attribute="Normal Text" context="#pop" char=")"/>@@ -5662,6 +6065,7 @@         <keyword attribute="Property" context="#stay" String="cache-properties"/>         <keyword attribute="Property" context="#stay" String="directory-properties"/>         <IncludeRules context="Detect More directory-properties"/>+        <keyword attribute="Property" context="#stay" String="fileset-properties"/>         <keyword attribute="Property" context="#stay" String="global-properties"/>         <IncludeRules context="Detect More global-properties"/>         <keyword attribute="Property" context="#stay" String="install-properties"/>@@ -5672,6 +6076,17 @@         <keyword attribute="Property" context="#stay" String="test-properties"/>         <IncludeRules context="User Function Args"/>       </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="discover_tests_ctx">+        <DetectChar attribute="Normal Text" context="discover_tests_ctx_op" char="("/>+        <DetectChar attribute="Normal Text" context="#pop" char=")"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="discover_tests_ctx_op">+        <DetectSpaces/>+        <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>+        <keyword attribute="Named Args" context="#stay" String="discover_tests_nargs"/>+        <keyword attribute="Property" context="#stay" String="test-properties"/>+        <IncludeRules context="User Function Args"/>+      </context>       <context attribute="Normal Text" lineEndContext="#stay" name="enable_language_ctx">         <DetectChar attribute="Normal Text" context="enable_language_ctx_op" char="("/>         <DetectChar attribute="Normal Text" context="#pop" char=")"/>@@ -5697,11 +6112,10 @@       </context>       <context attribute="Normal Text" lineEndContext="#stay" name="export_tgts">         <DetectSpaces/>-        <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>         <keyword attribute="Named Args" context="#pop" String="export_nargs" lookAhead="true"/>         <IncludeRules context="Detect Aliased Targets"/>         <IncludeRules context="Detect Targets"/>-        <IncludeRules context="User Function Args"/>+        <IncludeRules context="User Function Opened"/>       </context>       <context attribute="Normal Text" lineEndContext="#stay" name="get_source_file_property_ctx">         <DetectChar attribute="Normal Text" context="get_source_file_property_ctx_op" char="("/>@@ -5771,11 +6185,10 @@       </context>       <context attribute="Normal Text" lineEndContext="#stay" name="install_tgts">         <DetectSpaces/>-        <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>         <keyword attribute="Named Args" context="#pop" String="install_nargs" lookAhead="true"/>         <IncludeRules context="Detect Aliased Targets"/>         <IncludeRules context="Detect Targets"/>-        <IncludeRules context="User Function Args"/>+        <IncludeRules context="User Function Opened"/>       </context>       <context attribute="Normal Text" lineEndContext="#stay" name="link_directories_ctx">         <DetectChar attribute="Normal Text" context="link_directories_ctx_op" char="("/>@@ -5878,11 +6291,11 @@         <DetectChar attribute="Normal Text" context="target_compile_definitions_ctx_op_tgt_first" char="("/>         <DetectChar attribute="Normal Text" context="#pop" char=")"/>       </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="target_compile_definitions_ctx_op_tgt_first">+      <context attribute="Normal Text" lineEndContext="#stay" name="target_compile_definitions_ctx_op_tgt_first" fallthroughContext="target_compile_definitions_ctx_op">         <DetectSpaces/>         <RegExpr attribute="Aliased Targets" context="target_compile_definitions_ctx_op" String="&tgt_name_re;::&tgt_name_re;(?:\:\:&tgt_name_re;)*"/>         <RegExpr attribute="Targets" context="target_compile_definitions_ctx_op" String="&tgt_name_re;"/>-        <IncludeRules context="User Function Opened"/>+        <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>       </context>       <context attribute="Normal Text" lineEndContext="#stay" name="target_compile_definitions_ctx_op">         <DetectSpaces/>@@ -5894,11 +6307,11 @@         <DetectChar attribute="Normal Text" context="target_compile_features_ctx_op_tgt_first" char="("/>         <DetectChar attribute="Normal Text" context="#pop" char=")"/>       </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="target_compile_features_ctx_op_tgt_first">+      <context attribute="Normal Text" lineEndContext="#stay" name="target_compile_features_ctx_op_tgt_first" fallthroughContext="target_compile_features_ctx_op">         <DetectSpaces/>         <RegExpr attribute="Aliased Targets" context="target_compile_features_ctx_op" String="&tgt_name_re;::&tgt_name_re;(?:\:\:&tgt_name_re;)*"/>         <RegExpr attribute="Targets" context="target_compile_features_ctx_op" String="&tgt_name_re;"/>-        <IncludeRules context="User Function Opened"/>+        <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>       </context>       <context attribute="Normal Text" lineEndContext="#stay" name="target_compile_features_ctx_op">         <DetectSpaces/>@@ -5911,11 +6324,11 @@         <DetectChar attribute="Normal Text" context="target_compile_options_ctx_op_tgt_first" char="("/>         <DetectChar attribute="Normal Text" context="#pop" char=")"/>       </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="target_compile_options_ctx_op_tgt_first">+      <context attribute="Normal Text" lineEndContext="#stay" name="target_compile_options_ctx_op_tgt_first" fallthroughContext="target_compile_options_ctx_op">         <DetectSpaces/>         <RegExpr attribute="Aliased Targets" context="target_compile_options_ctx_op" String="&tgt_name_re;::&tgt_name_re;(?:\:\:&tgt_name_re;)*"/>         <RegExpr attribute="Targets" context="target_compile_options_ctx_op" String="&tgt_name_re;"/>-        <IncludeRules context="User Function Opened"/>+        <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>       </context>       <context attribute="Normal Text" lineEndContext="#stay" name="target_compile_options_ctx_op">         <DetectSpaces/>@@ -5927,11 +6340,11 @@         <DetectChar attribute="Normal Text" context="target_include_directories_ctx_op_tgt_first" char="("/>         <DetectChar attribute="Normal Text" context="#pop" char=")"/>       </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="target_include_directories_ctx_op_tgt_first">+      <context attribute="Normal Text" lineEndContext="#stay" name="target_include_directories_ctx_op_tgt_first" fallthroughContext="target_include_directories_ctx_op">         <DetectSpaces/>         <RegExpr attribute="Aliased Targets" context="target_include_directories_ctx_op" String="&tgt_name_re;::&tgt_name_re;(?:\:\:&tgt_name_re;)*"/>         <RegExpr attribute="Targets" context="target_include_directories_ctx_op" String="&tgt_name_re;"/>-        <IncludeRules context="User Function Opened"/>+        <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>       </context>       <context attribute="Normal Text" lineEndContext="#stay" name="target_include_directories_ctx_op">         <DetectSpaces/>@@ -5943,11 +6356,11 @@         <DetectChar attribute="Normal Text" context="target_link_libraries_ctx_op_tgt_first" char="("/>         <DetectChar attribute="Normal Text" context="#pop" char=")"/>       </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="target_link_libraries_ctx_op_tgt_first">+      <context attribute="Normal Text" lineEndContext="#stay" name="target_link_libraries_ctx_op_tgt_first" fallthroughContext="target_link_libraries_ctx_op">         <DetectSpaces/>         <RegExpr attribute="Aliased Targets" context="target_link_libraries_ctx_op" String="&tgt_name_re;::&tgt_name_re;(?:\:\:&tgt_name_re;)*"/>         <RegExpr attribute="Targets" context="target_link_libraries_ctx_op" String="&tgt_name_re;"/>-        <IncludeRules context="User Function Opened"/>+        <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>       </context>       <context attribute="Normal Text" lineEndContext="#stay" name="target_link_libraries_ctx_op">         <DetectSpaces/>@@ -5960,11 +6373,11 @@         <DetectChar attribute="Normal Text" context="target_precompile_headers_ctx_op_tgt_first" char="("/>         <DetectChar attribute="Normal Text" context="#pop" char=")"/>       </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="target_precompile_headers_ctx_op_tgt_first">+      <context attribute="Normal Text" lineEndContext="#stay" name="target_precompile_headers_ctx_op_tgt_first" fallthroughContext="target_precompile_headers_ctx_op">         <DetectSpaces/>         <RegExpr attribute="Aliased Targets" context="target_precompile_headers_ctx_op" String="&tgt_name_re;::&tgt_name_re;(?:\:\:&tgt_name_re;)*"/>         <RegExpr attribute="Targets" context="target_precompile_headers_ctx_op" String="&tgt_name_re;"/>-        <IncludeRules context="User Function Opened"/>+        <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>       </context>       <context attribute="Normal Text" lineEndContext="#stay" name="target_precompile_headers_ctx_op">         <DetectSpaces/>@@ -5976,11 +6389,11 @@         <DetectChar attribute="Normal Text" context="target_sources_ctx_op_tgt_first" char="("/>         <DetectChar attribute="Normal Text" context="#pop" char=")"/>       </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="target_sources_ctx_op_tgt_first">+      <context attribute="Normal Text" lineEndContext="#stay" name="target_sources_ctx_op_tgt_first" fallthroughContext="target_sources_ctx_op">         <DetectSpaces/>         <RegExpr attribute="Aliased Targets" context="target_sources_ctx_op" String="&tgt_name_re;::&tgt_name_re;(?:\:\:&tgt_name_re;)*"/>         <RegExpr attribute="Targets" context="target_sources_ctx_op" String="&tgt_name_re;"/>-        <IncludeRules context="User Function Opened"/>+        <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>       </context>       <context attribute="Normal Text" lineEndContext="#stay" name="target_sources_ctx_op">         <DetectSpaces/>@@ -6269,11 +6682,10 @@       </context>       <context attribute="Normal Text" lineEndContext="#stay" name="cmake_print_properties_tgts">         <DetectSpaces/>-        <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>         <keyword attribute="Named Args" context="#pop" String="cmake_print_properties_nargs" lookAhead="true"/>         <IncludeRules context="Detect Aliased Targets"/>         <IncludeRules context="Detect Targets"/>-        <IncludeRules context="User Function Args"/>+        <IncludeRules context="User Function Opened"/>       </context>       <context attribute="Normal Text" lineEndContext="#stay" name="cmake_push_check_state_ctx">         <DetectChar attribute="Normal Text" context="cmake_push_check_state_ctx_op" char="("/>@@ -6373,6 +6785,7 @@         <DetectSpaces/>         <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>         <keyword attribute="Named Args" context="#stay" String="ctest_coverage_collect_gcov_nargs"/>+        <keyword attribute="Special Args" context="#stay" String="ctest_coverage_collect_gcov_sargs"/>         <IncludeRules context="User Function Args"/>       </context>       <context attribute="Normal Text" lineEndContext="#stay" name="ExternalData_Add_Target_ctx">@@ -6512,11 +6925,11 @@         <DetectChar attribute="Normal Text" context="generate_export_header_ctx_op_tgt_first" char="("/>         <DetectChar attribute="Normal Text" context="#pop" char=")"/>       </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="generate_export_header_ctx_op_tgt_first">+      <context attribute="Normal Text" lineEndContext="#stay" name="generate_export_header_ctx_op_tgt_first" fallthroughContext="generate_export_header_ctx_op">         <DetectSpaces/>         <RegExpr attribute="Aliased Targets" context="generate_export_header_ctx_op" String="&tgt_name_re;::&tgt_name_re;(?:\:\:&tgt_name_re;)*"/>         <RegExpr attribute="Targets" context="generate_export_header_ctx_op" String="&tgt_name_re;"/>-        <IncludeRules context="User Function Opened"/>+        <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>       </context>       <context attribute="Normal Text" lineEndContext="#stay" name="generate_export_header_ctx_op">         <DetectSpaces/>@@ -6531,19 +6944,26 @@       <context attribute="Normal Text" lineEndContext="#stay" name="gtest_add_tests_ctx_op">         <DetectSpaces/>         <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>-        <WordDetect String="TARGET" attribute="Named Args" context="Target Name"/>+        <WordDetect String="TARGET" attribute="Named Args" context="gtest_add_tests_tgts"/>         <keyword attribute="Named Args" context="#stay" String="gtest_add_tests_nargs"/>         <IncludeRules context="User Function Args"/>       </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="gtest_add_tests_tgts">+        <DetectSpaces/>+        <keyword attribute="Named Args" context="#pop" String="gtest_add_tests_nargs" lookAhead="true"/>+        <IncludeRules context="Detect Aliased Targets"/>+        <IncludeRules context="Detect Targets"/>+        <IncludeRules context="User Function Opened"/>+      </context>       <context attribute="Normal Text" lineEndContext="#stay" name="gtest_discover_tests_ctx">         <DetectChar attribute="Normal Text" context="gtest_discover_tests_ctx_op_tgt_first" char="("/>         <DetectChar attribute="Normal Text" context="#pop" char=")"/>       </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="gtest_discover_tests_ctx_op_tgt_first">+      <context attribute="Normal Text" lineEndContext="#stay" name="gtest_discover_tests_ctx_op_tgt_first" fallthroughContext="gtest_discover_tests_ctx_op">         <DetectSpaces/>         <RegExpr attribute="Aliased Targets" context="gtest_discover_tests_ctx_op" String="&tgt_name_re;::&tgt_name_re;(?:\:\:&tgt_name_re;)*"/>         <RegExpr attribute="Targets" context="gtest_discover_tests_ctx_op" String="&tgt_name_re;"/>-        <IncludeRules context="User Function Opened"/>+        <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>       </context>       <context attribute="Normal Text" lineEndContext="#stay" name="gtest_discover_tests_ctx_op">         <DetectSpaces/>@@ -6556,11 +6976,11 @@         <DetectChar attribute="Normal Text" context="add_jar_ctx_op_tgt_first" char="("/>         <DetectChar attribute="Normal Text" context="#pop" char=")"/>       </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="add_jar_ctx_op_tgt_first">+      <context attribute="Normal Text" lineEndContext="#stay" name="add_jar_ctx_op_tgt_first" fallthroughContext="add_jar_ctx_op">         <DetectSpaces/>         <RegExpr attribute="Aliased Targets" context="add_jar_ctx_op" String="&tgt_name_re;::&tgt_name_re;(?:\:\:&tgt_name_re;)*"/>         <RegExpr attribute="Targets" context="add_jar_ctx_op" String="&tgt_name_re;"/>-        <IncludeRules context="User Function Opened"/>+        <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>       </context>       <context attribute="Normal Text" lineEndContext="#stay" name="add_jar_ctx_op">         <DetectSpaces/>@@ -6572,11 +6992,11 @@         <DetectChar attribute="Normal Text" context="install_jar_ctx_op_tgt_first" char="("/>         <DetectChar attribute="Normal Text" context="#pop" char=")"/>       </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="install_jar_ctx_op_tgt_first">+      <context attribute="Normal Text" lineEndContext="#stay" name="install_jar_ctx_op_tgt_first" fallthroughContext="install_jar_ctx_op">         <DetectSpaces/>         <RegExpr attribute="Aliased Targets" context="install_jar_ctx_op" String="&tgt_name_re;::&tgt_name_re;(?:\:\:&tgt_name_re;)*"/>         <RegExpr attribute="Targets" context="install_jar_ctx_op" String="&tgt_name_re;"/>-        <IncludeRules context="User Function Opened"/>+        <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>       </context>       <context attribute="Normal Text" lineEndContext="#stay" name="install_jar_ctx_op">         <DetectSpaces/>@@ -6591,10 +7011,17 @@       <context attribute="Normal Text" lineEndContext="#stay" name="create_javah_ctx_op">         <DetectSpaces/>         <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>-        <WordDetect String="TARGET" attribute="Named Args" context="Target Name"/>+        <WordDetect String="TARGET" attribute="Named Args" context="create_javah_tgts"/>         <keyword attribute="Named Args" context="#stay" String="create_javah_nargs"/>         <IncludeRules context="User Function Args"/>       </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="create_javah_tgts">+        <DetectSpaces/>+        <keyword attribute="Named Args" context="#pop" String="create_javah_nargs" lookAhead="true"/>+        <IncludeRules context="Detect Aliased Targets"/>+        <IncludeRules context="Detect Targets"/>+        <IncludeRules context="User Function Opened"/>+      </context>       <context attribute="Normal Text" lineEndContext="#stay" name="install_jar_exports_ctx">         <DetectChar attribute="Normal Text" context="install_jar_exports_ctx_op" char="("/>         <DetectChar attribute="Normal Text" context="#pop" char=")"/>@@ -6608,11 +7035,10 @@       </context>       <context attribute="Normal Text" lineEndContext="#stay" name="install_jar_exports_tgts">         <DetectSpaces/>-        <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>         <keyword attribute="Named Args" context="#pop" String="install_jar_exports_nargs" lookAhead="true"/>         <IncludeRules context="Detect Aliased Targets"/>         <IncludeRules context="Detect Targets"/>-        <IncludeRules context="User Function Args"/>+        <IncludeRules context="User Function Opened"/>       </context>       <context attribute="Normal Text" lineEndContext="#stay" name="export_jars_ctx">         <DetectChar attribute="Normal Text" context="export_jars_ctx_op" char="("/>@@ -6627,11 +7053,10 @@       </context>       <context attribute="Normal Text" lineEndContext="#stay" name="export_jars_tgts">         <DetectSpaces/>-        <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>         <keyword attribute="Named Args" context="#pop" String="export_jars_nargs" lookAhead="true"/>         <IncludeRules context="Detect Aliased Targets"/>         <IncludeRules context="Detect Targets"/>-        <IncludeRules context="User Function Args"/>+        <IncludeRules context="User Function Opened"/>       </context>       <context attribute="Normal Text" lineEndContext="#stay" name="find_jar_ctx">         <DetectChar attribute="Normal Text" context="find_jar_ctx_op" char="("/>@@ -6661,6 +7086,7 @@         <DetectSpaces/>         <DetectChar attribute="Normal Text" context="#pop" char=")" lookAhead="true"/>         <keyword attribute="Named Args" context="#stay" String="swig_add_library_nargs"/>+        <keyword attribute="Special Args" context="#stay" String="swig_add_library_sargs"/>         <IncludeRules context="User Function Args"/>       </context>       <context attribute="Normal Text" lineEndContext="#stay" name="squish_add_test_ctx">@@ -6842,7 +7268,7 @@       </context>        <context attribute="Normal Text" lineEndContext="#stay" name="Detect More target-properties">-        <RegExpr attribute="Property" context="#stay" String="\b(?:&var_ref_re;_((COMPIL|LINK)ER_LAUNCHER|CLANG_TIDY(_EXPORT_FIXES_DIR)?|CPP(CHECK|LINT)|INCLUDE_WHAT_YOU_USE|OUTPUT_NAME|POSTFIX|VISIBILITY_PRESET)|((ARCHIVE|LIBRARY|RUNTIME)_OUTPUT_(DIRECTORY|NAME)|COMPILE_PDB_(NAME|OUTPUT_DIRECTORY)|CXX_MODULE_(DIRS|SET)|EXCLUDE_FROM_DEFAULT_BUILD|FRAMEWORK_MULTI_CONFIG_POSTFIX|HEADER_(DIRS|SET)|IMPORTED_((NO_)?SONAME|IMPLIB|LIBNAME|LINK_(DEPENDENT_LIBRARIES|INTERFACE_(LANGUAGES|LIBRARIES|MULTIPLICITY))|LOCATION|OBJECTS)|INTERPROCEDURAL_OPTIMIZATION|LINK_(FLAGS|INTERFACE_(LIBRARIES|MULTIPLICITY)|LIBRARY_OVERRIDE)|LOCATION|MAP_IMPORTED_CONFIG|OSX_ARCHITECTURES|OUTPUT_NAME|PDB_(NAME|OUTPUT_DIRECTORY)|STATIC_LIBRARY_FLAGS|VS_(DOTNET_REFERENCE(PROP_&var_ref_re;_TAG)?|GLOBAL|SOURCE_SETTINGS))_&var_ref_re;|XCODE_(ATTRIBUTE_&var_ref_re;|EMBED_&var_ref_re;(_((CODE_SIGN|REMOVE_HEADERS)_ON_COPY|PATH))?))\b"/>+        <RegExpr attribute="Property" context="#stay" String="\b(?:&var_ref_re;_((COMPIL|LINK)ER_LAUNCHER|CLANG_TIDY(_EXPORT_FIXES_DIR)?|CPP(CHECK|LINT)|ICSTAT|INCLUDE_WHAT_YOU_USE|OUTPUT_NAME|POSTFIX|PVS_STUDIO|STANDARD(_REQUIRED)?|VISIBILITY_PRESET)|((ARCHIVE|LIBRARY|RUNTIME)_OUTPUT_(DIRECTORY|NAME)|COMPILE_PDB_(NAME|OUTPUT_DIRECTORY)|CXX_MODULE_(DIRS|SET)|EXCLUDE_FROM_DEFAULT_BUILD|FRAMEWORK_MULTI_CONFIG_POSTFIX|HEADER_(DIRS|SET)|IMPORTED_((NO_)?SONAME|CXX_MODULES|IMPLIB|LIBNAME|LINK_(DEPENDENT_LIBRARIES|INTERFACE_(LANGUAGES|LIBRARIES|MULTIPLICITY))|LOCATION|OBJECTS)|INTERPROCEDURAL_OPTIMIZATION|LINK_(FLAGS|INTERFACE_(LIBRARIES|MULTIPLICITY)|LIBRARY_OVERRIDE)|LOCATION|MAP_IMPORTED_CONFIG|OSX_ARCHITECTURES|OUTPUT_NAME|PDB_(NAME|OUTPUT_DIRECTORY)|STATIC_LIBRARY_FLAGS|VS_(DOTNET_REFERENCE(PROP_&var_ref_re;_TAG)?|GLOBAL|SOURCE_SETTINGS))_&var_ref_re;|XCODE_(ATTRIBUTE_&var_ref_re;|EMBED_&var_ref_re;(_((CODE_SIGN|REMOVE_HEADERS)_ON_COPY|PATH))?))\b"/>       </context>        <context attribute="Normal Text" lineEndContext="#stay" name="Detect More source-properties">@@ -6868,29 +7294,36 @@        <context attribute="Normal Text" lineEndContext="#stay" name="Detect More Builtin Variables">         <RegExpr attribute="CMake Internal Variable" context="#stay" String="\b(?:CMAKE_&var_ref_re;_(COMPILER_(ABI|ARCHITECTURE_ID|VERSION_INTERNAL)|PLATFORM_ID|USING_LINKER_MODE))\b"/>-        <RegExpr attribute="Builtin Variable" context="#stay" String="\b(?:&var_ref_re;_(((STATIC_)?LINK_)?LIBRARIES|(BINARY|SOURCE)_DIR|(C|LD)FLAGS(_OTHER)?|(INCLUDE|LIBRARY)_DIRS|CONFIG|CONSIDERED_(CONFIGS|VERSIONS)|DESCRIPTION|FIND_(COMPONENTS|REQUIRED(_&var_ref_re;)?|VERSION_(COMPLETE|COUNT|EXACT|M(AX|IN)(_(COUNT|MAJOR|MINOR|PATCH|TWEAK))?|RANGE(_(MAX|MIN))?)|QUIETLY)|FOUND|HOMEPAGE_URL|IS_TOP_LEVEL|KEYWORDS_MISSING_VALUES|MODULE_NAME|ROOT|UNPARSED_ARGUMENTS|VERSION(_(MAJOR|MINOR|PATCH|TWEAK|COUNT|STRING))?)|&var_ref_re;__TRYRUN_OUTPUT|(DOXYGEN|ExternalData_(CUSTOM_SCRIPT|URL_ALGO)|FETCHCONTENT_(SOURCE_DIR|UPDATES_DISCONNECTED))_&var_ref_re;|ARGV[0-9]+|BISON_&var_ref_re;_(COMPILE_FLAGS|DEFINED|INPUT|OUTPUT(S|_(HEADER|SOURCE)))|Boost_&var_ref_re;_LIBRARY(_(DEBUG|RELEASE))?|CMAKE_(&var_ref_re;_(ANDROID_TOOLCHAIN_((PRE|SUF)FIX|MACHINE)|ARCHIVE_(APPEND|CREATE|FINISH)|BYTE_ORDER|CLANG_TIDY(_EXPORT_FIXES_DIR)?|COMPILER(_(AR|EXTERNAL_TOOLCHAIN|FRONTEND_VARIANT|ID|LAUNCHER|LINKER(_(FRONTEND_VARIANT|ID|VERSION))?|LOADED|PREDEFINES_COMMAND|RANLIB|TARGET|VERSION))?|COMPILE_OBJECT|CPP(CHECK|LINT)|CREATE_(SHARED_(LIBRARY(_ARCHIVE)?|MODULE)|STATIC_LIBRARY)|DEVICE_LINK_MODE|EXTENSIONS(_DEFAULT)?|FLAGS(_((DEBUG|MINSIZEREL|REL(EASE|WITHDEBINFO)|&var_ref_re;)(_INIT)?|INIT))?|HOST_COMPILER(_ID)?|IGNORE_EXTENSIONS|IMPLICIT_(INCLUDE_DIRECTORIES|LINK_((FRAMEWORK_)?DIRECTORIES|LIBRARIES))|INCLUDE_WHAT_YOU_USE|LIBRARY_ARCHITECTURE|LINKER_(LAUNCHER|PREFERENCE(_PROPAGATES)?|WRAPPER_FLAG(_SEP)?)|LINK_(EXECUTABLE|GROUP_USING_&var_ref_re;(_SUPPORTED)?|LIBRARY_(FILE_FLAG|FLAG|SUFFIX|USING_&var_ref_re;(_SUPPORTED)?)|MODE|WHAT_YOU_USE_FLAG)|OUTPUT_EXTENSION|POSTFIX|SIMULATE_(ID|VERSION)|SIZEOF_DATA_PTR|SOURCE_FILE_EXTENSIONS|STANDARD_((INCLUDE_DIRECTO|LIBRA)RIES|DEFAULT|LATEST|LINK_DIRECTORIES)|USING_LINKER_&var_ref_re;|VISIBILITY_PRESET)|((ARCHIVE|(COMPILE_)?PDB|LIBRARY|RUNTIME)_OUTPUT_DIRECTORY|(DISABLE|REQUIRE)_FIND_PACKAGE|FRAMEWORK_MULTI_CONFIG_POSTFIX|GET_OS_RELEASE_FALLBACK_RESULT|INTERPROCEDURAL_OPTIMIZATION|MAP_IMPORTED_CONFIG|USER_MAKE_RULES_OVERRIDE|XCODE_ATTRIBUTE)_&var_ref_re;|(EXE|MODULE|SHARED|STATIC)_LINKER_FLAGS_&var_ref_re;(_INIT)?|LINK_(GROUP_USING_&var_ref_re;(_SUPPORTED)?|LIBRARY_(&var_ref_re;_ATTRIBUTES|USING_&var_ref_re;(_SUPPORTED)?))|PKG_CONFIG_&var_ref_re;_PRIVATE|PROJECT_&var_ref_re;_INCLUDE(_BEFORE)?)|CMAKE_(ARGV|MATCH_)[0-9]+|CMAKE_POLICY_(DEFAULT|WARNING)_CMP[0-9]{4}|CPACK_(&var_ref_re;_COMPONENT_INSTALL|ARCHIVE_&var_ref_re;_FILE_NAME|BINARY_&var_ref_re;|COMPONENT_&var_ref_re;_(DEPENDS|DESCRIPTION|DIS(ABLED|PLAY_NAME)|GROUP|HIDDEN|REQUIRED)|DEBIAN_&var_ref_re;_(DESCRIPTION|FILE_NAME|PACKAGE_((PRE)?DEPENDS|ARCHITECTURE|BREAKS|CONFLICTS|CONTROL_(EXTRA|STRICT_PERMISSION)|ENHANCES|MULTIARCH|NAME|PRIORITY|PROVIDES|RECOMMENDS|REPLACES|SECTION|SHLIBDEPS|SOURCE|SUGGESTS)|DEBUGINFO_PACKAGE)|DMG_&var_ref_re;_FILE_NAME|INNOSETUP_(&var_ref_re;_INSTALL_DIRECTORY|(DEFINE|SETUP)_&var_ref_re;)|NSIS_&var_ref_re;_INSTALL_DIRECTORY|NUGET_(&var_ref_re;_(PACKAGE_(AUTHORS|COPYRIGHT|DEPENDENCIES(_&var_ref_re;)?|DESCRIPTION(_SUMMARY)?|HOMEPAGE_URL|ICON(URL)?|LANGUAGE|LICENSE(URL|_(EXPRESSION|FILE_NAME))|NAME|OWNERS|README|RELEASE_NOTES|TAGS|TFMS|TITLE)|REPOSITORY_(BRANCH|COMMIT|TYPE|URL))|PACKAGE_DEPENDENCIES_&var_ref_re;)|P(RE|OST)FLIGHT_&var_ref_re;_SCRIPT|RPM_(&var_ref_re;_(DEFAULT_((DIR|FILE)_PERMISSIONS|GROUP|USER)|BUILD_SOURCE_DIRS_PREFIX|DEBUGINFO_(FILE_NAME|PACKAGE)|FILE_NAME|PACKAGE_(ARCHITECTURE|AUTO(PROV|REQ(PROV)?)|CONFLICTS|DESCRIPTION|GROUP|NAME|OBSOLETES|PREFIX|PROVIDES|REQUIRES(_P(RE|OST)(UN)?)?|SUGGESTS|SUMMARY|URL)|USER_(FILELIST|BINARY_SPECFILE))|NO_&var_ref_re;_INSTALL_PREFIX_RELOCATION)|WIX_(&var_ref_re;_EXT(ENSIONS|RA_FLAGS)|PROPERTY_&var_ref_re;))|ICU_&var_ref_re;_(LIBRARY|EXECUTABLE)|MPI_&var_ref_re;_(ADDITIONAL_INCLUDE_VARS|COMPILE(R|_(DEFINI|OP)TIONS)|LIB(_NAMES|RARY))|OpenACC_&var_ref_re;_(FLAGS|OPTIONS|SPEC_DATE)|OpenMP_&var_ref_re;_(FLAGS|LIB(_NAMES|RARY)|SPEC_DATE)|SWIG_MODULE_&var_ref_re;_EXTRA_DEPS)\b"/>+        <RegExpr attribute="Builtin Variable" context="#stay" String="\b(?:&var_ref_re;_(((STATIC_)?LINK_)?LIBRARIES|(BINARY|SOURCE)_DIR|(C|LD)FLAGS(_OTHER)?|(INCLUDE|LIBRARY)_DIRS|COMPAT_VERSION|CONFIG|CONSIDERED_(CONFIGS|VERSIONS)|DESCRIPTION|FIND_(COMPONENTS|REQUIRED(_&var_ref_re;)?|VERSION_(COMPLETE|COUNT|EXACT|M(AX|IN)(_(COUNT|MAJOR|MINOR|PATCH|TWEAK))?|RANGE(_(MAX|MIN))?)|QUIETLY)|FOUND|HOMEPAGE_URL|IS_TOP_LEVEL|KEYWORDS_MISSING_VALUES|MODULE_NAME|ROOT|SPDX_LICENSE|UNPARSED_ARGUMENTS|VERSION(_(MAJOR|MINOR|PATCH|TWEAK|COUNT|STRING))?)|&var_ref_re;__TRYRUN_OUTPUT|(DOXYGEN|ExternalData_(CUSTOM_SCRIPT|URL_ALGO)|FETCHCONTENT_(SOURCE_DIR|UPDATES_DISCONNECTED))_&var_ref_re;|ARGV[0-9]+|BISON_&var_ref_re;_(COMPILE_FLAGS|DEFINED|INPUT|OUTPUT(S|_(HEADER|SOURCE)))|Boost_&var_ref_re;_LIBRARY(_(DEBUG|RELEASE))?|CMAKE_(&var_ref_re;_(ANDROID_TOOLCHAIN_((PRE|SUF)FIX|MACHINE)|ARCHIVE_(APPEND|CREATE|FINISH)|BYTE_ORDER|CLANG_TIDY(_EXPORT_FIXES_DIR)?|COMPILER(_(AR|EXTERNAL_TOOLCHAIN|FRONTEND_VARIANT|ID|LAUNCHER|LINKER(_(FRONTEND_VARIANT|ID|VERSION))?|LOADED|PREDEFINES_COMMAND|RANLIB|TARGET|VERSION))?|COMPILE_OBJECT|CPP(CHECK|LINT)|CREATE_(SHARED_(LIBRARY(_ARCHIVE)?|MODULE)|STATIC_LIBRARY)|DEVICE_LINK_MODE|EXTENSIONS(_DEFAULT)?|FLAGS(_((DEBUG|MINSIZEREL|REL(EASE|WITHDEBINFO)|&var_ref_re;)(_INIT)?|INIT))?|HOST_COMPILER(_ID)?|ICSTAT|IGNORE_EXTENSIONS|IMPLICIT_(INCLUDE_DIRECTORIES|LINK_((FRAMEWORK_)?DIRECTORIES|LIBRARIES))|INCLUDE_WHAT_YOU_USE|LIBRARY_ARCHITECTURE|LINKER_(LAUNCHER|PREFERENCE(_PROPAGATES)?|WRAPPER_FLAG(_SEP)?)|LINK_(EXECUTABLE|FLAGS(_&var_ref_re;)?|GROUP_USING_&var_ref_re;(_SUPPORTED)?|LIBRARY_(FILE_FLAG|FLAG|SUFFIX|USING_&var_ref_re;(_SUPPORTED)?)|MODE|WHAT_YOU_USE_FLAG)|OUTPUT_EXTENSION|POSTFIX|PVS_STUDIO|SIMULATE_(ID|VERSION)|SIZEOF_DATA_PTR|SOURCE_FILE_EXTENSIONS|STANDARD_((INCLUDE_DIRECTO|LIBRA)RIES|DEFAULT|LATEST|LINK_DIRECTORIES)|USING_LINKER_&var_ref_re;|VISIBILITY_PRESET)|((ARCHIVE|(COMPILE_)?PDB|LIBRARY|RUNTIME)_OUTPUT_DIRECTORY|(DISABLE|REQUIRE)_FIND_PACKAGE|FRAMEWORK_MULTI_CONFIG_POSTFIX|GET_OS_RELEASE_FALLBACK_RESULT|IMPORT_LIBRARY_((PRE|SUF)FIX)|INTERPROCEDURAL_OPTIMIZATION|MAP_IMPORTED_CONFIG|USER_MAKE_RULES_OVERRIDE|XCODE_ATTRIBUTE)_&var_ref_re;|EXE_LINKER_FLAGS_&var_ref_re;(_INIT)?|LINK_(GROUP_USING_&var_ref_re;(_SUPPORTED)?|LIBRARY_(&var_ref_re;_ATTRIBUTES|USING_&var_ref_re;(_SUPPORTED)?))|MODULE_LINKER_FLAGS_&var_ref_re;(_INIT)?|PKG_CONFIG_&var_ref_re;_PRIVATE|PROJECT_&var_ref_re;_INCLUDE(_BEFORE)?|SHARED_((LIBRARY_((PRE|SUF)FIX)|MODULE_((PRE|SUF)FIX))_&var_ref_re;|LINKER_FLAGS_&var_ref_re;(_INIT)?)|STATIC_(LIBRARY_((PRE|SUF)FIX)_&var_ref_re;|LINKER_FLAGS_&var_ref_re;(_INIT)?))|CMAKE_(ARGV|MATCH_)[0-9]+|CMAKE_POLICY_(DEFAULT|WARNING)_CMP[0-9]{4}|CPACK_(&var_ref_re;_COMPONENT_INSTALL|ARCHIVE_&var_ref_re;_FILE_NAME|BINARY_&var_ref_re;|COMPONENT_&var_ref_re;_(DEPENDS|DESCRIPTION|DIS(ABLED|PLAY_NAME)|GROUP|HIDDEN|REQUIRED)|DEBIAN_&var_ref_re;_(DESCRIPTION|FILE_NAME|PACKAGE_((PRE)?DEPENDS|ARCHITECTURE|BREAKS|CONFLICTS|CONTROL_(EXTRA|STRICT_PERMISSION)|ENHANCES|MULTIARCH|NAME|PRIORITY|PROVIDES|RECOMMENDS|REPLACES|SECTION|SHLIBDEPS|SOURCE|SUGGESTS)|DEBUGINFO_PACKAGE)|DMG_&var_ref_re;_FILE_NAME|INNOSETUP_(&var_ref_re;_INSTALL_DIRECTORY|(DEFINE|SETUP)_&var_ref_re;)|NSIS_&var_ref_re;_INSTALL_DIRECTORY|NUGET_(&var_ref_re;_(PACKAGE_(AUTHORS|COPYRIGHT|DEPENDENCIES(_&var_ref_re;)?|DESCRIPTION(_SUMMARY)?|HOMEPAGE_URL|ICON(URL)?|LANGUAGE|LICENSE(URL|_(EXPRESSION|FILE_NAME))|NAME|OWNERS|README|RELEASE_NOTES|TAGS|TFMS|TITLE)|REPOSITORY_(BRANCH|COMMIT|TYPE|URL))|PACKAGE_DEPENDENCIES_&var_ref_re;)|P(RE|OST)FLIGHT_&var_ref_re;_SCRIPT|RPM_(&var_ref_re;_(DEFAULT_((DIR|FILE)_PERMISSIONS|GROUP|USER)|BUILD_SOURCE_DIRS_PREFIX|DEBUGINFO_(FILE_NAME|PACKAGE)|FILE_NAME|PACKAGE_(ARCHITECTURE|AUTO(PROV|REQ(PROV)?)|CONFLICTS|DESCRIPTION|ENHANCES|GROUP|NAME|OBSOLETES|PREFIX|PROVIDES|REQUIRES(_P(RE|OST)(UN)?)?|SUGGESTS|SUMMARY|SUPPLEMENTS|URL)|USER_(FILELIST|BINARY_SPECFILE))|NO_&var_ref_re;_INSTALL_PREFIX_RELOCATION)|WIX_(&var_ref_re;_EXT(ENSIONS|RA_FLAGS)|PROPERTY_&var_ref_re;))|ICU_&var_ref_re;_(LIBRARY|EXECUTABLE)|MPI_&var_ref_re;_(ADDITIONAL_INCLUDE_VARS|COMPILE(R|_(DEFINI|OP)TIONS)|LIB(_NAMES|RARY))|OpenACC_&var_ref_re;_(FLAGS|OPTIONS|SPEC_DATE)|OpenMP_&var_ref_re;_(FLAGS|LIB(_NAMES|RARY)|SPEC_DATE)|SWIG_MODULE_&var_ref_re;_EXTRA_DEPS)\b"/>       </context>        <context attribute="Normal Text" lineEndContext="#stay" name="Detect Variable Substitutions">-        <RegExpr attribute="Cache Variable Substitution" context="#stay" String="\$CACHE\{\s*[\w-]+\s*\}"/>+        <StringDetect attribute="Cache Variable Substitution" context="CacheVarSubst" String="$CACHE{"/>         <RegExpr attribute="Environment Variable Substitution" context="EnvVarSubst" String="\$?ENV\{"/>         <Detect2Chars attribute="Variable Substitution" context="VarSubst" char="$" char1="{"/>         <RegExpr attribute="@Variable Substitution" context="@VarSubst" String="@&var_ref_re;@" lookAhead="true"/>       </context> +      <context attribute="Cache Variable Substitution" lineEndContext="#pop" name="CacheVarSubst">+        <DetectChar attribute="Cache Variable Substitution" context="#pop" char="}"/>+        <IncludeRules context="Detect Builtin Variables"/>+        <IncludeRules context="Detect Variable Substitutions"/>+        <DetectIdentifier/>+      </context>+       <context attribute="Environment Variable Substitution" lineEndContext="#pop" name="EnvVarSubst">         <DetectChar attribute="Environment Variable Substitution" context="#pop" char="}"/>         <keyword attribute="Standard Environment Variable" context="#stay" String="environment-variables" insensitive="false"/>-        <RegExpr attribute="Standard Environment Variable" context="#stay" String="\b(?:&var_ref_re;_(DIR|ROOT)|ASM&var_ref_re;(FLAGS)?|CMAKE_&var_ref_re;_(COMPIL|LINK)ER_LAUNCHER)\b"/>-        <DetectIdentifier/>+        <RegExpr attribute="Standard Environment Variable" context="#stay" String="\b(?:&var_ref_re;_(DIR|ROOT)|ASM&var_ref_re;(FLAGS)?|CMAKE_&var_ref_re;_((COMPIL|LINK)ER_LAUNCHER|IMPLICIT_LINK_(DIRECTORIES_EXCLUDE|LIBRARIES_EXCLUDE)))\b"/>         <IncludeRules context="Detect Variable Substitutions"/>+        <DetectIdentifier/>       </context>        <context attribute="Variable Substitution" lineEndContext="#pop" name="VarSubst">         <DetectChar attribute="Variable Substitution" context="#pop" char="}"/>         <IncludeRules context="Detect Builtin Variables"/>-        <DetectIdentifier/>         <IncludeRules context="Detect Variable Substitutions"/>+        <DetectIdentifier/>       </context>        <context attribute="@Variable Substitution" lineEndContext="#pop" name="@VarSubst">@@ -6903,13 +7336,6 @@         <DetectIdentifier/>       </context> -      <context attribute="Normal Text" lineEndContext="#stay" name="Target Name">-        <DetectSpaces/>-        <RegExpr attribute="Aliased Targets" context="#pop" String="&tgt_name_re;::&tgt_name_re;(?:\:\:&tgt_name_re;)*"/>-        <IncludeRules context="Detect Targets"/>-        <IncludeRules context="User Function Opened"/>-      </context>-       <context attribute="Normal Text" lineEndContext="#stay" name="Detect Targets">         <RegExpr attribute="Targets" context="#stay" String="&tgt_name_re;"/>       </context>@@ -7002,11 +7428,17 @@         <DetectChar attribute="Comment" context="Comment" char="#"/>         <DetectChar attribute="Generator Expression" context="#pop" char="&gt;"/>         <keyword attribute="Generator Expression Keyword" context="#stay" String="generator-expressions" insensitive="false"/>+        <WordDetect String="STRING" attribute="Generator Expression Keyword" context="genex_STRING_ctx"/>         <WordDetect String="LIST" attribute="Generator Expression Keyword" context="genex_LIST_ctx"/>         <WordDetect String="PATH" attribute="Generator Expression Keyword" context="genex_PATH_ctx"/>         <IncludeRules context="Detect Aliased Targets"/>         <IncludeRules context="Detect Variable Substitutions"/>         <DetectIdentifier/>+      </context>+      <context attribute="Generator Expression" lineEndContext="#stay" name="genex_STRING_ctx" fallthroughContext="#pop">+        <DetectChar char=":" context="#stay"/>+        <DetectSpaces/>+        <keyword attribute="Generator Expression Sub-Command" context="#pop" String="genex-STRING-subcommands" insensitive="false"/>       </context>       <context attribute="Generator Expression" lineEndContext="#stay" name="genex_LIST_ctx" fallthroughContext="#pop">         <DetectChar char=":" context="#stay"/>
+ xml/cobol.xml view
@@ -0,0 +1,749 @@+<?xml version="1.0" encoding="UTF-8"?>+<!DOCTYPE language [+  <!ENTITY div "DATA|ENVIRONMENT|ID|IDENTIFICATION|PROCEDURE">+  <!ENTITY sec "COMMUNICATION|CONFIGURATION|FILE|INPUT-OUTPUT|LINKAGE|LOCAL-STORAGE|REPORT|SCREEN|WORKING-STORAGE">+  <!ENTITY seplist "[\s&lt;>+/*$,;():=.]">+  <!ENTITY picsym "([-+*$ABCDENPRSUVXZ910]+(\([0-9]+\))?)+">+]>+<language name="COBOL" section="Sources" version="2" kateversion="5.62"+          extensions="*.cob;*.cbl;*.cpy;*.copy;*.lst;*.pco;*.scb;*.sqb"+          author="Jonathan Poelen (jonathan.poelen@gmail.com);github.com/MihailJP" license="MIT">+<highlighting>++<list name="picture">+  <item>PIC</item>+  <item>PICTURE</item>+</list>++<list name="verbs">+  <item>ACCEPT</item>+  <item>ADD</item>+  <item>ALTER</item>+  <item>CALL</item>+  <item>COMPUTE</item>+  <item>DELETE</item>+  <item>DISPLAY</item>+  <item>DIVIDE</item>+  <item>END-ACCEPT</item>+  <item>END-ADD</item>+  <item>END-CALL</item>+  <item>END-COMPUTE</item>+  <item>END-DELETE</item>+  <item>END-DISPLAY</item>+  <item>END-DIVIDE</item>+  <item>END-EVALUATE</item>+  <item>END-IF</item>+  <item>END-MULTIPLY</item>+  <item>END-PERFORM</item>+  <item>END-READ</item>+  <item>END-RECEIVE</item>+  <item>END-RETURN</item>+  <item>END-REWRITE</item>+  <item>END-SEARCH</item>+  <item>END-START</item>+  <item>END-STRING</item>+  <item>END-SUBTRACT</item>+  <item>END-UNSTRING</item>+  <item>END-WRITE</item>+  <item>EVALUATE</item>+  <item>IF</item>+  <item>MULTIPLY</item>+  <item>PERFORM</item>+  <item>READ</item>+  <item>RECEIVE</item>+  <item>RETURN</item>+  <item>REWRITE</item>+  <item>SEARCH</item>+  <item>START</item>+  <item>STRING</item>+  <item>SUBTRACT</item>+  <item>UNSTRING</item>+  <item>WRITE</item>+  <item>ASSIGN</item>+  <item>CHAIN</item>+  <item>CLOSE</item>+  <item>CONTINUE</item>+  <item>CONTROL</item>+  <item>COPY</item>+  <item>COUNT</item>+  <item>ELSE</item>+  <item>ENABLE</item>+  <item>ERASE</item>+  <item>EXIT</item>+  <item>GENERATE</item>+  <item>GO</item>+  <item>GOBACK</item>+  <item>IGNORE</item>+  <item>INITIALIZE</item>+  <item>INITIATE</item>+  <item>INSPECT</item>+  <item>INVOKE</item>+  <item>MERGE</item>+  <item>MOVE</item>+  <item>OPEN</item>+  <item>RELEASE</item>+  <item>REPLACE</item>+  <item>RESERVE</item>+  <item>RESET</item>+  <item>REWIND</item>+  <item>ROLLBACK</item>+  <item>RUN</item>+  <item>SELECT</item>+  <item>SEND</item>+  <item>SET</item>+  <item>SORT</item>+  <item>STOP</item>+  <item>SUM</item>+  <item>SUPPRESS</item>+  <item>TERMINATE</item>+  <item>THEN</item>+  <item>TRANSFORM</item>+  <item>UNLOCK</item>+  <item>UPDATE</item>+  <item>USE</item>+  <item>WAIT</item>+  <item>WHEN</item>+</list>++<list name="usages">+  <item>BINARY</item>+  <item>BINARY-C-LONG</item>+  <item>BINARY-CHAR</item>+  <item>BINARY-DOUBLE</item>+  <item>BINARY-LONG</item>+  <item>BINARY-SHORT</item>+  <item>COMP</item>+  <item>COMP-1</item>+  <item>COMP-2</item>+  <item>COMP-3</item>+  <item>COMP-4</item>+  <item>COMP-5</item>+  <item>COMP-X</item>+  <item>COMPUTATIONAL</item>+  <item>COMPUTATIONAL-1</item>+  <item>COMPUTATIONAL-2</item>+  <item>COMPUTATIONAL-3</item>+  <item>COMPUTATIONAL-4</item>+  <item>COMPUTATIONAL-5</item>+  <item>COMPUTATIONAL-X</item>+  <item>FLOAT-BINARY-16</item>+  <item>FLOAT-BINARY-34</item>+  <item>FLOAT-BINARY-7</item>+  <item>FLOAT-DECIMAL-16</item>+  <item>FLOAT-DECIMAL-34</item>+  <item>FLOAT-EXTENDED</item>+  <item>FLOAT-LONG</item>+  <item>FLOAT-SHORT</item>+  <item>FUNCTION-POINTER</item>+  <item>INDEX</item>+  <item>NATIONAL</item>+  <item>PACKED-DECIMAL</item>+  <item>POINTER</item>+  <item>PROCEDURE-POINTER</item>+  <item>PROGRAM-POINTER</item>+  <item>SIGNED</item>+  <item>SIGNED-INT</item>+  <item>SIGNED-LONG</item>+  <item>SIGNED-SHORT</item>+  <item>UNSIGNED</item>+  <item>UNSIGNED-INT</item>+  <item>UNSIGNED-LONG</item>+  <item>UNSIGNED-SHORT</item>+</list>++<list name="keywords">+  <item>CD</item>+  <item>COMMUNICATION</item>+  <item>CONFIGURATION</item>+  <item>DATA</item>+  <item>DECLARATIVES</item>+  <item>DIVISION</item>+  <item>ENVIRONMENT</item>+  <item>FD</item>+  <item>FILE</item>+  <item>FILE-CONTROL</item>+  <item>I-O</item>+  <item>I-O-CONTROL</item>+  <item>ID</item>+  <item>IDENTIFICATION</item>+  <item>INPUT</item>+  <item>INPUT-OUTPUT</item>+  <item>LINKAGE</item>+  <item>LOCAL-STORAGE</item>+  <item>OUTPUT</item>+  <item>PROCEDURE</item>+  <item>PROGRAM</item>+  <item>RD</item>+  <item>REPORT</item>+  <item>REPOSITORY</item>+  <item>SD</item>+  <item>SECTION</item>+  <item>SPECIAL-NAMES</item>+  <item>WORKING-STORAGE</item>+</list>++<list name="keywords-block">+  <item>PROGRAM-ID</item>+  <item>FUNCTION-ID</item>+  <item>CLASS-ID</item>+  <item>INTERFACE-ID</item>+  <item>METHOD-ID</item>+  <item>FACTORY</item>+  <item>OBJECT</item>+</list>++<list name="logical">+  <item>AND</item>+  <item>EQUAL</item>+  <item>EQUALS</item>+  <item>GREATER</item>+  <item>LESS</item>+  <item>OR</item>+  <item>THAN</item>+</list>++<list name="constants">+  <item>HIGH-VALUEHIGH-VALUES</item>+  <item>LOW-VALUE</item>+  <item>LOW-VALUES</item>+  <item>NULL</item>+  <item>NULLS</item>+  <item>QUOTE</item>+  <item>QUOTES</item>+  <item>SPACE</item>+  <item>SPACES</item>+  <item>ZERO</item>+  <item>ZEROES</item>+  <item>ZEROS</item>+</list>++<list name="reserved">+  <item>ACCESS</item>+  <item>ACTIVE-CLASS</item>+  <item>ADDRESS</item>+  <item>ADVANCING</item>+  <item>AFTER</item>+  <item>ALIGNED</item>+  <item>ALL</item>+  <item>ALLOCATE</item>+  <item>ALPHABET</item>+  <item>ALPHABETIC</item>+  <item>ALPHABETIC-LOWER</item>+  <item>ALPHABETIC-UPPER</item>+  <item>ALPHANUMERIC</item>+  <item>ALPHANUMERIC-EDITED</item>+  <item>ALSO</item>+  <item>ALTERNATE</item>+  <item>ANY</item>+  <item>ANYCASE</item>+  <item>ARE</item>+  <item>AREA</item>+  <item>AREAS</item>+  <item>ARGUMENT-NUMBER</item>+  <item>ARGUMENT-VALUE</item>+  <item>ARITHMETIC</item>+  <item>AS</item>+  <item>ASCENDING</item>+  <item>AT</item>+  <item>ATTRIBUTE</item>+  <item>AUTO</item>+  <item>AUTO-SKIP</item>+  <item>AUTOMATIC</item>+  <item>AUTOTERMINATE</item>+  <item>B-AND</item>+  <item>B-NOT</item>+  <item>B-OR</item>+  <item>B-XOR</item>+  <item>BACKGROUND-COLOR</item>+  <item>BASED</item>+  <item>BEEP</item>+  <item>BEFORE</item>+  <item>BELL</item>+  <item>BIT</item>+  <item>BLANK</item>+  <item>BLINK</item>+  <item>BLOCK</item>+  <item>BOOLEAN</item>+  <item>BOTTOM</item>+  <item>BY</item>+  <item>BYTE-LENGTH</item>+  <item>CANCEL</item>+  <item>CENTER</item>+  <item>CF</item>+  <item>CH</item>+  <item>CHAINING</item>+  <item>CHARACTER</item>+  <item>CHARACTERS</item>+  <item>CLASS</item>+  <item>CLASSIFICATION</item>+  <item>CODE</item>+  <item>CODE-SET</item>+  <item>COL</item>+  <item>COLLATING</item>+  <item>COLS</item>+  <item>COLUMN</item>+  <item>COLUMNS</item>+  <item>COMMA</item>+  <item>COMMAND-LINE</item>+  <item>COMMIT</item>+  <item>COMMON</item>+  <item>CONDITION</item>+  <item>CONSTANT</item>+  <item>CONTAINS</item>+  <item>CONTENT</item>+  <item>CONTROLS</item>+  <item>CONVERTING</item>+  <item>CORR</item>+  <item>CORRESPONDING</item>+  <item>CRT</item>+  <item>CURRENCY</item>+  <item>CURSOR</item>+  <item>CYCLE</item>+  <item>DATA-POINTER</item>+  <item>DATE</item>+  <item>DAY</item>+  <item>DAY-OF-WEEK</item>+  <item>DE</item>+  <item>DEBUGGING</item>+  <item>DECIMAL-POINT</item>+  <item>DEFAULT</item>+  <item>DELIMITED</item>+  <item>DELIMITER</item>+  <item>DEPENDING</item>+  <item>DESCENDING</item>+  <item>DESTINATION</item>+  <item>DETAIL</item>+  <item>DISABLE</item>+  <item>DISK</item>+  <item>DOWN</item>+  <item>DUPLICATES</item>+  <item>DYNAMIC</item>+  <item>EBCDIC</item>+  <item>EC</item>+  <item>EGI</item>+  <item>EMI</item>+  <item>END</item>+  <item>END-OF-PAGE</item>+  <item>ENTRY</item>+  <item>ENTRY-CONVENTION</item>+  <item>ENVIRONMENT-NAME</item>+  <item>ENVIRONMENT-VALUE</item>+  <item>EO</item>+  <item>EOL</item>+  <item>EOP</item>+  <item>EOS</item>+  <item>ERROR</item>+  <item>ESCAPE</item>+  <item>ESI</item>+  <item>EXCEPTION</item>+  <item>EXCEPTION-OBJECT</item>+  <item>EXCLUSIVE</item>+  <item>EXPANDS</item>+  <item>EXTEND</item>+  <item>EXTERNAL</item>+  <item>FALSE</item>+  <item>FILE-ID</item>+  <item>FILLER</item>+  <item>FINAL</item>+  <item>FIRST</item>+  <item>FOOTING</item>+  <item>FOR</item>+  <item>FOREGROUND-COLOR</item>+  <item>FOREVER</item>+  <item>FORMAT</item>+  <item>FREE</item>+  <item>FROM</item>+  <item>FULL</item>+  <item>GET</item>+  <item>GIVING</item>+  <item>GLOBAL</item>+  <item>GROUP</item>+  <item>GROUP-USAGE</item>+  <item>HEADING</item>+  <item>HIGH-VALUE</item>+  <item>HIGH-VALUES</item>+  <item>HIGHLIGHT</item>+  <item>IGNORING</item>+  <item>IMPLEMENTS</item>+  <item>IN</item>+  <item>INDEXED</item>+  <item>INDICATE</item>+  <item>INFINITY</item>+  <item>INHERITS</item>+  <item>INITIAL</item>+  <item>INITIALIZED</item>+  <item>INTERFACE</item>+  <item>INTO</item>+  <item>INTRINSIC</item>+  <item>INVALID</item>+  <item>IS</item>+  <item>JUST</item>+  <item>JUSTIFIED</item>+  <item>KEY</item>+  <item>LABEL</item>+  <item>LAST</item>+  <item>LC_ALL</item>+  <item>LC_COLLATE</item>+  <item>LC_CTYPE</item>+  <item>LC_MESSAGES</item>+  <item>LC_MONETARY</item>+  <item>LC_NUMERIC</item>+  <item>LC_TIME</item>+  <item>LEADING</item>+  <item>LEFT</item>+  <item>LENGTH</item>+  <item>LIMIT</item>+  <item>LIMITS</item>+  <item>LINAGE</item>+  <item>LINAGE-COUNTER</item>+  <item>LINE</item>+  <item>LINE-COUNTER</item>+  <item>LINES</item>+  <item>LOCALE</item>+  <item>LOCK</item>+  <item>LOWLIGHT</item>+  <item>MANUAL</item>+  <item>MEMORY</item>+  <item>MESSAGE</item>+  <item>METHOD</item>+  <item>MINUS</item>+  <item>MODE</item>+  <item>MULTIPLE</item>+  <item>NATIONAL-EDITED</item>+  <item>NATIVE</item>+  <item>NEGATIVE</item>+  <item>NESTED</item>+  <item>NEXT</item>+  <item>NO</item>+  <item>NONE</item>+  <item>NORMAL</item>+  <item>NOT</item>+  <item>NUMBER</item>+  <item>NUMBERS</item>+  <item>NUMERIC</item>+  <item>NUMERIC-EDITED</item>+  <item>OBJECT-COMPUTER</item>+  <item>OBJECT-REFERENCE</item>+  <item>OCCURS</item>+  <item>OF</item>+  <item>OFF</item>+  <item>OMITTED</item>+  <item>ON</item>+  <item>ONLY</item>+  <item>OPTIONAL</item>+  <item>OPTIONS</item>+  <item>ORDER</item>+  <item>ORGANIZATION</item>+  <item>OTHER</item>+  <item>OVERFLOW</item>+  <item>OVERLINE</item>+  <item>OVERRIDE</item>+  <item>PADDING</item>+  <item>PAGE</item>+  <item>PAGE-COUNTER</item>+  <item>PARAGRAPH</item>+  <item>PF</item>+  <item>PH</item>+  <item>PLUS</item>+  <item>POSITION</item>+  <item>POSITIVE</item>+  <item>PRESENT</item>+  <item>PREVIOUS</item>+  <item>PRINTER</item>+  <item>PRINTING</item>+  <item>PROCEDURES</item>+  <item>PROCEED</item>+  <item>PROMPT</item>+  <item>PROPERTY</item>+  <item>PROTOTYPE</item>+  <item>PURGE</item>+  <item>QUEUE</item>+  <item>RAISE</item>+  <item>RAISING</item>+  <item>RANDOM</item>+  <item>RECORD</item>+  <item>RECORDING</item>+  <item>RECORDS</item>+  <item>RECURSIVE</item>+  <item>REDEFINES</item>+  <item>REEL</item>+  <item>REFERENCE</item>+  <item>RELATION</item>+  <item>RELATIVE</item>+  <item>REMAINDER</item>+  <item>REMOVAL</item>+  <item>RENAMES</item>+  <item>REPLACING</item>+  <item>REPORTING</item>+  <item>REPORTS</item>+  <item>REQUIRED</item>+  <item>RESUME</item>+  <item>RETRY</item>+  <item>RETURNING</item>+  <item>REVERSE-VIDEO</item>+  <item>RF</item>+  <item>RH</item>+  <item>RIGHT</item>+  <item>ROUNDED</item>+  <item>SAME</item>+  <item>SCREEN</item>+  <item>SCROLL</item>+  <item>SECONDS</item>+  <item>SECURE</item>+  <item>SEGMENT</item>+  <item>SEGMENT-LIMIT</item>+  <item>SELF</item>+  <item>SENTENCE</item>+  <item>SEPARATE</item>+  <item>SEQUENCE</item>+  <item>SEQUENTIAL</item>+  <item>SHARING</item>+  <item>SIGN</item>+  <item>SIZE</item>+  <item>SORT-MERGE</item>+  <item>SOURCE</item>+  <item>SOURCE-COMPUTER</item>+  <item>SOURCES</item>+  <item>STANDARD</item>+  <item>STANDARD-1</item>+  <item>STANDARD-2</item>+  <item>STATEMENT</item>+  <item>STATUS</item>+  <item>STEP</item>+  <item>STRONG</item>+  <item>SUB-QUEUE-1</item>+  <item>SUB-QUEUE-2</item>+  <item>SUB-QUEUE-3</item>+  <item>SUPER</item>+  <item>SYMBOL</item>+  <item>SYMBOLIC</item>+  <item>SYNC</item>+  <item>SYNCHRONIZED</item>+  <item>SYSTEM-DEFAULT</item>+  <item>TABLE</item>+  <item>TALLYING</item>+  <item>TAPE</item>+  <item>TERMINAL</item>+  <item>TEST</item>+  <item>TEXT</item>+  <item>THROUGH</item>+  <item>THRU</item>+  <item>TIME</item>+  <item>TIMES</item>+  <item>TO</item>+  <item>TOP</item>+  <item>TRAILING</item>+  <item>TRUE</item>+  <item>TYPE</item>+  <item>TYPEDEF</item>+  <item>UCS-4</item>+  <item>UNDERLINE</item>+  <item>UNIT</item>+  <item>UNIVERSAL</item>+  <item>UNTIL</item>+  <item>UP</item>+  <item>UPON</item>+  <item>USAGE</item>+  <item>USER-DEFAULT</item>+  <item>USING</item>+  <item>UTF-16</item>+  <item>UTF-8</item>+  <item>VAL-STATUS</item>+  <item>VALID</item>+  <item>VALIDATE</item>+  <item>VALIDATE-STATUS</item>+  <item>VALUE</item>+  <item>VALUES</item>+  <item>VARYING</item>+  <item>WITH</item>+  <item>WORDS</item>+  <item>YYYYDDD</item>+  <item>YYYYMMDD</item>+</list>++<list name="functions">+  <item>ABS</item>+  <item>ACOS</item>+  <item>ANNUITY</item>+  <item>ASIN</item>+  <item>ATAN</item>+  <item>BYTE-LENGTH</item>+  <item>CHAR</item>+  <item>CONCATENATE</item>+  <item>COS</item>+  <item>CURRENT-DATE</item>+  <item>DATE-OF-INTEGER</item>+  <item>DATE-TO-YYYYMMDD</item>+  <item>DAY-OF-INTEGER</item>+  <item>DAY-TO-YYYYDDD</item>+  <item>E</item>+  <item>EXCEPTION-FILE</item>+  <item>EXCEPTION-LOCATION</item>+  <item>EXCEPTION-STATEMENT</item>+  <item>EXCEPTION-STATUS</item>+  <item>EXP</item>+  <item>EXP10</item>+  <item>FACTORIAL</item>+  <item>FRACTION-PART</item>+  <item>INTEGER</item>+  <item>INTEGER-OF-DATE</item>+  <item>INTEGER-OF-DAY</item>+  <item>INTEGER-PART</item>+  <item>LENGTH</item>+  <item>LOCALE-DATE</item>+  <item>LOCALE-TIME</item>+  <item>LOG</item>+  <item>LOG10</item>+  <item>LOWER-CASE</item>+  <item>MAX</item>+  <item>MEAN</item>+  <item>MEDIAN</item>+  <item>MIDRANGE</item>+  <item>MIN</item>+  <item>MOD</item>+  <item>NUMVAL</item>+  <item>NUMVAL-C</item>+  <item>ORD</item>+  <item>ORD-MAX</item>+  <item>ORD-MIN</item>+  <item>PI</item>+  <item>PRESENT-VALUE</item>+  <item>RANDOM</item>+  <item>RANGE</item>+  <item>REM</item>+  <item>REVERSE</item>+  <item>SECONDS-FROM-FORMATTED-TIME</item>+  <item>SECONDS-PAST-MIDNIGHT</item>+  <item>SIGN</item>+  <item>SIN</item>+  <item>SQRT</item>+  <item>STANDARD-DEVIATION</item>+  <item>STORED-CHAR-LENGTH</item>+  <item>SUBSTITUTE</item>+  <item>SUBSTITUTE-CASE</item>+  <item>TAN</item>+  <item>TEST-DATE-YYYYMMDD</item>+  <item>TEST-DAY-YYYYDDD</item>+  <item>TRIM</item>+  <item>UPPER-CASE</item>+  <item>VARIANCE</item>+  <item>WHEN-COMPILED</item>+  <item>YEAR-TO-YYYY</item>+</list>++<contexts>++  <context name="Normal" attribute="Normal Text" lineEndContext="#stay">+    <DetectSpaces attribute="Normal Text"/>+    <Int attribute="Sequence Number Area" firstNonSpace="1"/>+    <DetectChar attribute="Comment" context="comment" char="*" column="6"/>+    <DetectChar attribute="Comment" context="comment" char="*" column="0"/>+    <DetectChar attribute="Comment" context="comment" char="/" column="6"/>+    <DetectChar attribute="Comment" context="comment" char="/" column="0"/>+    <DetectChar attribute="String" context="stringDQ" char="&quot;"/>+    <DetectChar attribute="String" context="stringSQ" char="'"/>+    <StringDetect attribute="Comment" context="comment" String="*>"/>+    <AnyChar attribute="Normal Text" String="&lt;>+/*$,;():="/>+    <keyword attribute="Keywords" String="keywords-block" beginRegion="ID"/>+    <keyword attribute="Other Reserved Words" context="picture" String="picture"/>+    <keyword attribute="Verb" String="verbs"/>+    <keyword attribute="Usage" String="usages"/>+    <keyword attribute="Constant" String="constants"/>+    <keyword attribute="Logical" String="logical"/>+    <WordDetect attribute="Keywords" context="end" String="END" insensitive="1"/>+    <RegExpr attribute="Division" String="\b(?!-)(&div;)\s+DIVISION\b(?!-)" insensitive="1"/>+    <RegExpr attribute="Section" String="\b(?!-)(&sec;)\s+SECTION\b(?!-)" insensitive="1"/>+    <keyword attribute="Keywords" String="keywords"/>+    <keyword attribute="Other Reserved Words" String="reserved"/>+    <WordDetect attribute="Other Reserved Words" context="function" String="FUNCTION" insensitive="1"/>+    <WordDetect context="exec" String="EXEC" insensitive="1" lookAhead="1"/>+    <RegExpr attribute="Float" String="(?&lt;=^|\s)-?[0-9]*\.[0-9]+(?=$|&seplist;)" context="#stay"/>+    <RegExpr attribute="Decimal" String="(?&lt;=^|\s)-?[0-9]+(?=$|&seplist;)" context="#stay"/>+    <RegExpr attribute="Hex" String="H(&quot;[0-9A-F]+&quot;|'[0-9A-F]+')" insensitive="1"/>+    <RegExpr attribute="Char" String="X(&quot;[0-9A-F]+&quot;|'[0-9A-F]+')" insensitive="1"/>+    <RegExpr attribute="Normal Text" String="[-\w]*[\s&lt;>+$,;():=.]"/>+  </context>++  <context name="end" attribute="Keywords" lineEndContext="#pop" fallthroughContext="#pop">+    <keyword attribute="Keywords" String="keywords-block" context="#pop" endRegion="ID"/>+  </context>++  <context name="comment" attribute="Comment" lineEndContext="#pop">+    <DetectSpaces attribute="Comment"/>+    <IncludeRules context="##Comments"/>+    <DetectIdentifier attribute="Comment"/>+  </context>++  <context name="stringDQ" attribute="String" lineEndContext="#pop">+    <DetectChar attribute="String" context="#pop" char="&quot;"/>+  </context>++  <context name="stringSQ" attribute="String" lineEndContext="#pop">+    <DetectChar attribute="String" context="#pop" char="'"/>+  </context>++  <context name="picture" attribute="String" lineEndContext="#pop" fallthroughContext="#pop!picture3">+    <DetectSpaces attribute="Normal Text"/>+    <WordDetect attribute="Other Reserved Words" context="#pop!picture2" String="IS" insensitive="1"/>+  </context>+  <context name="picture2" attribute="String" lineEndContext="#pop" fallthroughContext="#pop!picture3">+    <DetectSpaces attribute="Normal Text" context="#pop!picture3"/>+  </context>+  <context name="picture3" attribute="Error" lineEndContext="#pop">+    <RegExpr attribute="Picture" String="\s*&picsym;([,./]&picsym;)*(CR|DB)?" insensitive="1" context="#pop"/>+    <AnyChar attribute="Normal Text" context="#pop" String=",./ &#9;"/>+    <StringDetect attribute="Comment" context="#pop!comment" String="*>"/>+  </context>++  <context name="function" attribute="Error" lineEndContext="#pop">+    <keyword attribute="Function" context="#pop" String="functions"/>+    <WordDetect attribute="Other Reserved Words" context="#pop" String="ALL" insensitive="1"/>+    <AnyChar attribute="Normal Text" context="#pop" String=". &#9;"/>+    <StringDetect attribute="Comment" context="#pop!comment" String="*>"/>+  </context>++  <context name="exec" attribute="Normal Text" lineEndContext="#pop">+    <RegExpr attribute="SQL" String="EXEC\s+SQL\b(?!-)" context="#pop!sql" insensitive="1" beginRegion="sql"/>+    <DetectIdentifier attribute="Normal Text" context="#pop"/>+  </context>++  <context name="sql" attribute="Normal Text" lineEndContext="#stay">+    <StringDetect attribute="Comment" context="comment" String="*>"/>+    <WordDetect attribute="SQL" context="#pop" String="END-EXEC" insensitive="1" endRegion="sql"/>+    <IncludeRules context="##SQL" includeAttrib="1"/>+  </context>++</contexts>++<itemDatas>+  <itemData name="Normal Text" defStyleNum="dsNormal" spellChecking="0"/>+  <itemData name="Sequence Number Area" defStyleNum="dsComment" spellChecking="0" italic="1"/>+  <itemData name="Decimal" defStyleNum="dsDecVal" spellChecking="0"/>+  <itemData name="Float" defStyleNum="dsFloat" spellChecking="0"/>+  <itemData name="Hex" defStyleNum="dsBaseN" spellChecking="0"/>+  <itemData name="Constant" defStyleNum="dsConstant" spellChecking="0"/>+  <itemData name="Logical" defStyleNum="dsKeyword" spellChecking="0" italic="1"/>+  <itemData name="String" defStyleNum="dsString"/>+  <itemData name="Char" defStyleNum="dsChar" spellChecking="0"/>+  <itemData name="Division" defStyleNum="dsRegionMarker" spellChecking="0"/>+  <itemData name="Section" defStyleNum="dsRegionMarker" spellChecking="0"/>+  <itemData name="SQL" defStyleNum="dsRegionMarker" spellChecking="0"/>+  <itemData name="Keywords" defStyleNum="dsKeyword" spellChecking="0"/>+  <itemData name="Verb" defStyleNum="dsKeyword" spellChecking="0"/>+  <itemData name="Picture" defStyleNum="dsDataType" spellChecking="0"/>+  <itemData name="Usage" defStyleNum="dsDataType" spellChecking="0"/>+  <itemData name="Other Reserved Words" defStyleNum="dsOthers" spellChecking="0"/>+  <itemData name="Function" defStyleNum="dsFunction" spellChecking="0"/>+  <itemData name="Comment" defStyleNum="dsComment"/>+  <itemData name="Error" defStyleNum="dsError" spellChecking="0"/>+</itemDatas>++</highlighting>+<general>+  <comments>+    <comment name="singleLine" start="*>"/>+  </comments>+  <keywords casesensitive="0" weakDeliminator="-"/>+</general>+</language>+<!-- kate: space-indent on; indent-width 2; replace-tabs on; -->
+ xml/context.xml view
@@ -0,0 +1,214 @@+<?xml version="1.0" encoding="UTF-8"?>+<!DOCTYPE language+[+	<!-- The characters ! ? @ are "internal" or system macros, normally not usable, in general: user macros are just letters, see+	https://wiki.contextgarden.net/System_Macros/Scratch_Variables and https://www.mail-archive.com/ntg-context@ntg.nl/msg87737.html+	In practice any non-special character works, though english characters should be used, except for one character macros, they use any symbol -->+	<!ENTITY macro      "\\([[:alpha:]]+|[[:graph:]])">+]>+<language+	name="ConTeXt"+	version="12"+	section="Markup"+	kateversion="5.79"+	priority="9"+	extensions="*.ctx;*.mkiv;*.mkvi;*.mkxl;*.mklx"+	mimetype="text/x-tex"+	casesensitive="1"+	author="Philipp A. (flying-sheep@web.de)"+	license="GPL"+>+	<highlighting>+		<list name="titles">+			<item>\part</item>+			<item>\chapter</item>+			<item>\section</item>+			<item>\subsection</item>+			<item>\subsubsection</item>+			<item>\subsubsubsection</item>+			<item>\subsubsubsubsection</item>+			<item>\title</item>+			<item>\subject</item>+			<item>\subsubject</item>+			<item>\subsubsubject</item>+			<item>\subsubsubsubject</item>+			<item>\subsubsubsubsubject</item>+		</list>+		<list name="mathMacros">+			<item>\m</item>+			<item>\math</item>+			<item>\mathematics</item>+			<item>\formula</item>+		</list>+		<list name="startEnvironments">+			<item>\bTABLEhead</item>+			<item>\bTABLEnext</item>+			<item>\bTABLEbody</item>+			<item>\bTABLEfoot</item>+			<item>\bTABLE</item>+			<item>\bTR</item>+			<item>\bTD</item>+		</list>+		<list name="stopEnvironments">+			<item>\eTABLEhead</item>+			<item>\eTABLEnext</item>+			<item>\eTABLEbody</item>+			<item>\eTABLEfoot</item>+			<item>\eTABLE</item>+			<item>\eTR</item>+			<item>\eTD</item>+		</list>+		<list name="startMetaPost">+			<item>\startMPinclusions</item>+			<item>\startuseMPgraphic</item>+			<item>\startreusableMPgraphic</item>+			<item>\startstaticMPfigure</item>+			<item>\startuniqueMPgraphic</item>+			<item>\startMPpage</item>+			<item>\startMPcode</item>+			<item>\startMP</item>+		</list>+		<list name="stopMetaPost">+			<item>\stopMPinclusions</item>+			<item>\stopuseMPgraphic</item>+			<item>\stopreusableMPgraphic</item>+			<item>\stopstaticMPfigure</item>+			<item>\stopuniqueMPgraphic</item>+			<item>\stopMPpage</item>+			<item>\stopMPcode</item>+			<item>\stopMP</item>+		</list>++		<contexts>+			<!-- Normal text -->+			<context name="Normal Text" attribute="Normal Text" lineEndContext="#stay">+				<keyword      String="titles"        attribute="Section" context="#stay"/>+				<Detect2Chars char="$" char1="$"     attribute="Block" context="MathModeDisplay"/>+				<DetectChar   char="$"               attribute="Block" context="MathMode"/>+				<keyword      String="mathMacros"    attribute="Block" context="MathModeMacroFind"/>+				<StringDetect String="\startformula" attribute="Block" context="MathModeFormula" beginRegion="mathModeBlock"/>+				<StringDetect String="\starttyping"  attribute="Block" context="Verbatim"        beginRegion="typingBlock"/>+				<StringDetect String="\startluacode" attribute="Block" context="LuaCode"         beginRegion="luaBlock"/>+				<StringDetect String="\startLUA"     attribute="Block" context="LuaCode"         beginRegion="luaBlock"/>+				<StringDetect String="\startXML"     attribute="Block" context="XmlCode"         beginRegion="xmlBlock"/>+				<keyword      String="startMetaPost" attribute="Block" context="MetaPostCode"    beginRegion="metaPostBlock"/>+				<IncludeRules context="Common"/>+			</context>++			<!-- Comment -->+			<context name="Comment" attribute="Comment" lineEndContext="#pop">+				<IncludeRules context="##Comments"/>+			</context>++			<!-- Math Modes -->+			<context name="MathMode" attribute="Math" lineEndContext="#stay">+				<DetectChar   char="$"               attribute="Block" context="#pop"/>+				<StringDetect String="\stopformula"  attribute="Error" context="#stay" />+				<IncludeRules context="MathModeCommon"/>+			</context>+			<context name="MathModeMacroFind" attribute="Math" lineEndContext="#stay">+				<DetectChar   char="{"             attribute="Brace" context="#pop!MathModeMacro"/>+				<RegExpr      String="&macro;"     attribute="Macro" context="#pop"/> <!-- Single token -->+				<RegExpr      String="[[:graph:]]" attribute="Math"  context="#pop"/> <!-- Single token -->+			</context>+			<context name="MathModeMacro" attribute="Math" lineEndContext="#stay">+				<DetectChar   char="{"               attribute="Brace" context="MathModeMacro"/>+				<DetectChar   char="}"               attribute="Brace" context="#pop"/>+				<DetectChar   char="$"               attribute="Error" context="#stay"/>+				<StringDetect String="\stopformula"  attribute="Error" context="#stay"/>+				<IncludeRules context="MathModeCommon"/>+			</context>+			<context name="MathModeDisplay" attribute="Math" lineEndContext="#stay">+				<Detect2Chars char="$" char1="$"     attribute="Block" context="#pop"/>+				<DetectChar   char="$"               attribute="Error" context="#stay"/>+				<StringDetect String="\stopformula"  attribute="Error" context="#stay"/>+				<IncludeRules context="MathModeCommon"/>+			</context>+			<context name="MathModeFormula" attribute="Math" lineEndContext="#stay">+				<DetectChar   char="$"               attribute="Error" context="#stay"/>+				<StringDetect String="\stopformula"  attribute="Block" context="#pop" endRegion="mathModeBlock"/>+				<IncludeRules context="MathModeCommon"/>+			</context>+			<context name="MathModeCommon" attribute="Error" lineEndContext="#stay">+				<AnyChar      String="^_"            attribute="Brace" context="#stay"/>+				<StringDetect String="\startformula" attribute="Error" context="#stay"/>+				<StringDetect String="\text"         attribute="Block" context="MathModeTextFind"/>+				<IncludeRules context="Common"/>+			</context>+			<!--Math text-->+			<context name="MathModeTextFind" attribute="Normal Text" lineEndContext="#stay" >+				<DetectChar char="{" attribute="Brace" context="#pop!MathModeText"/>+			</context>+			<context name="MathModeText" attribute="Normal Text" lineEndContext="#stay" >+				<DetectChar char="{" attribute="Brace" context="MathModeText"/>+				<DetectChar char="}" attribute="Brace" context="#pop"/>+				<IncludeRules context="Normal Text"/>+			</context>++			<!--Verbatim TODO: \startC support-->+			<context name="Verbatim" attribute="Verbatim" lineEndContext="#stay">+				<StringDetect String="\starttyping" attribute="Verbatim" context="NestedVerbatim"/>+				<StringDetect String="\stoptyping"  attribute="Block"    context="#pop" endRegion="typingBlock"/>+			</context>++			<context name="NestedVerbatim" attribute="Verbatim" lineEndContext="#stay">+				<StringDetect String="\starttyping" attribute="Verbatim" context="NestedVerbatim"/>+				<StringDetect String="\stoptyping"  attribute="Verbatim" context="#pop"/>+			</context>++			<context name="MetaPostCode" attribute="Normal Text" lineEndContext="#stay">+				<keyword      String="stopMetaPost" attribute="Block" context="#pop" endRegion="metaPostBlock"/>+				<IncludeRules context="##Metapost/Metafont"/>+			</context>++			<context name="LuaCode" attribute="Normal Text" lineEndContext="#stay">+				<StringDetect String="\stopluacode" attribute="Block" context="#pop" endRegion="luaBlock"/>+				<StringDetect String="\stopLUA"     attribute="Block" context="#pop" endRegion="luaBlock"/>+				<IncludeRules context="##Lua"/>+			</context>++			<context name="XmlCode" attribute="Normal Text" lineEndContext="#stay">+				<StringDetect String="\stopXML"     attribute="Block" context="#pop" endRegion="xmlBlock"/>+				<IncludeRules context="##XML"/>+			</context>++			<!--Common-->+			<context name="Common" attribute="Error" lineEndContext="#stay">+				<DetectChar char="%"                    attribute="Comment" context="Comment"/>+				<RegExpr String="\\start(?:[a-zA-Z_]+)" attribute="Block" context="#stay" beginRegion="block"/>+				<RegExpr String="\\stop(?:[a-zA-Z_]+)"  attribute="Block" context="#stay" endRegion="block"/>+				<keyword String="startEnvironments"     attribute="Block" context="#stay" beginRegion="block"/>+				<keyword String="stopEnvironments"      attribute="Block" context="#stay" endRegion="block"/>+				<RegExpr String="&macro;"               attribute="Macro" context="#stay"/>+				<DetectChar char="{"                    attribute="Brace" context="#stay" beginRegion="block"/>+				<DetectChar char="}"                    attribute="Brace" context="#stay" endRegion="block"/>+			</context>+		</contexts>++		<itemDatas>+			<itemData name="Normal Text" defStyleNum="dsNormal"                            /><!--(Hi, I’m text)-->+			<itemData name="Comment"     defStyleNum="dsComment"                           /><!--(%Comment)-->+			<itemData name="Section"     defStyleNum="dsKeyword"                           /><!--\section{(Fancy!)}-->+			<itemData name="Brace"       defStyleNum="dsChar"         spellChecking="false"/><!--({})-->+			<itemData name="Math"        defStyleNum="dsOthers"       spellChecking="false"/><!--($5$)-->+			<itemData name="Macro"       defStyleNum="dsFunction"     spellChecking="false"/><!--(\foo)-->+			<itemData name="Block"       defStyleNum="dsRegionMarker" spellChecking="false"/><!--\start(bar), \stop(bar)-->+			<itemData name="Error"       defStyleNum="dsError"        spellChecking="false"/><!--$($$)-->+			<itemData name="Verbatim"    defStyleNum="dsString"       spellChecking="false"/><!--\starttyping(eggs)\stoptyping, \definetyping[C] \startC(umm…)\stopC-->+		</itemDatas>+	</highlighting>++	<general>+		<keywords weakDeliminator="\" wordWrapDeliminator=",{}[]"/>+		<comments>+			<comment name="singleLine" start="%" />+		</comments>+		<spellchecking>+			<encodings>+				<encoding string="''" />+			</encodings>+		</spellchecking>+	</general>+</language>++<!-- kate: space-indent off; indent-width 4; -->
xml/cpp.xml view
@@ -12,7 +12,7 @@     name="C++"     alternativeNames="CPP"     section="Sources"-    version="19"+    version="21"     kateversion="5.79"     indenter="cstyle"     style="C++"@@ -462,9 +462,11 @@     <item>Q_RELOCATABLE_TYPE</item>     <!-- http://doc.qt.io/qt-5/qqmlengine.html#macros -->     <!--https://doc.qt.io/qt-6/qqmlengine.html#macros-->+    <!-- https://doc.qt.io/qt-6/qqmlintegration-h.html#macros -->     <item>QML_ADDED_IN_MINOR_VERSION</item>     <item>QML_ANONYMOUS</item>     <item>QML_ATTACHED</item>+    <item>QML_CONSTRUCTIBLE_VALUE</item>     <item>QML_DECLARE_TYPE</item>     <item>QML_DECLARE_TYPEINFO</item>     <item>QML_ELEMENT</item>@@ -479,6 +481,7 @@     <item>QML_REMOVED_IN_MINOR_VERSION</item>     <item>QML_SEQUENTIAL_CONTAINER</item>     <item>QML_SINGLETON</item>+    <item>QML_STRUCTURED_VALUE</item>     <item>QML_UNAVAILABLE</item>     <item>QML_UNCREATABLE</item>     <item>QML_VALUE_TYPE</item>@@ -658,13 +661,17 @@   <list name="QtClasses">     <!-- Extracted with regular expression  Q[A-Z0-9][A-Za-z0-9]*  -->     <item>Q3DBars</item>+    <item>Q3DBarsWidgetItem</item>     <item>Q3DCamera</item>+    <item>Q3DGraphsWidgetItem</item>     <item>Q3DInputHandler</item>     <item>Q3DLight</item>     <item>Q3DObject</item>     <item>Q3DScatter</item>+    <item>Q3DScatterWidgetItem</item>     <item>Q3DScene</item>     <item>Q3DSurface</item>+    <item>Q3DSurfaceWidgetItem</item>     <item>Q3DTheme</item>     <item>QAbstract3DAxis</item>     <item>QAbstract3DGraph</item>@@ -686,6 +693,7 @@     <item>QAbstractClipBlendNode</item>     <item>QAbstractDataProxy</item>     <item>QAbstractEventDispatcher</item>+    <item>QAbstractEventDispatcherV2</item>     <item>QAbstractExtensionFactory</item>     <item>QAbstractExtensionManager</item>     <item>QAbstractFileIconProvider</item>@@ -737,8 +745,11 @@     <item>QAccelerometer</item>     <item>QAccelerometerFilter</item>     <item>QAccelerometerReading</item>+    <item>QAccessibilityHints</item>     <item>QAccessible</item>     <item>QAccessibleActionInterface</item>+    <item>QAccessibleAnnouncementEvent</item>+    <item>QAccessibleAttributesInterface</item>     <item>QAccessibleEditableTextInterface</item>     <item>QAccessibleEvent</item>     <item>QAccessibleInterface</item>@@ -810,6 +821,8 @@     <item>QAtomicScopedValueRollback</item>     <item>QAttribute</item>     <item>QAudioBuffer</item>+    <item>QAudioBufferInput</item>+    <item>QAudioBufferOutput</item>     <item>QAudioDecoder</item>     <item>QAudioDecoderControl</item>     <item>QAudioDevice</item>@@ -855,6 +868,7 @@     <item>QBarDataItem</item>     <item>QBarDataProxy</item>     <item>QBarLegendMarker</item>+    <item>QBarModelMapper</item>     <item>QBarSeries</item>     <item>QBarSet</item>     <item>QBaseIterator</item>@@ -963,6 +977,7 @@     <item>QCheckBox</item>     <item>QChildEvent</item>     <item>QChildWindowEvent</item>+    <item>QChronoTimer</item>     <item>QClearBuffers</item>     <item>QClipAnimator</item>     <item>QClipBlendNodeCreatedChangeBase</item>@@ -1089,6 +1104,7 @@     <item>QDir</item>     <item>QDirectionalLight</item>     <item>QDirIterator</item>+    <item>QDirListing</item>     <item>QDirModel</item>     <item>QDispatchCompute</item>     <item>QDistanceFilter</item>@@ -1101,6 +1117,7 @@     <item>QDnsMailExchangeRecord</item>     <item>QDnsServiceRecord</item>     <item>QDnsTextRecord</item>+    <item>QDnsTlsAssociationRecord</item>     <item>QDockWidget</item>     <item>QDomAttr</item>     <item>QDomCDATASection</item>@@ -1177,7 +1194,10 @@     <item>QFontInfo</item>     <item>QFontMetrics</item>     <item>QFontMetricsF</item>+    <item>QFontVariableAxis</item>     <item>QFormBuilder</item>+    <item>QFormDataBuilder</item>+    <item>QFormDataPartBuilder</item>     <item>QFormLayout</item>     <item>QForwardRenderer</item>     <item>QFrame</item>@@ -1295,21 +1315,26 @@     <item>QGraphicsView</item>     <item>QGraphicsWidget</item>     <item>QGraphTheme</item>+    <item>QGraphsTheme</item>     <item>QGregorianCalendar</item>     <item>QGridLayout</item>     <item>QGroupBox</item>+    <item>QGrpcBidiStream</item>     <item>QGrpcBidirStream</item>     <item>QGrpcCallOptions</item>     <item>QGrpcCallReply</item>     <item>QGrpcChannel</item>     <item>QGrpcChannelOperation</item>     <item>QGrpcChannelOptions</item>+    <item>QGrpcClientBase</item>     <item>QGrpcClientInterceptor</item>     <item>QGrpcClientInterceptorManager</item>     <item>QGrpcClientStream</item>     <item>QGrpcHttp2Channel</item>     <item>QGrpcInterceptorContinuation</item>     <item>QGrpcOperation</item>+    <item>QGrpcOperationContext</item>+    <item>QGrpcSerializationFormat</item>     <item>QGrpcServerStream</item>     <item>QGrpcStatus</item>     <item>QGuiApplication</item>@@ -1338,6 +1363,7 @@     <item>QHelpIndexWidget</item>     <item>QHelpLink</item>     <item>QHelpSearchEngine</item>+    <item>QHelpSearchEngineCore</item>     <item>QHelpSearchQuery</item>     <item>QHelpSearchQueryWidget</item>     <item>QHelpSearchResult</item>@@ -1361,11 +1387,13 @@     <item>QHttpMultiPart</item>     <item>QHttpPart</item>     <item>QHttpServer</item>+    <item>QHttpServerConfiguration</item>     <item>QHttpServerRequest</item>     <item>QHttpServerResponder</item>     <item>QHttpServerResponse</item>     <item>QHttpServerRouter</item>     <item>QHttpServerRouterRule</item>+    <item>QHttpServerWebSocketUpgradeResponse</item>     <item>QHumidityFilter</item>     <item>QHumidityReading</item>     <item>QHumiditySensor</item>@@ -1416,6 +1444,8 @@     <item>QIterable</item>     <item>QIterator</item>     <item>QJalaliCalendar</item>+    <item>QJniArray</item>+    <item>QJniArrayBase</item>     <item>QJniEnvironment</item>     <item>QJniObject</item>     <item>QJoint</item>@@ -1453,6 +1483,7 @@     <item>QLayoutItem</item>     <item>QLCDNumber</item>     <item>QLegend</item>+    <item>QLegendData</item>     <item>QLegendMarker</item>     <item>QLEInteger</item>     <item>QLerpClipBlend</item>@@ -1559,6 +1590,7 @@     <item>QMessageLogContext</item>     <item>QMessageLogger</item>     <item>QMetaClassInfo</item>+    <item>QMetaContainer</item>     <item>QMetaDataReaderControl</item>     <item>QMetaDataWriterControl</item>     <item>QMetaEnum</item>@@ -1679,6 +1711,9 @@     <item>QOAuth1</item>     <item>QOAuth1Signature</item>     <item>QOAuth2AuthorizationCodeFlow</item>+    <item>QOAuth2DeviceAuthorizationFlow</item>+    <item>QOAuthHttpServerReplyHandler</item>+    <item>QOAuthUriSchemeReplyHandler</item>     <item>QObject</item>     <item>QObjectBindableProperty</item>     <item>QObjectCleanupHandler</item>@@ -1822,6 +1857,7 @@     <item>QPainter</item>     <item>QPainterPath</item>     <item>QPainterPathStroker</item>+    <item>QPainterStateGuard</item>     <item>QPaintEvent</item>     <item>QPair</item>     <item>QPalette</item>@@ -1836,6 +1872,7 @@     <item>QPdfDocumentRenderOptions</item>     <item>QPdfLink</item>     <item>QPdfLinkModel</item>+    <item>QPdfOutputIntent</item>     <item>QPdfPageNavigation</item>     <item>QPdfPageNavigator</item>     <item>QPdfPageRenderer</item>@@ -1862,6 +1899,7 @@     <item>QPictureFormatPlugin</item>     <item>QPictureIO</item>     <item>QPieLegendMarker</item>+    <item>QPieModelMapper</item>     <item>QPieSeries</item>     <item>QPieSlice</item>     <item>QPinchGesture</item>@@ -1901,6 +1939,7 @@     <item>QPlaneGeometryView</item>     <item>QPlaneMesh</item>     <item>QPlatformSurfaceEvent</item>+    <item>QPlaybackOptions</item>     <item>QPluginLoader</item>     <item>QPoint</item>     <item>QPointer</item>@@ -1946,6 +1985,7 @@     <item>QProtobufJsonSerializer</item>     <item>QProtobufMessage</item>     <item>QProtobufMessageDeleter</item>+    <item>QProtobufRepeatedIterator</item>     <item>QProtobufSerializer</item>     <item>QProximityFilter</item>     <item>QProximityReading</item>@@ -2016,6 +2056,7 @@     <item>QRadioTunerControl</item>     <item>QRandomGenerator</item>     <item>QRandomGenerator64</item>+    <item>QRangeModel</item>     <item>QRasterMode</item>     <item>QRasterPaintEngine</item>     <item>QRasterWindow</item>@@ -2065,6 +2106,7 @@     <item>QRgba64</item>     <item>QRgbaFloat</item>     <item>QRhi</item>+    <item>QRhiAdapter</item>     <item>QRhiBuffer</item>     <item>QRhiColorAttachment</item>     <item>QRhiCommandBuffer</item>@@ -2098,6 +2140,7 @@     <item>QRhiShaderResourceBinding</item>     <item>QRhiShaderResourceBindings</item>     <item>QRhiShaderStage</item>+    <item>QRhiShadingRateMap</item>     <item>QRhiStats</item>     <item>QRhiSwapChain</item>     <item>QRhiSwapChainHdrInfo</item>@@ -2117,6 +2160,7 @@     <item>QRhiVulkanCommandBufferNativeHandles</item>     <item>QRhiVulkanInitParams</item>     <item>QRhiVulkanNativeHandles</item>+    <item>QRhiVulkanQueueSubmitParams</item>     <item>QRhiVulkanRenderPassNativeHandles</item>     <item>QRhiWidget</item>     <item>QRomanCalendar</item>@@ -2282,6 +2326,7 @@     <item>QSphereMesh</item>     <item>QSpinBox</item>     <item>QSplashScreen</item>+    <item>QSpline3DSeries</item>     <item>QSplineSeries</item>     <item>QSplitter</item>     <item>QSplitterHandle</item>@@ -2512,6 +2557,7 @@     <item>QTouchDevice</item>     <item>QTouchEvent</item>     <item>QTouchEventSequence</item>+    <item>QTouchEventWidgetSequence</item>     <item>QTransform</item>     <item>QTranslator</item>     <item>QTransposeProxyModel</item>@@ -2565,6 +2611,7 @@     <item>QVideoFilterRunnable</item>     <item>QVideoFrame</item>     <item>QVideoFrameFormat</item>+    <item>QVideoFrameInput</item>     <item>QVideoProbe</item>     <item>QVideoRendererControl</item>     <item>QVideoSink</item>@@ -2648,12 +2695,16 @@     <item>QWebEngineCertificateError</item>     <item>QWebEngineClientCertificateSelection</item>     <item>QWebEngineClientCertificateStore</item>+    <item>QWebEngineClientHints</item>     <item>QWebEngineContextMenuRequest</item>     <item>QWebEngineCookieStore</item>     <item>QWebEngineDesktopMediaRequest</item>     <item>QWebEngineDownloadRequest</item>+    <item>QWebEngineExtensionInfo</item>+    <item>QWebEngineExtensionManager</item>     <item>QWebEngineFileSystemAccessRequest</item>     <item>QWebEngineFindTextResult</item>+    <item>QWebEngineFrame</item>     <item>QWebEngineFullScreenRequest</item>     <item>QWebEngineHistory</item>     <item>QWebEngineHistoryItem</item>@@ -2664,7 +2715,9 @@     <item>QWebEngineNewWindowRequest</item>     <item>QWebEngineNotification</item>     <item>QWebEnginePage</item>+    <item>QWebEnginePermission</item>     <item>QWebEngineProfile</item>+    <item>QWebEngineProfileBuilder</item>     <item>QWebEngineQuotaRequest</item>     <item>QWebEngineRegisterProtocolHandlerRequest</item>     <item>QWebEngineScript</item>@@ -2744,6 +2797,7 @@     <item>QXmlStreamReader</item>     <item>QXmlStreamWriter</item>     <item>QXYLegendMarker</item>+    <item>QXYModelMapper</item>     <item>QXYSeries</item>     <!-- Not actually classes, but used like those -->     <item>QByteArrayLiteral</item>
xml/crystal.xml view
@@ -33,7 +33,7 @@  <!-- Hold the "language" opening tag on a single line, as mentioned in "language.dtd". --> <language name="Crystal" section="Sources"-	  version="0" kateversion="5.0"+	  version="1" kateversion="5.0" 	  extensions="*.cr" 	  mimetype="application/x-crystal" 	  style="crystal" indenter="ruby"@@ -42,6 +42,7 @@ 	<highlighting>  		<list name="keywords">+			<item>alias</item> 			<item>begin</item> 			<item>break</item> 			<item>case</item>@@ -50,13 +51,18 @@ 			<item>elsif</item> 			<item>end</item> 			<item>ensure</item>+			<item>enum</item> 			<item>for</item>+			<item>fun</item> 			<item>if</item> 			<item>in</item>+			<item>lib</item> 			<item>next</item> 			<item>rescue</item> 			<item>return</item> 			<item>then</item>+			<item>type</item>+			<item>union</item> 			<item>unless</item> 			<item>until</item> 			<item>when</item>
+ xml/csv.xml view
@@ -0,0 +1,214 @@+<?xml version="1.0" encoding="UTF-8"?>+<!DOCTYPE language [+  <!ENTITY sep ",">+]>+<!--+Inspired by Rainbow CSV++Language name     | Separator     | Extension | Properties+ CSV              | , (comma)     |   .csv    | Ignored inside double-quoted fields+ TSV              | \t (TAB)      | .tsv .tab |+ CSV (semicolon)  | ; (semicolon) |           | Ignored inside double-quoted fields+ CSV (whitespace) | whitespace    |           | Consecutive whitespaces are merged+ CSV (pipe)       | | (pipe)      |++https://www.rfc-editor.org/rfc/rfc4180++Although the RFC considers this invalid,+the syntax is tolerant of spaces before double quotes.++  aaa, "bbb,ccc", ddd+       ~ RFC: invalid character in non-escaped rule+-->+<language name="CSV" section="Other" version="2" kateversion="5.62" extensions="*.csv" mimetype="text/csv" priority="6" author="Jonathan Poelen (jonathan.poelen@gmail.com)" license="MIT">+  <highlighting>++    <contexts>+      <context name="Column0" lineEndContext="#stay" attribute="Column 0">+        <DetectChar char="&sep;" context="#pop!Column1" attribute="Column 0 Separator"/>+        <RangeDetect char="&quot;" char1="&quot;" context="Column0Quote"/>+        <DetectChar char="&quot;" context="Column0MultiLine"/>+        <IncludeRules context="FindField"/>+      </context>+      <context name="Column0Quote" lineEndContext="#pop" attribute="Column 0" fallthroughContext="#pop">+        <RangeDetect char="&quot;" char1="&quot;"/>+        <DetectChar char="&quot;" context="#pop!Column0MultiLine"/>+        <IncludeRules context="Error"/>+      </context>+      <context name="Column0MultiLine" lineEndContext="#stay" attribute="Column 0">+        <DetectChar char="&quot;" context="#pop!Column0Quote"/>+      </context>++      <context name="Column1" lineEndContext="#pop!Column0" attribute="Column 1">+        <DetectChar char="&sep;" context="#pop!Column2" attribute="Column 1 Separator"/>+        <RangeDetect char="&quot;" char1="&quot;" context="Column1Quote"/>+        <DetectChar char="&quot;" context="Column1MultiLine"/>+        <IncludeRules context="FindField"/>+      </context>+      <context name="Column1Quote" lineEndContext="#pop#pop!Column0" attribute="Column 1" fallthroughContext="#pop">+        <RangeDetect char="&quot;" char1="&quot;"/>+        <DetectChar char="&quot;" context="#pop!Column1MultiLine"/>+        <IncludeRules context="Error"/>+      </context>+      <context name="Column1MultiLine" lineEndContext="#stay" attribute="Column 1">+        <DetectChar char="&quot;" context="#pop!Column1Quote"/>+      </context>++      <context name="Column2" lineEndContext="#pop!Column0" attribute="Column 2">+        <DetectChar char="&sep;" context="#pop!Column3" attribute="Column 2 Separator"/>+        <RangeDetect char="&quot;" char1="&quot;" context="Column2Quote"/>+        <DetectChar char="&quot;" context="Column2MultiLine"/>+        <IncludeRules context="FindField"/>+      </context>+      <context name="Column2Quote" lineEndContext="#pop#pop!Column0" attribute="Column 2" fallthroughContext="#pop">+        <RangeDetect char="&quot;" char1="&quot;"/>+        <DetectChar char="&quot;" context="#pop!Column2MultiLine"/>+        <IncludeRules context="Error"/>+      </context>+      <context name="Column2MultiLine" lineEndContext="#stay" attribute="Column 2">+        <DetectChar char="&quot;" context="#pop!Column2Quote"/>+      </context>++      <context name="Column3" lineEndContext="#pop!Column0" attribute="Column 3">+        <DetectChar char="&sep;" context="#pop!Column4" attribute="Column 3 Separator"/>+        <RangeDetect char="&quot;" char1="&quot;" context="Column3Quote"/>+        <DetectChar char="&quot;" context="Column3MultiLine"/>+        <IncludeRules context="FindField"/>+      </context>+      <context name="Column3Quote" lineEndContext="#pop#pop!Column0" attribute="Column 3" fallthroughContext="#pop">+        <RangeDetect char="&quot;" char1="&quot;"/>+        <DetectChar char="&quot;" context="#pop!Column3MultiLine"/>+        <IncludeRules context="Error"/>+      </context>+      <context name="Column3MultiLine" lineEndContext="#stay" attribute="Column 3">+        <DetectChar char="&quot;" context="#pop!Column3Quote"/>+      </context>++      <context name="Column4" lineEndContext="#pop!Column0" attribute="Column 4">+        <DetectChar char="&sep;" context="#pop!Column5" attribute="Column 4 Separator"/>+        <RangeDetect char="&quot;" char1="&quot;" context="Column4Quote"/>+        <DetectChar char="&quot;" context="Column4MultiLine"/>+        <IncludeRules context="FindField"/>+      </context>+      <context name="Column4Quote" lineEndContext="#pop#pop!Column0" attribute="Column 4" fallthroughContext="#pop">+        <RangeDetect char="&quot;" char1="&quot;"/>+        <DetectChar char="&quot;" context="#pop!Column4MultiLine"/>+        <IncludeRules context="Error"/>+      </context>+      <context name="Column4MultiLine" lineEndContext="#stay" attribute="Column 4">+        <DetectChar char="&quot;" context="#pop!Column4Quote"/>+      </context>++      <context name="Column5" lineEndContext="#pop!Column0" attribute="Column 5">+        <DetectChar char="&sep;" context="#pop!Column6" attribute="Column 5 Separator"/>+        <RangeDetect char="&quot;" char1="&quot;" context="Column5Quote"/>+        <DetectChar char="&quot;" context="Column5MultiLine"/>+        <IncludeRules context="FindField"/>+      </context>+      <context name="Column5Quote" lineEndContext="#pop#pop!Column0" attribute="Column 5" fallthroughContext="#pop">+        <RangeDetect char="&quot;" char1="&quot;"/>+        <DetectChar char="&quot;" context="#pop!Column5MultiLine"/>+        <IncludeRules context="Error"/>+      </context>+      <context name="Column5MultiLine" lineEndContext="#stay" attribute="Column 5">+        <DetectChar char="&quot;" context="#pop!Column5Quote"/>+      </context>++      <context name="Column6" lineEndContext="#pop!Column0" attribute="Column 6">+        <DetectChar char="&sep;" context="#pop!Column7" attribute="Column 6 Separator"/>+        <RangeDetect char="&quot;" char1="&quot;" context="Column6Quote"/>+        <DetectChar char="&quot;" context="Column6MultiLine"/>+        <IncludeRules context="FindField"/>+      </context>+      <context name="Column6Quote" lineEndContext="#pop#pop!Column0" attribute="Column 6" fallthroughContext="#pop">+        <RangeDetect char="&quot;" char1="&quot;"/>+        <DetectChar char="&quot;" context="#pop!Column6MultiLine"/>+        <IncludeRules context="Error"/>+      </context>+      <context name="Column6MultiLine" lineEndContext="#stay" attribute="Column 6">+        <DetectChar char="&quot;" context="#pop!Column6Quote"/>+      </context>++      <context name="Column7" lineEndContext="#pop!Column0" attribute="Column 7">+        <DetectChar char="&sep;" context="#pop!Column8" attribute="Column 7 Separator"/>+        <RangeDetect char="&quot;" char1="&quot;" context="Column7Quote"/>+        <DetectChar char="&quot;" context="Column7MultiLine"/>+        <IncludeRules context="FindField"/>+      </context>+      <context name="Column7Quote" lineEndContext="#pop#pop!Column0" attribute="Column 7" fallthroughContext="#pop">+        <RangeDetect char="&quot;" char1="&quot;"/>+        <DetectChar char="&quot;" context="#pop!Column7MultiLine"/>+        <IncludeRules context="Error"/>+      </context>+      <context name="Column7MultiLine" lineEndContext="#stay" attribute="Column 7">+        <DetectChar char="&quot;" context="#pop!Column7Quote"/>+      </context>++      <context name="Column8" lineEndContext="#pop!Column0" attribute="Column 8">+        <DetectChar char="&sep;" context="#pop!Column9" attribute="Column 8 Separator"/>+        <RangeDetect char="&quot;" char1="&quot;" context="Column8Quote"/>+        <DetectChar char="&quot;" context="Column8MultiLine"/>+        <IncludeRules context="FindField"/>+      </context>+      <context name="Column8Quote" lineEndContext="#pop#pop!Column0" attribute="Column 8" fallthroughContext="#pop">+        <RangeDetect char="&quot;" char1="&quot;"/>+        <DetectChar char="&quot;" context="#pop!Column8MultiLine"/>+        <IncludeRules context="Error"/>+      </context>+      <context name="Column8MultiLine" lineEndContext="#stay" attribute="Column 8">+        <DetectChar char="&quot;" context="#pop!Column8Quote"/>+      </context>++      <context name="Column9" lineEndContext="#pop!Column0" attribute="Column 9">+        <DetectChar char="&sep;" context="#pop!Column0" attribute="Column 9 Separator"/>+        <RangeDetect char="&quot;" char1="&quot;" context="Column9Quote"/>+        <DetectChar char="&quot;" context="Column9MultiLine"/>+        <IncludeRules context="FindField"/>+      </context>+      <context name="Column9Quote" lineEndContext="#pop!Column0" attribute="Column 9" fallthroughContext="#pop">+        <RangeDetect char="&quot;" char1="&quot;"/>+        <DetectChar char="&quot;" context="#pop!Column9MultiLine"/>+        <IncludeRules context="Error"/>+      </context>+      <context name="Column9MultiLine" lineEndContext="#stay" attribute="Column 9">+        <DetectChar char="&quot;" context="#pop!Column9Quote"/>+      </context>++      <context name="FindField" lineEndContext="#stay" attribute="Column 0">+        <DetectSpaces/>+        <RegExpr String="[^&sep;]+"/>+      </context>++      <context name="Error" lineEndContext="#stay" attribute="Error">+        <RegExpr String="[^&sep;]+" context="#pop" attribute="Error"/>+      </context>+    </contexts>++    <itemDatas>+      <itemData name="Column 0" defStyleNum="dsNormal"/>+      <itemData name="Column 1" defStyleNum="dsVariable"/>+      <itemData name="Column 2" defStyleNum="dsString"/>+      <itemData name="Column 3" defStyleNum="dsBuiltIn"/>+      <itemData name="Column 4" defStyleNum="dsPreprocessor"/>+      <itemData name="Column 5" defStyleNum="dsChar"/>+      <itemData name="Column 6" defStyleNum="dsFunction"/>+      <itemData name="Column 7" defStyleNum="dsBaseN"/>+      <itemData name="Column 8" defStyleNum="dsOperator"/>+      <itemData name="Column 9" defStyleNum="dsDataType"/>++      <itemData name="Column 0 Separator" bold="1" defStyleNum="dsNormal"/>+      <itemData name="Column 1 Separator" bold="1" defStyleNum="dsVariable"/>+      <itemData name="Column 2 Separator" bold="1" defStyleNum="dsString"/>+      <itemData name="Column 3 Separator" bold="1" defStyleNum="dsBuiltIn"/>+      <itemData name="Column 4 Separator" bold="1" defStyleNum="dsPreprocessor"/>+      <itemData name="Column 5 Separator" bold="1" defStyleNum="dsChar"/>+      <itemData name="Column 6 Separator" bold="1" defStyleNum="dsFunction"/>+      <itemData name="Column 7 Separator" bold="1" defStyleNum="dsBaseN"/>+      <itemData name="Column 8 Separator" bold="1" defStyleNum="dsOperator"/>+      <itemData name="Column 9 Separator" bold="1" defStyleNum="dsDataType"/>++      <itemData name="Error" defStyleNum="dsError"/>+    </itemDatas>+  </highlighting>+</language>+<!-- kate: space-indent on; indent-width 2; replace-tabs on; -->
+ xml/desktop.xml view
@@ -0,0 +1,34 @@+<?xml version="1.0" encoding="UTF-8"?>+<!DOCTYPE language>+<language name=".desktop" version="6" kateversion="5.0"+          section="Configuration" extensions="*.desktop;*.kdelnk;*.desktop.cmake"+          mimetype="application/x-desktop">+  <highlighting>+    <contexts>+      <context attribute="Key" lineEndContext="#stay" name="Normal">+        <RegExpr String="^\[.*\]$" attribute="Section" context="#stay" beginRegion="Section" endRegion="Section" column="0"/>+        <RegExpr String="\[.*\]" attribute="Language" context="Value"/>+        <DetectChar char="#" attribute="Comment" context="Comment" firstNonSpace="true"/>+        <DetectChar char="=" attribute="Normal Text" context="Value"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="Value"/>+      <context attribute="Comment"     lineEndContext="#pop" name="Comment">+        <DetectSpaces />+        <IncludeRules context="##Comments"/>+      </context>+    </contexts>+    <itemDatas>+      <itemData name="Normal Text" defStyleNum="dsNormal" spellChecking="false"/>+      <itemData name="Section"  defStyleNum="dsKeyword" spellChecking="false"/>+      <itemData name="Key"  defStyleNum="dsDataType" spellChecking="false"/>+      <itemData name="Language"  defStyleNum="dsDecVal" bold="1" spellChecking="false"/>+      <itemData name="Comment" defStyleNum="dsComment"/>+    </itemDatas>+  </highlighting>+  <general>+    <comments>+      <comment name="singleLine" start="#"/>+    </comments>+  </general>+</language>+<!-- kate: replace-tabs on; tab-width 2; indent-width 2; -->
xml/dot.xml view
@@ -1,7 +1,7 @@ <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE language> <!-- Adapted from the VIM highlighter, by Markus Mottl (markus@oefai.at) -->-<language name="dot" version="5" kateversion="5.0" section="Scientific" extensions="*.dot" mimetype="text/x-dot" author="Postula Loïs (lois.postula@live.be)" priority="0">+<language name="dot" alternativeNames="Graphviz" version="6" kateversion="5.0" section="Scientific" extensions="*.dot" mimetype="text/x-dot" author="Postula Loïs (lois.postula@live.be)" priority="0">    <highlighting>
+ xml/elixir-eex.xml view
@@ -0,0 +1,60 @@+<?xml version="1.0" encoding="UTF-8"?>+<!DOCTYPE language [+  <!ENTITY identifier "[a-z][a-zA-Z0-9_]*[!?]?">+]>+<language author="Jade Pfeiffer (jade@pfeiffer.codes)"+          extensions="*.eex"+          indenter="none"+          kateversion="5.79"+          license="MIT"+          mimetype="text/x-elixir+eex"+          name="Elixir/EEx"+          section="Scripts"+          style="eex"+          version="1">+  <highlighting>+    <contexts>+      <context attribute="Normal Text" lineEndContext="#stay" name="Text">+        <!-- Search document using only 2 characters before matching -->+        <Detect2Chars char="&lt;" char1="%" context="Tag" lookAhead="true"/>+      </context>+      <context attribute="Normal Text" name="Tag">+        <!-- Comments: they are discarded from source -->+        <StringDetect String="&lt;%!--" attribute="Comment" context="#pop!Comment" beginRegion="comment" />+        <!-- EEx Quotation: returns the contents inside the tag as is -->+        <StringDetect String="&lt;%%" attribute="Quotation" context="#pop!Quotation" />+        <!-- Elixir expression: executes code and prints result -->+        <StringDetect String="&lt;%=" attribute="Tag" context="#pop!Expression" />+        <!-- Additional tags that are supported but don't have special meaning by default -->+        <StringDetect String="&lt;%|" attribute="Tag" context="#pop!Expression" />+        <StringDetect String="&lt;%/" attribute="Tag" context="#pop!Expression" />+        <!-- Elixir Expression: executes code but discards output -->+        <Detect2Chars char="&lt;" char1="%" attribute="Tag" context="#pop!Expression" />+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="Expression">+        <Detect2Chars char="%" char1="&gt;" attribute="Tag" context="#pop"/>+        <RegExpr String="@&identifier;" attribute="Assigns" context="#stay" />+        <IncludeRules context="Normal##Elixir" />+      </context>+      <context attribute="Quotation" lineEndContext="#stay" name="Quotation">+        <Detect2Chars char="%" char1="&gt;" attribute="Quotation" context="#pop"/>+      </context>+      <context attribute="Comment" lineEndContext="#stay" name="Comment">+        <StringDetect String="--%&gt;" attribute="Comment" context="#pop" endRegion="comment" />+      </context>+    </contexts>+    <itemDatas>+      <itemData defStyleNum="dsNormal"         name="Normal Text" spellChecking="false"/>+      <itemData defStyleNum="dsBuiltIn"        name="Tag"/>+      <itemData defStyleNum="dsVerbatimString" name="Quotation"/>+      <itemData defStyleNum="dsComment"        name="Comment"/>+      <itemData defStyleNum="dsFunction"       name="Assigns"/>+    </itemDatas>+  </highlighting>+  <general>+    <comments>+      <comment name="multiLine" start="&lt;%!--" end="--%&gt;" region="comment" />+    </comments>+  </general>+</language>+<!-- kate: replace-tabs on; tab-width 2; indent-width 2; -->
+ xml/elixir-heex.xml view
@@ -0,0 +1,248 @@+<?xml version="1.0" encoding="UTF-8"?>+<!DOCTYPE language [+  <!ENTITY identifier "[a-z][a-zA-Z0-9_]*[!?]?">+  <!ENTITY module "[A-Z][a-zA-Z0-9_]*">+  <!ENTITY attributename "[A-Za-z_:*#\(\[][\)\]\w.:_-]*">+  <!ENTITY htmltag "[A-Za-z_:][\w.:_-]*">+]>+<language author="Jade Pfeiffer (jade@pfeiffer.codes)"+          extensions="*.html.heex;*.heex"+          indenter="xml"+          kateversion="5.79"+          license="MIT"+          mimetype="text/x-elixir+heex"+          name="Elixir/HEEx"+          section="Scripts"+          style="heex"+          version="1">+  <highlighting>+    <list name="comprehensions">+      <item>let</item>+      <item>for</item>+      <item>if</item>+    </list>+    <list name="phx-variables">+      <item>assigns</item>+    </list>+    <list name="phx-bindings">+      <item>phx-click</item>+      <item>phx-click-away</item>+      <item>phx-change</item>+      <item>phx-submit</item>+      <item>phx-disable-with</item>+      <item>phx-trigger-action</item>+      <item>phx-auto-recover</item>+      <item>phx-blur</item>+      <item>phx-focus</item>+      <item>phx-window-blur</item>+      <item>phx-window-focus</item>+      <item>phx-keydown</item>+      <item>phx-keyup</item>+      <item>phx-window-keydown</item>+      <item>phx-window-keyup</item>+      <item>phx-key</item>+      <item>phx-viewport-top</item>+      <item>phx-viewport-bottom</item>+      <item>phx-update</item>+      <item>phx-mounted</item>+      <item>phx-remove</item>+      <item>phx-hook</item>+      <item>phx-connected</item>+      <item>phx-disconnected</item>+      <item>phx-debounce</item>+      <item>phx-throttle</item>+      <item>phx-track-static</item>+    </list>+    <contexts>+      <context attribute="Normal Text" lineEndContext="#stay" name="Text">+        <DetectChar char="&lt;" context="Tags" lookAhead="true"/>+        <IncludeRules context="Interpolated" />+        <DetectSpaces />+      </context>++      <context attribute="Normal Text" name="Tags">+        <!-- Hook into existing HTML definitions here so there is still control over attributes -->+        <Detect2Chars char="&lt;" char1="!" context="#pop!HTML Special" lookAhead="true" />+        <Detect2Chars char="&lt;" char1="/" attribute="Symbol" context="#pop!End Tags" />+        <!-- HEEx is still an EEx template, those rules can be inherited -->+        <IncludeRules context="Tag##Elixir/EEx" />+        <!-- Now Match -->+        <Detect2Chars char="&lt;" char1="." attribute="Symbol" context="#pop!Tag Name Component" />+        <Detect2Chars char="&lt;" char1=":" attribute="Symbol" context="#pop!Tag Name Slot" />+        <DetectChar char="&lt;" context="#pop!Tag Name" attribute="Symbol" />+      </context>+      <context attribute="Symbol" fallthroughContext="#pop!Tag Name End" name="End Tags">+        <DetectChar char="." attribute="Symbol" context="#pop!Tag Name End Component" />+        <DetectChar char=":" attribute="Symbol" context="#pop!Tag Name End Slot" />+      </context>++      <!-- Tag Name handling -->+      <context attribute="Element" name="Tag Name">+        <RegExpr String="&module;" attribute="Module" context="#pop!Tag Name Module"/>+        <WordDetect String="script" attribute="Element" context="#pop!Script Tag" />+        <WordDetect String="style" attribute="Element" context="#pop!Style Tag" />+        <RegExpr String="&htmltag;" attribute="Element" context="#pop!Tag Body" />+      </context>+      <context attribute="Element" name="Tag Name End">+        <RegExpr String="&module;" attribute="Module" context="#pop!Tag Name End Module"/>+        <RegExpr String="&htmltag;" attribute="Element" context="#pop!Tag End" />+      </context>++      <!-- Tag Module Name -->+      <context attribute="Normal Text" name="Tag Module">+        <DetectChar char="." context="#stay" />+        <RegExpr String="&module;" attribute="Module" context="#stay"/>+      </context>+      <context attribute="Normal Text" fallthroughContext="#pop!Tag Body" name="Tag Name Module">+        <IncludeRules context="Tag Module" />+        <IncludeRules context="Tag Name Component" />+      </context>+      <context attribute="Normal Text" fallthroughContext="#pop!Tag End" name="Tag Name End Module">+        <IncludeRules context="Tag Module" />+        <IncludeRules context="Tag Name End Component" />+      </context>++      <!-- Tag Component -->+      <context attribute="Normal Text" fallthroughContext="#pop!Tag Body" name="Tag Name Component">+        <RegExpr String="&identifier;" attribute="Function" context="#pop!Tag Body" />+      </context>+      <context attribute="Normal Text" fallthroughContext="#pop!Tag End" name="Tag Name End Component">+        <RegExpr String="&identifier;" attribute="Function" context="#pop!Tag End" />+      </context>+      <!-- Tag Component Slot -->+      <context attribute="Normal Text" fallthroughContext="#pop!Tag Body" name="Tag Name Slot">+        <RegExpr String="&identifier;" attribute="Symbol" context="#pop!Tag Body" />+      </context>+      <context attribute="Normal Text" fallthroughContext="#pop!Tag End" name="Tag Name End Slot">+        <RegExpr String="&identifier;" attribute="Symbol" context="#pop!Tag End" />+      </context>++      <!-- Tag Body -->+      <context attribute="Normal Text" lineEndContext="#stay" name="Tag Body">+        <IncludeRules context="Tag End" />+        <IncludeRules context="Attributes" />+        <IncludeRules context="Interpolated" />+        <DetectSpaces />+      </context>++      <!-- End Tag, include-only -->+      <context attribute="Normal Text" name="Tag End">+        <Detect2Chars char="/" char1="&gt;" attribute="Symbol" context="#pop"/>+        <DetectChar char="&gt;" attribute="Symbol" context="#pop" />+      </context>++      <!-- <script> Tags -->+      <context attribute="Normal Text" name="Script Tag">+        <Detect2Chars char="/" char1="&gt;" attribute="Symbol" context="#pop"/>+        <DetectChar char="&gt;" attribute="Symbol" context="#pop!Script" />+        <IncludeRules context="Attributes" />+        <IncludeRules context="Interpolated" />+        <DetectSpaces />+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="Script">+        <StringDetect String="&lt;/script>" context="#pop!Script Tag End" lookAhead="true" />+        <IncludeRules context="Text##Elixir/EEx" />+        <DetectChar attribute="String" context="Script String" char="&quot;" />+        <IncludeRules context="Normal##JavaScript" />+      </context>+      <context attribute="Normal Text" name="Script Tag End">+        <Detect2Chars char="&lt;" char1="/" attribute="Symbol" context="#stay" />+        <StringDetect String="script" attribute="Element" context="#stay" />+        <DetectChar char="&gt;" attribute="Symbol" context="#pop" />+      </context>+      <context attribute="Normal Text" name="Script String">+        <DetectChar attribute="String" context="#pop" char="&quot;" />+        <IncludeRules context="Text##Elixir/EEx" />+        <IncludeRules context="String##JavaScript" />+      </context>++      <!-- <style> Tags -->+      <context attribute="Normal Text" name="Style Tag">+        <Detect2Chars char="/" char1="&gt;" attribute="Symbol" context="#pop"/>+        <DetectChar char="&gt;" attribute="Symbol" context="#pop!Style" />+        <IncludeRules context="Attributes" />+        <IncludeRules context="Interpolated" />+        <DetectSpaces />+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="Style">+        <StringDetect String="&lt;/style>" context="#pop!Style Tag End" lookAhead="true" />+        <IncludeRules context="Text##Elixir/EEx" />+        <IncludeRules context="Base##CSS" />+      </context>+      <context attribute="Normal Text" name="Style Tag End">+        <Detect2Chars char="&lt;" char1="/" attribute="Symbol" context="#stay" />+        <StringDetect String="style" attribute="Element" context="#stay" />+        <DetectChar char="&gt;" attribute="Symbol" context="#pop" />+      </context>++      <!-- Tag Attributes -->+      <context attribute="Attribute" name="Attributes">+        <DetectChar char=":" attribute="Control Flow" context="Attribute BuiltIn" />+        <StringDetect String="phx-" context="Phoenix Binding" lookAhead="true" />+        <RegExpr String="&attributename;" attribute="Attribute" context="Attribute Equals" />+      </context>+      <context attribute="Control Flow" name="Attribute BuiltIn" fallthroughContext="#pop!Attribute Equals">+        <keyword String="comprehensions" attribute="Control Flow" context="#pop!Attribute Equals" />+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" fallthroughContext="#pop"  name="Attribute Equals">+        <DetectChar char="=" attribute="Operator" context="#pop!Attribute Value" />+      </context>+      <context attribute="String" lineEndContext="#stay" name="Attribute Value">+        <DetectChar char="&quot;" context="#pop!Attribute Value Quote" />+        <DetectChar char="{" attribute="String" context="#pop!Interpolate" beginRegion="interpolate"/>+        <DetectSpaces />+      </context>+      <context attribute="String" name="Attribute Value Quote">+        <DetectChar char="&quot;" attribute="String" context="#pop" />+        <IncludeRules context="FindEntityRefs##HTML" />+      </context>+      <context attribute="Symbol" name="Phoenix Binding">+        <keyword String="phx-bindings" attribute="Symbol" context="#pop!Attribute Equals" />+        <RegExpr String="phx-value-&attributename;" attribute="Symbol" context="#pop!Attribute Equals" />+        <RegExpr String="phx-(&attributename;)?" attribute="Normal Text" context="#pop!Attribute Equals" />+      </context>++      <context attribute="Normal Text" name="HTML Special">+        <IncludeRules context="FindHTML##HTML" />+      </context>++      <context attribute="Normal Text" name="Interpolated">+        <DetectChar char="{" attribute="String" context="Interpolate" beginRegion="interpolate"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="Interpolate">+        <!-- Add Phoenix-specific terms for the template -->+        <RegExpr String="@&identifier;" attribute="Assigns" context="#stay" />+        <keyword String="phx-variables" attribute="Assigns" context="#stay"/>++        <DetectChar char="{" beginRegion="map_or_struct_or_tuple" attribute="Braces" context="Interpolate Scope"/>+        <DetectChar char="}" attribute="String" context="#pop" endRegion="interpolate" />+        <IncludeRules context="Normal##Elixir" />+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="Interpolate Scope">+        <DetectChar char="}" attribute="String" context="#pop" endRegion="map_or_struct_or_tuple" />+        <IncludeRules context="Interpolate" />+      </context>+    </contexts>+    <itemDatas>+      <itemData defStyleNum="dsNormal"    name="Normal Text" spellChecking="false"/>+      <itemData defStyleNum="dsNormal"    name="Braces"/>+      <itemData defStyleNum="dsBuiltIn"   name="Symbol"/>+      <itemData defStyleNum="dsKeyword"   name="Element"/>+      <itemData defStyleNum="dsOperator"  name="Operator"/>+      <itemData defStyleNum="dsExtension" name="Control Flow"/>+      <itemData defStyleNum="dsString"    name="String"/>+      <itemData defStyleNum="dsNormal"    name="Module"/>+      <itemData defStyleNum="dsFunction"  name="Function"/>+      <itemData defStyleNum="dsOthers"    name="Assigns"/>+      <itemData defStyleNum="dsNormal"    name="Attribute"/>+    </itemDatas>+  </highlighting>+  <general>+    <comments>+      <!-- Same comments from Elixir/EEx -->+      <comment name="multiLine" start="&lt;%!--" end="--%&gt;" region="comment" />+    </comments>+    <keywords weakDeliminator=":-" />+  </general>+</language>+<!-- kate: replace-tabs on; tab-width 2; indent-width 2; -->
xml/elixir.xml view
@@ -1,12 +1,14 @@ <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE language [-  <!ENTITY symbols "(?:@{1,2}|\$)?[a-zA-Z_][a-zA-Z0-9_]*[=?!]?">+  <!ENTITY identifier "[a-z][a-zA-Z0-9_]*">+  <!ENTITY module "[A-Z][a-zA-Z0-9_]*"> ]> <!--   Elixir syntax highlighting definition for Kate.    Copyright (C) 2014  by Rubén Caro (ruben.caro.estevez@gmail.com)   Copyright (C) 2016  by Boris Egorov (egorov@linux.com)+  Copyright (C) 2025  by Jade Pfeiffer (jade@pfeiffer.codes)    This library is free software; you can redistribute it and/or   modify it under the terms of the GNU Library General Public@@ -22,8 +24,8 @@   Boston, MA  02110-1301, USA. --> <!-- Hold the "language" opening tag on a single line, as mentioned in "language.dtd". -->-<language author="Rubén Caro (ruben.caro.estevez@gmail.com), Boris Egorov (egorov@linux.com)"-          extensions="*.ex;*.exs;*.eex;*.xml.eex;*.js.eex;*.heex"+<language author="Rubén Caro (ruben.caro.estevez@gmail.com), Boris Egorov (egorov@linux.com), Jade Pfeiffer (jade@pfeiffer.codes)"+          extensions="*.ex;*.exs"           indenter="elixir"           kateversion="5.79"           license="LGPLv2+"@@ -31,7 +33,7 @@           name="Elixir"           section="Sources"           style="elixir"-          version="15"+          version="16"           priority="2">   <highlighting>     <list name="control-flow">@@ -40,6 +42,7 @@       <item>else</item>       <item>if</item>       <item>raise</item>+      <item>reraise</item>       <item>rescue</item>       <item>throw</item>       <item>try</item>@@ -47,44 +50,42 @@     </list>     <list name="keywords">       <item>case</item>-      <item>bc</item>-      <item>lc</item>+      <item>with</item>       <item>for</item>       <item>receive</item>-      <item>exit</item>       <item>after</item>       <item>quote</item>       <item>unquote</item>+      <item>unquote_splicing</item>       <item>super</item>       <item>and</item>       <item>not</item>       <item>or</item>       <item>when</item>-      <item>xor</item>       <item>in</item>-      <item>inlist</item>-      <item>inbits</item>     </list>-    <list name="pseudo-variables">+    <list name="atoms">       <item>nil</item>       <item>true</item>       <item>false</item>     </list>     <list name="definitions">       <item>defmodule</item>-      <item>def</item>-      <item>defp</item>       <item>defprotocol</item>       <item>defimpl</item>       <item>defrecord</item>       <item>defstruct</item>+      <item>defexception</item>+      <item>defoverridable</item>+    </list>+    <list name="def-functions">+      <item>def</item>+      <item>defp</item>       <item>defmacro</item>       <item>defmacrop</item>+      <item>defguard</item>+      <item>defguardp</item>       <item>defdelegate</item>-      <item>defcallback</item>-      <item>defmacrocallback</item>-      <item>defexception</item>-      <item>defoverridable</item>     </list>     <list name="mixin-macros">       <item>import</item>@@ -92,148 +93,435 @@       <item>alias</item>       <item>use</item>     </list>+    <list name="special-forms">+      <item>__MODULE__</item>+      <item>__ENV__</item>+      <item>__DIR__</item>+      <item>__STACKTRACE__</item>+      <item>__CALLER__</item>+    </list>+    <list name="module-attributes">+      <item>after_compile</item>+      <item>after_verify</item>+      <item>before_compile</item>+      <item>behaviour</item>+      <item>callback</item>+      <item>compile</item>+      <item>deprecated</item>+      <item>dialyzer</item>+      <item>external_resource</item>+      <item>file</item>+      <item>impl</item>+      <item>nifs</item>+      <item>on_definition</item>+      <item>on_load</item>+      <item>vsn</item>+    </list>+    <list name="struct-attributes">+      <item>derive</item>+      <item>enforce_keys</item>+    </list>+    <list name="typespec-attributes">+      <item>type</item>+      <item>typep</item>+      <item>opaque</item>+      <item>spec</item>+      <item>callback</item>+      <item>macrocallback</item>+      <item>optional_callbacks</item>+    </list>     <contexts>       <context attribute="Normal Text" lineEndContext="#stay" name="Normal">-        <!-- "shebang" line -->-        <RegExpr String="^#!\/.*" attribute="Keyword" column="0" context="#stay"/>--        <!-- End terminated blocks -->-        <!-- can be started by do or fn, but not by do: -->-        <RegExpr String="\bdo\b(?!:)" attribute="Keyword" beginRegion="doend_block"/>-        <WordDetect String="fn" attribute="Keyword" beginRegion="doend_block"/>-        <WordDetect String="end" attribute="Keyword" endRegion="doend_block"/>-         <!-- Lists -->-        <DetectChar char="[" beginRegion="list" attribute="Separator Array"/>-        <DetectChar char="]" endRegion="list" attribute="Separator Array"/>+        <DetectChar char="[" beginRegion="list" attribute="Braces"/>+        <DetectChar char="]" endRegion="list" attribute="Braces"/> -        <!-- Maps and Structs and tuples -->-        <DetectChar char="{" beginRegion="map_or_struct_or_tuple" attribute="Separator Pair"/>-        <DetectChar char="}" endRegion="map_or_struct_or_tuple" attribute="Separator Pair"/>+        <!-- Maps, Structs and Tuples -->+        <DetectChar char="%" attribute="Braces" context="Map Or Struct"/>+        <DetectChar char="{" beginRegion="map_or_struct_or_tuple" attribute="Braces"/>+        <DetectChar char="}" endRegion="map_or_struct_or_tuple" attribute="Braces"/>          <!-- Function calls and definitions -->-        <DetectChar char="(" beginRegion="parameters" attribute="Separator Pair"/>-        <DetectChar char=")" endRegion="parameters" attribute="Separator Pair"/>-+        <DetectChar char="(" beginRegion="parameters" attribute="Braces"/>+        <DetectChar char=")" endRegion="parameters" attribute="Braces"/>          <!-- Defined words -->         <keyword String="keywords" attribute="Keyword" context="#stay"/>         <keyword String="control-flow" attribute="Control Flow" context="#stay"/>         <keyword String="definitions" attribute="Definition" context="#stay"/>-        <keyword String="pseudo-variables" attribute="Pseudo variable" context="#stay"/>+        <keyword String="def-functions" attribute="Definition" context="Function Definition"/>+        <keyword String="atoms" attribute="Atom" context="#stay"/>         <keyword String="mixin-macros" attribute="Mixin macros" context="#stay"/>+        <keyword String="special-forms" attribute="Built In" context="#stay"/> -        <!-- special-character globals -->-        <RegExpr String="\b[_A-Z]+[A-Z_0-9]+\b" attribute="Global Constant" context="#stay"/>+        <!-- Numeric values. -->+        <DetectChar char="0" context="Numeric" lookAhead="true"/>+        <AnyChar String="123456789" context="Int" lookAhead="true"/> +        <DetectChar char="," attribute="Normal Text" context="#stay"/>+        <DetectChar char="?" context="CharacterLiteral" lookAhead="true"/>+        <IncludeRules context="Sigils"/>+        <Detect2Chars char=":" char1=":" attribute="Operator" context="#stay"/>+        <DetectChar char=":" attribute="Atom" context="AtomValue"/>++        <AnyChar String=".=+-*/\!^:|&amp;&lt;&gt;" context="Operators" lookAhead="true"/>+        <StringDetect String="&quot;&quot;&quot;" attribute="String" context="Heredoc"/>+        <DetectChar char="&quot;" attribute="String" context="Bitstring" lookAhead="true"/>+        <DetectChar char="'" attribute="Charlist" context="Charlist"/>+        <DetectChar char="#" attribute="Comment" context="Line Comment"/>+        <DetectChar char="@" context="Module Attribute" lookAhead="true"/>++        <!-- Identifiers -->+        <DetectChar char="_" context="Underscore" lookAhead="true"/>         <!-- Generally a module or class name like "File", "MyModule_1", .. -->-        <RegExpr String="\b[A-Z]+_*(?:[0-9]|[a-z])[_a-zA-Z0-9]*\b" attribute="Constant" context="#stay"/>+        <RegExpr String="&module;" attribute="Module" context="#stay"/>+        <RegExpr String="(&identifier;[?!]?)" context="Identifier" lookAhead="true"/>+        <DetectSpaces/>+      </context> -        <!-- Numeric values. Note that we have to allow underscores between two digits (thus the creepy regular expressions). -->-        <RegExpr String="\b\-?0[xX](?:[0-9a-fA-F]|_[0-9a-fA-F])+" attribute="Hex" context="#stay"/>-        <RegExpr String="\b\-?0[bB](?:[01]|_[01])+" attribute="Bin" context="#stay"/>-        <RegExpr String="\b\-?0[1-7](?:[0-7]|_[0-7])*" attribute="Octal" context="#stay"/>-        <RegExpr String="\b\-?[0-9](?:[0-9]|_[0-9])*\.[0-9](?:[0-9]|_[0-9])*(?:[eE]\-?[1-9](?:[0-9]|_[0-9])*(?:\.[0-9]*)?)?" attribute="Float" context="#stay"/>-        <RegExpr String="\b\-?[1-9](?:[0-9]|_[0-9])*\b" attribute="Dec" context="#stay"/>-        <Int attribute="Dec" context="#stay"/>-        <HlCChar attribute="Char" context="#stay"/>-        <DetectChar attribute="Operator" char="." context="#stay"/>-        <Detect2Chars attribute="Operator" char="&amp;" char1="&amp;" context="#stay"/>-        <Detect2Chars attribute="Operator" char="|" char1="|" context="#stay"/>-        <!-- \s!|/=\s is regexp hack -->-        <RegExpr String="\s[\?\:\%]\s|[|&amp;&lt;&gt;\^\+*~\-=/]+|\s!|/=\s" attribute="Operator" context="#stay"/>-        <Detect2Chars char="%" char1="=" attribute="Operator" context="#stay"/>-        <RegExpr String=":&symbols;|\b&symbols;:|:\[\]=?" attribute="Symbol" context="#stay"/>-        <RegExpr String="@(?:module)?doc\s+&quot;&quot;&quot;" attribute="Attribute" context="Documentation"/>-        <StringDetect String="&quot;&quot;&quot;" attribute="String" context="Triple Quoted String"/>-        <DetectChar attribute="String" char="&quot;" context="Quoted String"/>-        <DetectChar attribute="Raw String" char="'" context="Apostrophed String"/>-        <Detect2Chars char="?" char1="#" attribute="Normal Text" context="#stay"/>-        <DetectChar attribute="Comment" char="#" context="General Comment"/>-        <RegExpr String="@[a-zA-Z_0-9]+" attribute="Attribute" context="#stay"/>-        <!-- handle the different regular expression formats -->-        <DetectIdentifier attribute="Normal Text" context="#stay"/>+      <context attribute="Normal Text" fallthroughContext="#pop" name="Map Or Struct">+        <DetectChar char="{" context="#pop" lookAhead="true"/>+        <keyword String="special-forms" attribute="Built In" context="#stay"/>+        <RegExpr String="_*&module;" attribute="Module" context="#stay"/>       </context>-      <context attribute="DocComment" lineEndContext="#stay" name="Documentation">-        <StringDetect String="&quot;&quot;&quot;" attribute="Attribute" context="#pop"/>-        <RegExpr attribute="MarkdownHead" String="^\s*#+\s.*[#]?$" column="0"/>-        <RegExpr attribute="MarkdownBullet" String="^\s*[\*\+\-]\s" column="0"/>-        <RegExpr attribute="MarkdownNumlist" String="^\s*[\d]+\.\s" column="0"/>-        <RegExpr attribute="MarkdownCode" context="Markdown Code" String="^\s*\`\`\`\s*$" column="0"/>-        <DetectSpaces />-        <IncludeRules context="Normal Text##Markdown"/>++      <!-- Operators -->+      <context attribute="Operator" fallthroughContext="#pop" name="Operators">+        <Detect2Chars char="=" char1=">" attribute="Operator" context="#pop"/>+        <Detect2Chars char=":" char1=":" attribute="Operator" context="#pop"/>+        <AnyChar String="&lt;&gt;" context="Arrows" lookAhead="true"/>+        <StringDetect String="..." attribute="Operator" context="#pop"/>+        <Detect2Chars char="." char1="." attribute="Operator" context="#pop"/>+        <DetectChar char="." attribute="Normal Text" context="#pop"/>+        <AnyChar String="=+-*/\!^:|&amp;~" context="Atomable Operators" lookAhead="true"/>       </context>-      <context attribute="String" lineEndContext="#stay" name="Triple Quoted String">+      <context attribute="Error" fallthroughContext="#pop" name="Atomable Operators">+        <Detect2Chars char="*" char1="*" context="#pop"/>+        <Detect2Chars char="=" char1="~" context="#pop"/>+        <Detect2Chars char="\" char1="\" context="#pop"/>+        <Detect2Chars char="|" char1="&gt;" context="#pop"/>+        <Detect2Chars char="-" char1="&gt;" context="#pop"/>+        <Detect2Chars char="&gt;" char1="=" context="#pop"/>+        <AnyChar String="*/^" context="#pop"/>+        <RegExpr String="([\+\-\=\|\!\&amp;])(?:\1\1?)?|&lt;(?:&lt;&lt;|~?&gt;|&lt;?~|[-=])?|(?:[~&gt;]&gt;&gt;|[~=]?&gt;)" context="#pop"/>+      </context>+      <context attribute="Operator" fallthroughContext="#pop!Atomable Operators" name="Arrows">+        <StringDetect String="&lt;&lt;&lt;" attribute="Operator" context="#pop"/>+        <StringDetect String="&gt;&gt;&gt;" attribute="Operator" context="#pop"/>+        <StringDetect String="&lt;&lt;" attribute="Braces" context="#pop" beginRegion="bitstring"/>+        <StringDetect String="&gt;&gt;" attribute="Braces" context="#pop" endRegion="bitstring"/>+      </context>++      <!-- Numeric Literals -->+      <context attribute="Integer" lineEndContext="#pop" fallthroughContext="#pop" name="Numeric">+        <Detect2Chars char="0" char1="b" attribute="Bin" context="#pop!Base Bin"/>+        <Detect2Chars char="0" char1="x" attribute="Hex" context="#pop!Base Hex"/>+        <Detect2Chars char="0" char1="o" attribute="Octal" context="#pop!Base Oct"/>+        <Detect2Chars char="0" char1="." attribute="Float" context="#pop!Float Point"/>+        <DetectChar char="0" attribute="Integer" context="#pop!Int" lookAhead="true"/>+      </context>+      <context attribute="Hex" lineEndContext="#pop" fallthroughContext="#pop" name="Base Hex">+        <AnyChar String="0123456789ABCDEFabcdef" context="#stay"/>+        <RegExpr String="_[\dA-F]+" insensitive="true" context="#stay"/>+      </context>+      <context attribute="Octal" lineEndContext="#pop" fallthroughContext="#pop" name="Base Oct">+        <AnyChar String="01234567" context="#stay"/>+        <RegExpr String="_[0-7]+" context="#stay"/>+      </context>+      <context attribute="Bin" lineEndContext="#pop" fallthroughContext="#pop" name="Base Bin">+        <AnyChar String="01" context="#stay"/>+        <Detect2Chars char="_" char1="1" context="#stay"/>+        <Detect2Chars char="_" char1="0" context="#stay"/>+      </context>++      <context attribute="Integer" lineEndContext="#pop" fallthroughContext="#pop" name="Int">+        <RegExpr String="\d+(_\d+)*\.[^\.]" attribute="Float" context="#pop!Float Point"/>+        <AnyChar String="0123456789" context="#stay"/>+        <RegExpr String="_\d+" context="#stay"/>+        <Detect2Chars char="." char1="." context="#pop!Operators"/>+        <DetectChar char="." context="#pop!Float Point"/>+      </context>+      <context attribute="Float" lineEndContext="#pop" fallthroughContext="#pop" name="Float Point">+        <AnyChar String="0123456789" context="#stay"/>+        <RegExpr String="_\d+" context="#stay"/>+        <Detect2Chars char="e" char1="-" context="#pop!Scientific Notation"/>+        <DetectChar char="e" context="#pop!Scientific Notation"/>+      </context>+      <context attribute="Float" lineEndContext="#pop" fallthroughContext="#pop" name="Scientific Notation">+        <AnyChar String="0123456789" context="#stay"/>+        <RegExpr String="_\d+" context="#stay"/>+      </context>++      <context attribute="Char Literal" fallthroughContext="#pop" name="CharacterLiteral">+        <RegExpr String="\?(\\\S|[^\s\\])" attribute="Char Literal" context="#pop"/>+        <Detect2Chars char="?" char1="\" attribute="Error" context="#pop"/>+      </context>++      <!-- Variables, Functions, Keywords -->+      <context attribute="Variable Underscore" name="Underscore">+        <RegExpr String="_*&identifier;[?!]?" attribute="Variable Underscore" context="#pop"/>+        <DetectChar char="_" attribute="Variable Underscore" context="#pop"/>+      </context>+      <context attribute="Variable" fallthroughContext="#pop" name="Identifier">+        <RegExpr String="(%1)\(" context="#pop!Function" lookAhead="true" dynamic="true"/>+        <RegExpr String="%1:(?!:)" attribute="Atom" context="#pop" dynamic="true"/>++        <!-- End terminated blocks -->+        <WordDetect String="do" attribute="Keyword" beginRegion="doend_block"/>+        <WordDetect String="fn" attribute="Keyword" beginRegion="doend_block"/>+        <WordDetect String="end" attribute="Keyword" endRegion="doend_block"/>++        <StringDetect String="%1" attribute="Variable" context="#pop" dynamic="true"/>+        <DetectSpaces lookAhead="true" context="#pop"/>+      </context>+      <context attribute="Function" fallthroughContext="#pop" name="Function">+        <StringDetect String="%1" attribute="Function" context="#pop" dynamic="true"/>+        <DetectChar char="(" context="#pop" beginRegion="parameters" attribute="Braces"/>+      </context>+      <context attribute="Function" fallthroughContext="#pop" name="Function Definition">+        <RegExpr String="_*&identifier;[?!]?" attribute="Function" context="#pop"/>+        <DetectSpaces attribute="Normal Text"/>+      </context>++      <context attribute="Attribute" lineEndContext="#pop" name="Module Attribute">+        <RegExpr String="(@(?:module|type)?doc)" context="#pop!Doc" lookAhead="true"/>+        <DetectChar char="@" attribute="Normal Text" context="#stay"/>+        <keyword String="module-attributes" attribute="Built In" context="#stay"/>+        <keyword String="struct-attributes" attribute="Built In" context="#stay"/>+        <keyword String="typespec-attributes" attribute="Built In" context="#stay"/>+        <RegExpr String="(&identifier;[?!]?)" attribute="Normal Text" context="#pop"/>+        <DetectSpaces context="#pop"/>+      </context>++      <!-- @moduledoc, @typedoc, and @doc -->+      <context attribute="Attribute" lineEndContext="#pop" fallthroughContext="#pop" name="Doc">+        <RegExpr String="%1 (?:~[Ss])?(&quot;(?:&quot;&quot;)?)" context="#pop!Doc Interp" beginRegion="doc_comment" dynamic="true"/>+        <StringDetect String="%1" context="#pop" dynamic="true"/>+      </context>+      <context attribute="DocComment" lineEndContext="#stay" name="Doc Interp">+        <StringDetect String="%1" attribute="DocComment" context="#pop" endRegion="doc_comment" dynamic="true"/>+        <IncludeRules context="Interpolated"/>+        <IncludeRules context="Markdown"/>+      </context>++      <!-- Atoms (keys: and :values) -->+      <context attribute="Atom" fallthroughContext="#pop!AtomOperator" name="AtomValue">+        <RegExpr String="(&quot;|')" attribute="Atom" context="#pop!Quoted Atom"/>+        <RegExpr String="(?:_|&identifier;)" attribute="Atom" context="#pop!AtomNodeName"/>+      </context>+      <context attribute="Atom" lineEndContext="#pop" fallthroughContext="#pop" name="AtomNodeName">+        <!-- Used for Node names -->+        <AnyChar String="!?" attribute="Atom" context="#pop"/>+        <RegExpr String="&identifier;|@[a-zA-Z0-9_]*(\.&identifier;)*" attribute="Atom" context="#stay"/>+      </context>+      <context attribute="Atom" lineEndContext="#pop" fallthroughContext="#pop" name="AtomOperator">+        <DetectChar char="@" attribute="Atom" context="#pop"/>+        <Detect2Chars char="{" char1="}" attribute="Atom" context="#pop"/>+        <StringDetect String="%{}" attribute="Atom" context="#pop"/>+        <StringDetect String="&lt;&lt;&gt;&gt;" attribute="Atom" context="#pop"/>+        <StringDetect String="..." attribute="Atom" context="#pop"/>+        <Detect2Chars char="." char1="." attribute="Atom" context="#pop"/>+        <DetectChar char="." attribute="Atom" context="#pop"/>+        <AnyChar String=".=+-*/\!^~:|&amp;&lt;&gt;" context="AtomValue Operator" lookAhead="true"/>+      </context>+      <context attribute="Error" fallthroughContext="#pop"  name="AtomValue Operator">+        <IncludeRules context="Atomable Operators"/>+      </context>+      <context attribute="Atom" lineEndContext="#stay" name="Quoted Atom">+        <StringDetect String="%1" attribute="Atom" context="#pop" dynamic="true"/>+        <IncludeRules context="Interpolated"/>+      </context>+      <context attribute="Atom" name="Atom Bitstring Key">+        <DetectChar char="&quot;" attribute="Atom" context="#pop!Atom Bitstring Key Body"/>+      </context>+      <context attribute="Atom" name="Atom Bitstring Key Body">+        <Detect2Chars char="&quot;" char1=":" attribute="Atom" context="#pop"/>+        <IncludeRules context="Interpolated"/>+      </context>++      <context attribute="DocComment" name="Markdown">+        <RegExpr String="^(\s*)#{1,7}\s" context="Markdown Header" column="0" lookAhead="true"/>+        <RegExpr String="^\s*([\+\-\*]|\d+\.)\s" attribute="MarkdownMark" column="0"/>+        <RegExpr String="`.+`" context="Markdown Code" minimal="true" lookAhead="true"/>+        <DetectSpaces/>+      </context>+      <context attribute="MarkdownHead" lineEndContext="#pop" name="Markdown Header">+        <StringDetect String="%1" attribute="Normal Text" dynamic="true"/>+        <DetectSpaces/>+      </context>+      <context attribute="Normal Text" name="Markdown Code">+        <DetectChar char="`" attribute="DocComment" context="#pop!Markdown Code Body"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="Markdown Code Body">+        <DetectChar char="`" context="#pop"/>+        <IncludeRules context="Normal"/>+      </context>++      <context attribute="String" lineEndContext="#stay" name="Heredoc">         <StringDetect String="&quot;&quot;&quot;" attribute="String" context="#pop"/>       </context>-      <context attribute="String" lineEndContext="#stay" name="Quoted String">-        <Detect2Chars char="\" char1="\" attribute="String" context="#stay"/>-        <Detect2Chars char="\" char1="&quot;" attribute="String" context="#stay"/>-        <RegExpr String="#@{1,2}" attribute="Substitution" context="Short Subst"/>-        <Detect2Chars attribute="Substitution" char="#" char1="{" context="Subst"/>-        <DetectChar attribute="String" char="&quot;" context="#pop"/>+      <context attribute="String" name="Bitstring">+        <!-- Atom keys can also have interpolatation if they are a "String" -->+        <RegExpr String="&quot;(?:\\.|#\{.+\}|[^&quot;])*&quot;:\s" attribute="Atom" context="#pop!Atom Bitstring Key" minimal="true" lookAhead="true"/>+        <DetectChar char="&quot;" attribute="String" context="#pop!Bitstring Body"/>       </context>-      <context attribute="Raw String" lineEndContext="#stay" name="Apostrophed String">-        <Detect2Chars char="\" char1="\" attribute="String" context="#stay"/>-        <Detect2Chars char="\" char1="'" attribute="String" context="#stay"/>-        <DetectChar attribute="Raw String" char="'" context="#pop"/>+      <context attribute="String" lineEndContext="#stay" name="Bitstring Body">+        <DetectChar char="&quot;" attribute="String" context="#pop"/>+        <IncludeRules context="Interpolated"/>       </context>-      <!-- Substitutions can be nested -->-      <context attribute="Normal Text" lineEndContext="#stay" name="Subst">-        <DetectChar attribute="Substitution" char="}" context="#pop"/>-        <!-- Highlight substitution as code. -->+      <context attribute="Charlist" lineEndContext="#stay" name="Charlist">+        <DetectChar char="'" attribute="Charlist" context="#pop"/>+        <IncludeRules context="Interpolated"/>+      </context>++      <!-- Sigils -->+      <context attribute="String" name="Sigils">+        <StringDetect String="~H&quot;" context="Sigil HEEx" lookAhead="true"/>+        <RegExpr String="~(?:[a-z]|[A-Z][A-Z\d]*)[/|&quot;'\(\{\[\&lt;]" attribute="String" context="Sigil" lookAhead="true"/>+        <DetectChar char="~" attribute="Operator" context="Operators" lookAhead="true"/>+      </context>+      <context attribute="String" name="Sigil">+        <DetectChar char="~" attribute="String" context="#stay"/>+        <RegExpr String="[a-z]" attribute="String" context="#pop!Sigil Delimeter Interp"/>+        <RegExpr String="[A-Z]" attribute="String" context="#pop!Sigil Delimeter Raw"/>+      </context>++      <context attribute="String" name="Sigil HEEx">+        <DetectChar char="~" attribute="String" context="#stay" beginRegion="sigil_heex"/>+        <DetectChar char="H" attribute="String" context="#stay"/>+        <RegExpr String="(&quot;&quot;&quot;|[/|&quot;'])" attribute="String" context="#pop!Sigil Interp HEEx" beginRegion="sigil"/>+      </context>+      <context attribute="Normal Text" name="Sigil Interp HEEx">+        <StringDetect String="%1" attribute="String" context="#pop" dynamic="true"/>+        <IncludeRules context="Text##Elixir/HEEx"/>+      </context>++      <!-- Sigils, Interpolated -->+      <context attribute="String" name="Sigil Delimeter Interp">+        <DetectChar char="[" attribute="String" context="#pop!Sigil Interp Square" beginRegion="sigil"/>+        <DetectChar char="(" attribute="String" context="#pop!Sigil Interp Paren" beginRegion="sigil"/>+        <DetectChar char="{" attribute="String" context="#pop!Sigil Interp Curly" beginRegion="sigil"/>+        <DetectChar char="&lt;" attribute="String" context="#pop!Sigil Interp Angle" beginRegion="sigil"/>+        <RegExpr String="(&quot;&quot;&quot;|[/|&quot;'])" attribute="String" context="#pop!Sigil Interp Match" beginRegion="sigil"/>+      </context>+      <context attribute="String" lineEndContext="#stay" name="Sigil Interp Square">+        <IncludeRules context="Sigil Square"/>+        <IncludeRules context="Interpolated"/>+      </context>+      <context attribute="String" lineEndContext="#stay" name="Sigil Interp Paren">+        <IncludeRules context="Sigil Paren"/>+        <IncludeRules context="Interpolated"/>+      </context>+      <context attribute="String" lineEndContext="#stay" name="Sigil Interp Curly">+        <IncludeRules context="Sigil Curly"/>+        <IncludeRules context="Interpolated"/>+      </context>+      <context attribute="String" lineEndContext="#stay" name="Sigil Interp Angle">+        <IncludeRules context="Sigil Angle"/>+        <IncludeRules context="Interpolated"/>+      </context>+      <context attribute="String" lineEndContext="#stay" name="Sigil Interp Match">+        <IncludeRules context="Sigil Match"/>+        <IncludeRules context="Interpolated"/>+      </context>++      <!-- Sigils, Non-Interpolated -->+      <context attribute="String" name="Sigil Delimeter Raw">+        <DetectChar char="[" attribute="String" context="#pop!Sigil Square" beginRegion="sigil"/>+        <DetectChar char="(" attribute="String" context="#pop!Sigil Paren" beginRegion="sigil"/>+        <DetectChar char="{" attribute="String" context="#pop!Sigil Curly" beginRegion="sigil"/>+        <DetectChar char="&lt;" attribute="String" context="#pop!Sigil Angle" beginRegion="sigil"/>+        <RegExpr String="(&quot;&quot;&quot;|[/|&quot;'])" attribute="String" context="#pop!Sigil Match" beginRegion="sigil"/>+      </context>+      <context attribute="String" lineEndContext="#stay" name="Sigil Square">+        <DetectChar char="]" attribute="String" context="#pop!Sigil Delimeter Modifiers" endRegion="sigil"/>+      </context>+      <context attribute="String" lineEndContext="#stay" name="Sigil Paren">+        <DetectChar char=")" attribute="String" context="#pop!Sigil Delimeter Modifiers" endRegion="sigil"/>+      </context>+      <context attribute="String" lineEndContext="#stay" name="Sigil Curly">+        <DetectChar char="}" attribute="String" context="#pop!Sigil Delimeter Modifiers" endRegion="sigil"/>+      </context>+      <context attribute="String" lineEndContext="#stay" name="Sigil Angle">+        <DetectChar char="&gt;" attribute="String" context="#pop!Sigil Delimeter Modifiers" endRegion="sigil"/>+      </context>+      <context attribute="String" lineEndContext="#stay" name="Sigil Match">+        <StringDetect String="%1" attribute="String" context="#pop!Sigil Delimeter Modifiers" dynamic="true" endRegion="sigil"/>+      </context>++      <context attribute="Normal Text" fallthroughContext="#pop" lineEndContext="#pop" name="Sigil Delimeter Modifiers">+        <!-- Captures modifiers after delimeter -->+        <RegExpr String="[a-zA-Z]*" attribute="String" context="#pop"/>+      </context>++      <!-- Interpolatation format -->+      <context attribute="Interpolation" name="Interpolated">+        <!-- Escapes can only happen in the same context as Interpolated strings -->+        <DetectChar char="\" context="Escape Sequence" lookAhead="true"/>+        <Detect2Chars char="#" char1="{" attribute="Interpolation" context="Interp"/>+      </context>+      <!-- Interpolations can be nested -->+      <context attribute="Normal Text" lineEndContext="#stay" name="Interp">+        <DetectChar char="}" attribute="Interpolation" context="#pop"/>+        <!-- Highlight interpolation as code. -->         <IncludeRules context="Normal"/>       </context>-      <context attribute="Substitution" lineEndContext="#pop" name="Short Subst">-        <!-- Check for e.g.: "#@var#@@xy" -->-        <RegExpr String="#@{1,2}" attribute="Substitution" context="#stay"/>-        <RegExpr String="\w(?!\w)" attribute="Substitution" context="#pop"/>+      <context attribute="Special Char" name="Escape Sequence">+        <RegExpr String="\\(?:.|x[\dA-F]{2}|u(?:[\dA-F]{4}|\{[\dA-F]+\}))" attribute="Special Char" insensitive="true" context="#pop"/>       </context>-      <context attribute="Comment" lineEndContext="#pop" name="General Comment">-        <DetectSpaces />++      <context attribute="Comment" lineEndContext="#pop" name="Line Comment">+        <DetectSpaces/>         <IncludeRules context="##Comments"/>       </context>-      <context attribute="MarkdownCode" lineEndContext="#stay" name="Markdown Code">-        <RegExpr String="^\s*```\s*$" attribute="MarkdownCode" context="#pop" column="0"/>-      </context>+     </contexts>     <itemDatas>-      <itemData name="Global Constant" defStyleNum="dsConstant"/>-      <itemData name="Constant" defStyleNum="dsConstant"/>-      <itemData defStyleNum="dsNormal" name="Normal Text"/>-      <itemData defStyleNum="dsKeyword" name="Keyword"/>+      <itemData defStyleNum="dsNormal"      name="Normal Text"/>+      <itemData defStyleNum="dsNormal"      name="Braces"/>+      <itemData defStyleNum="dsOperator"    name="Operator"/>+      <itemData defStyleNum="dsKeyword"     name="Keyword"/>       <itemData defStyleNum="dsControlFlow" name="Control Flow"/>-      <itemData defStyleNum="dsKeyword" name="Definition"/>-      <itemData defStyleNum="dsImport" name="Mixin macros"/>-      <itemData defStyleNum="dsConstant" name="Pseudo variable"/>-      <itemData defStyleNum="dsDecVal" name="Dec"/>-      <itemData defStyleNum="dsFloat" name="Float"/>-      <itemData defStyleNum="dsChar" name="Char"/>-      <itemData defStyleNum="dsBaseN" name="Octal"/>-      <itemData defStyleNum="dsBaseN" name="Hex"/>-      <itemData defStyleNum="dsBaseN" name="Bin"/>-      <itemData defStyleNum="dsVariable" name="Symbol"/>-      <itemData defStyleNum="dsString" name="String"/>-      <itemData defStyleNum="dsVerbatimString" name="Raw String"/>-      <itemData defStyleNum="dsOthers" name="Substitution"/>-      <itemData defStyleNum="dsOthers" name="Attribute"/>-      <itemData defStyleNum="dsComment" name="Comment"/>-      <itemData defStyleNum="dsComment" name="DocComment"/>-      <itemData defStyleNum="dsFunction" name="Separator Pair"/>-      <itemData defStyleNum="dsOthers" name="Separator Array"/>+      <itemData defStyleNum="dsKeyword"     name="Definition"/>+      <itemData defStyleNum="dsImport"      name="Mixin macros"/>+      <itemData defStyleNum="dsNormal"      name="Variable"/>+      <itemData defStyleNum="dsComment"     name="Variable Underscore"/>+      <itemData defStyleNum="dsNormal"      name="Module"/>+      <itemData defStyleNum="dsNormal"      name="Attribute"/>+      <itemData defStyleNum="dsBuiltIn"     name="Built In"/>+      <itemData defStyleNum="dsFunction"    name="Function"/>+      <itemData defStyleNum="dsVariable"    name="Atom"/>++      <!-- Literals -->+      <itemData defStyleNum="dsDecVal" name="Integer"/>+      <itemData defStyleNum="dsFloat"  name="Float"/>+      <itemData defStyleNum="dsBaseN"  name="Octal"/>+      <itemData defStyleNum="dsBaseN"  name="Hex"/>+      <itemData defStyleNum="dsBaseN"  name="Bin"/>++      <itemData defStyleNum="dsChar"   name="Char Literal"/>++      <itemData defStyleNum="dsString"         name="String" spellChecking="true"/>+      <itemData defStyleNum="dsVerbatimString" name="Charlist"/>+      <itemData defStyleNum="dsSpecialChar"    name="Special Char"/>+      <itemData defStyleNum="dsFunction"       name="Interpolation"/>++      <!-- Comments and Documentation -->+      <itemData defStyleNum="dsComment"       name="Comment"/>+      <itemData defStyleNum="dsDocumentation" name="DocComment"/>++      <itemData defStyleNum="dsDocumentation" name="MarkdownHead" bold="true" underline="true"/>+      <itemData defStyleNum="dsDocumentation" name="MarkdownMark" bold="true"/>+       <!-- use these to mark errors and alerts things -->-      <itemData defStyleNum="dsOperator" name="Operator"/>-      <itemData name="MarkdownHead" defStyleNum="dsFunction" bold="true"/>-      <itemData name="MarkdownBullet" defStyleNum="dsFunction"/>-      <itemData name="MarkdownNumlist" defStyleNum="dsFunction"/>-      <itemData name="MarkdownCode" defStyleNum="dsFunction"/>+      <itemData defStyleNum="dsError" name="Error"/>     </itemDatas>   </highlighting>   <general>     <comments>       <comment name="singleLine" start="#"/>     </comments>-    <keywords casesensitive="1" weakDeliminator="!?"/>+    <keywords casesensitive="1" weakDeliminator="!?:"/>   </general> </language> <!-- kate: replace-tabs on; tab-width 2; indent-width 2; -->
+ xml/haml.xml view
@@ -0,0 +1,1424 @@+<?xml version="1.0" encoding="UTF-8"?>+<!--+  https://haml.info/docs/yardoc/file.REFERENCE.html++Ruby code inserted with `=`, `-` and others differs slightly from Ruby syntax:+- In Ruby, '\' at the end of a line is used for a line continuation,+  Haml uses the regex '( \||,)\s*$'.+- Blocks are automatically closed according to indentation.+  This means that `do ... end` in Ruby need not contain `end` in Haml.++As a result of these differences, the ruby.xml file is not used,+but copied and modified accordingly.+-->+<!DOCTYPE language [+  <!ENTITY tagc "[-a-zA-Z0-9_:]">+  <!ENTITY tagid "#(&tagc;+|(?![{@$])|$)">+  <!ENTITY entityname "(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\w.:_-]*)">++  <!--+    Ruby syntax+  -->++  <!ENTITY dec "[0-9](_?[0-9]++)*+">+  <!ENTITY percent_lit "[QqxwWiIsr]?[^\s[:alnum:]]">++  <!ENTITY ident "[_[:alpha:]]\w*+">+  <!-- NOTE Haml: without "(?!^__END__$)" -->+  <!ENTITY global_constant "(\b_+\d[_\d]*\b|\b(_[_\d]*)?[[:upper:]][_\d[:upper:]]*\b)">+  <!ENTITY constant "\b[[:upper:]][_\d[:upper:]]*[[:lower:]]\w*">+  <!ENTITY no_param "abort|alias|and|at_exit|attr_accessor|attr_reader|attr_writer|begin|binding|break|callcc|caller|case|catch|class|def|do|else|elsif|end|ensure|eval|exec|extend|fail|false|__FILE__|for|fork|format|getc|gets|global_variables|if|in|include|lambda|__LINE__|load|local_variables|loop|method_missing|module|next|nil|not|open|or|p|prepend|print|printf|private|private_class_method|proc|protected|public|public_class_method|putc|puts|raise|rand|readline|readlines|redo|refine|require|require_relative|rescue|retry|return|scan|select|self|set_trace_func|sleep|split|sprintf|srand|super|syscall|system|test|then|throw|trace_var|trap|true|undef|unless|until|untrace_var|using|warn|when|while|yield|autoload|chomp|chop|exit|gsub|sub">+  <!-- ignore keyword, constant, class name and symbol (e.g. sym:).+      Constants can be preceded by ? or !, but this doesn't work with <keyword>+  -->+  <!ENTITY is_constant "((_[_\d]*)?[[:upper:]]\w*+|_+\d[_\d]*+\b)([^?!]|$)">+  <!ENTITY ident_not_kw "\b((?!(abort|alias|and|at_exit|attr_accessor|attr_reader|attr_writer|begin|binding|break|callcc|caller|case|catch|class|def|do|else|elsif|end|ensure|eval|exec|extend|fail|false|for|fork|format|getc|gets|global_variables|if|in|include|lambda|load|local_variables|loop|method_missing|module|next|nil|not|open|or|p|prepend|print|printf|private|private_class_method|proc|protected|public|public_class_method|putc|puts|raise|rand|readline|readlines|redo|refine|require|require_relative|rescue|retry|return|scan|select|self|set_trace_func|sleep|split|sprintf|srand|super|syscall|system|test|then|throw|trace_var|trap|true|undef|unless|until|untrace_var|using|warn|when|while|yield)([^?!\w]|$)|\bautoload([^!\w]|$)|(block_given\?|defined\?|iterator\?)|(chomp|chop|exit|gsub|sub)([^?\w]|$)|&is_constant;)|(?&lt;=[!?])(?=[[:lower:]]))&ident;(?!:)[?!]?">+  <!ENTITY msg "\b(?!&is_constant;)&ident;[?!]?">++  <!ENTITY special_escape "[0-7]{1,3}|x[0-9a-fA-F]{1,2}|u\{[0-9a-fA-F]{0,6}\}|u[0-9a-fA-F]{4}|(c(\\M-)?|C-|M-(\\c|\\C-)?)(\\([^0-7xucCM]|[0-7]{1,3}|x[0-9a-fA-F]{1,2}|$)|[ -BD-LN-\[\]-bd-tv-~])">+  <!ENTITY escape "\\([^0-7xucCM]|&special_escape;|$)">+  <!ENTITY partial_escape "[ux][0-9a-fA-F]*|u(\{[0-9a-fA-F]{0,6})?|(c(\\M-)?|C-|M-(\\c|\\C-)?)(\\[xucCM]?)?|c(\\M?)?|C|M(-(\\c?|\\(C-?)?)?)?">++  <!-- https://docs.ruby-lang.org/en/master/globals_rdoc.html -->+  <!-- $= $, $; are deprecated -->+  <!ENTITY global_var "\$([!@~&amp;`'+/\\&lt;>._*$?:&quot;=,;]|[0-9]+|-\w|[[:alpha:]]\w+)">++  <!-- NOTE Haml: " |[\t ]*$" is not an operator -->+  <!-- without ? : % / < = -->+  <!ENTITY safe_op "(?:[-+*~^&amp;]+|===?|&lt;(=>?|(?!&lt;))|[!>]=?|\.\.\.?|(?&lt;! )[|]|[|](?![\t ]*$))">+  <!ENTITY op1 "&safe_op;++|([?:/&#37;]|&lt;&lt;)&safe_op;*+">+  <!-- /= %= <<= -->+  <!-- / spaces -->+  <!-- % which is not gld -->+  <!-- << which is not heredoc -->+  <!-- nospace / -->+  <!-- nospace % -->+  <!-- nospace << -->+  <!ENTITY op2 "&safe_op;++|[?:](?=\s|$)|([/&#37;]|&lt;&lt;)(?=[\s=]|$)|&#37;(?!&percent_lit;)|&lt;&lt;(?=\s|$|[^-~\w'&quot;`]|[-~][^\w'&quot;`])|(?&lt;!\s)([/&#37;]|&lt;&lt;)&safe_op;*+">++  <!ENTITY sym_op "\[\]=?|[-+~]@?|![=~@]?|[/&#37;|^&amp;]|&lt;(=>?)?|>=?|=~|===?|\*\*?">+  <!ENTITY symbol "&ident;[=?!]?:(?!:)|\[\]=?:">+]>+<language name="Haml" version="16" kateversion="5.79" section="Markup"+          extensions="*.haml"+          author="Cies Breijs (cies_at_kde_nl), Jonathan Poelen (jonathan.poelen@gmail.com)" license="LGPL"+          mimetype="text/x-haml">+<!--      mimetype="text/x-haml"     this might be a problem as is doesn't exist -->++  <highlighting>++    <list name="ruby-keyword1">+      <item>and</item>+      <item>begin</item>+      <item>do</item>+      <item>else</item>+      <item>elsif</item>+      <item>ensure</item>+      <item>for</item>+      <item>if</item>+      <item>not</item>+      <item>or</item>+      <item>rescue</item>+      <item>then</item>+      <item>unless</item>+      <item>until</item>+      <item>when</item>+      <item>while</item>+    </list>++    <list name="ruby-keyword2">+      <item>break</item>+      <item>case</item>+      <item>defined?</item>+      <item>end</item>+      <item>in</item>+      <item>module</item>+      <item>next</item>+      <item>redo</item>+      <item>retry</item>+      <item>return</item>+      <item>yield</item>+    </list>++    <list name="keyword">+      <include>ruby-keyword1</include>+      <include>ruby-keyword2</include>+      <item>class</item>+      <item>def</item>+    </list>++    <list name="access-control">+      <include>access-control##Ruby</include>+    </list>++    <list name="attribute-definitions">+      <include>attribute-definitions##Ruby</include>+    </list>++    <list name="definitions">+      <include>definitions##Ruby</include>+    </list>++    <list name="pseudo-variables">+      <include>pseudo-variables##Ruby</include>+    </list>++    <list name="kernel-methods">+      <include>kernel-methods##Ruby</include>+    </list>++    <list name="mixin-methods">+      <include>mixin-methods##Ruby</include>+    </list>++    <contexts>+      <context attribute="Normal Text" name="normal" fallthroughContext="Text">+        <RegExpr attribute="Comment" context="mlComment2" column="0" String="^(\s)(\s*)(?:-#.*|/\s*$)"/>+        <!-- match filters for special syntax highlighting before detecting spaces so we know how far we need to indent -->+        <RegExpr context="SelectFilter" column="0" String="^\s*:" lookAhead="1"/>++        <DetectSpaces/>++        <RegExpr attribute="Tag" context="Elem" String="%&tagc;*"/>+        <RegExpr attribute="Div Id" context="Elem" String="&tagid;"/>+        <RegExpr attribute="Div Class" context="Elem" String="\.&tagc;*"/>++        <StringDetect attribute="Keyword" context="Text" String="=="/>+        <AnyChar attribute="Keyword" context="RubySourceLine" String="=~"/>+        <StringDetect attribute="Keyword" context="Text" String="!=="/>+        <StringDetect attribute="Keyword" context="RubySourceLine" String="!="/>+        <StringDetect attribute="Keyword" context="Text" String="!~="/>+        <StringDetect attribute="Keyword" context="RubySourceLine" String="!~"/>+        <StringDetect attribute="Keyword" context="Text" String="&amp;=="/>+        <StringDetect attribute="Keyword" context="RubySourceLine" String="&amp;="/>+        <StringDetect attribute="Keyword" context="Text" String="&amp;~="/>+        <StringDetect attribute="Keyword" context="RubySourceLine" String="&amp;~"/>+        <StringDetect attribute="Keyword" context="Text" String="! "/>+        <StringDetect attribute="Keyword" context="Text" String="&amp; "/>++        <RegExpr attribute="Comment" context="mlComment1" column="0" String="^-#.*|^/\s*$"/>+        <DetectChar attribute="Keyword" context="RubySourceLine" char="-"/>+        <DetectChar attribute="Comment" context="comment" char="/"/>+        <DetectChar attribute="Escaped Text" context="EscapedAny" char="\"/>++        <StringDetect attribute="Doctype" context="Doctype" String="!!!" column="0"/>+      </context>++      <context attribute="Normal Text" name="EscapedAny" lineEndContext="#pop">+        <RegExpr attribute="Escaped Text" context="#pop!Text" String="."/>+      </context>++      <context attribute="Normal Text" name="SelectFilter">+        <RegExpr attribute="Filter" column="0" context="filterRuby" String="^(\s*):ruby\b"/>+        <RegExpr attribute="Filter" column="0" context="filterCSS" String="^(\s*):css\b"/>+        <RegExpr attribute="Filter" column="0" context="filterCoffeeScript" String="^(\s*):coffee(?:script)?\b"/>+        <RegExpr attribute="Filter" column="0" context="filterERB" String="^(\s*):erb\b"/>+        <RegExpr attribute="Filter" column="0" context="filterPlain" String="^(\s*):[a-zA-Z0-9_\-]*\b"/>+        <DetectSpaces context="#pop#pop!normal"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#pop" name="Elem" fallthroughContext="Attr">+        <RegExpr attribute="Element Id" String="&tagid;"/>+        <RegExpr attribute="Element Class" String="\.&tagc;*"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#pop#pop" name="Attr" fallthroughContext="ElemOpt">+        <DetectChar attribute="Operator" context="hash" char="{" beginRegion="Hash"/>+        <DetectChar attribute="Operator" context="parenthesis" char="(" beginRegion="Parenthesis"/>+        <DetectChar attribute="Operator" context="array" char="[" beginRegion="Array"/>+        <StringDetect attribute="Keyword" context="ElemOpt" String="&lt;>"/>+        <StringDetect attribute="Keyword" context="ElemOpt" String=">&lt;"/>+        <AnyChar attribute="Keyword" context="ElemOpt" String=">&lt;"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#pop#pop#pop" name="ElemOpt" fallthroughContext="#pop#pop#pop!Text">+        <DetectChar attribute="Keyword" context="Empty" char="/"/>+        <AnyChar context="#pop#pop#pop" String="=~!&amp;" lookAhead="1"/>+      </context>++      <context attribute="Error" lineEndContext="#pop#pop#pop#pop" name="Empty">+        <DetectSpaces attribute="Normal Text"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#pop" name="Text">+        <RegExpr attribute="Normal Text" String="([^&amp;#\\|]++|#(?![{@$])|\\\\?#(?![{@$])|&amp;(?!&entityname;;)|(?&lt;! )\||\|(?!\s*$))++"/>+        <StringDetect attribute="Ruby Substitution" String="#{" context="RubySourceLineSubst"/>+        <StringDetect lookAhead="1" String="#" context="MaybeShortSubst"/>+        <StringDetect attribute="Escaped Text" String="\\"/>+        <StringDetect attribute="Escaped Text" String="\#{"/>+        <StringDetect attribute="Escaped Text" String="\#@"/>+        <StringDetect attribute="Escaped Text" String="\#$"/>+        <StringDetect attribute="Escaped Text" String="|" context="MultiLineText"/>+        <RegExpr attribute="Entity" String="&amp;&entityname;;"/>+      </context>++      <context attribute="Normal Text" name="MaybeShortSubst">+        <RegExpr attribute="Ruby Substitution" String="#@[[:upper:]]\w*|#\$([0-9]+|[[:alpha:]]\w*)" context="#pop"/>+        <StringDetect attribute="Error" String="#@" context="#pop"/>+        <StringDetect attribute="Error" String="#$" context="#pop"/>+        <StringDetect attribute="Normal Text" String="#" context="#pop"/>+      </context>++      <context attribute="Normal Text" name="MultiLineText" lineEndContext="CheckMultiLineText">+      </context>+      <!-- Check that the line ends with '|'. Otherwise, this is a new Haml "instruction" -->+      <context attribute="Normal Text" name="CheckMultiLineText" fallthroughContext="#pop#pop#pop">+        <RegExpr String="^.* \|[\t ]*$" context="#pop#pop" column="0" lookAhead="1"/>+        <RegExpr String="^\s+$" column="0" attribute="Normal Text"/>+      </context>++      <context attribute="Normal Text" name="MultiLineText2" lineEndContext="CheckMultiLineText2">+      </context>+      <!-- Check that the line ends with '|'. Otherwise, this is a new Haml "instruction" -->+      <context attribute="Normal Text" name="CheckMultiLineText2" fallthroughContext="#pop#pop#pop#pop">+        <IncludeRules context="CheckMultiLineText"/>+      </context>++      <context attribute="Normal Text" name="MultiLineText3" lineEndContext="CheckMultiLineText3">+      </context>+      <!-- Check that the line ends with '|'. Otherwise, this is a new Haml "instruction" -->+      <context attribute="Normal Text" name="CheckMultiLineText3" fallthroughContext="#pop#pop#pop#pop#pop">+        <IncludeRules context="CheckMultiLineText"/>+      </context>++      <context attribute="Comment" name="mlComment1" fallthroughContext="#pop">+        <DetectSpaces attribute="Comment" context="CommentLine"/>+      </context>+      <context attribute="Comment" name="mlComment2" fallthroughContext="#pop">+        <StringDetect attribute="Comment" column="0" context="CommentLine" dynamic="1" String="%1%2%1"/>+      </context>+      <context attribute="Comment" name="CommentLine" lineEndContext="#pop">+      </context>++      <context attribute="Normal Text" name="filterRuby" fallthroughContext="#pop#pop">+        <!-- detect base indentation + 1 whitespace for code -->+        <StringDetect attribute="Normal Text" context="RubySourceLine" String="%1 " dynamic="true"/>+      </context>++      <context attribute="Normal Text" name="filterCoffeeScript" fallthroughContext="#pop#pop">+        <!-- detect base indentation + 1 whitespace for code -->+        <StringDetect attribute="Normal Text" context="coffeesourceline" String="%1 " dynamic="true"/>+      </context>++      <context attribute="Normal Text" name="filterCSS" fallthroughContext="#pop#pop">+        <!-- detect base indentation + 1 whitespace for code -->+        <StringDetect attribute="Normal Text" context="csssourceline" String="%1 " dynamic="true"/>+      </context>++      <context attribute="Normal Text" name="filterERB" fallthroughContext="#pop#pop">+        <!-- detect base indentation + 1 whitespace for code -->+        <StringDetect attribute="Normal Text" context="erbsourceline" String="%1 " dynamic="true"/>+      </context>++      <context attribute="Normal Text" name="filterPlain" fallthroughContext="#pop#pop">+        <!-- detect base indentation + 1 whitespace for code -->+        <StringDetect attribute="Normal Text" context="plainsourceline" String="%1 " dynamic="true"/>+      </context>++      <context attribute="Ruby Normal Text" name="array" fallthroughContext="RubySourceLineExpr">+        <DetectChar attribute="Operator" context="#pop" char="]" endRegion="Array"/>+        <!-- leads to a syntax error in Haml -->+        <DetectChar attribute="Error" char="#" context="#pop!LineError"/>+        <IncludeRules context="RubySourceLine"/>+      </context>++      <context attribute="Ruby Normal Text" name="hash" fallthroughContext="#pop!hash2">+        <DetectSpaces attribute="Ruby Normal Text"/>+      </context>+      <context attribute="Ruby Normal Text" name="hash2" lineEndContext="hash3" fallthroughContext="RubySourceLineExpr">+        <DetectChar attribute="Operator" context="#pop" char="}" endRegion="Hash"/>+        <IncludeRules context="RubySourceLineSubstInner"/>+      </context>+      <context attribute="Ruby Normal Text" name="hash3" fallthroughContext="#pop#pop#pop#pop">+        <DetectChar attribute="Operator" context="#pop#pop" char="}" endRegion="Hash"/>+        <RegExpr attribute="Ruby Normal Text" String="^\s+(?=}|$)" column="0"/>+      </context>++      <context attribute="Ruby Normal Text" name="parenthesis" lineEndContext="AttrError">+        <DetectSpaces attribute="Normal Text"/>+        <WordDetect attribute="Special Attribute" String="class"/>+        <WordDetect attribute="Special Attribute" String="id"/>+        <DetectIdentifier attribute="Normal Text"/>+        <DetectChar attribute="Ruby Operator" char="=" context="parenthesisValue"/>+        <DetectChar attribute="Operator" context="#pop" char=")" endRegion="Parenthesis"/>+        <DetectChar char='"' attribute="Error" context="DQuote"/>+        <DetectChar char="'" attribute="Error" context="SQuote"/>+      </context>+      <context attribute="Ruby Normal Text" name="parenthesisValue" lineEndContext="#pop!AttrError" fallthroughContext="#pop">+        <DetectChar char='"' attribute="String" context="#pop!DQuote"/>+        <DetectChar char="'" attribute="String" context="#pop!SQuote"/>+        <DetectChar attribute="Operator" context="#pop#pop" char=")" endRegion="Parenthesis"/>+        <DetectSpaces attribute="Normal Text"/>+        <keyword attribute="Ruby Pseudo variable" String="pseudo-variables" context="#pop"/>+        <DetectIdentifier attribute="Ruby Normal Text" context="#pop"/>+        <RegExpr attribute="Ruby Number" String="\b(0[xX][0-9a-fA-F](_?[0-9a-fA-F]++)*+|0[bB][01](_?[01]++)*+|0[oO]?[0-7](_?[0-7]++)*+|((0[dD][0-9]|[1-9])(_?[0-9]++)*+|0)([eE]&dec;)?)" context="#pop"/>+      </context>++      <context name="AttrError" attribute="Error" fallthroughContext="#pop#pop">+        <DetectSpaces attribute="Error" context="#pop#pop"/>+      </context>++      <context name="DQuote" attribute="String">+        <DetectChar char='"' attribute="String" context="#pop"/>+        <IncludeRules context="CommonString"/>+      </context>++      <context name="SQuote" attribute="String">+        <DetectChar char="'" attribute="String" context="#pop"/>+        <IncludeRules context="CommonString"/>+      </context>++      <context attribute="String" lineEndContext="#pop" name="CommonString">+        <DetectIdentifier/>+        <DetectSpaces/>+        <StringDetect attribute="Ruby Substitution" String="#{" context="RubySourceLineSubst"/>+        <RegExpr attribute="Escaped Text" String="\\.?"/>+      </context>+++      <context attribute="Comment" lineEndContext="#pop" name="comment">+        <DetectSpaces/>+        <IncludeRules context="##Comments"/>+        <DetectIdentifier/>+        <StringDetect attribute="Error" String="--"/>+      </context>++      <context name="csssourceline" attribute="Other code embedded in haml" lineEndContext="#pop">+        <IncludeRules context="##CSS"/>+      </context>++      <context name="coffeesourceline" attribute="Other code embedded in haml" lineEndContext="#pop">+        <IncludeRules context="##CoffeeScript"/>+      </context>++      <context name="erbsourceline" attribute="Other code embedded in haml" lineEndContext="#pop">+        <IncludeRules context="##Ruby/Rails/RHTML"/>+      </context>++      <context name="plainsourceline" attribute="Other code embedded in haml" lineEndContext="#pop"/>++      <context name="Doctype" attribute="Doctype" lineEndContext="#pop"/>++      <context name="LineError" attribute="Error" lineEndContext="#pop"/>++      <context name="RubySourceMultiLine" attribute="Ruby Normal Text">+        <DetectChar char="," context="IgnoreEmptyLine" attribute="Ruby Normal Text"/>+        <DetectChar char="|" context="#pop!MultiLineText" attribute="Escaped Text"/>+      </context>++      <context name="RubySourceMultiLine2" attribute="Ruby Normal Text">+        <DetectChar char="," context="IgnoreEmptyLine" attribute="Ruby Normal Text"/>+        <DetectChar char="|" context="#pop!MultiLineText2" attribute="Escaped Text"/>+      </context>++      <context name="RubySourceMultiLine3" attribute="Ruby Normal Text">+        <DetectChar char="," context="IgnoreEmptyLine" attribute="Ruby Normal Text"/>+        <DetectChar char="|" context="#pop!MultiLineText3" attribute="Escaped Text"/>+      </context>++      <context name="IgnoreEmptyLine" attribute="Ruby Normal Text" fallthroughContext="#pop#pop">+        <DetectSpaces attribute="Ruby Normal Text"/>+      </context>++      <context name="RubySourceLineContinue" attribute="Ruby Normal Text">+        <RegExpr String="(,|(?&lt;= )\|)[\t ]*$" context="RubySourceMultiLine" lookAhead="1"/>+      </context>++      <context name="RubySourceLineContinue2" attribute="Ruby Normal Text">+        <RegExpr String="(,|(?&lt;= )\|)[\t ]*$" context="RubySourceMultiLine2" lookAhead="1"/>+      </context>++      <context name="RubySourceLineContinue3" attribute="Ruby Normal Text">+        <RegExpr String="(,|(?&lt;= )\|)[\t ]*$" context="RubySourceMultiLine3" lookAhead="1"/>+      </context>+++      <!--+        Ruby syntax+      -->++      <context name="RubySourceLine" attribute="Ruby Normal Text" lineEndContext="#pop" fallthroughContext="RubySourceLineExpr">+        <DetectSpaces attribute="Ruby Normal Text"/>++        <AnyChar attribute="Ruby Normal Text" String=";("/>+        <DetectChar attribute="Ruby Normal Text" char=")" context="RubySourceLineOp1ThenExpr"/>++        <DetectChar attribute="Ruby Delimiter" char="]" context="RubySourceLineOp1ThenExpr"/>++        <DetectChar attribute="Ruby Operator" char="{" beginRegion="brace"/>+        <DetectChar attribute="Ruby Operator" char="}" context="RubySourceLineOp1ThenExpr" endRegion="brace"/>++        <DetectChar attribute="Ruby Comment" char="#" context="RubySourceLineGeneral Comment"/>++        <RegExpr attribute="Ruby Normal Text" String="&ident_not_kw;" context="RubySourceLineMsgParamOrOp2"/>++        <!-- Detects key symbol in a hash+              Unfortunately in the absence of a space before ':',+              the syntax is ambiguous with a function call containing a symbol.++              hash:    {sym:foo}+              function: foo:sym  <- 'foo:' is considered as a symbol+        -->+        <RegExpr attribute="Ruby Symbol" String="&symbol;" context="RubySourceLineMsgParamOrOp2"/>++        <DetectChar attribute="Ruby Delimiter" char="[" context="RubySourceLineMsgParamOrOp2"/>++        <keyword attribute="Ruby Keyword" String="ruby-keyword1"/>+        <keyword attribute="Ruby Keyword" String="ruby-keyword2" context="RubySourceLineMsgParamOrOp2"/>++        <keyword attribute="Ruby Attribute Definition" String="attribute-definitions"  context="RubySourceLineOp2ThenExpr"/>+        <keyword attribute="Ruby Access Control" String="access-control" context="RubySourceLineOp2ThenExpr"/>+        <keyword attribute="Ruby Definition" String="definitions" context="RubySourceLineExpr"/>+        <keyword attribute="Ruby Pseudo variable" String="pseudo-variables" context="RubySourceLineOp1ThenExpr"/>+        <keyword attribute="Ruby Kernel methods" String="kernel-methods" context="RubySourceLineOp2ThenExpr"/>+        <keyword attribute="Ruby Module mixin methods" String="mixin-methods" context="RubySourceLineOp2ThenExpr"/>++        <WordDetect attribute="Ruby Keyword" String="class" context="RubySourceLineOp1ThenExpr"/>+        <WordDetect attribute="Ruby Keyword" String="def" context="RubySourceLineDefFn"/>+        <WordDetect attribute="Ruby Definition" String="alias" context="RubySourceLineAlias"/>+        <WordDetect attribute="Ruby Definition" String="undef" context="RubySourceLineAlias"/>++        <!-- Generally a module or class name like "File", "MyModule_1", .. -->+        <RegExpr attribute="Ruby Constant" String="&constant;" context="RubySourceLineMsgParamOrOp2"/>+        <RegExpr attribute="Ruby Global Constant" String="&global_constant;" context="RubySourceLineMsgParamOrOp2"/>++        <DetectIdentifier attribute="Ruby Normal Text" context="RubySourceLineSuffixFunctionMsgParamOrOp2"/>++        <IncludeRules context="RubySourceLineContinue"/>+        <DetectChar attribute="Ruby Normal Text" char="," context="RubySourceLineMsgParamOrOp2"/>+      </context>++      <context name="RubySourceLineSuffixFunctionMsgParamOrOp2" attribute="Ruby Normal Text" lineEndContext="#pop" fallthroughContext="#pop!RubySourceLineMsgParamOrOp2">+        <AnyChar attribute="Ruby Normal Text" String="!?" context="#pop!RubySourceLineMsgParamOrOp2"/>+      </context>++      <!-- after function call+        Assume that+            foo /a is a regex but not foo /=a+            foo %+ is a percent literal+            foo <<a is a heredoc+        (This is not true when foo is a variable...)+      -->+      <context name="RubySourceLineMsgParamOrOp2" attribute="Ruby Normal Text" lineEndContext="#pop" fallthroughContext="#pop!RubySourceLineExpr">+        <DetectSpaces attribute="Ruby Normal Text"/>+        <RegExpr attribute="Ruby Operator" String="&op2;" context="#pop!RubySourceLineExpr"/>+        <DetectChar attribute="Ruby Member" char="." context="RubySourceLineMemberAccessCall"/>+        <StringDetect attribute="Ruby Operator" String="::" context="RubySourceLineMemberAccessCall"/>+        <DetectChar char="," context="#pop" lookAhead="1"/>+        <IncludeRules context="RubySourceLineContinue2"/>+      </context>++      <context name="RubySourceLineMsgFnName" attribute="Ruby Normal Text" lineEndContext="#pop#pop#pop" fallthroughContext="#pop!RubySourceLineFnParent">+        <DetectSpaces attribute="Ruby Normal Text"/>+        <DetectChar attribute="Ruby Member" char="." context="RubySourceLineMemberAccess"/>+        <StringDetect attribute="Ruby Operator" String="::" context="RubySourceLineMemberAccess"/>+        <DetectChar char="," context="#pop" lookAhead="1"/>+        <IncludeRules context="RubySourceLineContinue2"/>+      </context>++      <context name="RubySourceLineExpr" attribute="Ruby Normal Text" lineEndContext="#pop">+        <DetectSpaces attribute="Ruby Normal Text"/>++        <StringDetect attribute="Ruby Operator" String=".." context="RubySourceLineDot2Op"/>+        <DetectChar attribute="Ruby Member" char="." context="RubySourceLineMemberAccess"/>++        <DetectChar attribute="Ruby Operator" char="=" context="#pop"/>++        <!-- pop to parent for interpolation -->+        <AnyChar String="{}]" context="#pop" lookAhead="1"/>++        <AnyChar attribute="Ruby Normal Text" String=";(" context="#pop"/>+        <LineContinue attribute="Ruby Normal Text" char="," context="IgnoreEmptyLine"/>+        <DetectChar attribute="Ruby Normal Text" char=")" context="RubySourceLineOp1"/>++        <DetectChar attribute="Ruby Comment" char="#" context="#pop!RubySourceLineGeneral Comment"/>++        <DetectChar char="@" context="RubySourceLineAtVar" lookAhead="1"/>+        <DetectChar char="$" context="RubySourceLineVar" lookAhead="1"/>++        <HlCChar attribute="Ruby Char" context="RubySourceLineOp1"/>+        <DetectChar attribute="Ruby String" char='"' context="RubySourceLineDQuote"/>+        <DetectChar attribute="Ruby Raw String" char="'" context="RubySourceLineSQuote"/>+        <DetectChar attribute="Ruby Command" char="`" context="RubySourceLineCommand String"/>++        <DetectChar attribute="Ruby Regular Expression" char="/" context="RubySourceLineRegEx"/>+        <!-- Check for "ASCII code operator". e.g.: ?a -->+        <DetectChar char="?" context="RubySourceLineMaybeCharLiteral" lookAhead="1"/>++        <AnyChar context="RubySourceLineNumber" String="0123456789" lookAhead="1"/>++        <RegExpr attribute="Ruby Normal Text" String="&ident_not_kw;" context="RubySourceLineOp2"/>++        <RegExpr attribute="Ruby Symbol" String="&symbol;" context="#pop!RubySourceLineMsgParamOrOp2"/>++        <DetectChar attribute="Ruby Delimiter" char="[" context="#pop!RubySourceLineMsgParamOrOp2"/>++        <StringDetect attribute="Ruby Operator" String="::" context="RubySourceLineMemberAccess"/>++        <keyword attribute="Ruby Keyword" String="ruby-keyword1" context="#pop"/>+        <keyword attribute="Ruby Keyword" String="ruby-keyword2" context="#pop!RubySourceLineMsgParamOrOp2"/>++        <keyword attribute="Ruby Attribute Definition" String="attribute-definitions" context="RubySourceLineOp2"/>+        <keyword attribute="Ruby Access Control" String="access-control" context="RubySourceLineOp2"/>+        <keyword attribute="Ruby Pseudo variable" String="pseudo-variables" context="RubySourceLineOp1"/>+        <keyword attribute="Ruby Kernel methods" String="kernel-methods" context="RubySourceLineOp2"/>+        <keyword attribute="Ruby Module mixin methods" String="mixin-methods" context="RubySourceLineOp2"/>++        <WordDetect attribute="Ruby Keyword" String="class" context="RubySourceLineOp1"/>+        <WordDetect attribute="Ruby Keyword" String="def" context="#pop!RubySourceLineDefFn"/>+        <WordDetect attribute="Ruby Definition" String="alias" context="RubySourceLineAlias"/>+        <WordDetect attribute="Ruby Definition" String="undef" context="RubySourceLineAlias"/>++        <keyword attribute="Ruby Definition" String="definitions"/>++        <!-- Generally a module or class name like "File", "MyModule_1", .. -->+        <RegExpr attribute="Ruby Constant" String="&constant;" context="RubySourceLineOp1"/>+        <RegExpr attribute="Ruby Global Constant" String="&global_constant;" context="RubySourceLineOp1"/>++        <RegExpr attribute="Ruby Symbol" String=":((@@?|\$)&ident;|&ident;([?]|!(?!=)|=(?![=>~]))?|&sym_op;|(?=['&quot;])|&global_var;)" context="RubySourceLineOp1"/>++        <!-- recognize the beginning of a general delimited input format -->+        <!-- this moves to the next context to separate out the exact nature of the GDL input -->+        <RegExpr attribute="Ruby GDL input" context="RubySourceLinefind_gdl_input" String="%(?=&percent_lit;)" beginRegion="GdlInput"/>++        <!-- recognize the beginning of a HEREDOC -->+        <RegExpr attribute="Ruby Operator" context="RubySourceLineHeredoc" String="&lt;&lt;(?=[-~]?(\w+|'\w+'|&quot;\w+&quot;|`\w+`))" beginRegion="HereDocument"/>++        <!-- should not happen in valid syntax -->+        <RegExpr attribute="Ruby Operator" String="([/%?:]|&lt;&lt;?)&safe_op;*|&safe_op;+"/>+        <DetectIdentifier attribute="Ruby Normal Text" context="RubySourceLineSuffixFunction"/>++        <IncludeRules context="RubySourceLineContinue2"/>+      </context>++      <!-- alias / ++                 ~ never regex+            same for undef+      -->+      <context name="RubySourceLineAlias" attribute="Ruby Normal Text" lineEndContext="#pop" fallthroughContext="#pop">+        <DetectSpaces attribute="Ruby Normal Text"/>+        <AnyChar attribute="Ruby Operator" String="-+*~^|&amp;=&lt;>!%/"/>+        <DetectChar char="$" context="RubySourceLineVar" lookAhead="1"/>+        <DetectChar attribute="Ruby String" char='"' context="RubySourceLineAliasDQuote"/>+        <DetectChar attribute="Ruby Raw String" char="'" context="RubySourceLineAliasSQuote"/>+        <RegExpr attribute="Ruby Symbol" String=":(&ident;[=?!]?|&sym_op;)"/>+        <RegExpr attribute="Ruby Normal Text" String="\b(?!(&no_param;)([^?!\w]|$))&ident;"/>+        <IncludeRules context="RubySourceLineContinue2"/>+        <LineContinue attribute="Ruby Normal Text" char=","/>+      </context>+      <context name="RubySourceLineAliasDQuote" attribute="Ruby String">+        <DetectChar char='"' attribute="Ruby String" context="RubySourceLineAliasCheckSym"/>+        <IncludeRules context="RubySourceLineDQuoteSpecial"/>+      </context>+      <context name="RubySourceLineAliasSQuote" attribute="Ruby Raw String">+        <Detect2Chars attribute="Ruby String" char="\" char1="\"/>+        <Detect2Chars attribute="Ruby String" char="\" char1="'"/>+        <DetectChar char="'" attribute="Ruby Raw String" context="RubySourceLineAliasCheckSym"/>+      </context>+      <context name="RubySourceLineAliasCheckSym" attribute="Ruby Raw String" lineEndContext="#pop#pop#pop" fallthroughContext="#pop#pop">+        <DetectChar char=":" attribute="Ruby Symbol" context="#pop#pop"/>+      </context>++      <context name="RubySourceLineDot2Op" attribute="Ruby Operator" lineEndContext="#pop#pop" fallthroughContext="#pop">+        <!-- triple dot -->+        <DetectChar attribute="Ruby Operator" char="." context="#pop"/>+      </context>++      <context name="RubySourceLineSuffixFunction" attribute="Ruby Normal Text" lineEndContext="#pop" fallthroughContext="#pop!RubySourceLineOp2">+        <AnyChar attribute="Ruby Normal Text" String="!?" context="#pop!RubySourceLineOp2"/>+      </context>++      <!-- A slash is always a division operator, even if preceeded by whitespace -->+      <context name="RubySourceLineOp1" attribute="Ruby Normal Text" lineEndContext="#pop" fallthroughContext="#pop">+        <DetectSpaces attribute="Ruby Normal Text"/>+        <DetectChar attribute="Ruby Operator" char="=" context="#pop#pop"/>+        <RegExpr attribute="Ruby Operator" String="&op1;" context="#pop"/>+        <DetectChar char="," context="#pop" lookAhead="1"/>+        <IncludeRules context="RubySourceLineContinue3"/>+      </context>++      <context name="RubySourceLineOp1ThenExpr" attribute="Ruby Normal Text" lineEndContext="#pop" fallthroughContext="#pop!RubySourceLineExpr">+        <DetectSpaces attribute="Ruby Normal Text"/>+        <DetectChar attribute="Ruby Operator" char="=" context="#pop"/>+        <RegExpr attribute="Ruby Operator" String="&op1;" context="#pop!RubySourceLineExpr"/>+        <DetectChar char="," context="#pop" lookAhead="1"/>+        <IncludeRules context="RubySourceLineContinue2"/>+      </context>++      <!-- A slash is division operator if it's the first character, or if preceeded and followed by whitespace -->+      <context name="RubySourceLineOp2" attribute="Ruby Normal Text" lineEndContext="#pop" fallthroughContext="#pop">+        <DetectSpaces attribute="Ruby Normal Text"/>+        <DetectChar attribute="Ruby Operator" char="=" context="#pop#pop"/>+        <RegExpr attribute="Ruby Operator" String="&op2;" context="#pop"/>+        <DetectChar char="," context="#pop" lookAhead="1"/>+        <IncludeRules context="RubySourceLineContinue3"/>+      </context>++      <context name="RubySourceLineOp2ThenExpr" attribute="Ruby Normal Text" lineEndContext="#pop" fallthroughContext="#pop!RubySourceLineExpr">+        <DetectSpaces attribute="Ruby Normal Text"/>+        <DetectChar attribute="Ruby Operator" char="=" context="#pop"/>+        <RegExpr attribute="Ruby Operator" String="&op2;" context="#pop!RubySourceLineExpr"/>+        <DetectChar char="," context="#pop" lookAhead="1"/>+        <IncludeRules context="RubySourceLineContinue2"/>+      </context>++      <context name="RubySourceLineVar" attribute="Ruby Normal Text" lineEndContext="#pop#pop">+        <!-- (global) vars starting with $ -->+        <RegExpr attribute="Ruby Global Variable" String="\$(?!(stdin|stdout|stderr|_|LOAD_PATH|LOADED_FEATURES|FILENAME|DEBUG|VERBOSE)\b)[0-9]+|[[:alpha:]]\w*|\$-(?![ailpFIvWwdx])\w" context="#pop!RubySourceLineOp1"/>+        <!-- special-character globals and other predefined variables -->+        <RegExpr attribute="Ruby Default globals" String="&global_var;" context="#pop!RubySourceLineOp1"/>+        <DetectChar attribute="Error" char="$" context="#pop!RubySourceLineOp1"/>+      </context>++      <context name="RubySourceLineAtVar" attribute="Ruby Normal Text" lineEndContext="#pop#pop">+        <RegExpr attribute="Ruby Instance Variable" String="@&ident;" context="#pop!RubySourceLineOp1"/>+        <RegExpr attribute="Ruby Class Variable" String="@@&ident;" context="#pop!RubySourceLineOp1"/>+        <DetectChar attribute="Error" char="@"/>+      </context>++      <!-- def foo() block-statement+              ~~~ any ident (including keyword)++          def Abc::foo() block-statement+              ~~~  ~~~ ident (no keyword)+      -->+      <context name="RubySourceLineDefFn" attribute="Ruby Normal Text" lineEndContext="#pop" fallthroughContext="RubySourceLineFnName">+        <DetectSpaces attribute="Ruby Normal Text"/>+        <DetectChar attribute="Ruby Comment" char="#" context="RubySourceLineGeneral Comment"/>+        <DetectChar char="," context="#pop" lookAhead="1"/>+        <IncludeRules context="RubySourceLineContinue2"/>+      </context>+      <context name="RubySourceLineFnName" attribute="Ruby Normal Text" lineEndContext="#pop" fallthroughContext="RubySourceLineFnParent">+        <RegExpr attribute="Ruby Normal Text" String="&ident_not_kw;" context="RubySourceLineMsgFnName"/>++        <keyword attribute="Ruby Attribute Definition" String="attribute-definitions" context="RubySourceLineFnParent" weakDeliminator=":"/>+        <keyword attribute="Ruby Access Control" String="access-control" context="RubySourceLineFnParent" weakDeliminator=":"/>+        <keyword attribute="Ruby Definition" String="definitions" context="RubySourceLineFnParent" weakDeliminator=":"/>+        <keyword attribute="Ruby Pseudo variable" String="pseudo-variables" context="RubySourceLineFnParent" weakDeliminator=":"/>+        <keyword attribute="Ruby Kernel methods" String="kernel-methods" context="RubySourceLineFnParent" weakDeliminator=":"/>+        <keyword attribute="Ruby Module mixin methods" String="mixin-methods" context="RubySourceLineFnParent" weakDeliminator=":"/>+        <keyword attribute="Ruby Keyword" String="keyword" context="RubySourceLineFnParent" weakDeliminator=":"/>++        <RegExpr attribute="Ruby Operator" String="[-+~]@?|![~@]?|[/%^]|\*\*?|\|\||&amp;&amp;|&lt;(=>?)?|>=?|===?|\*\*?" context="RubySourceLineFnParent"/>+        <RegExpr attribute="Ruby Constant" String="&constant;" context="RubySourceLineMsgFnName"/>+        <RegExpr attribute="Ruby Global Constant" String="&global_constant;" context="RubySourceLineMsgFnName"/>++        <StringDetect attribute="Ruby Symbol" String="[]=" context="RubySourceLineFnParent"/>+        <StringDetect attribute="Ruby Symbol" String="[]" context="RubySourceLineFnParent"/>+        <DetectChar attribute="Ruby Comment" char="#" context="RubySourceLineGeneral Comment"/>+      </context>+      <context name="RubySourceLineFnParent" attribute="Ruby Normal Text" lineEndContext="#pop" fallthroughContext="#pop#pop#pop">+        <DetectChar attribute="Ruby Normal Text" char="(" context="RubySourceLineDefFnParams"/>+        <DetectSpaces attribute="Ruby Normal Text"/>+        <DetectChar attribute="Ruby Comment" char="#" context="RubySourceLineGeneral Comment"/>+        <DetectChar char="," context="#pop" lookAhead="1"/>+        <IncludeRules context="RubySourceLineContinue2"/>+      </context>+      <context name="RubySourceLineDefFnParams" attribute="Ruby Normal Text" lineEndContext="#pop" fallthroughContext="#pop#pop#pop#pop">+        <DetectChar attribute="Ruby Normal Text" char=")" context="#pop#pop#pop#pop"/>+        <DetectChar attribute="Ruby Comment" char="#" context="RubySourceLineGeneral Comment"/>+        <RegExpr attribute="Ruby Normal Text" String="([\s,]+|\b(?!(&no_param;)\b|[[:upper:]])&ident;(?=$|[^?!]))++"/>+        <RegExpr attribute="Ruby Constant" String="&constant;"/>+        <RegExpr attribute="Ruby Global Constant" String="&global_constant;"/>+        <keyword attribute="Ruby Attribute Definition" String="attribute-definitions"/>+        <keyword attribute="Ruby Access Control" String="access-control"/>+        <keyword attribute="Ruby Kernel methods" String="kernel-methods"/>+        <keyword attribute="Ruby Module mixin methods" String="mixin-methods"/>+        <IncludeRules context="RubySourceLineContinue2"/>+      </context>+++      <!-- Numeric values. Note that we have to allow underscores between two digits. -->+      <context name="RubySourceLineNumber" attribute="Ruby Normal Text" lineEndContext="#pop#pop" fallthroughContext="RubySourceLineNumberError">+        <RegExpr attribute="Ruby Number" String="\b([1-9](_?[0-9]++)*+|0)(\.&dec;([eE][-+]?&dec;)?|[eE][-+]?&dec;)|\b(0[dD]&dec;|(0(\b|(?=[ri]))|[1-9](_?[0-9]++)*+))|\b0[xX][0-9a-fA-F](_?[0-9a-fA-F]++)*+|\b0[bB][01](_?[01]++)*+|\b0[oO]?[0-7](_?[0-7]++)*+" context="RubySourceLineNumberSuffix"/>+        <DetectChar char="0" attribute="Ruby Number" context="RubySourceLineNumberError"/>+      </context>++      <context name="RubySourceLineNumberSuffix" attribute="Ruby Number Suffix" lineEndContext="#pop#pop#pop" fallthroughContext="#pop!RubySourceLineNumberError">+        <StringDetect attribute="Ruby Number Suffix" String="ri" context="#pop!RubySourceLineNumberError"/>+        <AnyChar attribute="Ruby Number Suffix" String="ri" context="#pop!RubySourceLineNumberError"/>+      </context>++      <context name="RubySourceLineNumberError" attribute="Error" lineEndContext="#pop#pop#pop" fallthroughContext="#pop#pop!RubySourceLineOp1">+        <DetectIdentifier/>+        <AnyChar String="0123456789"/>+      </context>++      <context name="RubySourceLineBrace" attribute="Ruby Normal Text" fallthroughContext="#pop!RubySourceLineBraceInner">+        <DetectSpaces attribute="Ruby Normal Text"/>+      </context>+      <context name="RubySourceLineBraceInner" attribute="Ruby Normal Text" lineEndContext="#pop" fallthroughContext="RubySourceLineExpr">+        <DetectChar attribute="Ruby Operator" char="}" context="#pop!RubySourceLineOp1ThenExpr" endRegion="brace"/>+        <DetectChar attribute="Ruby Operator" char="{" context="RubySourceLineBrace" beginRegion="brace"/>+        <IncludeRules context="RubySourceLine"/>+      </context>++      <!-- "..." -->+      <context name="RubySourceLineDQuote" attribute="Ruby String">+        <DetectChar char='"' attribute="Ruby String" context="RubySourceLineCheckSym"/>+        <IncludeRules context="RubySourceLineDQuoteSpecial"/>+      </context>++      <!-- "...": -->+      <context name="RubySourceLineCheckSym" attribute="Ruby Raw String" lineEndContext="#pop#pop!RubySourceLineOp1" fallthroughContext="#pop#pop!RubySourceLineOp1">+        <DetectChar char=":" attribute="Ruby Symbol" context="#pop#pop#pop"/>+      </context>++      <!-- \ in "..." -->+      <context name="RubySourceLineDQuoteSpecial" attribute="Ruby String">+        <DetectChar char="\" context="RubySourceLineDQuoteEscape" lookAhead="1"/>+        <DetectChar char="#" context="RubySourceLineDQuoteSubstitution" lookAhead="1"/>+        <IncludeRules context="RubySourceLineContinue3"/>+      </context>+      <context name="RubySourceLineDQuoteEscape" attribute="Ruby String">+        <RegExpr attribute="Ruby String Char" String="&escape;" context="#pop"/>+        <RegExpr attribute="Error" String="\\(&partial_escape;|)" context="#pop"/>+      </context>+      <context name="RubySourceLineDQuoteSubstitution" attribute="Ruby String">+        <StringDetect attribute="Ruby Substitution" String="#{" context="#pop!RubySourceLineSubst"/>+        <RegExpr attribute="Ruby Substitution" String="#@@?\w+|#&global_var;" context="#pop"/>+        <DetectChar char="#" context="#pop"/>+      </context>++      <!-- '...' -->+      <context name="RubySourceLineSQuote" attribute="Ruby Raw String">+        <Detect2Chars attribute="Ruby String" char="\" char1="\"/>+        <Detect2Chars attribute="Ruby String" char="\" char1="'"/>+        <DetectChar char="'" attribute="Ruby Raw String" context="RubySourceLineCheckSym"/>+        <IncludeRules context="RubySourceLineContinue3"/>+      </context>++      <!-- `...` -->+      <context name="RubySourceLineCommand String" attribute="Ruby Command">+        <DetectChar char="`" attribute="Ruby Command" context="#pop!RubySourceLineOp1"/>+        <Detect2Chars attribute="Ruby String" char="\" char1="\"/>+        <Detect2Chars attribute="Ruby String" char="\" char1="`"/>+        <DetectChar char="#" context="RubySourceLineDQuoteSubstitution" lookAhead="1"/>+        <IncludeRules context="RubySourceLineContinue3"/>+      </context>++      <!-- ?x -->+      <context name="RubySourceLineMaybeCharLiteral" attribute="Ruby String" lineEndContext="#pop" fallthroughContext="#pop!RubySourceLineOp1">+        <RegExpr attribute="Ruby Operator" String="\?(?=\s|$)" context="#pop"/>+        <DetectChar attribute="Ruby Char Literal" char="?" context="RubySourceLineCharLiteral"/>+      </context>+      <context name="RubySourceLineCharLiteral" attribute="Ruby String">+        <RegExpr attribute="Ruby Char" String="[^\\\s]" context="#pop#pop!RubySourceLineOp1"/>+        <RegExpr attribute="Ruby String Char" String="&escape;" context="#pop#pop!RubySourceLineOp1"/>+        <RegExpr attribute="Error" String="\\(&partial_escape;|)" context="#pop#pop!RubySourceLineOp1"/>+      </context>++      <context name="RubySourceLineRegEx" attribute="Ruby Regular Expression">+        <DetectChar attribute="Ruby Regular Expression" context="RubySourceLineRegExMode" char="/"/>+        <IncludeRules context="RubySourceLineRegExSpecial"/>+      </context>+      <!-- as DQuoteSpecial, but with \. and \p{...} -->+      <context name="RubySourceLineRegExSpecial" attribute="Ruby String Char">+        <DetectChar char="#" context="RubySourceLineDQuoteSubstitution" lookAhead="1"/>+        <DetectChar char="\" context="RubySourceLineRegExEscape" lookAhead="1"/>+      </context>+      <context name="RubySourceLineRegExEscape" attribute="Ruby String">+        <RegExpr attribute="Ruby String Char" String="\\([^0-7xucCMp]|&special_escape;|p\{[-[:alpha:]]*\}|$)" context="#pop"/>+        <RegExpr attribute="Error" String="\\(&partial_escape;|p\{?|)" context="#pop"/>+      </context>++      <context name="RubySourceLineRegExMode" attribute="Ruby String" lineEndContext="#pop#pop" fallthroughContext="#pop#pop!RubySourceLineOp1">+        <AnyChar attribute="Ruby Regular Expression" String="imxonues"/>+      </context>++      <!-- Substitutions can be nested -->+      <context name="RubySourceLineSubst" attribute="Ruby Normal Text" fallthroughContext="RubySourceLineExpr">+        <DetectChar attribute="Ruby Substitution" char="}" context="#pop"/>+        <IncludeRules context="RubySourceLineSubstInner"/>+      </context>+      <context attribute="Ruby Normal Text" name="RubySourceLineSubstInner">+        <DetectChar attribute="Ruby Operator" char="{" context="RubySourceLineBrace" beginRegion="brace"/>+        <!-- leads to a syntax error in Haml -->+        <DetectChar attribute="Error" char="#" context="#pop!LineError"/>+        <IncludeRules context="RubySourceLine"/>+      </context>++      <!-- This handles access of nested module classes and class methods -->+      <context name="RubySourceLineMemberAccess" attribute="Ruby Member" fallthroughContext="#pop!RubySourceLineOp1">+        <DetectSpaces attribute="Ruby Normal Text"/>+        <!-- marks a message (being sent, not defined) -->+        <RegExpr attribute="Ruby Message" String="&msg;" context="#pop!RubySourceLineOp1"/>+        <RegExpr attribute="Ruby Constant" String="&constant;" context="#pop!RubySourceLineOp1"/>+        <RegExpr attribute="Ruby Constant Value" String="&global_constant;" context="#pop!RubySourceLineOp1"/>+        <RegExpr attribute="Ruby Operator" String="&sym_op;" context="#pop"/>+      </context>++      <context name="RubySourceLineMemberAccessCall" attribute="Ruby Member" fallthroughContext="#pop">+        <DetectSpaces attribute="Ruby Normal Text"/>+        <!-- marks a message (being sent, not defined) -->+        <RegExpr attribute="Ruby Message" String="&msg;" context="#pop"/>+        <RegExpr attribute="Ruby Constant" String="&constant;" context="#pop"/>+        <RegExpr attribute="Ruby Constant Value" String="&global_constant;" context="#pop"/>+        <RegExpr attribute="Ruby Operator" String="&sym_op;" context="#pop"/>+      </context>++      <context name="RubySourceLineGeneral Comment" attribute="Ruby Comment" lineEndContext="#pop">+        <DetectSpaces/>+        <IncludeRules context="##Comments"/>+        <DetectIdentifier/>+      </context>++      <!-- HEREDOC support+        The contexts below support both normal and indented heredocs+        -->+      <!-- here we markup the heredoc markers -->+      <context name="RubySourceLineHeredoc" attribute="Ruby Normal Text">+        <AnyChar attribute="Ruby Operator" String="-~" context="#pop!RubySourceLineIndentedHeredoc"/>+        <RegExpr attribute="Ruby Keyword" context="RubySourceLineapostrophed_normal_heredoc" String="'(\w+)'"/>+        <RegExpr attribute="Ruby Keyword" context="RubySourceLinenormal_heredoc" String="(?|(\w+)|&quot;(\w+)&quot;|`(\w+)`)"/>+      </context>+      <context name="RubySourceLineIndentedHeredoc" attribute="Ruby Normal Text">+        <RegExpr attribute="Ruby Keyword" context="RubySourceLineapostrophed_indented_heredoc" String="'(\w+)'"/>+        <RegExpr attribute="Ruby Keyword" context="RubySourceLineindented_heredoc" String="(?|(\w+)|&quot;(\w+)&quot;|`(\w+)`)"/>+      </context>+      <!-- these are the real heredoc contexts -->+      <context name="RubySourceLineindented_heredoc" attribute="Ruby Here Document">+        <RegExpr attribute="Ruby Keyword" context="#pop#pop" String="%1$" dynamic="true" endRegion="HereDocument" firstNonSpace="true"/>+        <IncludeRules context="RubySourceLineDQuoteSpecial"/>+      </context>+      <context name="RubySourceLineapostrophed_indented_heredoc" attribute="Ruby Here Document">+        <RegExpr attribute="Ruby Keyword" context="#pop#pop" String="%1$" dynamic="true" endRegion="HereDocument" firstNonSpace="true"/>+      </context>++      <context name="RubySourceLinenormal_heredoc" attribute="Ruby Here Document">+        <RegExpr attribute="Ruby Keyword" context="#pop#pop" String="^%1$" dynamic="true" endRegion="HereDocument" column="0"/>+        <IncludeRules context="RubySourceLineDQuoteSpecial"/>+      </context>+      <context name="RubySourceLineapostrophed_normal_heredoc" attribute="Ruby Here Document">+        <RegExpr attribute="Ruby Keyword" context="#pop#pop" String="^%1$" dynamic="true" endRegion="HereDocument" column="0"/>+      </context>++      <!-- General delimited input support+        The contexts below handle the various gdl formats+        -->+      <context name="RubySourceLinefind_gdl_input" attribute="Ruby Normal Text" lineEndContext="#pop">+        <!-- handle double-quoted strings -->+        <DetectChar attribute="Ruby GDL input" context="RubySourceLine%Q(" char="("/>+        <DetectChar attribute="Ruby GDL input" context="RubySourceLine%Q{" char="{"/>+        <DetectChar attribute="Ruby GDL input" context="RubySourceLine%Q[" char="["/>+        <DetectChar attribute="Ruby GDL input" context="RubySourceLine%Q&lt;" char="&lt;"/>+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%Q(" String="Q("/>+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%Q{" String="Q{"/>+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%Q[" String="Q["/>+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%Q&lt;" String="Q&lt;"/>++        <!-- handle token arrays -->+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%Q(" String="W("/>+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%Q{" String="W{"/>+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%Q[" String="W["/>+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%Q&lt;" String="W&lt;"/>++        <!-- handle token arrays -->+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%Q(" String="I("/>+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%Q{" String="I{"/>+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%Q[" String="I["/>+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%Q&lt;" String="I&lt;"/>++        <!-- then we handle the 'any char' format -->+        <RegExpr attribute="Ruby GDL input" context="RubySourceLine%Q_" String="[QWI]?([^[:alnum:]])"/>++        <!-- handle token arrays -->+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%w(" String="w("/>+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%w{" String="w{"/>+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%w[" String="w["/>+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%w&lt;" String="w&lt;"/>++        <!-- handle token arrays -->+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%w(" String="i("/>+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%w{" String="i{"/>+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%w[" String="i["/>+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%w&lt;" String="i&lt;"/>++        <!-- then we handle the 'any char' format -->+        <RegExpr attribute="Ruby GDL input" context="RubySourceLine%w_" String="[wi]([^[:alnum:]])"/>++        <!-- handle apostrophed strings -->+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%q(" String="q("/>+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%q{" String="q{"/>+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%q[" String="q["/>+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%q&lt;" String="q&lt;"/>+        <!-- then we handle the 'any char' format -->+        <RegExpr attribute="Ruby GDL input" context="RubySourceLine%q_" String="q([^[:alnum:]])"/>++        <!-- handle token arrays -->+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%s(" String="s("/>+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%s{" String="s{"/>+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%s[" String="s["/>+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%s&lt;" String="s&lt;"/>+        <!-- then ie handle the 'any char' format -->+        <RegExpr attribute="Ruby GDL input" context="RubySourceLine%s_" String="s([^[:alnum:]])"/>++        <!-- handle regular expressions -->+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%r(" String="r("/>+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%r{" String="r{"/>+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%r[" String="r["/>+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%r&lt;" String="r&lt;"/>+        <!-- then we handle the 'any char' format -->+        <RegExpr attribute="Ruby GDL input" context="RubySourceLine%r_" String="r([^[:alnum:]])"/>++        <!-- handle shell commands -->+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%x(" String="x("/>+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%x{" String="x{"/>+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%x[" String="x["/>+        <StringDetect attribute="Ruby GDL input" context="RubySourceLine%x&lt;" String="x&lt;"/>+        <!-- then we handle the 'any char' format -->+        <RegExpr attribute="Ruby GDL input" context="RubySourceLine%x_" String="x([^[:alnum:]])"/>+      </context>+++      <!-- double-quoted string specific contexts follow -->++      <context name="RubySourceLine%Q(" attribute="Ruby String">+        <DetectChar attribute="Ruby GDL input" context="#pop#pop!RubySourceLineOp1" char=")" endRegion="GdlInput"/>+        <IncludeRules context="RubySourceLine%Q(_rule"/>+      </context>+      <context name="RubySourceLine%Q(_nested" attribute="Ruby String">+        <DetectChar attribute="Ruby String" context="#pop" char=")"/>+        <IncludeRules context="RubySourceLine%Q(_rule"/>+      </context>+      <context name="RubySourceLine%Q(_rule" attribute="Ruby String">+        <DetectChar attribute="Ruby String" context="RubySourceLine%Q(_nested" char="("/>+        <IncludeRules context="RubySourceLineDQuoteSpecial"/>+      </context>++      <!-- note that here substitution should win over nesting -->+      <context name="RubySourceLine%Q{" attribute="Ruby String">+        <DetectChar attribute="Ruby GDL input" context="#pop#pop!RubySourceLineOp1" char="}" endRegion="GdlInput"/>+        <IncludeRules context="RubySourceLine%Q{_rule"/>+      </context>+      <context name="RubySourceLine%Q{_nested" attribute="Ruby String">+        <DetectChar attribute="Ruby String" context="#pop" char="}"/>+        <IncludeRules context="RubySourceLine%Q{_rule"/>+      </context>+      <context name="RubySourceLine%Q{_rule" attribute="Ruby String">+        <DetectChar attribute="Ruby String" context="RubySourceLine%Q{_nested" char="{"/>+        <IncludeRules context="RubySourceLineDQuoteSpecial"/>+      </context>++      <context name="RubySourceLine%Q[" attribute="Ruby String">+        <DetectChar attribute="Ruby GDL input" context="#pop#pop!RubySourceLineOp1" char="]" endRegion="GdlInput"/>+        <IncludeRules context="RubySourceLine%Q[_rule"/>+      </context>+      <context name="RubySourceLine%Q[_nested" attribute="Ruby String">+        <DetectChar attribute="Ruby String" context="#pop" char="]"/>+        <IncludeRules context="RubySourceLine%Q[_rule"/>+      </context>+      <context name="RubySourceLine%Q[_rule" attribute="Ruby String">+        <DetectChar attribute="Ruby String" context="RubySourceLine%Q[_nested" char="["/>+        <IncludeRules context="RubySourceLineDQuoteSpecial"/>+      </context>++      <context name="RubySourceLine%Q&lt;" attribute="Ruby String">+        <DetectChar attribute="Ruby GDL input" context="#pop#pop!RubySourceLineOp1" char=">" endRegion="GdlInput"/>+        <IncludeRules context="RubySourceLine%Q&lt;_rule"/>+      </context>+      <context name="RubySourceLine%Q&lt;_nested" attribute="Ruby String">+        <DetectChar attribute="Ruby String" context="#pop" char=">"/>+        <IncludeRules context="RubySourceLine%Q&lt;_rule"/>+      </context>+      <context name="RubySourceLine%Q&lt;_rule" attribute="Ruby String">+        <DetectChar attribute="Ruby String" context="RubySourceLine%Q&lt;_nested" char="&lt;"/>+        <IncludeRules context="RubySourceLineDQuoteSpecial"/>+      </context>++      <!-- this format doesn't allow nesting. it is terminated by the next occurrence of the+        delimiter character+        -->+      <context name="RubySourceLine%Q_" attribute="Ruby String">+        <DetectChar attribute="Ruby GDL input" context="#pop#pop!RubySourceLineOp1" char="1" dynamic="true" endRegion="GdlInput"/>+        <IncludeRules context="RubySourceLineDQuoteSpecial"/>+      </context>+++      <!-- token array specific contexts -->++      <context name="RubySourceLine%w(" attribute="Ruby Raw String">+        <DetectChar attribute="Ruby GDL input" context="#pop#pop!RubySourceLineOp1" char=")" endRegion="GdlInput"/>+        <IncludeRules context="RubySourceLine%w(_rule"/>+      </context>+      <context name="RubySourceLine%w(_nested" attribute="Ruby Raw String">+        <DetectChar attribute="Ruby Raw String" context="#pop" char=")"/>+        <IncludeRules context="RubySourceLine%w(_rule"/>+      </context>+      <context name="RubySourceLine%w(_rule" attribute="Ruby Raw String">+        <DetectChar attribute="Ruby Raw String" context="RubySourceLine%w(_nested" char="("/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1=" "/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1="\"/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1=")"/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1="("/>+      </context>++      <context name="RubySourceLine%w{" attribute="Ruby Raw String">+        <DetectChar attribute="Ruby GDL input" context="#pop#pop!RubySourceLineOp1" char="}" endRegion="GdlInput"/>+        <IncludeRules context="RubySourceLine%w{_rule"/>+      </context>+      <context name="RubySourceLine%w{_nested" attribute="Ruby Raw String">+        <DetectChar attribute="Ruby Raw String" context="#pop" char="}"/>+        <IncludeRules context="RubySourceLine%w{_rule"/>+      </context>+      <context name="RubySourceLine%w{_rule" attribute="Ruby Raw String">+        <DetectChar attribute="Ruby Raw String" context="RubySourceLine%w{_nested" char="{"/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1=" "/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1="\"/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1="}"/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1="{"/>+      </context>++      <context name="RubySourceLine%w[" attribute="Ruby Raw String">+        <DetectChar attribute="Ruby GDL input" context="#pop#pop!RubySourceLineOp1" char="]" endRegion="GdlInput"/>+        <IncludeRules context="RubySourceLine%w[_rule"/>+      </context>+      <context name="RubySourceLine%w[_nested" attribute="Ruby Raw String">+        <DetectChar attribute="Ruby Raw String" context="#pop" char="]"/>+        <IncludeRules context="RubySourceLine%w[_rule"/>+      </context>+      <context name="RubySourceLine%w[_rule" attribute="Ruby Raw String">+        <DetectChar attribute="Ruby Raw String" context="RubySourceLine%w[_nested" char="["/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1=" "/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1="\"/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1="]"/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1="["/>+      </context>++      <context name="RubySourceLine%w&lt;" attribute="Ruby Raw String">+        <DetectChar attribute="Ruby GDL input" context="#pop#pop!RubySourceLineOp1" char=">" endRegion="GdlInput"/>+        <IncludeRules context="RubySourceLine%w&lt;_rule"/>+      </context>+      <context name="RubySourceLine%w&lt;_nested" attribute="Ruby Raw String">+        <DetectChar attribute="Ruby Raw String" context="#pop" char=">"/>+        <IncludeRules context="RubySourceLine%w&lt;_rule"/>+      </context>+      <context name="RubySourceLine%w&lt;_rule" attribute="Ruby Raw String">+        <DetectChar attribute="Ruby Raw String" context="RubySourceLine%w&lt;_nested" char="&lt;"/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1=" "/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1="\"/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1=">"/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1="&lt;"/>+      </context>++      <!-- this format doesn't allow nesting. it is terminated by the next occurrence of the+        delimiter character+        -->+      <context name="RubySourceLine%w_" attribute="Ruby Raw String">+        <Detect2Chars attribute="Ruby String Char" char="\" char1=" "/>+        <IncludeRules context="RubySourceLine%q_"/>+      </context>+++      <!-- apostrophed string specific contexts -->++      <context name="RubySourceLine%q(" attribute="Ruby Raw String">+        <DetectChar attribute="Ruby GDL input" context="#pop#pop!RubySourceLineOp1" char=")" endRegion="GdlInput"/>+        <IncludeRules context="RubySourceLine%q(_rule"/>+      </context>+      <context name="RubySourceLine%q(_nested" attribute="Ruby Raw String">+        <DetectChar attribute="Ruby Raw String" context="#pop" char=")"/>+        <IncludeRules context="RubySourceLine%q(_rule"/>+      </context>+      <context name="RubySourceLine%q(_rule" attribute="Ruby Raw String">+        <DetectChar attribute="Ruby Raw String" context="RubySourceLine%q(_nested" char="("/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1="\"/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1=")"/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1="("/>+      </context>++      <context name="RubySourceLine%q{" attribute="Ruby Raw String">+        <DetectChar attribute="Ruby GDL input" context="#pop#pop!RubySourceLineOp1" char="}" endRegion="GdlInput"/>+        <IncludeRules context="RubySourceLine%q{_rule"/>+      </context>+      <context name="RubySourceLine%q{_nested" attribute="Ruby Raw String">+        <DetectChar attribute="Ruby Raw String" context="#pop" char="}"/>+        <IncludeRules context="RubySourceLine%q{_rule"/>+      </context>+      <context name="RubySourceLine%q{_rule" attribute="Ruby Raw String">+        <DetectChar attribute="Ruby Raw String" context="RubySourceLine%q{_nested" char="{"/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1="\"/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1="}"/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1="{"/>+      </context>++      <context name="RubySourceLine%q[" attribute="Ruby Raw String">+        <DetectChar attribute="Ruby GDL input" context="#pop#pop!RubySourceLineOp1" char="]" endRegion="GdlInput"/>+        <IncludeRules context="RubySourceLine%q[_rule"/>+      </context>+      <context name="RubySourceLine%q[_nested" attribute="Ruby Raw String">+        <DetectChar attribute="Ruby Raw String" context="#pop" char="]"/>+        <IncludeRules context="RubySourceLine%q[_rule"/>+      </context>+      <context name="RubySourceLine%q[_rule" attribute="Ruby Raw String">+        <DetectChar attribute="Ruby Raw String" context="RubySourceLine%q[_nested" char="["/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1="\"/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1="]"/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1="["/>+      </context>++      <context name="RubySourceLine%q&lt;" attribute="Ruby Raw String">+        <DetectChar attribute="Ruby GDL input" context="#pop#pop!RubySourceLineOp1" char=">" endRegion="GdlInput"/>+        <IncludeRules context="RubySourceLine%q&lt;_rule"/>+      </context>+      <context name="RubySourceLine%q&lt;_nested" attribute="Ruby Raw String">+        <DetectChar attribute="Ruby Raw String" context="#pop" char=">"/>+        <IncludeRules context="RubySourceLine%q&lt;_rule"/>+      </context>+      <context name="RubySourceLine%q&lt;_rule" attribute="Ruby Raw String">+        <DetectChar attribute="Ruby Raw String" context="RubySourceLine%q&lt;_nested" char="&lt;"/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1="\"/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1=">"/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1="&lt;"/>+      </context>++      <!-- this format doesn't allow nesting. it is terminated by the next occurrence of the+        delimiter character+        -->+      <context name="RubySourceLine%q_" attribute="Ruby Raw String">+        <Detect2Chars attribute="Ruby Raw String" char="\" char1="\"/>+        <DetectChar attribute="Ruby GDL input" context="#pop#pop!RubySourceLineOp1" char="1" dynamic="true" endRegion="GdlInput"/>+        <StringDetect attribute="Ruby String Char" String="\%1" dynamic="true"/>+      </context>+++      <!-- symbol string specific contexts -->++      <context name="RubySourceLine%s(" attribute="Ruby Symbol">+        <DetectChar attribute="Ruby GDL input" context="#pop#pop!RubySourceLineOp1" char=")" endRegion="GdlInput"/>+        <IncludeRules context="RubySourceLine%s(_rule"/>+      </context>+      <context name="RubySourceLine%s(_nested" attribute="Ruby Symbol">+        <DetectChar attribute="Ruby Symbol" context="#pop" char=")"/>+        <IncludeRules context="RubySourceLine%s(_rule"/>+      </context>+      <context name="RubySourceLine%s(_rule" attribute="Ruby Symbol">+        <DetectChar attribute="Ruby Symbol" context="RubySourceLine%s(_nested" char="("/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1="\"/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1=")"/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1="("/>+      </context>++      <context name="RubySourceLine%s{" attribute="Ruby Symbol">+        <DetectChar attribute="Ruby GDL input" context="#pop#pop!RubySourceLineOp1" char="}" endRegion="GdlInput"/>+        <IncludeRules context="RubySourceLine%s{_rule"/>+      </context>+      <context name="RubySourceLine%s{_nested" attribute="Ruby Symbol">+        <DetectChar attribute="Ruby Symbol" context="#pop" char="}"/>+        <IncludeRules context="RubySourceLine%s{_rule"/>+      </context>+      <context name="RubySourceLine%s{_rule" attribute="Ruby Symbol">+        <DetectChar attribute="Ruby Symbol" context="RubySourceLine%s{_nested" char="{"/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1="\"/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1="}"/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1="{"/>+      </context>++      <context name="RubySourceLine%s[" attribute="Ruby Symbol">+        <DetectChar attribute="Ruby GDL input" context="#pop#pop!RubySourceLineOp1" char="]" endRegion="GdlInput"/>+        <IncludeRules context="RubySourceLine%s[_rule"/>+      </context>+      <context name="RubySourceLine%s[_nested" attribute="Ruby Symbol">+        <DetectChar attribute="Ruby Symbol" context="#pop" char="]"/>+        <IncludeRules context="RubySourceLine%s[_rule"/>+      </context>+      <context name="RubySourceLine%s[_rule" attribute="Ruby Symbol">+        <DetectChar attribute="Ruby Symbol" context="RubySourceLine%s[_nested" char="["/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1="\"/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1="]"/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1="["/>+      </context>++      <context name="RubySourceLine%s&lt;" attribute="Ruby Symbol">+        <DetectChar attribute="Ruby GDL input" context="#pop#pop!RubySourceLineOp1" char=">" endRegion="GdlInput"/>+        <IncludeRules context="RubySourceLine%s&lt;_rule"/>+      </context>+      <context name="RubySourceLine%s&lt;_nested" attribute="Ruby Symbol">+        <DetectChar attribute="Ruby Symbol" context="#pop" char=">"/>+        <IncludeRules context="RubySourceLine%s&lt;_rule"/>+      </context>+      <context name="RubySourceLine%s&lt;_rule" attribute="Ruby Symbol">+        <DetectChar attribute="Ruby Symbol" context="RubySourceLine%s&lt;_nested" char="&lt;"/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1="\"/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1=">"/>+        <Detect2Chars attribute="Ruby String Char" char="\" char1="&lt;"/>+      </context>++      <!-- this format doesn't allow nesting. it is terminated by the next occurrence of the+        delimiter character+        -->+      <context name="RubySourceLine%s_" attribute="Ruby Symbol">+        <Detect2Chars attribute="Ruby Symbol" char="\" char1="\"/>+        <DetectChar attribute="Ruby GDL input" context="#pop#pop!RubySourceLineOp1" char="1" dynamic="true" endRegion="GdlInput"/>+        <StringDetect attribute="Ruby String Char" String="\%1" dynamic="true"/>+      </context>+++      <!-- regular expression specific contexts -->++      <context name="RubySourceLine%r(" attribute="Ruby String">+        <DetectChar attribute="Ruby GDL input" context="#pop!RubySourceLineRegExMode" char=")" endRegion="GdlInput"/> <IncludeRules context="RubySourceLine%r(_rule"/>+      </context>+      <context name="RubySourceLine%r(_nested" attribute="Ruby String">+        <DetectChar attribute="Ruby String" context="#pop" char=")"/>+        <IncludeRules context="RubySourceLine%r(_rule"/>+      </context>+      <context name="RubySourceLine%r(_rule" attribute="Ruby String">+        <DetectChar attribute="Ruby String" context="RubySourceLine%r(_nested" char="("/>+        <IncludeRules context="RubySourceLineRegExSpecial"/>+      </context>++      <context name="RubySourceLine%r{" attribute="Ruby String">+        <DetectChar attribute="Ruby GDL input" context="#pop!RubySourceLineRegExMode" char="}" endRegion="GdlInput"/>+        <IncludeRules context="RubySourceLine%r{_rule"/>+      </context>+      <context name="RubySourceLine%r{_nested" attribute="Ruby String">+        <DetectChar attribute="Ruby String" context="#pop" char="}"/>+        <IncludeRules context="RubySourceLine%r{_rule"/>+      </context>+      <context name="RubySourceLine%r{_rule" attribute="Ruby String">+        <DetectChar attribute="Ruby String" context="RubySourceLine%r{_nested" char="{"/>+        <IncludeRules context="RubySourceLineRegExSpecial"/>+      </context>++      <context name="RubySourceLine%r[" attribute="Ruby String">+        <DetectChar attribute="Ruby GDL input" context="#pop!RubySourceLineRegExMode" char="]" endRegion="GdlInput"/>+        <IncludeRules context="RubySourceLine%r[_rule"/>+      </context>+      <context name="RubySourceLine%r[_nested" attribute="Ruby String">+        <DetectChar attribute="Ruby String" context="#pop" char="]"/>+        <IncludeRules context="RubySourceLine%r[_rule"/>+      </context>+      <context name="RubySourceLine%r[_rule" attribute="Ruby String">+        <DetectChar attribute="Ruby String" context="RubySourceLine%r[_nested" char="["/>+        <IncludeRules context="RubySourceLineRegExSpecial"/>+      </context>++      <context name="RubySourceLine%r&lt;" attribute="Ruby String">+        <DetectChar attribute="Ruby GDL input" context="#pop!RubySourceLineRegExMode" char=">" endRegion="GdlInput"/>+        <IncludeRules context="RubySourceLine%r&lt;_rule"/>+      </context>+      <context name="RubySourceLine%r&lt;_nested" attribute="Ruby String">+        <DetectChar attribute="Ruby String" context="#pop" char=">"/>+        <IncludeRules context="RubySourceLine%r&lt;_rule"/>+      </context>+      <context name="RubySourceLine%r&lt;_rule" attribute="Ruby String">+        <DetectChar attribute="Ruby String" context="RubySourceLine%r&lt;_nested" char="&lt;"/>+        <IncludeRules context="RubySourceLineRegExSpecial"/>+      </context>++      <!-- this format doesn't allow nesting. it is terminated by the next occurrence of the+        delimiter character+        -->+      <context name="RubySourceLine%r_" attribute="Ruby Regular Expression">+        <DetectChar attribute="Ruby GDL input" context="#pop!RubySourceLineRegExMode" char="1" dynamic="true" endRegion="GdlInput"/>+        <StringDetect attribute="Ruby String Char" String="\%1" dynamic="true"/>+        <IncludeRules context="RubySourceLineRegExSpecial"/>+      </context>+++      <!-- shell command specific contexts -->++      <context name="RubySourceLine%x(" attribute="Ruby Command">+        <DetectChar attribute="Ruby GDL input" context="#pop#pop!RubySourceLineOp1" char=")" endRegion="GdlInput"/>+        <IncludeRules context="RubySourceLine%x(_rule"/>+      </context>+      <context name="RubySourceLine%x(_nested" attribute="Ruby Command">+        <DetectChar attribute="Ruby Command" context="#pop" char=")"/>+        <IncludeRules context="RubySourceLine%x(_rule"/>+      </context>+      <context name="RubySourceLine%x(_rule" attribute="Ruby Command">+        <DetectChar attribute="Ruby Command" context="RubySourceLine%x(_nested" char="("/>+        <IncludeRules context="RubySourceLineDQuoteSpecial"/>+      </context>++      <context name="RubySourceLine%x{" attribute="Ruby Command">+        <DetectChar attribute="Ruby GDL input" context="#pop#pop!RubySourceLineOp1" char="}" endRegion="GdlInput"/>+        <IncludeRules context="RubySourceLine%x{_rule"/>+      </context>+      <context name="RubySourceLine%x{_nested" attribute="Ruby Command">+        <DetectChar attribute="Ruby Command" context="#pop" char="}"/>+        <IncludeRules context="RubySourceLine%x{_rule"/>+      </context>+      <context name="RubySourceLine%x{_rule" attribute="Ruby Command">+        <DetectChar attribute="Ruby Command" context="RubySourceLine%x{_nested" char="{"/>+        <IncludeRules context="RubySourceLineDQuoteSpecial"/>+      </context>++      <context name="RubySourceLine%x[" attribute="Ruby Command">+        <DetectChar attribute="Ruby GDL input" context="#pop#pop!RubySourceLineOp1" char="]" endRegion="GdlInput"/>+        <IncludeRules context="RubySourceLine%x[_rule"/>+      </context>+      <context name="RubySourceLine%x[_nested" attribute="Ruby Command">+        <DetectChar attribute="Ruby Command" context="#pop" char="]"/>+        <IncludeRules context="RubySourceLine%x[_rule"/>+      </context>+      <context name="RubySourceLine%x[_rule" attribute="Ruby Command">+        <DetectChar attribute="Ruby Command" context="RubySourceLine%x[_nested" char="["/>+        <IncludeRules context="RubySourceLineDQuoteSpecial"/>+      </context>++      <context name="RubySourceLine%x&lt;" attribute="Ruby Command">+        <DetectChar attribute="Ruby GDL input" context="#pop#pop!RubySourceLineOp1" char=">" endRegion="GdlInput"/>+        <IncludeRules context="RubySourceLine%x&lt;_rule"/>+      </context>+      <context name="RubySourceLine%x&lt;_nested" attribute="Ruby Command">+        <DetectChar attribute="Ruby Command" context="#pop" char=">"/>+        <IncludeRules context="RubySourceLine%x&lt;_rule"/>+      </context>+      <context name="RubySourceLine%x&lt;_rule" attribute="Ruby Command">+        <DetectChar attribute="Ruby Command" context="RubySourceLine%x&lt;_nested" char="&lt;"/>+        <IncludeRules context="RubySourceLineDQuoteSpecial"/>+      </context>++      <!-- this format doesn't allow nesting. it is terminated by the next occurrence of the+        delimiter character+        -->+      <context name="RubySourceLine%x_" attribute="Ruby Command">+        <IncludeRules context="RubySourceLine%Q_"/>+      </context>++    </contexts>+++    <itemDatas>+      <!-- HAML itemData -->++      <itemData name="Normal Text" defStyleNum="dsNormal"/>+      <itemData name="Other code embedded in haml" defStyleNum="dsNormal"/>+      <itemData name="Keyword" defStyleNum="dsKeyword"/>+      <itemData name="String" defStyleNum="dsString"/>+      <itemData name="Escaped Text" defStyleNum="dsSpecialChar"/>+      <itemData name="Operator" defStyleNum="dsPreprocessor"/>+      <itemData name="Comment" defStyleNum="dsComment"/>+      <itemData name="Doctype" defStyleNum="dsDataType" bold="1"/>+      <itemData name="Filter" defStyleNum="dsOthers"/>+      <itemData name="Element Id" defStyleNum="dsFloat" bold="1"/>+      <itemData name="Element Class" defStyleNum="dsFloat"/>+      <itemData name="Special Attribute" defStyleNum="dsAttribute"/>+      <itemData name="Div Id" defStyleNum="dsDecVal" bold="1"/>+      <itemData name="Div Class" defStyleNum="dsDecVal"/>+      <itemData name="Tag" defStyleNum="dsKeyword"/>+      <itemData name="Entity" defStyleNum="dsDecVal"/>+      <!-- use these to mark errors and alerts things -->+      <itemData name="Error" defStyleNum="dsError"/>++      <!-- Ruby itemData -->++      <itemData name="Ruby Normal Text" defStyleNum="dsNormal"/>++      <itemData name="Ruby Keyword" defStyleNum="dsControlFlow"/>+      <itemData name="Ruby Attribute Definition" defStyleNum="dsOthers"/>+      <itemData name="Ruby Access Control" defStyleNum="dsAttribute" bold="1"/> <!-- #0000FF -->+      <itemData name="Ruby Definition" defStyleNum="dsKeyword"/>+      <itemData name="Ruby Pseudo variable" defStyleNum="dsDecVal"/>++      <itemData name="Ruby Number" defStyleNum="dsDecVal"/>+      <itemData name="Ruby Number Suffix" defStyleNum="dsBuiltIn"/>++      <itemData name="Ruby Symbol" defStyleNum="dsWarning" bold="0" underline="0"/> <!-- #D40000 -->+      <itemData name="Ruby String" defStyleNum="dsString"/>+      <itemData name="Ruby String Char" defStyleNum="dsSpecialChar" spellChecking="false"/>+      <itemData name="Ruby Raw String" defStyleNum="dsVerbatimString"/> <!-- #DD4A4A -->+      <itemData name="Ruby Char Literal" defStyleNum="dsSpecialChar" spellChecking="false"/>+      <itemData name="Ruby Char" defStyleNum="dsChar"/>++      <itemData name="Ruby Command" defStyleNum="dsInformation"/> <!-- #AA3000 -->+      <itemData name="Ruby Message" defStyleNum="dsAttribute" bold="0"/> <!-- #4000A7 -->+      <itemData name="Ruby Regular Expression" defStyleNum="dsSpecialString" spellChecking="false"/> <!-- #4A5704 -->+      <itemData name="Ruby Substitution"	defStyleNum="dsSpecialChar"/>+      <!-- short for 'general delimited input' -->+      <itemData name="Ruby GDL input" defStyleNum="dsOthers"/>++      <itemData name="Ruby Default globals" defStyleNum="dsVariable" bold="1"/> <!-- #C00000 -->+      <itemData name="Ruby Global Variable" defStyleNum="dsVariable"/> <!-- #C00000 -->+      <itemData name="Ruby Global Constant" defStyleNum="dsConstant" bold="1"/> <!-- #bb1188 -->+      <itemData name="Ruby Constant" defStyleNum="dsDataType"/>+      <itemData name="Ruby Constant Value" defStyleNum="dsConstant" bold="0"/> <!-- #bb1188 -->+      <itemData name="Ruby Kernel methods" defStyleNum="dsFunction" bold="1"/> <!-- #CC0E86 -->+      <itemData name="Ruby Module mixin methods" defStyleNum="dsFunction" bold="1"/> <!-- #CC0E86 -->+      <itemData name="Ruby Member" defStyleNum="dsAttribute"/>+      <itemData name="Ruby Instance Variable" defStyleNum="dsOthers"/>+      <itemData name="Ruby Class Variable" defStyleNum="dsOthers"/>++      <itemData name="Ruby Comment" defStyleNum="dsComment"/>++      <itemData name="Ruby Here Document" defStyleNum="dsDocumentation"/>++      <itemData name="Ruby Delimiter" defStyleNum="dsKeyword"/> <!-- #FF9FEC -->+      <itemData name="Ruby Operator" defStyleNum="dsOperator" bold="1"/> <!-- #FF9FEC -->++    </itemDatas>+  </highlighting>+  <general>+    <folding indentationsensitive="1"/>+    <emptyLines>+      <emptyLine regexpr="\s+"/>+    </emptyLines>+    <comments>+      <comment name="singleLine" start="/" position="afterwhitespace"/>+    </comments>+    <keywords casesensitive="1" weakDeliminator="!?"/>+  </general>+</language>+<!-- kate: replace-tabs on; tab-width 2; indent-width 2; -->
xml/haskell.xml view
@@ -1,8 +1,8 @@ <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE language [-  <!ENTITY symbolops "\-!#\$&#37;&amp;\*\+/&lt;=&gt;\?&#92;@\^\|~\.:">+  <!ENTITY symbolops "\-!#\$&#37;&amp;\*\+/&lt;=&gt;\?&#92;&#92;@\^\|~\.:"> ]>-<language name="Haskell" alternativeNames="HS" version="21" kateversion="5.53" section="Sources" extensions="*.hs;*.chs;*.hs-boot" mimetype="text/x-haskell" author="Nicolas Wu (zenzike@gmail.com)" license="LGPL" indenter="haskell" style="haskell">+<language name="Haskell" alternativeNames="HS" version="22" kateversion="5.53" section="Sources" extensions="*.hs;*.chs;*.hs-boot" mimetype="text/x-haskell" author="Nicolas Wu (zenzike@gmail.com)" license="LGPL" indenter="haskell" style="haskell">   <highlighting>   <list name="keywords">     <item>case</item>@@ -473,7 +473,8 @@       <RegExpr attribute="Special"          context="#stay" String="(::|=&gt;|-&gt;|&lt;-|=)(?![&symbolops;])" />       <RegExpr attribute="Signature"        context="#stay" String="\s*[a-z_][a-zA-Z0-9_']*\s*(?=::([^&symbolops;]|$))|\s*(\([&symbolops;]*\))*\s*(?=::[^&symbolops;])" />       <RegExpr attribute="Function"         context="#stay" String="([A-Z][a-zA-Z0-9_']*\.)*[a-z_][a-zA-Z0-9_']*" />-      <RegExpr attribute="Operator"         context="#stay" String="([A-Z][a-zA-Z0-9_']*\.)*[&symbolops;]+" />+      <!-- Match backslash operators before general operators (order matters for precedence) -->+      <RegExpr attribute="Operator"         context="#stay" String="([A-Z][a-zA-Z0-9_']*\.)*\\[!#\$%&amp;\*\+/&lt;=&gt;\?\\@\^\|~\.:]+|([A-Z][a-zA-Z0-9_']*\.)*[&symbolops;]+" />       <RegExpr attribute="Type"             context="#stay" String="([A-Z][a-zA-Z0-9_']*\.)*[A-Z][a-zA-Z0-9_']*|'(?![A-Z]')([A-Z][a-zA-Z0-9_']*\.)*[A-Z][a-zA-Z0-9_']*" />        <RegExpr    attribute="Float"   context="#stay" String ="\d+\.\d+([Ee][+-]?\d+)?|\d+[Ee][+-]?\d+"/>@@ -541,11 +542,12 @@     </context>     <context attribute="Normal" lineEndContext="#pop" name="import">       <DetectSpaces attribute="Normal" />+      <IncludeRules context="FindComment" />       <keyword attribute="Keyword"          context="#stay" String="import_keywords" />       <RegExpr attribute="Function"         context="#stay" String="([A-Z][a-zA-Z0-9_']*\.)*[a-z][a-zA-Z0-9_']*" />       <RegExpr attribute="Type"             context="#stay" String="([A-Z][a-zA-Z0-9_']*\.)*[A-Z][a-zA-Z0-9_']*" />--      <IncludeRules context="FindComment" />+      <!-- Add operator matching to import context (backslash operators matched first) -->+      <RegExpr attribute="Operator"         context="#stay" String="([A-Z][a-zA-Z0-9_']*\.)*\\[!#\$%&amp;\*\+/&lt;=&gt;\?\\@\^\|~\.:]+|([A-Z][a-zA-Z0-9_']*\.)*[&symbolops;]+" />     </context>      <!-- Haddock -->
+ xml/idl.xml view
@@ -0,0 +1,120 @@+<?xml version="1.0" encoding="UTF-8"?>+<!DOCTYPE language>+<language name="IDL" version="7" kateversion="5.0" section="Sources" extensions="*.idl" mimetype="text/x-idl-src">+  <highlighting>+    <list name="keywords">+      <item>any</item>+      <item>attribute</item>+      <item>case</item>+      <item>const</item>+      <item>context</item>+      <item>default</item>+      <item>enum</item>+      <item>exception</item>+      <item>FALSE</item>+      <item>fixed</item>+      <item>public</item>+      <item>in</item>+      <item>inout</item>+      <item>interface</item>+      <item>module</item>+      <item>Object</item>+      <item>oneway</item>+      <item>out</item>+      <item>raises</item>+      <item>readonly</item>+      <item>sequence</item>+      <item>struct</item>+      <item>switch</item>+      <item>TRUE</item>+      <item>typedef</item>+      <item>unsigned</item>+      <item>union</item>+    </list>+    <list name="types">+      <item>boolean</item>+      <item>char</item>+      <item>double</item>+      <item>float</item>+      <item>long</item>+      <item>octet</item>+      <item>short</item>+      <item>string</item>+      <item>void</item>+      <item>wchar</item>+      <item>wstring</item>+    </list>+    <contexts>+      <context attribute="Normal Text" lineEndContext="#stay" name="Normal">+        <keyword attribute="Keyword" context="#stay" String="keywords" />+        <keyword attribute="Data Type" context="#stay" String="types" />+        <HlCOct attribute="Octal" context="#stay"/>+        <HlCHex attribute="Hex" context="#stay"/>+        <HlCChar attribute="Char" context="#stay"/>+        <DetectChar attribute="String" context="String" char="&quot;"/>+        <IncludeRules context="FindComments" />+        <AnyChar attribute="Symbol" context="#stay" String="!%&amp;()+,-&lt;=&gt;?[]^{|}~"/>+        <StringDetect attribute="Comment" context="Some Context3" String="#if 0" insensitive="false"/>+        <DetectChar attribute="Preprocessor" context="Preprocessor" char="#" column="0"/>+      </context>+      <context name="FindComments" attribute="Normal Text" lineEndContext="#pop">+        <Detect2Chars attribute="Comment" context="MatchComment" char="/" char1="/" lookAhead="true"/>+        <Detect2Chars attribute="Comment" context="MatchComment" char="/" char1="*" lookAhead="true" />+      </context>+      <context name="MatchComment" attribute="Normal Text" lineEndContext="#pop" fallthrough="true" fallthroughContext="#pop">+        <IncludeRules context="##Doxygen" />+        <Detect2Chars attribute="Comment" context="#pop!Commentar 1" char="/" char1="/" />+        <Detect2Chars attribute="Comment" context="#pop!Commentar 2" char="/" char1="*" beginRegion="Comment" />+      </context>+      <context attribute="String" lineEndContext="#stay" name="String">+        <LineContinue attribute="String" context="Some Context"/>+        <HlCStringChar attribute="String Char" context="#stay"/>+        <DetectChar attribute="String" context="#pop" char="&quot;"/>+      </context>+      <context attribute="Comment" lineEndContext="#pop" name="Commentar 1">+        <DetectSpaces />+        <IncludeRules context="##Comments" />+      </context>+      <context attribute="Comment" lineEndContext="#stay" name="Commentar 2">+        <Detect2Chars attribute="Comment" context="#pop" char="*" char1="/" endRegion="Comment"/>+        <DetectSpaces />+        <IncludeRules context="##Comments" />+      </context>+      <context attribute="Preprocessor" lineEndContext="#pop" name="Preprocessor">+        <LineContinue attribute="Preprocessor" context="Some Context2"/>+        <RangeDetect attribute="Prep. Lib" context="#stay" char="&quot;" char1="&quot;"/>+        <RangeDetect attribute="Prep. Lib" context="#stay" char="&lt;" char1="&gt;"/>+        <IncludeRules context="FindComments" />+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="Some Context"/>+      <context attribute="Normal Text" lineEndContext="#pop" name="Some Context2"/>+      <context attribute="Normal Text" lineEndContext="#stay" name="Some Context3">+        <DetectSpaces />+        <IncludeRules context="##Comments" />+        <StringDetect attribute="Comment" context="#pop" String="#endif" column="0"/>+      </context>+    </contexts>+    <itemDatas>+      <itemData name="Normal Text" defStyleNum="dsNormal"/>+      <itemData name="Keyword"  defStyleNum="dsKeyword"/>+      <itemData name="Data Type"  defStyleNum="dsDataType"/>+      <itemData name="Octal"  defStyleNum="dsBaseN"/>+      <itemData name="Hex"  defStyleNum="dsBaseN"/>+      <itemData name="Char"  defStyleNum="dsChar"/>+      <itemData name="String"  defStyleNum="dsString"/>+      <itemData name="String Char"  defStyleNum="dsChar"/>+      <itemData name="Comment"  defStyleNum="dsComment"/>+      <itemData name="Symbol"  defStyleNum="dsOperator"/>+      <itemData name="Preprocessor"  defStyleNum="dsOthers"/>+      <itemData name="Prep. Lib"  defStyleNum="dsOthers"/>+    </itemDatas>+  </highlighting>+  <general>+    <comments>+      <comment name="singleLine" start="//" />+      <comment name="multiLine" start="/*" end="*/" region="Comment" />+    </comments>+    <keywords casesensitive="1" />+  </general>+</language>+<!-- kate: replace-tabs on; tab-width 2; indent-width 2; -->
xml/j.xml view
@@ -1,121 +1,129 @@ <?xml version="1.0" encoding="UTF-8"?>-<!----Changes:--Version 1.5 (2015-04-29) by Igor Zhuravlov-- language/@kateversion upgraded from "2.4" to "3.4"--Version 1.4 (2015-04-20) by Igor Zhuravlov-- merge versions 1.2 and 1.3-- removed not used def and defc entities-- approached color scheme to JQt-- separated out color scheme to j14.katehlcolor file-- dropped ExpArg: n. m. u. v. x. y.-- reformatted a bit--Version 1.3 (2014-05-26) by greg heil-- based on version 1.1-- add Foldable feature-- change color scheme-- add def and defc entities-- split long lines--Version 1.2 (2013-09-29) by Igor Zhuravlov-- fix Adverb regexp's pattern-- fix Verb regexp's pattern--Version 1.1 (2013-03-18) by Igor Zhuravlov-- fix enum entity's exponent definition-- rework String regexp's pattern-- use entities in Number regexp's pattern-- use entities in Control regexp's pattern--Version 1.0 (2012-03-21) by Igor Zhuravlov-- initial release----> <!DOCTYPE language [-  <!ENTITY unum "\d+">                                 <!-- Unsigned integer number -->-  <!ENTITY anum "[a-z\d]+">                            <!-- Non-10-based unsigned integer number, e.g. 1a -->-  <!ENTITY bnum "\b&unum;b_?&anum;(\.&anum;)\b">       <!-- Based integer number, e.g. 36b_1a.z2 -->-  <!ENTITY inum "_?&unum;">                            <!-- Integer number -->+  <!ENTITY unum "\d+">                                 <!-- Unsigned integer number, e.g. 123 -->+  <!ENTITY inum "_?&unum;">                            <!-- Integer number, e.g. _123 -->+  <!ENTITY anum "[a-z\d]+">                            <!-- Non-decimal unsigned integer number, e.g. 1a -->+  <!ENTITY bnum "\b_?&unum;b_?&anum;(\.&anum;)?\b">    <!-- Non-decimal number, e.g. _36b_1a.z2 -->   <!ENTITY xnum "\b&inum;x\b">                         <!-- Extended precision integer number, e.g. _123x -->   <!ENTITY rnum "\b&inum;r&inum;\b">                   <!-- Rational number, e.g. _1r23 -->-  <!ENTITY fnum "&inum;(\.&unum;)?">                   <!-- Floating point number, e.g. 1.23 -->-  <!ENTITY enum "(&fnum;(e&inum;)?|_?_|_\.)">          <!-- Exponential (scientific) notation, e.g. 1.2e_3 -->-  <!ENTITY cnum "&enum;((j|a[dr])&enum;)?">            <!-- Complex number, e.g. 1.2e3j4.5e_6 -->-  <!ENTITY pnum "\b&cnum;([px]&cnum;)?(?![a-z\d_.])">  <!-- Number based on pi or e, e.g. 1j2p3j4 -->-  <!ENTITY name "[a-zA-Z][a-zA-Z\d_]*">                <!-- Name -->+  <!ENTITY fnum "&inum;(\.&unum;)?">                   <!-- Floating point number, e.g. _1.23 -->+  <!ENTITY enum "(&fnum;(e&inum;)?|_?_|_\.)">          <!-- Exponential (scientific) notation, e.g. _1.2e_3 -->+  <!ENTITY cnum "&enum;((j|a[dr])&enum;)?">            <!-- Complex number, e.g. _1.2e3j_4.5e_6 -->+  <!ENTITY pnum "\b&cnum;([px]&cnum;)?(?![a-z\d_.])">  <!-- Number based on pi or on e, e.g. _1j2p3j4 -->+  <!ENTITY name "[a-zA-Z]\w*">                         <!-- Name -->   <!ENTITY lname "\b&name;_(&name;)?_\b">              <!-- Locative, a__ means a_base_ -->   <!ENTITY ilname "\b&name;__&name;\b">                <!-- Indirect locative --> ]> <!---  j.xml syntax highlighting for J programming language under Kate+  J language Syntax Highlighting Definition+  See updates and changelog at https://github.com/jip/syntax-highlighting -  J is a modern, high-level, general-purpose, high-performance, portable programming language-  http://www.jsoftware.com+  J is a high-level, general-purpose programming language+  https://www.jsoftware.com -  Kate is a KDE Advanced Text Editor-  http://kate.kde.org/+  This file is part of the KDE's KSyntaxHighlighting framework+  https://invent.kde.org/frameworks/syntax-highlighting++  SPDX-FileCopyrightText: 2012,2013,2015,2016,2020,2023,2026 Igor Zhuravlov <zhuravlov.ip@ya.ru>+  SPDX-FileCopyrightText: 2014 greg heil <gheil.j@gmail.com>+  SPDX-License-Identifier: GPL-3.0-or-later --> <language name="J"           section="Scripts"-          version="5"+          version="7"           kateversion="5.0"-          extensions="*.ijs;*.ijt;*.IJS;*.IJT"+          extensions="*.ijs;*.ijt;*.ijx"           mimetype="text/x-j;text/x-jsrc"           author="Igor Zhuravlov (zhuravlov.ip@ya.ru), greg heil (gheil.j@gmail.com)"           indenter="normal"           license="GPL">   <highlighting>+    <list name="controls">+      <item>{{</item>+      <item>}}</item>+      <item>assert.</item>+      <item>break.</item>+      <item>case.</item>+      <item>catch.</item>+      <item>catchd.</item>+      <item>catcht.</item>+      <item>continue.</item>+      <item>do.</item>+      <item>else.</item>+      <item>elseif.</item>+      <item>end.</item>+      <item>for.</item>+      <item>fcase.</item>+      <item>if.</item>+      <item>return.</item>+      <item>select.</item>+      <item>throw.</item>+      <item>try.</item>+      <item>while.</item>+      <item>whilst.</item>+    </list>     <contexts>       <context attribute="Sentence" lineEndContext="#pop" name="sentence">         <DetectSpaces/>-        <RegExpr      attribute="Foldable"       context="#stay"        String=":\s*0|\bdefine\b" beginRegion="Fold"/>-        <LineContinue attribute="Foldable"       context="#stay"        char=")" endRegion="Fold" column="0"/>-        <StringDetect attribute="Comment"        context="#stay"        String="NB.(" beginRegion="Fold"/>-        <StringDetect attribute="Comment"        context="#stay"        String="NB.)" endRegion="Fold"/>+        <StringDetect attribute="Comment"        context="#stay"        String="NB.(" beginRegion="CommentBlock"/>+        <StringDetect attribute="Comment"        context="#stay"        String="NB.)" endRegion="CommentBlock"/>+        <StringDetect attribute="Annotation"     context="annotation"   String="NB. * "/>         <StringDetect attribute="Comment"        context="comment line" String="NB."/>+        <RegExpr      attribute="Foldable"       context="noun block"   String="(?&lt;![.\w])0\s+:\s*0|\bNote\s*&apos;" beginRegion="DefBlock"/>+        <RegExpr      attribute="Foldable"       context="#stay"        String=":\s*0|\bdefine\b" beginRegion="DefBlock"/>+        <LineContinue attribute="Foldable"       context="#stay"        char=")" endRegion="DefBlock" column="0"/>+        <StringDetect attribute="Foldable"       context="#stay"        String="{{" beginRegion="DDBlock"/>+        <StringDetect attribute="Foldable"       context="#stay"        String="}}" endRegion="DDBlock"/>         <RegExpr      attribute="String"         context="#stay"        String="&apos;([^&apos;]|&apos;&apos;)*&apos;"/>-        <RegExpr      attribute="Adverb"         context="#stay"        String="([/\\]\.|\b[bfMt]\.|\bt:|[~/\\}])(?![.:])"/>-        <RegExpr      attribute="Verb"           context="#stay"        String="(_?\d:|p\.\.|[ACeEIjLor]\.|[_/\\iqsux]:|\{::|[=!\]]|[-&lt;&gt;+*%$|,#\{][.:]?|[;\[]:?|[~}&quot;ip][.:]|[?^]\.?)(?![.:])"/>+        <RegExpr      attribute="Adverb"         context="#stay"        String="([/\\]\.|/\.\.|\]:|\b[bfM]\.|[~/\\}])(?![.:])"/>+        <RegExpr      attribute="Verb"           context="#stay"        String="(_?\d:|p\.\.|[AcCeEIjLor]\.|__?:|[/\\iqsuxZ]:|\{::|[=!\]]|[-&lt;&gt;+*%$|,#\{][.:]?|[;\[]:?|[~}&quot;ip][.:]|[?^]\.?|\b[uv](\b|\.))(?![.:])"/>         <RegExpr      attribute="Number"         context="#stay"        String="&bnum;|&xnum;|&rnum;|&pnum;"/>-        <AnyChar      attribute="Parens"         context="#stay"        String="()"/>-        <RegExpr      attribute="Conjunction"    context="#stay"        String="(&quot;|[@&amp;][.:]?|[.:][.:]?|[!D][.:]|&amp;\.:|[;dHT]\.|`:?|[LS^]:)(?![.:])"/>-        <RegExpr      attribute="Control"        context="#stay"        String="\b(assert|break|f?case|catch[dt]?|continue|do|else(if)?|end|for(_&name;)?|(goto|label)_&name;|if|return|select|throw|try|whil(e|st))\.(?![.:])"/>-        <Detect2Chars attribute="Copulae Global" context="#stay"        char="=" char1=":"/>-        <Detect2Chars attribute="Copulae Local"  context="#stay"        char="=" char1="."/>-        <RegExpr      attribute="ExpArg"         context="#stay"        String="\b[nmuvxy](?![\w:.])"/>-        <RegExpr      attribute="Noun"           context="#stay"        String="\ba[.:](?![.:])"/>+        <AnyChar      attribute="Parenthese"     context="#stay"        String="()"/>+        <RegExpr      attribute="Conjunction"    context="#stay"        String="(&quot;|[:@&amp;][.:]?|;?\.|![.:]|&amp;\.:|[;[\]Hmt]\.|`:?|[LS^]:)(?![.:])"/>+        <keyword      attribute="Control"        context="#stay"        String="controls"/>+        <RegExpr      attribute="Control"        context="#stay"        String="\b(for|goto|label)_&name;\.(?![.:])"/>+        <StringDetect attribute="Copulae Global" context="#stay"        String="=:"/>+        <StringDetect attribute="Copulae Local"  context="#stay"        String="=."/>+        <RegExpr      attribute="Noun"           context="#stay"        String="\b(a[.:](?![.:])|[mnxy](?![\w.:]))"/>       </context>+      <context attribute="NounBlock" lineEndContext="#stay" name="noun block">+        <DetectChar   attribute="Foldable"       context="#pop"         char=")" endRegion="DefBlock" column="0"/>+      </context>+      <context attribute="Annotation" lineEndContext="#pop" name="annotation">+        <DetectSpaces/>+        <IncludeRules context="##Comments"/>+        <DetectIdentifier/>+      </context>       <context attribute="Comment" lineEndContext="#pop" name="comment line">-        <DetectSpaces />+        <DetectSpaces/>         <IncludeRules context="##Comments"/>+        <DetectIdentifier/>       </context>     </contexts>     <itemDatas>-      <itemData name="Sentence"       defStyleNum="dsNormal"/>-      <itemData name="Adverb"         defStyleNum="dsKeyword"      spellChecking="false"/>-      <itemData name="Comment"        defStyleNum="dsComment"      spellChecking="true"/>-      <itemData name="Conjunction"    defStyleNum="dsKeyword"      spellChecking="false"/>-      <itemData name="Control"        defStyleNum="dsKeyword"      spellChecking="false"/>-      <itemData name="Copulae Global" defStyleNum="dsKeyword"      spellChecking="false"/>-      <itemData name="Copulae Local"  defStyleNum="dsKeyword"      spellChecking="false"/>-      <itemData name="ExpArg"         defStyleNum="dsKeyword"      spellChecking="false" italic="true"/>-      <itemData name="Foldable"       defStyleNum="dsRegionMarker" spellChecking="false"/>-      <itemData name="Noun"           defStyleNum="dsKeyword"      spellChecking="false" bold="true"/>-      <itemData name="Number"         defStyleNum="dsDecVal"       spellChecking="false"/>-      <itemData name="Parens"         defStyleNum="dsRegionMarker" spellChecking="false"/>-      <itemData name="String"         defStyleNum="dsString"       spellChecking="false"/>-      <itemData name="Verb"           defStyleNum="dsKeyword"      spellChecking="false"/>+      <itemData name="Sentence"       defStyleNum="dsNormal"        spellChecking="false"/>+      <itemData name="Adverb"         defStyleNum="dsOperator"      spellChecking="false" bold="true"/>+      <itemData name="Annotation"     defStyleNum="dsAnnotation"    spellChecking="false"/>+      <itemData name="Comment"        defStyleNum="dsComment"       spellChecking="true"/>+      <itemData name="Conjunction"    defStyleNum="dsOperator"      spellChecking="false" bold="true"/>+      <itemData name="Control"        defStyleNum="dsControlFlow"   spellChecking="false"/>+      <itemData name="Copulae Global" defStyleNum="dsBuiltIn"       spellChecking="false"/>+      <itemData name="Copulae Local"  defStyleNum="dsBuiltIn"       spellChecking="false" bold="false"/>+      <itemData name="Foldable"       defStyleNum="dsRegionMarker"  spellChecking="false"/>+      <itemData name="Noun"           defStyleNum="dsKeyword"       spellChecking="false"/>+      <itemData name="NounBlock"      defStyleNum="dsNormal"        spellChecking="false"/>+      <itemData name="Number"         defStyleNum="dsDecVal"        spellChecking="false"/>+      <itemData name="Parenthese"     defStyleNum="dsRegionMarker"  spellChecking="false"/>+      <itemData name="String"         defStyleNum="dsString"        spellChecking="false"/>+      <itemData name="Verb"           defStyleNum="dsOperator"      spellChecking="false" bold="true"/>     </itemDatas>   </highlighting>   <general>+    <keywords casesensitive="true" weakDeliminator=".{}"/>     <comments>-      <comment name="multiLine" start="NB.(" end="NB.)" region="Fold"/>-      <comment name="singleLine" start="NB."/>+      <comment name="singleLine" start="NB." position="afterwhitespace"/>+      <comment name="multiLine" start="NB.(" end="NB.)" region="CommentBlock"/>     </comments>     <folding indentationsensitive="true"/>   </general>
+ xml/jinja.xml view
@@ -0,0 +1,298 @@+<?xml version="1.0" encoding="UTF-8"?>+<!DOCTYPE language>+<!-- Base Jinja syntax for embedding into other grammars by the jinjize script. -->+<!-- Also serves as a standalone grammar for pure Jinja macro definiton files. -->+<language name="Jinja" version="1" kateversion="5.62" section="Other" license="MIT"+          extensions="*.jinja;*.jinja2;*.j2" mimetype="text/jinja"+          priority="-99" author="zoltan.gera@qt.io">+  <highlighting>+    <list name="jinja_operators">+      <item>and</item>+      <item>in</item>+      <item>not</item>+      <item>or</item>+    </list>+    <list name="jinja_ctrlflows">+      <item>break</item>+      <item>continue</item>+      <item>else</item>+      <item>elif</item>+      <item>endfor</item>+      <item>endif</item>+      <item>for</item>+      <item>if</item>+      <item>recursive</item>+    </list>+    <list name="jinja_keywords">+      <item>autoescape</item>+      <item>block</item>+      <item>call</item>+      <item>debug</item>+      <item>do</item>+      <item>endautoescape</item>+      <item>endblock</item>+      <item>endcall</item>+      <item>endfilter</item>+      <item>endmacro</item>+      <item>endraw</item>+      <item>endset</item>+      <item>endtrans</item>+      <item>endwith</item>+      <item>extends</item>+      <item>filter</item>+      <item>macro</item>+      <item>notrimmed</item>+      <item>pluralize</item>+      <item>raw</item>+      <item>required</item>+      <item>scoped</item>+      <item>set</item>+      <item>trans</item>+      <item>trimmed</item>+      <item>with</item>+    </list>+    <list name="jinja_imports">+      <item>as</item>+      <item>context</item>+      <item>from</item>+      <item>include</item>+      <item>ignore</item>+      <item>import</item>+      <item>missing</item>+      <item>with</item>+      <item>without</item>+    </list>+    <list name="jinja_constants">+      <item>false</item>+      <item>none</item>+      <item>true</item>+      <item>False</item>+      <item>None</item>+      <item>True</item>+    </list>+    <list name="jinja_globals">+      <item>caller</item>+      <item>cycler</item>+      <item>dict</item>+      <item>joiner</item>+      <item>kwargs</item>+      <item>lipsum</item>+      <item>loop</item>+      <item>namespace</item>+      <item>range</item>+      <item>self</item>+      <item>super</item>+      <item>varargs</item>+    </list>+    <list name="jinja_builtin_filters">+      <item>abs</item>+      <item>attr</item>+      <item>batch</item>+      <item>capitalize</item>+      <item>center</item>+      <item>default</item>+      <item>dictsort</item>+      <item>escape</item>+      <item>filesizeformat</item>+      <item>first</item>+      <item>float</item>+      <item>forceescape</item>+      <item>format</item>+      <item>groupby</item>+      <item>indent</item>+      <item>int</item>+      <item>items</item>+      <item>join</item>+      <item>last</item>+      <item>length</item>+      <item>list</item>+      <item>lower</item>+      <item>map</item>+      <item>max</item>+      <item>min</item>+      <item>pprint</item>+      <item>random</item>+      <item>reject</item>+      <item>rejectattr</item>+      <item>replace</item>+      <item>reverse</item>+      <item>round</item>+      <item>safe</item>+      <item>select</item>+      <item>selectattr</item>+      <item>slice</item>+      <item>sort</item>+      <item>string</item>+      <item>striptags</item>+      <item>sum</item>+      <item>title</item>+      <item>tojson</item>+      <item>trim</item>+      <item>truncate</item>+      <item>unique</item>+      <item>upper</item>+      <item>urlencode</item>+      <item>urlize</item>+      <item>wordcount</item>+      <item>wordwrap</item>+      <item>xmlattr</item>+    </list>+    <list name="jinja_builtin_tests">+      <item>boolean</item>+      <item>callable</item>+      <item>defined</item>+      <item>divisibleby</item>+      <item>eq</item>+      <item>escaped</item>+      <item>even</item>+      <item>false</item>+      <item>filter</item>+      <item>float</item>+      <item>ge</item>+      <item>gt</item>+      <item>in</item>+      <item>integer</item>+      <item>iterable</item>+      <item>le</item>+      <item>lower</item>+      <item>lt</item>+      <item>mapping</item>+      <item>ne</item>+      <item>none</item>+      <item>number</item>+      <item>odd</item>+      <item>sameas</item>+      <item>sequence</item>+      <item>string</item>+      <item>test</item>+      <item>true</item>+      <item>undefined</item>+      <item>upper</item>+    </list>+    <contexts>+      <context name="jinja_boot" attribute="jinja_normal" lineEndContext="#stay">+        <Detect2Chars context="jinja_statement_boot" attribute="jinja_delimiter" beginRegion="jinjaStatement" char="{" char1="%" />+        <Detect2Chars context="jinja_expression_boot" attribute="jinja_delimiter" beginRegion="jinjaExpression" char="{" char1="{" />+        <Detect2Chars context="jinja_comment_boot" attribute="jinja_delimiter" beginRegion="jinjaComment" char="{" char1="#" />+      </context>+      <context name="jinja_statement_boot" attribute="jinja_normal" fallthroughContext="#pop!jinja_statement_1st">+        <AnyChar context="#pop!jinja_statement_1st" attribute="jinja_delimiter" String="-+" />+      </context>+      <context name="jinja_expression_boot" attribute="jinja_normal" fallthroughContext="#pop!jinja_expression">+        <AnyChar context="#pop!jinja_expression" attribute="jinja_delimiter" String="-+" />+      </context>+      <context name="jinja_comment_boot" attribute="jinja_normal" fallthroughContext="#pop!jinja_comment">+        <AnyChar context="#pop!jinja_comment" attribute="jinja_delimiter" String="-+" />+      </context>+      <context name="jinja_statement_1st" attribute="jinja_code" lineEndContext="#stay" fallthroughContext="#pop!jinja_statement">+        <DetectSpaces context="#stay" attribute="jinja_code" />+        <WordDetect context="#pop!jinja_statement" attribute="jinja_ctrlflow" beginRegion="jinjaFor" String="for" />+        <WordDetect context="#pop!jinja_statement" attribute="jinja_ctrlflow" endRegion="jinjaFor" String="endfor" />+        <WordDetect context="#pop!jinja_statement" attribute="jinja_ctrlflow" beginRegion="jinjaIf" String="if" />+        <WordDetect context="#pop!jinja_statement" attribute="jinja_ctrlflow" endRegion="jinjaIf" String="endif" />+        <WordDetect context="#pop!jinja_statement" attribute="jinja_keyword" beginRegion="jinjaAutoescape" String="autoescape" />+        <WordDetect context="#pop!jinja_statement" attribute="jinja_keyword" endRegion="jinjaAutoescape" String="endautoescape" />+        <WordDetect context="#pop!jinja_statement" attribute="jinja_keyword" beginRegion="jinjaBlock" String="block" />+        <WordDetect context="#pop!jinja_statement" attribute="jinja_keyword" endRegion="jinjaBlock" String="endblock" />+        <WordDetect context="#pop!jinja_statement" attribute="jinja_keyword" beginRegion="jinjaCall" String="call" />+        <WordDetect context="#pop!jinja_statement" attribute="jinja_keyword" endRegion="jinjaCall" String="endcall" />+        <WordDetect context="#pop!jinja_statement" attribute="jinja_keyword" beginRegion="jinjaFilter" String="filter" />+        <WordDetect context="#pop!jinja_statement" attribute="jinja_keyword" endRegion="jinjaFilter" String="endfilter" />+        <WordDetect context="#pop!jinja_statement" attribute="jinja_keyword" beginRegion="jinjaMacro" String="macro" />+        <WordDetect context="#pop!jinja_statement" attribute="jinja_keyword" endRegion="jinjaMacro" String="endmacro" />+        <!-- TODO: Use multi-stacking to avoid Jinja highlighting inside the raw region. -->+        <WordDetect context="#pop!jinja_statement" attribute="jinja_keyword" beginRegion="jinjaRaw" String="raw" />+        <WordDetect context="#pop!jinja_statement" attribute="jinja_keyword" endRegion="jinjaRaw" String="endraw" />+        <WordDetect context="#pop!jinja_statement" attribute="jinja_keyword" beginRegion="jinjaTrans" String="trans" />+        <WordDetect context="#pop!jinja_statement" attribute="jinja_keyword" endRegion="jinjaTrans" String="endtrans" />+        <WordDetect context="#pop!jinja_statement" attribute="jinja_keyword" beginRegion="jinjaWith" String="with" />+        <WordDetect context="#pop!jinja_statement" attribute="jinja_keyword" endRegion="jinjaWith" String="endwith" />+      </context>+      <context name="jinja_statement" attribute="jinja_code" lineEndContext="#pop!jinja_statement_1st">+        <DetectSpaces context="#stay" attribute="jinja_code" />+        <StringDetect context="#pop" attribute="jinja_delimiter" endRegion="jinjaStatement" String="-%}" />+        <StringDetect context="#pop" attribute="jinja_delimiter" endRegion="jinjaStatement" String="+%}" />+        <Detect2Chars context="#pop" attribute="jinja_delimiter" endRegion="jinjaStatement" char="%" char1="}" />+        <IncludeRules context="jinja_source" />+      </context>+      <context name="jinja_expression" attribute="jinja_code" lineEndContext="#stay">+        <DetectSpaces context="#stay" attribute="jinja_code" />+        <StringDetect context="#pop" attribute="jinja_delimiter" endRegion="jinjaExpression" String="-}}" />+        <StringDetect context="#pop" attribute="jinja_delimiter" endRegion="jinjaExpression" String="+}}" />+        <Detect2Chars context="#pop" attribute="jinja_delimiter" endRegion="jinjaExpression" char="}" char1="}" />+        <IncludeRules context="jinja_source" />+      </context>+      <context name="jinja_comment" attribute="jinja_comment" lineEndContext="#stay">+        <DetectSpaces context="#stay" attribute="jinja_comment" />+        <StringDetect context="#pop" attribute="jinja_delimiter" endRegion="jinjaComment" String="-#}" />+        <StringDetect context="#pop" attribute="jinja_delimiter" endRegion="jinjaComment" String="+#}" />+        <Detect2Chars context="#pop" attribute="jinja_delimiter" endRegion="jinjaComment" char="#" char1="}" />+      </context>+      <context name="jinja_source" attribute="jinja_code" lineEndContext="#stay">+        <HlCHex context="#stay" attribute="jinja_basen" />+        <HlCOct context="#stay" attribute="jinja_basen" />+        <Float context="#stay" attribute="jinja_float" />+        <Int context="#stay" attribute="jinja_decimal" />+        <DetectChar context="jinja_string1" attribute="jinja_string" char="'" />+        <DetectChar context="jinja_string2" attribute="jinja_string" char="&quot;" />+        <AnyChar context="#stay" attribute="jinja_operator" String=".[]{}()+-*/%&lt;&gt;=!~" />+        <DetectChar context="jinja_filter" attribute="jinja_operator" char="|" />+        <WordDetect context="jinja_test" attribute="jinja_operator" String="is" />+        <keyword context="#stay" attribute="jinja_operator" String="jinja_operators" />+        <keyword context="#stay" attribute="jinja_ctrlflow" String="jinja_ctrlflows" />+        <keyword context="#stay" attribute="jinja_keyword" String="jinja_keywords" />+        <keyword context="#stay" attribute="jinja_import" String="jinja_imports" />+        <keyword context="#stay" attribute="jinja_constant" String="jinja_constants" />+        <keyword context="#stay" attribute="jinja_builtin" String="jinja_globals" />+        <RegExpr context="#stay" attribute="jinja_function" String="[a-zA-Z_][a-zA-Z0-9_]*(?=\()" />+      </context>+      <context name="jinja_string1" attribute="jinja_string" lineEndContext="#stay">+        <DetectChar context="#pop" attribute="jinja_string" char="'"/>+        <IncludeRules context="jinja_string_common"/>+      </context>+      <context name="jinja_string2" attribute="jinja_string" lineEndContext="#stay">+        <DetectChar context="#pop" attribute="jinja_string" char="&quot;"/>+        <IncludeRules context="jinja_string_common"/>+      </context>+      <context name="jinja_string_common" attribute="jinja_string" lineEndContext="#stay">+        <DetectSpaces context="#stay" attribute="jinja_string" />+        <HlCStringChar context="#stay" attribute="jinja_escape" />+        <RegExpr context="#stay" attribute="jinja_escape" String="\\[uU][0-9a-fA-F]{4,8}" />+      </context>+      <context name="jinja_filter" attribute="jinja_code" lineEndContext="#stay" fallthroughContext="#pop">+        <DetectSpaces context="#stay" attribute="jinja_code" />+        <keyword context="#pop" attribute="jinja_builtin" String="jinja_builtin_filters" />+        <DetectIdentifier context="#pop" attribute="jinja_function" />+      </context>+      <context name="jinja_test" attribute="jinja_code" lineEndContext="#stay" fallthroughContext="#pop">+        <DetectSpaces context="#stay" attribute="jinja_code" />+        <WordDetect context="#stay" attribute="jinja_operator" String="not" />+        <keyword context="#pop" attribute="jinja_builtin" String="jinja_builtin_tests" />+        <DetectIdentifier context="#pop" attribute="jinja_function" />+      </context>+    </contexts>+    <itemDatas>+      <itemData name="jinja_normal" defStyleNum="dsNormal" spellChecking="false" />+      <itemData name="jinja_delimiter" defStyleNum="dsRegionMarker" bold="true" spellChecking="false" />+      <itemData name="jinja_code" defStyleNum="dsNormal" spellChecking="false" />+      <itemData name="jinja_comment" defStyleNum="dsComment" spellChecking="true" />+      <itemData name="jinja_basen" defStyleNum="dsBaseN" spellChecking="false" />+      <itemData name="jinja_float" defStyleNum="dsFloat" spellChecking="false" />+      <itemData name="jinja_decimal" defStyleNum="dsDecVal" spellChecking="false" />+      <itemData name="jinja_string" defStyleNum="dsString" spellChecking="true" />+      <itemData name="jinja_escape" defStyleNum="dsSpecialChar" spellChecking="false" />+      <itemData name="jinja_operator" defStyleNum="dsOperator" spellChecking="false" />+      <itemData name="jinja_ctrlflow" defStyleNum="dsControlFlow" spellChecking="false" />+      <itemData name="jinja_keyword" defStyleNum="dsKeyword" spellChecking="false" />+      <itemData name="jinja_import" defStyleNum="dsImport" spellChecking="false" />+      <itemData name="jinja_constant" defStyleNum="dsConstant" spellChecking="false" />+      <itemData name="jinja_builtin" defStyleNum="dsBuiltIn" spellChecking="false" />+      <itemData name="jinja_function" defStyleNum="dsFunction" spellChecking="false" />+    </itemDatas>+  </highlighting>+  <general>+    <keywords casesensitive="1" />+  </general>+</language>++<!-- kate: tab-width 2; replace-tabs on; indent-width 2; -->
+ xml/jira.xml view
@@ -0,0 +1,779 @@+<?xml version = '1.0' encoding = 'UTF-8'?>+<!DOCTYPE language [++  <!ENTITY start "(^|(?&lt;=\s))">+  <!ENTITY citation "&start;\?\?(?=[^\s][^?]+\?\?([\s.,;:-]|$))">+  <!ENTITY deleted "&start;\-(?=[^\s][^\-]+\-([\s.,;:?]|$))">+  <!ENTITY emphasis "&start;_(?=[^\s][^_]+_([\s.,;:-]|\?|$))">+  <!ENTITY inserted "&start;\+(?=[^\s][^\+]+\+([\s.,;:-]|\?|$))">+  <!ENTITY monospaced "&start;\{\{(?=[^\s][^}]+\}\}([\s.,;:-]|$))">+  <!ENTITY strong "&start;\*(?=[^\s][^\*]+\*([\s.,;:-]|\?|$))">+  <!ENTITY subscript "&start;~(?=[^\s][^~]+~([\s.,;:-]|\?|$))">+  <!ENTITY superscript "&start;\^(?=[^\s][^\^]+\^([\s.,;:-]|\?|$))">++  <!ENTITY attachment     "&start;\[\^(?=[^]\s][^]]+\])">+  <!ENTITY bracketAnchor  "&start;\[#(?=[^]\s][^]]+\])">+  <!ENTITY taggedLink     "&start;\[(?=[^]\s|][^]|]+(\|[^]\s|][^]|]+)?\])">+  <!ENTITY userTag        "&start;\[~(?=[^]\s][^]]+\])">++  <!ENTITY embeddedItem   "&start;!(?=[^!\s][^!]+!)">++  <!ENTITY panel          "&start;\{panel(?=[^\}]*\})">++  <!ENTITY code           "&start;\{code(?=[^\}]*\})">++  <!ENTITY url "(http:|https:|ftp:|mailto:)[^]|) ]*(?=$|[]|\s|\)])">+]>+<language name="Jira" section="Markup" version="15" kateversion="6.22" extensions="*.jira" mimetype="" license="FDL" >+  <highlighting>++    <!--+    Documentation about the Jira syntax: https://jira.atlassian.com/secure/WikiRendererHelpAction.jspa?section=all+    -->++    <contexts>++      <!-- Main Context -->+      <context name="Start" attribute="Normal" lineEndContext="#stay">+        <DetectSpaces />+        <IncludeRules context="FindHeader" />+        <IncludeRules context="FindBlockQuote" />+        <IncludeRules context="FindText" />+        <IncludeRules context="FindListItem" />+        <IncludeRules context="FindIcons" />+        <IncludeRules context="FindTables" />+        <IncludeRules context="FindColor" />+        <IncludeRules context="FindQuote" />+        <IncludeRules context="FindNoFormat" />+        <IncludeRules context="FindPanels" />+        <IncludeRules context="FindCode" />+        <IncludeRules context="FindTextBreaks" />+        <IncludeRules context="FindEmbeddedItems" />+        <IncludeRules context="FindLinks" />+        <IncludeRules context="FindEscapeSequences" />+        <IncludeRules context="FindLineBreaks" />+      </context>+++      <!-- Contexts -->++      <!-- Headings -->+      <context name="Header" attribute="Header" lineEndContext="#pop" />+++      <!-- Images / Attachments -->+      <context name="EmbeddedItemContent" attribute="Link" lineEndContext="#stay" fallthroughContext="EmbeddedItemLink">+        <!-- !spaceKey:pageTitle^attachment.mov! -->+        <RegExpr String="[^:!|]+(?=:[^!|]*\^)" attribute="Label" context="EmbeddedItemPageTitle" />+      </context>+      <context name="EmbeddedItemLink" attribute="Link" lineEndContext="#stay">+        <DetectChar char="|" attribute="Special Character" context="EmbeddedItemAttributes" />+        <DetectChar char="!" attribute="Special Character" context="#pop#pop" />+      </context>+      <context name="EmbeddedItemPageTitle" attribute="Label" lineEndContext="#stay">+        <DetectChar char=":" attribute="Special Character" context="#stay" />+        <DetectChar char="^" attribute="Special Character" context="#pop!EmbeddedItemLink" />+      </context>+      <context name="EmbeddedItemAttributes" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="!" attribute="Special Character" context="#pop#pop#pop" />+        <DetectChar char="=" attribute="Normal" context="EmbeddedItemAttributeValue" />+        <DetectIdentifier attribute="AttributeKeyword" context="#stay" />+      </context>+      <context name="EmbeddedItemAttributeValue" attribute="AttributeValue" lineEndContext="#stay">+        <DetectChar char="," attribute="Normal" context="#pop" />+        <DetectChar char="!" attribute="Special Character" context="#pop#pop#pop#pop" />+        <DetectIdentifier attribute="AttributeValue" context="#stay" />+      </context>++      <context name="PanelStartTagContent" attribute="Normal" lineEndContext="#stay">+        <DetectChar char=":" attribute="Special Character" context="PanelAttributes" />+        <DetectChar char="}" attribute="Special Character" context="PanelContent" />+      </context>+      <context name="PanelContent" attribute="Normal" lineEndContext="#stay">+        <DetectSpaces />+        <StringDetect String="{panel}" attribute="Special Character" context="#pop#pop" />+        <IncludeRules context="FindBlockQuote" />+        <IncludeRules context="FindText" />+        <IncludeRules context="FindListItem" />+        <IncludeRules context="FindIcons" />+        <IncludeRules context="FindTables" />+        <IncludeRules context="FindColor" />+        <IncludeRules context="FindQuote" />+        <IncludeRules context="FindNoFormat" />+        <IncludeRules context="FindCode" />+        <IncludeRules context="FindTextBreaks" />+        <IncludeRules context="FindEmbeddedItems" />+        <IncludeRules context="FindLinks" />+        <IncludeRules context="FindEscapeSequences" />+        <IncludeRules context="FindLineBreaks" />+      </context>+      <context name="PanelAttributes" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="#pop!PanelContent" />+        <DetectChar char="=" attribute="Normal" context="PanelAttributeValue" />+        <DetectIdentifier attribute="AttributeKeyword" context="#stay" />+      </context>+      <context name="PanelAttributeValue" attribute="AttributeValue" lineEndContext="#stay">+        <DetectChar char="|" attribute="Special Character" context="#pop" />+        <DetectChar char="}" attribute="Special Character" context="#pop#pop!PanelContent" />+      </context>+++      <!-- See https://confluence.atlassian.com/display/DOC/Code+Block+Macro for keywords -->+      <context name="CodeContext" lineEndContext="#stay" attribute="Normal" fallthroughContext="JavaCodeStartTagContent">+        <!-- TODO see note -->+          <!-- Note: Commented out lines are for languages that Jira supports but KTextEditor does not yet. -->+<!--         <RegExpr String=":(?= *actionscript3 *[|}])" attribute="Special Character" context="JavaCodeStartTagContent" /> -->+        <RegExpr String=":(?= *(ada|title=[- \w]+\.(adb|ads|ada|a)) *[|}])" attribute="Special Character" context="AdaCodeStartTagContent" />+<!--         <RegExpr String=":(?= *AppleScript *[|}])" attribute="Special Character" context="AppleScriptCodeStartTagContent" /> -->+        <RegExpr String=":(?= *(bash|title=[- \w]*\.(sh|bash)) *[|}])" attribute="Special Character" context="BashCodeStartTagContent" />+        <RegExpr String=":(?= *(csharp|title=[- \w]*\.(cs|ashx)) *[|}])" attribute="Special Character" context="CSharpCodeStartTagContent" />+        <RegExpr String=":(?= *(coldfusion|title=[- \w]*\.(cfm|cfc|cfml|dbm)) *[|}])" attribute="Special Character" context="ColdFusionCodeStartTagContent" />+        <RegExpr String=":(?= *(c(pp)?|title=[- \w]*\.([cChH]|cpp|hpp|cxx|c\+\+|cc|cu|hh)) *[|}])" attribute="Special Character" context="CppCodeStartTagContent" />+        <RegExpr String=":(?= *(css|title=[- \w]*\.css) *[|}])" attribute="Special Character" context="CssCodeStartTagContent" />+        <RegExpr String=":(?= *(delphi|title=[- \w]*\.(p|pas|pp)) *[|}])" attribute="Special Character" context="PascalCodeStartTagContent" />+        <RegExpr String=":(?= *(diff|title=[- \w]*\.(diff|patch)) *[|}])" attribute="Special Character" context="DiffCodeStartTagContent" />+        <RegExpr String=":(?= *(erlang|title=[- \w]*\.erl) *[|}])" attribute="Special Character" context="ErlangCodeStartTagContent" />+        <RegExpr String=":(?= *(groovy|title=([- \w]*\.(groovy|gradle|gvy)|Jenkinsfile)) *[|}])" attribute="Special Character" context="GroovyCodeStartTagContent" />+        <RegExpr String=":(?= *(haskell|title=[- \w]*\.c?hs) *[|}])" attribute="Special Character" context="HaskellCodeStartTagContent" />+        <RegExpr String=":(?= *(html|title=[- \w]*\.(s?html?|aspx)) *[|}])" attribute="Special Character" context="HtmlCodeStartTagContent" />+        <RegExpr String=":(?= *(java|title=[- \w]*\.java) *[|}])" attribute="Special Character" context="JavaCodeStartTagContent" />+<!--         <RegExpr String=":(?= *javafx *[|}])" attribute="Special Character" context="JavaCodeStartTagContent" /> -->+        <RegExpr String=":(?= *(javascript|title=[- \w]*\.([cm]?js)) *[|}])" attribute="Special Character" context="JavaScriptCodeStartTagContent" />+        <RegExpr String=":(?= *(json|title=[- \w]*\.json) *[|}])" attribute="Special Character" context="JsonCodeStartTagContent" />+        <RegExpr String=":(?= *(lua|title=[- \w]*\.(lua|rockspec)) *[|}])" attribute="Special Character" context="LuaCodeStartTagContent" />+        <RegExpr String=":(?= *none *[|}])" attribute="Special Character" context="NoneCodeStartTagContent" />+<!-- <RegExpr String=":(?= *nyan *[|}])" attribute="Special Character" context="NyanCodeStartTagContent" /> -->+        <RegExpr String=":(?= *(perl|title=[- \w]*\.(pl|PL|pm)) *[|}])" attribute="Special Character" context="PerlCodeStartTagContent" />+        <RegExpr String=":(?= *(php|title=[- \w]*\.php) *[|}])" attribute="Special Character" context="PhpCodeStartTagContent" />+        <RegExpr String=":(?= *(powershell|title=[- \w]*\.(ps1|psm1|psd1)) *[|}])" attribute="Special Character" context="PowerShellCodeStartTagContent" />+        <RegExpr String=":(?= *(python|title=[- \w]*\.py) *[|}])" attribute="Special Character" context="PythonCodeStartTagContent" />+        <RegExpr String=":(?= *(ruby|title=([- \w]*\.(rb|rake|gemspec)|Rakefile|Gemfile|Vagrantfile)) *[|}])" attribute="Special Character" context="RubyCodeStartTagContent" />+        <RegExpr String=":(?= *(ruby|title=([- \w]*\.erv)) *[|}])" attribute="Special Character" context="RHTMLCodeStartTagContent" />+        <RegExpr String=":(?= *(scala|title=[- \w]*\.(scala|sbt)) *[|}])" attribute="Special Character" context="ScalaCodeStartTagContent" />+        <RegExpr String=":(?= *(sql|title=[- \w]*\.sql) *[|}])" attribute="Special Character" context="SqlCodeStartTagContent" />+        <RegExpr String=":(?= *(swift|title=[- \w]*\.swift) *[|}])" attribute="Special Character" context="SwiftCodeStartTagContent" />+<!--         <RegExpr String=":(?= *vb *[|}])" attribute="Special Character" context="VisualBasicCodeStartTagContent" /> -->+        <RegExpr String=":(?= *(xml|title=[- \w]*\.(xml|xslt?)) *[|}])" attribute="Special Character" context="XmlCodeStartTagContent" />+        <RegExpr String=":(?= *(yaml|title=[- \w]*\.ya?ml) *[|}])" attribute="Special Character" context="YamlCodeStartTagContent" />+      </context>++      <context name="FindCodeAttributes" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="|" attribute="Special Character" context="#stay" />+        <DetectChar char="=" attribute="Normal" context="CodeAttributeValue" />+        <DetectIdentifier attribute="AttributeKeyword" context="#stay" />+      </context>+      <context name="CodeAttributeValue" attribute="AttributeValue" lineEndContext="#stay">+        <AnyChar String="|}" context="#pop" lookAhead="true" />+      </context>++      <context name="FindEndCode" attribute="Normal" lineEndContext="#stay">+        <StringDetect String="{code}" attribute="Special Character" context="#pop#pop#pop" />+      </context>++      <context name="AdaCodeStartTagContent" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="AdaCodeContent" />+        <IncludeRules context="FindCodeAttributes" />+      </context>+      <context name="AdaCodeContent" attribute="Normal" lineEndContext="#stay">+        <IncludeRules context="FindEndCode" />+        <IncludeRules context="##Ada" />+      </context>++      <context name="BashCodeStartTagContent" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="BashCodeContent" />+        <IncludeRules context="FindCodeAttributes" />+      </context>+      <context name="BashCodeContent" attribute="Normal" lineEndContext="#stay" fallthroughContext="Command##Bash">+        <IncludeRules context="FindEndCode" />+        <IncludeRules context="##Bash" />+      </context>++      <context name="CSharpCodeStartTagContent" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="CSharpCodeContent" />+        <IncludeRules context="FindCodeAttributes" />+      </context>+      <context name="CSharpCodeContent" attribute="Normal" lineEndContext="#stay">+        <IncludeRules context="FindEndCode" />+        <IncludeRules context="##C#" />+      </context>++      <context name="ColdFusionCodeStartTagContent" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="ColdFusionCodeContent" />+        <IncludeRules context="FindCodeAttributes" />+      </context>+      <context name="ColdFusionCodeContent" attribute="Normal" lineEndContext="#stay">+        <IncludeRules context="FindEndCode" />+        <IncludeRules context="##ColdFusion" />+      </context>++      <context name="CppCodeStartTagContent" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="CppCodeContent" />+        <IncludeRules context="FindCodeAttributes" />+      </context>+      <context name="CppCodeContent" attribute="Normal" lineEndContext="#stay">+        <IncludeRules context="FindEndCode" />+        <IncludeRules context="##C++" />+      </context>++      <context name="CssCodeStartTagContent" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="CssCodeContent" />+        <IncludeRules context="FindCodeAttributes" />+      </context>+      <context name="CssCodeContent" attribute="Normal" lineEndContext="#stay">+        <IncludeRules context="FindEndCode" />+        <IncludeRules context="##CSS" />+      </context>++      <context name="DiffCodeStartTagContent" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="DiffCodeContent" />+        <IncludeRules context="FindCodeAttributes" />+      </context>+      <context name="DiffCodeContent" attribute="Normal" lineEndContext="#stay">+        <IncludeRules context="FindEndCode" />+        <IncludeRules context="##Diff" />+      </context>++      <context name="ErlangCodeStartTagContent" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="ErlangCodeContent" />+        <IncludeRules context="FindCodeAttributes" />+      </context>+      <context name="ErlangCodeContent" attribute="Normal" lineEndContext="#stay">+        <IncludeRules context="FindEndCode" />+        <IncludeRules context="##Erlang" />+      </context>++      <context name="GroovyCodeStartTagContent" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="GroovyCodeContent" />+        <IncludeRules context="FindCodeAttributes" />+      </context>+      <context name="GroovyCodeContent" attribute="Normal" lineEndContext="#stay">+        <IncludeRules context="FindEndCode" />+        <IncludeRules context="##Groovy" />+      </context>++      <context name="HaskellCodeStartTagContent" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="HaskellCodeContent" />+        <IncludeRules context="FindCodeAttributes" />+      </context>+      <context name="HaskellCodeContent" attribute="Normal" lineEndContext="#stay">+        <IncludeRules context="FindEndCode" />+        <IncludeRules context="##Haskell" />+      </context>++      <context name="HtmlCodeStartTagContent" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="HtmlCodeContent" />+        <IncludeRules context="FindCodeAttributes" />+      </context>+      <context name="HtmlCodeContent" attribute="Normal" lineEndContext="#stay">+        <IncludeRules context="FindEndCode" />+        <IncludeRules context="##HTML" />+      </context>++      <context name="JavaCodeStartTagContent" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="JavaCodeContent" />+        <IncludeRules context="FindCodeAttributes" />+      </context>+      <context name="JavaCodeContent" attribute="Normal" lineEndContext="#stay">+        <IncludeRules context="FindEndCode" />+        <IncludeRules context="##Java" />+      </context>++      <context name="JavaScriptCodeStartTagContent" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="JavaScriptCodeContent" />+        <IncludeRules context="FindCodeAttributes" />+      </context>+      <context name="JavaScriptCodeContent" attribute="Normal" lineEndContext="#stay">+        <IncludeRules context="FindEndCode" />+        <IncludeRules context="Normal##JavaScript" />+      </context>++      <context name="JsonCodeStartTagContent" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="JsonCodeContent" />+        <IncludeRules context="FindCodeAttributes" />+      </context>+      <context name="JsonCodeContent" attribute="Normal" lineEndContext="#stay">+        <IncludeRules context="FindEndCode" />+        <IncludeRules context="##JSON" />+      </context>++      <context name="LuaCodeStartTagContent" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="LuaCodeContent" />+        <IncludeRules context="FindCodeAttributes" />+      </context>+      <context name="LuaCodeContent" attribute="Normal" lineEndContext="#stay">+        <IncludeRules context="FindEndCode" />+        <IncludeRules context="##Lua" />+      </context>++      <context name="NoneCodeStartTagContent" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="NoneCodeContent" />+        <IncludeRules context="FindCodeAttributes" />+      </context>+      <context name="NoneCodeContent" attribute="Normal" lineEndContext="#stay">+        <IncludeRules context="FindEndCode" />+      </context>++      <context name="PascalCodeStartTagContent" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="PascalCodeContent" />+        <IncludeRules context="FindCodeAttributes" />+      </context>+      <context name="PascalCodeContent" attribute="Normal" lineEndContext="#stay">+        <IncludeRules context="FindEndCode" />+        <IncludeRules context="##Pascal" />+      </context>++      <context name="PerlCodeStartTagContent" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="PerlCodeContent" />+        <IncludeRules context="FindCodeAttributes" />+      </context>+      <context name="PerlCodeContent" attribute="Normal" lineEndContext="#stay">+        <IncludeRules context="FindEndCode" />+        <IncludeRules context="##Perl" />+      </context>++      <context name="PhpCodeStartTagContent" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="PhpCodeContent" />+        <IncludeRules context="FindCodeAttributes" />+      </context>+      <context name="PhpCodeContent" attribute="Normal" lineEndContext="#stay">+        <IncludeRules context="FindEndCode" />+        <IncludeRules context="phpsource##PHP/PHP" />+      </context>++      <context name="PowerShellCodeStartTagContent" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="PowerShellCodeContent" />+        <IncludeRules context="FindCodeAttributes" />+      </context>+      <context name="PowerShellCodeContent" attribute="Normal" lineEndContext="#stay">+        <IncludeRules context="FindEndCode" />+        <IncludeRules context="##PowerShell" />+      </context>++      <context name="PythonCodeStartTagContent" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="PythonCodeContent" />+        <IncludeRules context="FindCodeAttributes" />+      </context>+      <context name="PythonCodeContent" attribute="Normal" lineEndContext="#stay">+        <IncludeRules context="FindEndCode" />+        <IncludeRules context="##Python" />+      </context>++      <context name="RubyCodeStartTagContent" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="RubyCodeContent" />+        <IncludeRules context="FindCodeAttributes" />+      </context>+      <context name="RubyCodeContent" attribute="Normal" lineEndContext="#stay" fallthroughContext="Expr##Ruby">+        <IncludeRules context="FindEndCode" />+        <IncludeRules context="Ruby##Ruby" />+      </context>++      <context name="RHTMLCodeStartTagContent" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="RHTMLCodeContent" />+        <IncludeRules context="FindCodeAttributes" />+      </context>+      <context name="RHTMLCodeContent" attribute="Normal" lineEndContext="#stay">+        <IncludeRules context="FindEndCode" />+        <IncludeRules context="##Ruby/Rails/RHTML" />+      </context>++      <context name="ScalaCodeStartTagContent" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="ScalaCodeContent" />+        <IncludeRules context="FindCodeAttributes" />+      </context>+      <context name="ScalaCodeContent" attribute="Normal" lineEndContext="#stay">+        <IncludeRules context="FindEndCode" />+        <IncludeRules context="##Scala" />+      </context>++      <context name="SqlCodeStartTagContent" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="SqlCodeContent" />+        <IncludeRules context="FindCodeAttributes" />+      </context>+      <context name="SqlCodeContent" attribute="Normal" lineEndContext="#stay">+        <IncludeRules context="FindEndCode" />+        <IncludeRules context="##SQL" />+      </context>++      <context name="SwiftCodeStartTagContent" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="SwiftCodeContent" />+        <IncludeRules context="FindCodeAttributes" />+      </context>+      <context name="SwiftCodeContent" attribute="Normal" lineEndContext="#stay">+        <IncludeRules context="FindEndCode" />+        <IncludeRules context="Normal##Swift" />+      </context>++      <context name="XmlCodeStartTagContent" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="XmlCodeContent" />+        <IncludeRules context="FindCodeAttributes" />+      </context>+      <context name="XmlCodeContent" attribute="Normal" lineEndContext="#stay">+        <IncludeRules context="FindEndCode" />+        <IncludeRules context="##XML" />+      </context>++      <context name="YamlCodeStartTagContent" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="YamlCodeContent" />+        <IncludeRules context="FindCodeAttributes" />+      </context>+      <context name="YamlCodeContent" attribute="Normal" lineEndContext="#stay" fallthroughContext="Lvl0Text##YAML">+        <IncludeRules context="FindEndCode" />+        <IncludeRules context="##YAML" />+      </context>+++      <!-- Links -->+      <context name="BracketAnchorContent" attribute="Link" lineEndContext="#stay">+        <DetectChar char="]" attribute="Special Character" context="#pop" />+      </context>++      <context name="AttachmentLinkContent" attribute="Link" lineEndContext="#stay">+        <DetectChar char="]" attribute="Special Character" context="#pop" />+      </context>++      <context name="UserTagContent" attribute="Link" lineEndContext="#stay">+        <DetectChar char="]" attribute="Special Character" context="#pop" />+      </context>++      <context name="TaggedLinkContent" attribute="Link" lineEndContext="#stay" fallthroughContext="TaggedLinkUrl">+        <DetectChar char="|" attribute="Special Character" context="TaggedLinkUrl" />+        <RegExpr String="[^]|]+(?=\|)" attribute="Label" context="#stay" />+      </context>+      <context name="TaggedLinkUrl" attribute="Link" lineEndContext="#stay">+        <DetectChar char="]" attribute="Special Character" context="#pop#pop" />+      </context>++      <context name="BraceAnchorContent" attribute="Link" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="#pop#pop" />+      </context>+++      <!-- Text Effects -->+      <context name="ColorTagColor" attribute="Normal" lineEndContext="#stay">+        <!-- Black and White have been skipped on purpose. -->+        <StringDetect String="silver}"  context="ColorSilverTagColor" lookAhead="true" />+        <StringDetect String="gray}"  context="ColorGrayTagColor" lookAhead="true" />+        <StringDetect String="red}"  context="ColorRedTagColor" lookAhead="true" />+        <StringDetect String="maroon}"  context="ColorMaroonTagColor" lookAhead="true" />+        <StringDetect String="yellow}"  context="ColorYellowTagColor" lookAhead="true" />+        <StringDetect String="olive}"  context="ColorOliveTagColor" lookAhead="true" />+        <StringDetect String="lime}"  context="ColorLimeTagColor" lookAhead="true" />+        <StringDetect String="green}"  context="ColorGreenTagColor" lookAhead="true" />+        <StringDetect String="aqua}"  context="ColorAquaTagColor" lookAhead="true" />+        <StringDetect String="teal}"  context="ColorTealTagColor" lookAhead="true" />+        <StringDetect String="blue}"  context="ColorBlueTagColor" lookAhead="true" />+        <StringDetect String="navy}"  context="ColorNavyTagColor" lookAhead="true" />+        <StringDetect String="fuchsia}"  context="ColorFuchsiaTagColor" lookAhead="true" />+        <StringDetect String="purple}"  context="ColorPurpleTagColor" lookAhead="true" />+        <DetectChar char="}"  attribute="Special Character" context="HighlightedColorContent" />+      </context>+      <context name="HighlightedColorContent" attribute="Normal" lineEndContext="#stay">+        <DetectSpaces />+        <DetectIdentifier />+        <StringDetect String="{color}" attribute="Special Character" context="#pop#pop" />+      </context>+      <context name="ColorSilverTagColor" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="#pop!SilverContent" />+        <StringDetect String="silver" attribute="Silver" />+      </context>+      <context name="SilverContent" attribute="Silver" lineEndContext="#stay">+        <IncludeRules context="HighlightedColorContent" />+      </context>+      <context name="ColorGrayTagColor" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="#pop!GrayContent" />+        <StringDetect String="gray" attribute="Gray" />+      </context>+      <context name="GrayContent" attribute="Gray" lineEndContext="#stay">+        <IncludeRules context="HighlightedColorContent" />+      </context>+      <context name="ColorRedTagColor" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="#pop!RedContent" />+        <StringDetect String="red" attribute="Red" />+      </context>+      <context name="RedContent" attribute="Red" lineEndContext="#stay">+        <IncludeRules context="HighlightedColorContent" />+      </context>+      <context name="ColorMaroonTagColor" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="#pop!MaroonContent" />+        <StringDetect String="maroon" attribute="Maroon" />+      </context>+      <context name="MaroonContent" attribute="Maroon" lineEndContext="#stay">+        <IncludeRules context="HighlightedColorContent" />+      </context>+      <context name="ColorYellowTagColor" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="#pop!YellowContent" />+        <StringDetect String="yellow" attribute="Yellow" />+      </context>+      <context name="YellowContent" attribute="Yellow" lineEndContext="#stay">+        <IncludeRules context="HighlightedColorContent" />+      </context>+      <context name="ColorOliveTagColor" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="#pop!OliveContent" />+        <StringDetect String="olive" attribute="Olive" />+      </context>+      <context name="OliveContent" attribute="Olive" lineEndContext="#stay">+        <IncludeRules context="HighlightedColorContent" />+      </context>+      <context name="ColorLimeTagColor" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="#pop!LimeContent" />+        <StringDetect String="lime" attribute="Lime" />+      </context>+      <context name="LimeContent" attribute="Lime" lineEndContext="#stay">+        <IncludeRules context="HighlightedColorContent" />+      </context>+      <context name="ColorGreenTagColor" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="#pop!GreenContent" />+        <StringDetect String="green" attribute="Green" />+      </context>+      <context name="GreenContent" attribute="Green" lineEndContext="#stay">+        <IncludeRules context="HighlightedColorContent" />+      </context>+      <context name="ColorAquaTagColor" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="#pop!AquaContent" />+        <StringDetect String="aqua" attribute="Aqua" />+      </context>+      <context name="AquaContent" attribute="Aqua" lineEndContext="#stay">+        <IncludeRules context="HighlightedColorContent" />+      </context>+      <context name="ColorTealTagColor" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="#pop!TealContent" />+        <StringDetect String="teal" attribute="Teal" />+      </context>+      <context name="TealContent" attribute="Teal" lineEndContext="#stay">+        <IncludeRules context="HighlightedColorContent" />+      </context>+      <context name="ColorBlueTagColor" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="#pop!BlueContent" />+        <StringDetect String="blue" attribute="Blue" />+      </context>+      <context name="BlueContent" attribute="Blue" lineEndContext="#stay">+        <IncludeRules context="HighlightedColorContent" />+      </context>+      <context name="ColorNavyTagColor" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="#pop!NavyContent" />+        <StringDetect String="navy" attribute="Navy" />+      </context>+      <context name="NavyContent" attribute="Navy" lineEndContext="#stay">+        <IncludeRules context="HighlightedColorContent" />+      </context>+      <context name="ColorFuchsiaTagColor" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="#pop!FuchsiaContent" />+        <StringDetect String="fuchsia" attribute="Fuchsia" />+      </context>+      <context name="FuchsiaContent" attribute="Fuchsia" lineEndContext="#stay">+        <IncludeRules context="HighlightedColorContent" />+      </context>+      <context name="ColorPurpleTagColor" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="}" attribute="Special Character" context="#pop!PurpleContent" />+        <StringDetect String="purple" attribute="Purple" />+      </context>+      <context name="PurpleContent" attribute="Purple" lineEndContext="#stay">+        <IncludeRules context="HighlightedColorContent" />+      </context>++      <context name="BlockQuote" lineEndContext="#stay" lineEmptyContext="#pop" attribute="Block Quotation"/>+      <context name="BoldContent" attribute="Bold" lineEndContext="#stay">+        <DetectChar char="*" attribute="Special Character" context="#pop" />+      </context>+      <context name="CitationContent" attribute="Citation" lineEndContext="#stay">+        <Detect2Chars char="?" char1="?" attribute="Special Character" context="#pop" />+      </context>+      <context name="DeletedContent" attribute="Stroked Out" lineEndContext="#stay">+        <DetectChar char="-" attribute="Special Character" context="#pop" />+      </context>+      <context name="InsertedContent" attribute="Underlined" lineEndContext="#stay">+        <DetectChar char="+" attribute="Special Character" context="#pop" />+      </context>+      <context name="ItalicContent" attribute="Italic" lineEndContext="#stay">+        <DetectChar char="_" attribute="Special Character" context="#pop" />+      </context>+      <context name="Monospaced" attribute="Normal" lineEndContext="#stay">+        <Detect2Chars char="}" char1="}" attribute="Special Character" context="#pop" />+      </context>+      <context name="Quote" attribute="Block Quotation" lineEndContext="#stay">+        <DetectSpaces />+        <DetectIdentifier />+        <StringDetect String="{quote}" context="#pop" attribute="Special Character" />+      </context>+      <context name="SubscriptContent" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="~" attribute="Special Character" context="#pop" />+      </context>+      <context name="SuperscriptContent" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="^" attribute="Special Character" context="#pop" />+      </context>+++      <!-- Tables -->+      <context name="TableHeaderRow" attribute="Bold" lineEndContext="#pop">+        <DetectSpaces />+        <DetectIdentifier />+        <Detect2Chars char="|" char1="|" attribute="Special Character" context="#stay" />+        <IncludeRules context="FindTextBreaks" />+        <IncludeRules context="FindEscapeSequences" />+        <IncludeRules context="FindIcons" />+      </context>+      <context name="TableRegularRow" attribute="Normal" lineEndContext="#pop">+        <DetectSpaces />+        <DetectChar char="|" attribute="Special Character" context="#stay" />+        <IncludeRules context="FindText" />+        <IncludeRules context="FindTextBreaks" />+        <IncludeRules context="FindEscapeSequences" />+        <IncludeRules context="FindLinks" />+        <IncludeRules context="FindColor" />+        <IncludeRules context="FindIcons" />+      </context>++      <context name="NoFormat" attribute="Normal" lineEndContext="#stay">+        <DetectSpaces />+        <DetectIdentifier />+        <StringDetect String="{noformat}" attribute="Special Character" context="#pop" />+      </context>+++      <!-- Rules to Include -->++      <!-- BlockQuotes -->+      <context name="FindBlockQuote" attribute="Normal" lineEndContext="#stay">+        <StringDetect String="bq. " context="BlockQuote" attribute="Special Character" column="0" />+      </context>++      <!-- Colors -->+      <context name="FindColor" attribute="Normal" lineEndContext="#stay">+        <RegExpr String="\{color:(?=[^}]+\})" attribute="Special Character" context="ColorTagColor" />+      </context>++      <!-- Headings -->+      <context name="FindHeader" attribute="Normal" lineEndContext="#stay">+        <RegExpr String="^h[1-6]\. " context="Header" attribute="Special Character" column="0" />+      </context>++      <!-- Quotes -->+      <context name="FindQuote" attribute="Normal" lineEndContext="#stay">+        <StringDetect String="{quote}" context="Quote" attribute="Special Character" />+      </context>++      <!-- Text Breaks -->+      <context name="FindTextBreaks" attribute="Normal" lineEndContext="#stay">+        <Detect2Chars char="\" char1="\" attribute="Special Character" />+        <StringDetect String="----" attribute="Special Character" column="0" />+        <StringDetect String="---" attribute="Special Character" />+        <Detect2Chars char="-" char1="-" attribute="Special Character" />+      </context>++      <!-- Embedded Items -->+      <context name="FindEmbeddedItems" attribute="Normal" lineEndContext="#stay">+        <RegExpr String="&embeddedItem;" attribute="Special Character" context="EmbeddedItemContent" />+      </context>++      <!-- Links -->+      <context name="FindLinks" attribute="Normal" lineEndContext="#stay">+        <RegExpr String="&bracketAnchor;" attribute="Special Character" context="BracketAnchorContent" />+        <RegExpr String="&attachment;" attribute="Special Character" context="AttachmentLinkContent" />+        <RegExpr String="&userTag;" attribute="Special Character" context="UserTagContent" />+        <RegExpr String="&taggedLink;" attribute="Special Character" context="TaggedLinkContent" />+        <RegExpr String="\{anchor:(?=[^}]+\})" attribute="Special Character" context="BraceAnchorContent" />+        <RegExpr String="&url;" attribute="Link" />+      </context>++      <!-- Lists -->+      <context name="FindListItem" attribute="Normal" lineEndContext="#stay">+        <RegExpr String="^([*#]+|-)(?=\s)" attribute="Special Character" context="#stay" column="0" />+      </context>++      <!-- Text Effects -->+      <context name="FindTextEffects" attribute="Normal" lineEndContext="#stay">+        <RegExpr String="&strong;" attribute="Special Character" context="BoldContent" />+        <RegExpr String="&citation;" attribute="Special Character" context="CitationContent" />+        <RegExpr String="&deleted;" attribute="Special Character" context="DeletedContent" />+        <RegExpr String="&inserted;" attribute="Special Character" context="InsertedContent" />+        <RegExpr String="&subscript;" attribute="Special Character" context="SubscriptContent" />+        <RegExpr String="&superscript;" attribute="Special Character" context="SuperscriptContent" />+        <RegExpr String="&monospaced;" attribute="Special Character" context="Monospaced" />+      </context>+      <context name="EmphasisOrIdentifier" attribute="Normal" lineEndContext="#stay">+        <RegExpr String="&emphasis;" attribute="Special Character" context="#pop!ItalicContent" />+        <DetectIdentifier context="#pop" />+      </context>++      <!-- Text -->+      <context name="FindText" attribute="Normal" lineEndContext="#stay">+        <DetectChar char="_" context="EmphasisOrIdentifier" lookAhead="true" />+        <DetectIdentifier />+        <IncludeRules context="FindTextEffects" />+      </context>++      <!-- Tables -->+      <context name="FindTables" attribute="Normal" lineEndContext="#stay">+        <Detect2Chars char="|" char1="|" attribute="Special Character" context="TableHeaderRow" column="0" />+        <DetectChar char="|" attribute="Special Character" context="TableRegularRow" column="0" />+      </context>++      <!-- No format -->+      <context name="FindNoFormat" attribute="Normal" lineEndContext="#stay">+        <StringDetect String="{noformat}" context="NoFormat" attribute="Special Character" />+      </context>++      <!-- Panels -->+      <context name="FindPanels" attribute="Normal" lineEndContext="#stay">+        <RegExpr String="&panel;" attribute="Special Character" context="PanelStartTagContent" />+      </context>++      <!-- Code -->+      <context name="FindCode" attribute="Normal" lineEndContext="#stay">+        <RegExpr String="&code;" attribute="Special Character" context="CodeContext" />+      </context>++      <!-- Escape Sequences -->+      <context name="FindEscapeSequences" attribute="Normal" lineEndContext="#stay">+        <RegExpr String="\\[^ \\]" attribute="EscapeSequence" />+      </context>++      <!-- Line Breaks -->+      <context name="FindLineBreaks" attribute="Normal" lineEndContext="#stay">+        <LineContinue attribute="Special Character" />+      </context>++      <!-- Icons -->+      <context name="FindIcons" attribute="Normal" lineEndContext="#stay">+        <RegExpr String=":\)|:\(|:P|:D|;\)|\(([yni/x!+-?*]|on|off|[*][rgby]|flag|flagoff)\)" attribute="Special Character" />+      </context>++    </contexts>+    <itemDatas>+      <itemData name="Normal" defStyleNum="dsNormal" /><!-- Must be first. -->++      <itemData name="Bold" defStyleNum="dsNormal" bold="true" />+      <itemData name="Header" defStyleNum="dsKeyword" />+      <itemData name="Italic" defStyleNum="dsNormal" italic="true" />+      <itemData name="Citation" defStyleNum="dsNormal" italic="true" />+      <itemData name="Block Quotation" defStyleNum="dsNormal" />+      <itemData name="Special Character" defStyleNum="dsDecVal" bold="true" />+      <itemData name="Stroked Out" defStyleNum="dsNormal" strikeOut="true" />+      <itemData name="Underlined" defStyleNum="dsNormal" underline="true" />+      <itemData name="AttributeKeyword" defStyleNum="dsOthers" spellChecking="false" />+      <itemData name="AttributeValue" defStyleNum="dsString" spellChecking="false" />+      <itemData name="EscapeSequence" defStyleNum="dsChar" spellChecking="false" />+      <itemData name="Link" defStyleNum="dsPreprocessor" spellChecking="false" />+      <itemData name="Label" defStyleNum="dsAnnotation" spellChecking="false" />++      <!-- Colors -->+      <itemData name="Silver" defStyleNum="dsNormal" color="silver" />+      <itemData name="Gray" defStyleNum="dsNormal" color="gray" />+      <itemData name="Red" defStyleNum="dsNormal" color="red" />+      <itemData name="Maroon" defStyleNum="dsNormal" color="maroon" />+      <itemData name="Yellow" defStyleNum="dsNormal" color="yellow" />+      <itemData name="Olive" defStyleNum="dsNormal" color="olive" />+      <itemData name="Lime" defStyleNum="dsNormal" color="lime" />+      <itemData name="Green" defStyleNum="dsNormal" color="green" />+      <itemData name="Aqua" defStyleNum="dsNormal" color="aqua" />+      <itemData name="Teal" defStyleNum="dsNormal" color="teal" />+      <itemData name="Blue" defStyleNum="dsNormal" color="blue" />+      <itemData name="Navy" defStyleNum="dsNormal" color="navy" />+      <itemData name="Fuchsia" defStyleNum="dsNormal" color="fuchsia" />+      <itemData name="Purple" defStyleNum="dsNormal" color="purple" />+    </itemDatas>+  </highlighting>+  <general>+    <keywords casesensitive="0" />+  </general>+</language>
+ xml/k.xml view
@@ -0,0 +1,424 @@+<?xml version="1.0" encoding="UTF-8"?>+<!DOCTYPE language [+  <!ENTITY kDateTime1 "(?:\d{4}\.\d\dm|\d{4}\.\d\d\.\d\d(?:|[DT](?:\d*|\d\d:\d\d|\d\d:\d\d:\d\d|\d\d:\d\d:\d\d\.\d*)))">+  <!ENTITY kDateTime2 "\d+D(?:\d*|\d\d:\d\d|\d\d:\d\d:\d\d|\d\d:\d\d:\d\d\.\d*)">+  <!ENTITY kDateTime3 "(?:\d+t|\d\d:\d*|\d\d:\d\d:\d\d(?:|\.\d+))">++  <!ENTITY kNumber1 "[-]?(?:0(?:n|Ne|ne|Nf|nf)|(?:[\d]+\.[\d]*|\.?[\d]+)e[-]?\d+|(?:[\d]+\.[\d]*[ef]?|\.[\d]+[ef]?|[\d]+[ef]))">+  <!ENTITY kNumber2 "[-]?(?:0N[hj]?|[\d]+[ijh]?)">+]>+<language name="k" version="7" kateversion="5.0" section="Scripts" extensions="*.k" license="LGPLv2+" author="James Schmitz (james.schmitz@gmail.com)">+<highlighting>+    <list name="flowcontrol" >+      <item>while</item>+      <item>if</item>+      <item>do</item>+    </list>+    <list name="kkeywords" >+      <item>abs</item>+      <item>acos</item>+      <item>asin</item>+      <item>atan</item>+      <item>avg</item>+      <item>bin</item>+      <item>by</item>+      <item>cos</item>+      <item>delete</item>+      <item>div</item>+      <item>exec</item>+      <item>exit</item>+      <item>exp</item>+      <item>from</item>+      <item>getenv</item>+      <item>i</item>+      <item>in</item>+      <item>insert</item>+      <item>last</item>+      <item>like</item>+      <item>log</item>+      <item>max</item>+      <item>min</item>+      <item>prd</item>+      <item>select</item>+      <item>setenv</item>+      <item>sin</item>+      <item>sqrt</item>+      <item>ss</item>+      <item>sum</item>+      <item>tan</item>+      <item>update</item>+      <item>wavg</item>+      <item>within</item>+      <item>wsum</item>+      <item>xexp</item>+    </list>+    <list name="DotQ">+      <item>.Q.addmonths</item>+      <item>.Q.addr</item>+      <item>.Q.host</item>+      <item>.Q.chk</item>+      <item>.Q.cn</item>+      <item>.Q.dd</item>+      <item>.Q.dpft</item>+      <item>.Q.dsftg</item>+      <item>.Q.def</item>+      <item>.Q.en</item>+      <item>.Q.fc</item>+      <item>.Q.fk</item>+      <item>.Q.fmt</item>+      <item>.Q.foo</item>+      <item>.Q.fs</item>+      <item>.Q.ft</item>+      <item>.Q.fu</item>+      <item>.Q.gc</item>+      <item>.Q.hdpf</item>+      <item>.Q.ind</item>+      <item>.Q.j10</item>+      <item>.Q.x10</item>+      <item>.Q.j12</item>+      <item>.Q.x12</item>+      <item>.Q.k</item>+      <item>.Q.l</item>+      <item>.Q.opt</item>+      <item>.Q.par</item>+      <item>.Q.qp</item>+      <item>.Q.qt</item>+      <item>.Q.s</item>+      <item>.Q.s1</item>+      <item>.Q.ty</item>+      <item>.Q.v</item>+      <item>.Q.V</item>+      <item>.Q.view</item>+      <item>.Q.w</item>+      <item>.Q.M</item>+      <item>.Q.pf</item>+      <item>.Q.pt</item>+      <item>.Q.PD</item>+      <item>.Q.PV</item>+      <item>.Q.pd</item>+      <item>.Q.pv</item>+      <item>.Q.pn</item>+      <item>.Q.bv</item>+      <item>.Q.vp</item>+      <item>.Q.P</item>+      <item>.Q.D</item>+      <item>.Q.u</item>+    </list>+    <list name="Doth" >+      <item>.h.br</item>+      <item>.h.c0</item>+      <item>.h.c1</item>+      <item>.h.cd</item>+      <item>.h.code</item>+      <item>.h.data</item>+      <item>.h.eb</item>+      <item>.h.ec</item>+      <item>.h.ed</item>+      <item>.h.edsn</item>+      <item>.h.es</item>+      <item>.h.ex</item>+      <item>.h.fram</item>+      <item>.h.ha</item>+      <item>.h.hb</item>+      <item>.h.hc</item>+      <item>.h.he</item>+      <item>.h.hn</item>+      <item>.h.hp</item>+      <item>.h.hr</item>+      <item>.h.ht</item>+      <item>.h.hta</item>+      <item>.h.htac</item>+      <item>.h.htc</item>+      <item>.h.html</item>+      <item>.h.http</item>+      <item>.h.hu</item>+      <item>.h.hug</item>+      <item>.h.hy</item>+      <item>.h.iso8601</item>+      <item>.h.jx</item>+      <item>.h.logo</item>+      <item>.h.nbr</item>+      <item>.h.pre</item>+      <item>.h.text</item>+      <item>.h.tx</item>+      <item>.h.ty</item>+      <item>.h.uh</item>+      <item>.h.xd</item>+      <item>.h.xmp</item>+      <item>.h.xs</item>+      <item>.h.xt</item>+    </list>+    <list name="Doto" >+      <item>.o.B0</item>+      <item>.o.C0</item>+      <item>.o.Cols</item>+      <item>.o.Columns</item>+      <item>.o.FG</item>+      <item>.o.Fkey</item>+      <item>.o.Gkey</item>+      <item>.o.Key</item>+      <item>.o.PS</item>+      <item>.o.Special</item>+      <item>.o.Stats</item>+      <item>.o.T</item>+      <item>.o.T0</item>+      <item>.o.TI</item>+      <item>.o.Tables</item>+      <item>.o.Ts</item>+      <item>.o.TypeInfo</item>+      <item>.o.ex</item>+      <item>.o.o</item>+      <item>.o.t</item>+    </list>+    <list name="Dotz" >+      <item>.z.a</item>+      <item>.z.ac</item>+      <item>.z.b</item>+      <item>.z.bm</item>+      <item>.z.c</item>+      <item>.z.exit</item>+      <item>.z.f</item>+      <item>.z.h</item>+      <item>.z.i</item>+      <item>.z.k</item>+      <item>.z.K</item>+      <item>.z.l</item>+      <item>.z.n</item>+      <item>.z.N</item>+      <item>.z.o</item>+      <item>.z.p</item>+      <item>.z.P</item>+      <item>.z.pc</item>+      <item>.z.pg</item>+      <item>.z.ph</item>+      <item>.z.pi</item>+      <item>.z.po</item>+      <item>.z.pp</item>+      <item>.z.ps</item>+      <item>.z.pw</item>+      <item>.z.q</item>+      <item>.z.s</item>+      <item>.z.ts</item>+      <item>.z.u</item>+      <item>.z.vs</item>+      <item>.z.w</item>+      <item>.z.W</item>+      <item>.z.ws</item>+      <item>.z.x</item>+      <item>.z.z</item>+      <item>.z.Z</item>+      <item>.z.t</item>+      <item>.z.T</item>+      <item>.z.d</item>+      <item>.z.D</item>+      <item>.z.zd</item>+    </list>+    <list name="Dotq" >+      <item>.q.aj</item>+      <item>.q.aj0</item>+      <item>.q.all</item>+      <item>.q.and</item>+      <item>.q.any</item>+      <item>.q.asc</item>+      <item>.q.asof</item>+      <item>.q.attr</item>+      <item>.q.avgs</item>+      <item>.q.ceiling</item>+      <item>.q.cols</item>+      <item>.q.cor</item>+      <item>.q.count</item>+      <item>.q.cov</item>+      <item>.q.cross</item>+      <item>.q.csv</item>+      <item>.q.cut</item>+      <item>.q.deltas</item>+      <item>.q.desc</item>+      <item>.q.dev</item>+      <item>.q.differ</item>+      <item>.q.distinct</item>+      <item>.q.each</item>+      <item>.q.ej</item>+      <item>.q.enlist</item>+      <item>.q.eval</item>+      <item>.q.except</item>+      <item>.q.fby</item>+      <item>.q.fills</item>+      <item>.q.first</item>+      <item>.q.fkeys</item>+      <item>.q.flip</item>+      <item>.q.floor</item>+      <item>.q.get</item>+      <item>.q.group</item>+      <item>.q.gtime</item>+      <item>.q.hclose</item>+      <item>.q.hcount</item>+      <item>.q.hdel</item>+      <item>.q.hopen</item>+      <item>.q.hsym</item>+      <item>.q.iasc</item>+      <item>.q.idesc</item>+      <item>.q.ij</item>+      <item>.q.inter</item>+      <item>.q.inv</item>+      <item>.q.key</item>+      <item>.q.keys</item>+      <item>.q.lj</item>+      <item>.q.load</item>+      <item>.q.lower</item>+      <item>.q.lsq</item>+      <item>.q.ltime</item>+      <item>.q.ltrim</item>+      <item>.q.mavg</item>+      <item>.q.maxs</item>+      <item>.q.mcount</item>+      <item>.q.md5</item>+      <item>.q.mdev</item>+      <item>.q.med</item>+      <item>.q.meta</item>+      <item>.q.mins</item>+      <item>.q.mmax</item>+      <item>.q.mmin</item>+      <item>.q.mmu</item>+      <item>.q.mod</item>+      <item>.q.msum</item>+      <item>.q.neg</item>+      <item>.q.next</item>+      <item>.q.not</item>+      <item>.q.null</item>+      <item>.q.or</item>+      <item>.q.over</item>+      <item>.q.parse</item>+      <item>.q.peach</item>+      <item>.q.pj</item>+      <item>.q.plist</item>+      <item>.q.prds</item>+      <item>.q.prev</item>+      <item>.q.prior</item>+      <item>.q.rand</item>+      <item>.q.rank</item>+      <item>.q.ratios</item>+      <item>.q.raze</item>+      <item>.q.read0</item>+      <item>.q.read1</item>+      <item>.q.reciprocal</item>+      <item>.q.reverse</item>+      <item>.q.rload</item>+      <item>.q.rotate</item>+      <item>.q.rsave</item>+      <item>.q.rtrim</item>+      <item>.q.save</item>+      <item>.q.scan</item>+      <item>.q.set</item>+      <item>.q.show</item>+      <item>.q.signum</item>+      <item>.q.ssr</item>+      <item>.q.string</item>+      <item>.q.sublist</item>+      <item>.q.sums</item>+      <item>.q.sv</item>+      <item>.q.system</item>+      <item>.q.tables</item>+      <item>.q.til</item>+      <item>.q.trim</item>+      <item>.q.txf</item>+      <item>.q.type</item>+      <item>.q.uj</item>+      <item>.q.ungroup</item>+      <item>.q.union</item>+      <item>.q.upper</item>+      <item>.q.upsert</item>+      <item>.q.value</item>+      <item>.q.var</item>+      <item>.q.view</item>+      <item>.q.views</item>+      <item>.q.vs</item>+      <item>.q.where</item>+      <item>.q.wj</item>+      <item>.q.wj1</item>+      <item>.q.xasc</item>+      <item>.q.xbar</item>+      <item>.q.xcol</item>+      <item>.q.xcols</item>+      <item>.q.xdesc</item>+      <item>.q.xgroup</item>+      <item>.q.xkey</item>+      <item>.q.xlog</item>+      <item>.q.xprev</item>+      <item>.q.xrank</item>+    </list>+    <contexts>+      <context attribute="Normal Text" lineEndContext="#stay" name="Normal Text" >+        <RegExpr attribute="kSystemCommand" String="^\\[^\s].*" context="#stay" column="0" />+        <DetectChar attribute="String" context="string" char="&quot;" />+        <AnyChar attribute="kSeparators" String="{([|])}" context="#stay" />+        <RegExpr attribute="kHSym" String="`:[\w/:.]*" context="#stay" />+        <RegExpr attribute="kSymbol" String="(`[a-zA-Z\d.][\w:.]*|`|\d[a-zA-Z\d:.]*s)" context="#stay" />+        <keyword attribute="FlowControl" context="#stay" String="flowcontrol" />+        <RegExpr attribute="FlowControl" String="\$(?=\[)" context="#stay" />+        <keyword attribute="kKeyword" context="#stay" String="kkeywords" />+        <keyword attribute="DotQfunctions" context="#stay" String="DotQ" />+        <keyword attribute="Dotzfunctions" context="#stay" String="Dotz" />+        <keyword attribute="Dothfunctions" context="#stay" String="Doth" />+        <keyword attribute="Dotofunctions" context="#stay" String="Doto" />+        <keyword attribute="Dotqfunctions" context="#stay" String="Dotq" />+        <RegExpr attribute="kIdentifier" String="(?:[a-zA-Z][\w.]*|\.[a-zA-Z][\w.]*)" context="#stay" />+        <RegExpr attribute="kBool" String="[01]+b" context="#stay" />+        <RegExpr attribute="kByte" String="0x[0-9a-fA-F]*" context="#stay" />+        <RegExpr attribute="kGuid" String="[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}" context="#stay" />+        <RegExpr attribute="kDateTime" String="&kDateTime1;|&kDateTime2;|&kDateTime3;" context="#stay" />+        <RegExpr attribute="kNumber" String="&kNumber1;|&kNumber2;" context="#stay" />+        <Detect2Chars attribute="Comment" context="comment" char=" " char1="/" />+        <RegExpr String="^\\[\s]*$" attribute="CommentToEOF" context="commentToEOF" column="0" />+        <RegExpr String="^/[\s]*$" attribute="MultiLineComment" context="multicomment" beginRegion="Comment" column="0" />+        <DetectChar attribute="Comment" context="comment" char="/" firstNonSpace="true" /> +      </context>+      <context attribute="String" lineEndContext="#stay" name="string" >+        <DetectChar attribute="String" context="#pop" char="&quot;" />+      </context>+      <context name="comment" attribute="Comment" lineEndContext="#pop" >+        <DetectSpaces />+        <IncludeRules context="##Comments" />+      </context>+      <context name="multicomment" attribute="MultiLineComment" lineEndContext="#stay" >+        <RegExpr String="^\\[\s]*$" attribute="MultiLineComment" context="#pop" endRegion="Comment" column="0" />+        <DetectSpaces />+        <IncludeRules context="##Comments" />+      </context>+      <context name="commentToEOF" attribute="CommentToEOF" lineEndContext="#stay" >+        <DetectSpaces />+        <IncludeRules context="##Comments" />+      </context>+    </contexts>+    <itemDatas>+      <itemData name="Normal Text" spellChecking="false" defStyleNum="dsNormal" />+      <itemData name="kSystemCommand" spellChecking="false" defStyleNum="dsOthers" />+      <itemData name="kSeparators" defStyleNum="dsNormal" />+      <itemData name="kSymbol" spellChecking="false" defStyleNum="dsOthers" />+      <itemData name="kHSym" spellChecking="false" defStyleNum="dsOthers" />+      <itemData name="FlowControl" defStyleNum="dsKeyword" />+      <itemData name="kKeyword" defStyleNum="dsKeyword" />+      <itemData name="Dothfunctions" defStyleNum="dsKeyword" />+      <itemData name="DotQfunctions" defStyleNum="dsKeyword" />+      <itemData name="Dotzfunctions" defStyleNum="dsKeyword" />+      <itemData name="Dotofunctions" defStyleNum="dsKeyword" />+      <itemData name="Dotqfunctions" defStyleNum="dsKeyword" />+      <itemData name="kIdentifier" spellChecking="false" defStyleNum="dsNormal" />+      <itemData name="kNumber" spellChecking="false" defStyleNum="dsDecVal" />+      <itemData name="kBool" spellChecking="false" defStyleNum="dsBaseN" />+      <itemData name="kGuid" spellChecking="false" defStyleNum="dsBaseN" />+      <itemData name="kByte" spellChecking="false" defStyleNum="dsBaseN" />+      <itemData name="String" spellChecking="false" defStyleNum="dsString" />+      <itemData name="kDateTime" spellChecking="false" defStyleNum="dsOthers" />+      <itemData name="Comment" spellChecking="true" defStyleNum="dsComment" />+      <itemData name="MultiLineComment" spellChecking="true" defStyleNum="dsComment" />+      <itemData name="CommentToEOF" defStyleNum="dsComment" />+    </itemDatas>+  </highlighting>+  <general>+    <comments>+      <comment name="singleLine" start="/" />+    </comments>+    <keywords casesensitive="1" weakDeliminator="." additionalDeliminator="`#'@$&quot;" />+  </general>+</language>+<!-- kate: replace-tabs on; tab-width 2; indent-width 2; -->
+ xml/logfile.xml view
@@ -0,0 +1,36 @@+<?xml version="1.0" encoding="UTF-8"?>+<!DOCTYPE language [+  <!-- same as logfile-advanced.xml -->+  <!ENTITY critical "crit|critical|fatal|QFATAL">+  <!ENTITY debug "debug|QDEBUG">+  <!ENTITY error "err|error|fail|failure|QCRITICAL">+  <!ENTITY info "info|information|QINFO">+  <!ENTITY warn "warn|warning|QWARN">+  <!ENTITY firstchars "cdefiqw">+  <!ENTITY search "^([^&firstchars;]*+((?!\b(&critical;|&debug;|&error;|&info;|&warn;)\b)[&firstchars;])?)*+">+]>+<language name="Log File (simplified)" section="Other" version="3" kateversion="5.62" extensions="*.log;*.log.*;syslog;syslog.*" priority="-10" author="Jonathan Poelen (jonathan.poelen@gmail.com)" license="MIT">+  <highlighting>++    <contexts>+      <context name="Start" lineEndContext="#stay" attribute="Normal">+        <RegExpr String="&search;\b(&info;)\b.*" attribute="Information" insensitive="1" column="0"/>+        <RegExpr String="&search;\b(&debug;)\b.*" attribute="Debug" insensitive="1" column="0"/>+        <RegExpr String="&search;\b(&warn;)\b.*" attribute="Warning" insensitive="1" column="0"/>+        <RegExpr String="&search;\b(&error;)\b.*" attribute="Error" insensitive="1" column="0"/>+        <RegExpr String="&search;\b(&critical;)\b.*" attribute="Critical" insensitive="1" column="0"/>+        <RegExpr String=".*" attribute="Normal"/>+      </context>+    </contexts>++    <itemDatas>+      <itemData name="Normal" defStyleNum="dsNormal"/>+      <itemData name="Information" defStyleNum="dsPreprocessor"/>+      <itemData name="Warning" defStyleNum="dsInformation"/>+      <itemData name="Error" defStyleNum="dsError" underline="0"/>+      <itemData name="Critical" defStyleNum="dsAlert"/>+      <itemData name="Debug" defStyleNum="dsDataType"/>+    </itemDatas>+  </highlighting>+</language>+<!-- kate: space-indent on; indent-width 2; replace-tabs on; -->
xml/markdown.xml view
@@ -94,7 +94,7 @@ <!ENTITY checkbox "\[[ x]\](?=\s)"> ]> -<language name="Markdown" version="31" kateversion="5.79" section="Markup" extensions="*.md;*.mmd;*.markdown;*.md.html" mimetype="text/markdown" priority="15" author="Darrin Yeager, Claes Holmerson" license="GPL,BSD">+<language name="Markdown" version="33" kateversion="6.22" section="Markup" extensions="*.md;*.mmd;*.markdown;*.md.html" mimetype="text/markdown" priority="15" author="Darrin Yeager, Claes Holmerson" license="GPL,BSD">   <highlighting>     <contexts>       <!-- Start of the Markdown document: find metadata or code block -->@@ -367,6 +367,7 @@         <RegExpr attribute="Fenced Code" context="#pop!python-code" String="&fcode;\s*(?:python[23]?|py[23w]?|[rc]py|sconstruct|gypi?)&end;" insensitive="true" beginRegion="code-block"/>         <RegExpr attribute="Fenced Code" context="#pop!qml-code" String="&fcode;\s*qml(?:types)?&end;" insensitive="true" beginRegion="code-block"/>         <RegExpr attribute="Fenced Code" context="#pop!r-code" String="&fcode;\s*(?:r|rprofile|rscript)&end;" insensitive="true" beginRegion="code-block"/>+        <RegExpr attribute="Fenced Code" context="#pop!raku-code" String="&fcode;\s*(?:raku(?:mod|doc|test)?|perl6|p[lm]?6|pod6|nqp)&end;" insensitive="true" beginRegion="code-block"/>         <RegExpr attribute="Fenced Code" context="#pop!rest-code" String="&fcode;\s*(?:rst|rest|restructuredtext)&end;" insensitive="true" beginRegion="code-block"/> <!-- Included in the CMake definition -->         <RegExpr attribute="Fenced Code" context="#pop!ruby-code" String="&fcode;\s*(?:ruby|rbx?|rjs|rake|f?cgi|gemspec|irbrc|ru|prawn|Appraisals|(?:Rake|Cap|Chef|Gem|Guard|Hobo|Vagrant||Rant|Berks|Thor|Puppet)file|rxml)&end;" insensitive="true" beginRegion="code-block"/>         <RegExpr attribute="Fenced Code" context="#pop!rhtml-code" String="&fcode;\s*((?:xml\.|js\.)?erb)&end;" insensitive="true" beginRegion="code-block"/>@@ -375,6 +376,9 @@         <RegExpr attribute="Fenced Code" context="#pop!nim-code" String="&fcode;\s*(?:nims?)&end;" insensitive="true" beginRegion="code-block"/>         <RegExpr attribute="Fenced Code" context="#pop!typescript-code" String="&fcode;\s*(?:typescript|ts)&end;" insensitive="true" beginRegion="code-block"/>         <RegExpr attribute="Fenced Code" context="#pop!xml-code" String="&fcode;\s*(?:xml|xsd|xspf|tld|jsp|c?pt|dtml|rss|opml|svg|daml|rdf|ui|kcfg|qrc|wsdl|scxml|xbel|dae|sch|brd|docbook)&end;" insensitive="true" beginRegion="code-block"/>+        <RegExpr attribute="Fenced Code" context="#pop!toml-code" String="&fcode;\s*toml&end;" insensitive="true" beginRegion="code-block"/>+        <RegExpr attribute="Fenced Code" context="#pop!ini-code" String="&fcode;\s*ini&end;" insensitive="true" beginRegion="code-block"/>+        <RegExpr attribute="Fenced Code" context="#pop!desktop-code" String="&fcode;\s*desktop&end;" insensitive="true" beginRegion="code-block"/>         <RegExpr attribute="Fenced Code" context="#pop!code" String="&fcode;.*$" beginRegion="code-block"/>       </context>       <context name="code" attribute="Code" lineEndContext="#stay"> <!-- Unknown language -->@@ -448,7 +452,7 @@         <IncludeRules context="code"/>         <IncludeRules context="##JSON" includeAttrib="true"/>       </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="yaml-code">+      <context attribute="Normal Text" lineEndContext="#stay" name="yaml-code" fallthroughContext="Lvl0Text##YAML">         <IncludeRules context="code"/>         <IncludeRules context="##YAML" includeAttrib="true"/>       </context>@@ -519,6 +523,18 @@       <context attribute="Normal Text" lineEndContext="#stay" name="xml-code">         <IncludeRules context="code"/>         <IncludeRules context="##XML" includeAttrib="true"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="toml-code">+        <IncludeRules context="code"/>+        <IncludeRules context="##TOML" includeAttrib="true"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="ini-code">+        <IncludeRules context="code"/>+        <IncludeRules context="##INI Files" includeAttrib="true"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="desktop-code">+        <IncludeRules context="code"/>+        <IncludeRules context="Normal##.desktop" includeAttrib="true"/>       </context>        <!-- Common -->
− xml/markdown.xml.patch 
@@ -1,23 +0,0 @@-diff --git a/skylighting-core/xml/markdown.xml b/skylighting-core/xml/markdown.xml-index 92831ed..d2975fe 100644---- a/skylighting-core/xml/markdown.xml-+++ b/skylighting-core/xml/markdown.xml-@@ -339,7 +339,6 @@-         <RegExpr attribute="Fenced Code" context="#pop!python-code" String="&fcode;\s*(?:python[23]?|py[23w]?|[rc]py|sconstruct|gypi?)&end;" insensitive="true" beginRegion="code-block"/>-         <RegExpr attribute="Fenced Code" context="#pop!qml-code" String="&fcode;\s*qml(?:types)?&end;" insensitive="true" beginRegion="code-block"/>-         <RegExpr attribute="Fenced Code" context="#pop!r-code" String="&fcode;\s*(?:r|rprofile|rscript)&end;" insensitive="true" beginRegion="code-block"/>--        <RegExpr attribute="Fenced Code" context="#pop!raku-code" String="&fcode;\s*(?:raku(?:mod|doc|test)?|perl6|p[lm]?6|pod6|nqp)&end;" insensitive="true" beginRegion="code-block"/>-         <RegExpr attribute="Fenced Code" context="#pop!rest-code" String="&fcode;\s*(?:rst|rest|restructuredtext)&end;" insensitive="true" beginRegion="code-block"/> <!-- Included in the CMake definition -->-         <RegExpr attribute="Fenced Code" context="#pop!ruby-code" String="&fcode;\s*(?:ruby|rbx?|rjs|rake|f?cgi|gemspec|irbrc|ru|prawn|Appraisals|(?:Rake|Cap|Chef|Gem|Guard|Hobo|Vagrant||Rant|Berks|Thor|Puppet)file|rxml|(?:xml|js)\.erb)&end;" insensitive="true" beginRegion="code-block"/>-         <RegExpr attribute="Fenced Code" context="#pop!rust-code" String="&fcode;\s*(?:rust|rs)&end;" insensitive="true" beginRegion="code-block"/>-@@ -456,10 +455,6 @@-         <IncludeRules context="code"/>-         <IncludeRules context="##R Script" includeAttrib="true"/>-       </context>--      <context attribute="Normal Text" lineEndContext="#stay" name="raku-code">--        <IncludeRules context="code"/>--        <IncludeRules context="base##Raku" includeAttrib="true"/>--      </context>-       <context attribute="Normal Text" lineEndContext="#stay" name="rest-code">-         <IncludeRules context="code"/>-         <IncludeRules context="##reStructuredText" includeAttrib="true"/>
+ xml/mermaid.xml view
@@ -0,0 +1,4811 @@+<?xml version="1.0" encoding="UTF-8"?>+<!DOCTYPE language [+  <!ENTITY mmd_ent_part "([a-zA-Z]+|[0-9]+);">+  <!ENTITY html_ent_part "([a-zA-Z]+|#[0-9]+);">+  <!ENTITY mmd_ent "#&mmd_ent_part;">+  <!ENTITY html_ent "&amp;&html_ent_part;">+  <!ENTITY prefix_mmd_ent_no_ent "#(?!&mmd_ent_part;)">+  <!ENTITY prefix_html_ent_no_ent "&amp;(?!&html_ent_part;)">+  <!ENTITY prefix_ent_no_ent "&prefix_mmd_ent_no_ent;|&prefix_html_ent_no_ent;">++  <!ENTITY prefix_html_tag "&lt;(?=[/a-zA-Z])">+  <!ENTITY prefix_html_tag_no_tag "&lt;(?![/a-zA-Z])">++  <!ENTITY md_syms "$\\*_#&lt;&amp;">+  <!ENTITY md_no_underscore "\B_++\B">+  <!ENTITY md_sym_no_undescore_math_escape "&md_no_underscore;|\$(?!\$)|\\(?=$|[[:alnum:]\s]|\$\$)">+  <!ENTITY md_sym_no_md_no_lt "&md_sym_no_undescore_math_escape;|&prefix_ent_no_ent;">+  <!ENTITY md_sym_no_md "&md_sym_no_md_no_lt;|&prefix_html_tag_no_tag;">+  <!ENTITY md_unescapable_ent "\\(?=&mmd_ent;|&html_ent;)">++  <!ENTITY md_strict_syms "\\*_#&lt;&amp;">+  <!ENTITY md_strict_text "([^&md_strict_syms;]++|&md_no_underscore;|\\(?=$|[[:alnum:]\s])|&prefix_html_ent_no_ent;|&prefix_html_tag_no_tag;)++">++  <!-- '&lt' is a entity, but ';' in '&lt;' is not an entity part...+  Considers '&' as simple text -->+  <!ENTITY md_mmd_syms "$\\*_#&lt;">+  <!ENTITY md_mmd_no_md "&md_sym_no_undescore_math_escape;|&prefix_mmd_ent_no_ent;|&prefix_html_tag_no_tag;">+++  <!--+  Generic keywords+  -->++  <!ENTITY accessibility "accTitle\s*:|accDescr\s*[:{]">+  <!-- direction is bugged: https://github.com/mermaid-js/mermaid/pull/7009 -->+  <!ENTITY direction "direction(?=\s+(TB|TD|BT|RL|LR))">++  <!--+  Flowchart+  -->++  <!ENTITY flowchart_node_nospecial "&md_sym_no_md;|&md_unescapable_ent;">+  <!ENTITY flowchart_qtext_syms "&md_syms;&quot;">+  <!ENTITY flowchart_qtext_no_md "&flowchart_node_nospecial;|\\(?=&quot;)">+  <!ENTITY flowchart_qtext  "([^&flowchart_qtext_syms;]++|&flowchart_qtext_no_md;)++">+  <!ENTITY flowchart_mdtext "([^&md_syms;&quot;`]++|&flowchart_node_nospecial;|\\(?=`))++">++  <!ENTITY flowchart_symbol_in_node          "&amp;&#37;#$!*_+'\\/?`.,">+  <!ENTITY flowchart_symbol_in_node_no_comma "&amp;&#37;#$!*_+'\\/?`.">+  <!-- click: https://github.com/mermaid-js/mermaid/issues/7023 -->+  <!ENTITY flowchart_kw_no_node "(?!\b(&accessibility;|&direction;|click\b(?![-:&flowchart_symbol_in_node;=~;(){}\[\]|@])|(subgraph|end|linkStyle|style|classDef|class|graph|flowchart)\b))(?![ox](-[-.]|==))">+  <!ENTITY flowchart_node+    "&flowchart_kw_no_node;([0-9\p{L}_&flowchart_symbol_in_node;]+|-(?![-.])|:(?!::))+">+  <!ENTITY flowchart_node_no_comma+    "&flowchart_kw_no_node;([0-9\p{L}_&flowchart_symbol_in_node_no_comma;]+|-(?![-.])|:(?!::))+">+  <!ENTITY css_class_name "([0-9\p{L}_&amp;&quot;&#37;`\':.#?!$/*+]+|-(?![-.]))+">+  <!-- whitout '{},' -->+  <!ENTITY new_shape_syms "./\;[]()`&#37;#&amp;!$@*=&lt;&gt;?|'&quot;:-+">++  <!--+  Sequence Diagram+  -->++  <!ENTITY seq_kw_no_node "(?!&accessibility;|(autonumber|participant|box|end|links?|create|destroy|activate|deactivate|Note|loop|alt|else|opt|par|and|critical|option|break|rect|sequenceDiagram)\b)">+  <!ENTITY seq_node "&seq_kw_no_node;([^-;:#(&#37;&lt;&gt;,\\/]++|-(?![->x)]|[|][\\/]|//|\\\\)|\((?!\))|\\(?![\\|]-)|/(?![/|]-))++">++  <!--+  Class Diagram+  -->++  <!ENTITY class_kw_no_node "(?!&accessibility;|&direction;|(class|namespace|callback|click|link|classDef|cssClass|style|note for|note|classDiagram)\b)">+  <!ENTITY class_node "&class_kw_no_node;([0-9\p{L}_]+|-(?![-])|\.(?!\.))+">+  <!ENTITY class_syms_no_label ";:">++  <!--+  State Diagram+  -->++  <!ENTITY state_kw_no_node "(?!(&accessibility;|&direction;|(state|note|classDef|class|stateDiagram)(?=$|[-\s{}:])))">+  <!ENTITY state_node "&state_kw_no_node;([^-\s{}:&#37;&quot;])[^-\s{}:]*">++  <!--+  Entity Relationship Diagram+  -->++  <!-- https://github.com/mermaid-js/mermaid/issues/7093 -->+  <!-- without direction: https://github.com/mermaid-js/mermaid/pull/7009 -->+  <!ENTITY er_kw "((erDiagram|classDef|style|1|one|many|to|u|zero or (one|more|many)|only one|optionally to)\b|0[+])">+  <!ENTITY er_kw_no_node "(?!(&accessibility;|&direction;|&er_kw;))">+  <!ENTITY er_node "&er_kw_no_node;([\w*]+|-(?![-])|\.(?!\.))+">+  <!ENTITY er_link "[|}][o|]([.][.]|--)[|o][{|]">++  <!--+  User Journey Diagram+  -->++  <!ENTITY journey_kw_no_task "(?!&accessibility;|title(\s|$)|section(\s[^:]|\s?$)|journey\b)">+  <!ENTITY journey_task "&journey_kw_no_task;[^#:;]+">++  <!--+  Gantt Diagram+  -->++  <!ENTITY gantt_kw_no_task "(?!&accessibility;|(title|excludes|weekend|section|dateFormat|axisFormat|tickInterval|weekday|todayMarker)(\s|$)|gantt\b)">+  <!ENTITY gantt_task "&gantt_kw_no_task;[^#:]+">++  <!--+  Quadrant Chart+  -->++  <!ENTITY quadrant_kw "((title|classDef)\b|quadrantChart|quadrant-[1234]|[xy]-axis)">+  <!ENTITY quadrant_kw_no_text "(?!&accessibility;|&quadrant_kw;)">+  <!ENTITY quadrant_invalid_char ";(){}[]&lt;>~:&quot;|^@">+  <!ENTITY quadrant_text "&quadrant_kw_no_text;([^\Q&quadrant_invalid_char;\E&#37;\-qxytc]++|&#37;(?!&#37;)|--(?!>)|-(?!->)|(?!\b&quadrant_kw;)\w++)++">++  <!--+  Requirement Diagram+  -->++  <!ENTITY requirement_kw "(requirementDiagram|functionalRequirement|performanceRequirement|interfaceRequirement|physicalRequirement|designConstraint|requirement|element|type|docref|id|text|risk|verifymethod|Low|Medium|High|Analysis|Inspection|Test|Demonstration|style|classDef|class)\b">+  <!ENTITY requirement_kw_no_item "(?!&accessibility;|&requirement_kw;|&direction;|[^a-zA-Z0-9])">+  <!ENTITY requirement_node_in_node  "([^-=,:&lt;>{&md_syms;]++|&md_sym_no_md_no_lt;)++">+  <!ENTITY requirement_node_in_ref "([^-\s=,:&lt;>{&md_syms;]++|&md_sym_no_md_no_lt;)++">+  <!ENTITY requirement_node "&requirement_kw_no_item;&requirement_node_in_node;">+  <!ENTITY requirement_ref  "(?![^a-zA-Z0-9])&requirement_node_in_ref;">++  <!--+  Requirement Diagram+  -->++  <!ENTITY zenuml_no_node "(?!(title|as|new|if|else|while|opt|par|try|catch|finally|return)(?=$|[^a-zA-Z0-9(]))">+  <!ENTITY zenuml_node "&zenuml_no_node;(?:[^-:.{}()\s]++|-(?=$|[^>])|\s+(?!as($|\s)))+">++  <!--+  XY Chart+  -->++  <!-- https://github.com/mermaid-js/mermaid/issues/7157 -->+  <!-- '_' and 0-9 are not a word part... At the beginning only -->+  <!ENTITY xy_wend "($|[^_a-z0-9])">+  <!ENTITY xy_no_kw "([ac-gi-km-suwz]|t(?!itle&xy_wend;)|x(?!-axis&xy_wend;)|y(?!-axis&xy_wend;)|b(?!ar&xy_wend;)|l(?!ine&xy_wend;)|h(?!orizontal&xy_wend;)|v(?!ertical&xy_wend;))">+  <!ENTITY xy_text "[-*=+#.&amp;;_\s0-9]*+(&xy_no_kw;[a-z0-9]*+[-*=+#.&amp;;_\s0-9]*+)*+">+  <!ENTITY xy_title "[*=+#.&amp;;\s]*+(((_|&xy_no_kw;)[_a-z]*+|-(?![0-9]))[*=+#.&amp;;\s]*+)*+">++  <!--+  Block Diagram+  -->++  <!ENTITY block_no_kw "(?!block\b|end\b|space\b|columns\s+[0-9]|style\s|classDef\s|class\s)">+  <!ENTITY block_in_node       "([^-(){}[&lt;>: #&amp;]+|&prefix_ent_no_ent;)">+  <!ENTITY block_first_ch_node "([^-(){}[&lt;>: #&amp;&quot;]|&prefix_ent_no_ent;)">+  <!ENTITY block_node "(\s*&block_no_kw;&block_first_ch_node;&block_in_node;*+)">++  <!--+  Kanban Diagram+  -->++  <!ENTITY kanban_node "([^\[\](){}@&md_syms;]+|&md_sym_no_md;)++">+  <!ENTITY kanban_qtext "([^\[\]()}@&md_syms;]+|&md_sym_no_md;)++">++  <!--+  Architecture Diagram+  -->++  <!ENTITY archi_id_ch "0123456789_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz">++  <!--+  Radar Diagram+  -->++  <!ENTITY radar_id_ch "-0123456789_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz">+]>+<!-- Priority greater than Markdown which also uses .mmd -->+<language+  name="Mermaid" section="Scientific" priority="30"+  version="2" kateversion="6.22"+  mimetype="text/vnd.mermaid" extensions="*.mmd;*.mermaid"+  author="Jonathan Poelen (jonathan.poelen@gmail.com)"+  license="MIT"+>+  <!--+  https://mermaid.js.org/syntax/+  https://mermaid.live/edit++  Flowchart (flowchart, graph) based on v11.12+  Sequence diagrams (sequenceDiagram) based on v11.12+    + half arrow and central connection circle: https://github.com/mermaid-js/mermaid/pull/6789+  Class diagrams (classDiagram) based on v11.12+  State diagrams (stateDiagram-v2, stateDiagram) based on v11.12+  Entity Relationship Diagram (erDiagram) based on v11.12+  User Journey Diagram (journey) based on v11.12+  Gantt diagrams (gantt) based on v11.12+  Pie chart diagrams (pie) based on v11.12+  Quadrant Chart (quadrantChart) based on v11.12+  Requirement Diagram (requirementDiagram) based on v11.12+  GitGraph Diagram (gitGraph) based on v11.12+  Mindmap (mindmap) based on v11.12+  Timeline Diagram (timeline) based on v11.12+  ZenUML (zenuml) based on v11.12+  Sankey diagram (sankey) based on v11.12+  XY Chart (xychart) based on v11.12+  Block Diagram (block) based on v11.12+  Packet Diagram (packet) based on v11.12+  Mermaid Kanban Diagram (kanban) based on v11.12+  Architecture Diagram (architecture-beta) based on v11.12+  Radar Diagram (radar-beta) based on v11.12+  Treemap Diagram (treemap-beta) based on v11.12+  -->++  <highlighting>++    <contexts>++      <context name="Normal" attribute="Normal" lineEndContext="Mermaid"+               fallthroughContext="Mermaid">+        <StringDetect String="---" attribute="Comment" context="Frontmatter" column="0"/>+      </context>++      <!-- https://mermaid.js.org/intro/syntax-reference.html#frontmatter-for-diagram-code -->+      <context name="Frontmatter" attribute="Normal" fallthroughContext="Lvl0Text##YAML">+        <StringDetect String="---" attribute="Comment" context="#pop!Mermaid" column="0"/>+        <IncludeRules context="##YAML" includeAttrib="1"/>+      </context>++      <context name="Mermaid" attribute="Error">+        <DetectSpaces attribute="Normal"/>++        <WordDetect String="flowchart" attribute="Keyword" context="Flowchart"/>+        <WordDetect String="graph"     attribute="Keyword" context="Flowchart"/>+        <WordDetect String="sequenceDiagram" attribute="Keyword" context="SequenceDiag"/>+        <WordDetect String="classDiagram" attribute="Keyword"+                    context="ClassDiag!LineErrorExceptSpaces"/>+        <WordDetect String="stateDiagram-v2" attribute="Keyword"+                    context="StateDiag!LineErrorExceptSpaces"/>+        <WordDetect String="stateDiagram" attribute="Keyword"+                    context="StateDiag!LineErrorExceptSpaces"/>+        <WordDetect String="erDiagram" attribute="Keyword"+                    context="erDiag!LineErrorExceptSpaces"/>+        <WordDetect String="journey" attribute="Keyword" context="Journey"/>+        <WordDetect String="gantt" attribute="Keyword" context="Gantt"/>+        <WordDetect String="pie" attribute="Keyword" context="Pie"/>+        <WordDetect String="quadrantChart" attribute="Keyword" context="Quadrant"/>+        <WordDetect String="requirementDiagram" attribute="Keyword" context="Requirement"/>+        <WordDetect String="gitGraph" attribute="Keyword" context="Git"/>+        <WordDetect String="mindmap" attribute="Keyword" context="Mindmap"/>+        <WordDetect String="timeline" attribute="Keyword" context="Timeline"/>+        <WordDetect String="zenuml" attribute="Keyword" context="ZenUML"/>+        <WordDetect String="sankey" attribute="Keyword" context="Sankey"+                    additionalDeliminator="&quot;"/>+        <WordDetect String="xychart" attribute="Keyword" context="XYChart"/>+        <WordDetect String="block" attribute="Keyword" context="Block"/>+        <WordDetect String="packet" attribute="Keyword" context="Packet"/>+        <WordDetect String="kanban" attribute="Keyword" context="Kanban"/>+        <WordDetect String="architecture-beta" attribute="Keyword" context="Archi"/>+        <WordDetect String="radar-beta" attribute="Keyword" context="Radar"/>+        <WordDetect String="treemap-beta" attribute="Keyword" context="Treemap"+                    additionalDeliminator="&quot;'"/>++        <IncludeRules context="Find_Comment"/>+      </context>++      <!--+      @{ Accessibility+      https://mermaid.js.org/config/accessibility.html+      -->+      <context name="Find_Accessibility" attribute="Error">+        <WordDetect String="accTitle" attribute="Keyword" context="accTitle"+                    weakDeliminator="!%&amp;()*+,-./&lt;=>?[\\]^{|}~"/>+        <WordDetect String="accDescr" attribute="Keyword" context="accDescr"+                    weakDeliminator="!%&amp;()*+,-./&lt;=>?[\\]^|}~"/>+      </context>++      <context name="Find_Accessibility_Insensitive" attribute="Error">+        <WordDetect String="accTitle" attribute="Keyword" context="accTitle" insensitive="1"+                    weakDeliminator="!%&amp;()*+,-./&lt;=>?[\\]^{|}~"/>+        <WordDetect String="accDescr" attribute="Keyword" context="accDescr" insensitive="1"+                    weakDeliminator="!%&amp;()*+,-./&lt;=>?[\\]^|}~"/>+      </context>++      <context name="accTitle" attribute="Normal" lineEndContext="#pop"+               fallthroughContext="#pop">+        <StringDetect String=":" attribute="Keyword Property Separator" context="accTitle_Text"/>+        <DetectSpaces/>+      </context>+      <context name="accTitle_Text" attribute="Text" lineEndContext="#pop#pop">+      </context>++      <context name="accDescr" attribute="Normal" lineEndContext="#pop"+               fallthroughContext="#pop">+        <StringDetect String="{" attribute="Curly Bracket Block Delimiter"+                      context="accDescr_Block" beginRegion="block"/>+        <IncludeRules context="accTitle"/>+      </context>+      <context name="accDescr_Block" attribute="Text">+        <StringDetect String="}" attribute="Curly Bracket Block Delimiter" context="#pop#pop"+                      endRegion="block"/>+      </context>+      <!--+      @} Accessibility+      -->+++      <!--+      @{ Flowcharts https://mermaid.js.org/syntax/flowchart.html+      -->++      <context name="Flowchart" attribute="Normal" lineEndContext="Flowchart_Body"+               fallthroughContext="Flowchart_Body!LineError">+        <StringDetect String=";" attribute="Symbol Separator" context="Flowchart_Body"/>+        <DetectSpaces attribute="Normal"/>+        <StringDetect String="TB" attribute="Keyword Parameter"/>+        <StringDetect String="TD" attribute="Keyword Parameter"/>+        <StringDetect String="BT" attribute="Keyword Parameter"/>+        <StringDetect String="RL" attribute="Keyword Parameter"/>+        <StringDetect String="LR" attribute="Keyword Parameter"/>+      </context>++      <context name="Flowchart_Body" attribute="Error" fallthroughContext="Flowchart_AfterNode">+        <DetectSpaces attribute="Normal"/>+        <IncludeRules context="Flowchart_Find_MdText"/>+        <IncludeRules context="Flowchart_Find_UnicodeText"/>+        <StringDetect String=":::" attribute="Class Name Delimiter"+                      context="Flowchart_AfterNode!Flowchart_DeclClassName"/>++        <StringDetect String='|' attribute="Error"+                      context="Flowchart_LinkPipe!Flowchart_QText"/>++        <StringDetect String=";" attribute="Symbol Separator"/>+        <IncludeRules context="Find_Comment"/>++        <RegExpr String="&flowchart_node;" attribute="Node" context="Flowchart_AfterNode"/>++        <WordDetect String="subgraph" attribute="Keyword" beginRegion="kwblock"/>+        <WordDetect String="end" attribute="Keyword" endRegion="kwblock"/>+        <WordDetect String="direction" attribute="Keyword" context="Flowchart_KwDirection"/>+        <WordDetect String="linkStyle" attribute="Keyword" context="Flowchart_KwLinkStyle"/>+        <WordDetect String="style" attribute="Keyword" context="Flowchart_KwStyle"/>+        <WordDetect String="class" attribute="Keyword" context="Flowchart_KwClass"/>+        <WordDetect String="classDef" attribute="Keyword" context="Flowchart_KwClassDef"/>+        <WordDetect String="click" attribute="Keyword" context="Flowchart_KwClick"/>++        <IncludeRules context="Find_Accessibility"/>++        <!-- because mermaid... -->+        <StringDetect String="graph" attribute="Error" context="#pop"/>+        <StringDetect String="flowchart" attribute="Error" context="#pop"/>+      </context>++      <!-- :::classname+              ~~~~~~~~~ -->+      <context name="Flowchart_DeclClassName" attribute="Normal"+               lineEndContext="#pop" fallthroughContext="#pop">+        <RegExpr String="&css_class_name;" attribute="Class Name" context="#pop"/>+      </context>++      <context name="Flowchart_AfterNode" attribute="Normal" lineEndContext="#pop">+        <StringDetect String=";" attribute="Symbol Separator" context="#pop"/>+        <!-- no space for edge id: `A@{}id@==>`+        https://github.com/mermaid-js/mermaid/issues/7032 -->+        <StringDetect String="@" attribute="Node Separator"+                      context="#pop!Flowchart_AfterNode_Spaces!Flowchart_NewShape"/>+        <DetectSpaces context="#pop!Flowchart_AfterNode_Spaces"/>+        <IncludeRules context="Flowchart_Find_Link"/>+        <IncludeRules context="Flowchart_Find_Shape"/>+        <StringDetect String=":::" attribute="Class Name Delimiter"+                      context="Flowchart_DeclClassName"/>+        <IncludeRules context="CharErrorAndPop"/>+      </context>++      <context name="Flowchart_AfterNode_Spaces" attribute="Normal" lineEndContext="#pop">+        <StringDetect String=";" attribute="Symbol Separator" context="#pop"/>+        <StringDetect String="&amp; " attribute="Union" context="#pop"/>+        <IncludeRules context="Flowchart_Find_Link"/>+        <!-- Normally no spaces before, but subgraph keyword -->+        <IncludeRules context="Flowchart_Find_Shape"/>+        <!-- Normally any character, but the IDs are no longer referable... -->+        <RegExpr String="[a-zA-F][a-zA-F0-9]*(?=@)" attribute="ID" context="Flowchart_ID"/>+        <IncludeRules context="CharErrorAndPop"/>+      </context>+      <context name="Flowchart_ID" attribute="Normal">+        <StringDetect String="@" attribute="ID Separator" context="#pop#pop!Flowchart_LinkOrError"/>+      </context>++      <context name="Flowchart_LinkOrError" attribute="Normal" lineEndContext="#pop">+        <IncludeRules context="Flowchart_Find_Link"/>+        <DetectSpaces attribute="Error" context="#pop"/>+        <IncludeRules context="CharErrorAndPop"/>+      </context>++      <context name="Flowchart_Find_Link" attribute="Normal">+        <StringDetect String="--"     attribute="Link" context="Flowchart_LinkLine"/>+        <StringDetect String="&lt;--" attribute="Link" context="Flowchart_LinkLine"/>+        <StringDetect String="o--"    attribute="Link" context="Flowchart_LinkLine"/>+        <StringDetect String="x--"    attribute="Link" context="Flowchart_LinkLine"/>++        <StringDetect String="=="     attribute="Link" context="Flowchart_LinkThick"/>+        <StringDetect String="&lt;==" attribute="Link" context="Flowchart_LinkThick"/>+        <StringDetect String="o=="    attribute="Link" context="Flowchart_LinkThick"/>+        <StringDetect String="x=="    attribute="Link" context="Flowchart_LinkThick"/>++        <StringDetect String="-."     attribute="Link" context="Flowchart_LinkDotted"/>+        <StringDetect String="&lt;-." attribute="Link" context="Flowchart_LinkDotted"/>+        <StringDetect String="o-."    attribute="Link" context="Flowchart_LinkDotted"/>+        <StringDetect String="x-."    attribute="Link" context="Flowchart_LinkDotted"/>++        <StringDetect String="~~~" attribute="Link" context="Flowchart_LinkInvisible"/>++        <AnyChar String="-=~" attribute="Error" context="#pop"/>+      </context>++      <context name="Flowchart_Find_Shape" attribute="Normal">+        <!-- [[...]] -->+        <StringDetect String="[[" attribute="Shape" context="Flowchart_TextNode_End[[]]!Flowchart_TextNode_Text!Flowchart_QText"/>+        <!-- [(...)] -->+        <StringDetect String="[(" attribute="Shape" context="Flowchart_TextNode_End[()]!Flowchart_TextNode_Text!Flowchart_QText"/>+        <!-- [/.../] or [/...\] -->+        <StringDetect String="[/" attribute="Shape" context="Flowchart_TextNode_Text[//]!Flowchart_QText"/>+        <!-- [\.../] or [\...\] -->+        <StringDetect String="[\" attribute="Shape" context="Flowchart_TextNode_Text[//]!Flowchart_QText"/>+        <!-- [...] -->+        <StringDetect String="[" attribute="Shape" context="Flowchart_TextNode_End[]!Flowchart_TextNode_Text!Flowchart_QText"/>+        <!-- (((...))) -->+        <StringDetect String="(((" attribute="Shape" context="Flowchart_TextNode_End((()))!Flowchart_TextNode_Text!Flowchart_QText"/>+        <!-- ((...)) -->+        <StringDetect String="((" attribute="Shape" context="Flowchart_TextNode_End(())!Flowchart_TextNode_Text!Flowchart_QText"/>+        <!-- ([...]) -->+        <StringDetect String="([" attribute="Shape" context="Flowchart_TextNode_End([])!Flowchart_TextNode_Text!Flowchart_QText"/>+        <!-- (...) -->+        <StringDetect String="(" attribute="Shape" context="Flowchart_TextNode_End()!Flowchart_TextNode_Text!Flowchart_QText"/>+        <!-- {{...}} -->+        <StringDetect String="{{" attribute="Shape" context="Flowchart_TextNode_End{{}}!Flowchart_TextNode_Text!Flowchart_QText"/>+        <!-- {...} -->+        <StringDetect String="{" attribute="Shape" context="Flowchart_TextNode_End{}!Flowchart_TextNode_Text!Flowchart_QText"/>+        <!-- >...] -->+        <StringDetect String=">" attribute="Shape" context="Flowchart_TextNode_End[]!Flowchart_TextNode_Text!Flowchart_QText"/>+      </context>+++      <!--+      @{ Link: ==>, etc+      -->+      <context name="Flowchart_Find_LinkText_Common" attribute="Link Text">+        <IncludeRules context="EmptyQuotedText"/>+        <StringDetect String='"' attribute="Error"/>+        <IncludeRules context="Find_Comment_InText"/>+      </context>+      <context name="Flowchart_Find_LinkText_Special_Common" attribute="Link Text">+        <IncludeRules context="EmptyQuotedText_ThenPop"/>+        <StringDetect String='"' attribute="Error" context="#pop"/>+        <IncludeRules context="Find_Md_Syms_ThenPop"/>+      </context>++      <!-- A - - note - - - B+           A - - note - - - - -x B+           A - - - B+           A - - - - - -x B+           A - - | note | B+           A - - - -x| note | B+                 ~~~~~~~~~~~~~~~+      -->+      <context name="Flowchart_LinkLine" attribute="Link"+               lineEndContext="Flowchart_LinkLine_Text!Flowchart_LinkText_Q"+               fallthroughContext="Flowchart_LinkLine_Text!Flowchart_LinkText_Q">+        <AnyChar String="ox>" attribute="Link" context="Flowchart_LinkEnd_PipeOrNoLink"/>+        <StringDetect String="-" attribute="Link"+                      context="Flowchart_LinkEnd_PipeOrNoLink!Flowchart_LinkLine_End"/>+      </context>+      <context name="Flowchart_LinkLine_End" attribute="Link"+               lineEndContext="#pop" fallthroughContext="#pop">+        <AnyChar String="ox>" attribute="Link" context="#pop"/>+        <StringDetect String="-"/>+      </context>+      <!-- A - - note - - - B+                ~~~~~~~~~~~~~+      -->+      <context name="Flowchart_LinkLine_Text" attribute="Link Text"+               fallthroughContext="Flowchart_LinkLine_Text_Special">+        <StringDetect String="--" attribute="Link"+                      context="#pop#pop!Flowchart_LinkLine_TextEnd"/>+        <IncludeRules context="Flowchart_Find_LinkText_Common"/>+        <RegExpr String='([^-"&md_syms;]++|&md_sym_no_md;|-(?!-))++(\\(?=--[->xo]))?'+                 attribute="Link Text" context="Flowchart_LinkLine_Text_Special"/>+      </context>+      <context name="Flowchart_LinkLine_Text_Special" attribute="Link Text"+               lineEndContext="#pop">+        <StringDetect String="--" attribute="Link"+                      context="#pop#pop#pop!Flowchart_LinkLine_TextEnd"/>+        <IncludeRules context="Flowchart_Find_LinkText_Special_Common"/>+        <IncludeRules context="Find_Md_Html_LinkLine_ThenPop"/>+      </context>+      <!-- A - - note - - - B+                         ~~~~+      -->+      <context name="Flowchart_LinkLine_TextEnd" attribute="Link" lineEndContext="#pop">+        <AnyChar String="ox>" attribute="Link" context="Flowchart_LinkEnd_NoLink"/>+        <StringDetect String="-" attribute="Link"+                      context="Flowchart_LinkEnd_NoLink!Flowchart_LinkLine_End"/>+        <RegExpr String="." attribute="Error" context="#pop#pop"/>+      </context>+++      <!-- A == note === B+           A == note =====x B+           A === B+           A =====x B+           A == | note | B+           A ===x| note | B+               ~~~~~~~~~~~~~~~+      -->+      <!-- === -->+      <context name="Flowchart_LinkThick" attribute="Link"+               lineEndContext="Flowchart_LinkThick_Text!Flowchart_LinkText_Q"+               fallthroughContext="Flowchart_LinkThick_Text!Flowchart_LinkText_Q">+        <AnyChar String="ox>" attribute="Link" context="Flowchart_LinkEnd_PipeOrNoLink"/>+        <StringDetect String="=" attribute="Link"+                      context="Flowchart_LinkEnd_PipeOrNoLink!Flowchart_LinkThick_End"/>+      </context>+      <context name="Flowchart_LinkThick_End" attribute="Link"+               lineEndContext="#pop" fallthroughContext="#pop">+        <AnyChar String="ox>" attribute="Link" context="#pop"/>+        <StringDetect String="="/>+      </context>+      <!-- A == note === B+               ~~~~~~~~~~~+      -->+      <context name="Flowchart_LinkThick_Text" attribute="Link Text"+               fallthroughContext="Flowchart_LinkThick_Text_Special">+        <StringDetect String="==" attribute="Link"+                      context="#pop#pop!Flowchart_LinkThick_TextEnd"/>+        <StringDetect String="=" attribute="Error"/>+        <IncludeRules context="Flowchart_Find_LinkText_Common"/>+        <RegExpr String='([^="&md_syms;]++|&md_sym_no_md;|\\(?==))++'+                 attribute="Link Text" context="Flowchart_LinkThick_Text_Special"/>+      </context>+      <context name="Flowchart_LinkThick_Text_Special" attribute="Link Text"+               lineEndContext="#pop">+        <StringDetect String="==" attribute="Link"+                      context="#pop#pop#pop!Flowchart_LinkThick_TextEnd"/>+        <StringDetect String="=" attribute="Error" context="#pop"/>+        <IncludeRules context="Flowchart_Find_LinkText_Special_Common"/>+        <IncludeRules context="Find_Md_Html_LinkThick_ThenPop"/>+      </context>+      <!-- A == note === B+                       ~~~+      -->+      <context name="Flowchart_LinkThick_TextEnd" attribute="Link" lineEndContext="#pop">+        <AnyChar String="ox>" attribute="Link" context="Flowchart_LinkEnd_NoLink"/>+        <StringDetect String="=" attribute="Link"+                      context="Flowchart_LinkEnd_NoLink!Flowchart_LinkThick_End"/>+        <RegExpr String="." context="#pop#pop"/>+      </context>+++      <!-- A -. note .- B+           A -. note ....-x B+           A -.- B+           A -....-x B+           A -.- | note | B+           A -....-x| note | B+               ~~~~~~~~~~~~~+      -->+      <context name="Flowchart_LinkDotted" attribute="Link"+               lineEndContext="Flowchart_LinkDotted_Text!Flowchart_LinkText_Q"+               fallthroughContext="Flowchart_LinkDotted_Text!Flowchart_LinkText_Q">+        <RegExpr String="[.]*-[ox>]?" attribute="Link"+                 context="Flowchart_LinkEnd_PipeOrNoLink"/>+      </context>+      <!-- -.note.-+             ~~~~~~+      -->+      <context name="Flowchart_LinkDotted_Text" attribute="Link Text"+               fallthroughContext="Flowchart_LinkDotted_Text_Special">+        <StringDetect String="." context="#pop#pop!Flowchart_LinkDotted_TextEnd" lookAhead="1"/>+        <IncludeRules context="Flowchart_Find_LinkText_Common"/>+        <RegExpr String='([^."&md_syms;]++|&md_sym_no_md;|\\(?=\.))++'+                 attribute="Link Text" context="Flowchart_LinkDotted_Text_Special"/>+      </context>+      <context name="Flowchart_LinkDotted_Text_Special" attribute="Link Text"+               lineEndContext="#pop">+        <StringDetect String="." context="#pop#pop#pop!Flowchart_LinkDotted_TextEnd"+                      lookAhead="1"/>+        <IncludeRules context="Flowchart_Find_LinkText_Special_Common"/>+        <IncludeRules context="Find_Md_Html_LinkDotted_ThenPop"/>+      </context>+      <!-- -.note.-+                 ~~+      -->+      <context name="Flowchart_LinkDotted_TextEnd" attribute="Link Text">+        <RegExpr String="[.]*-[ox>]?" attribute="Link" context="Flowchart_LinkEnd_NoLink"/>+        <RegExpr String="[.]+>?|." attribute="Error" context="#pop#pop"/>+      </context>+++      <!-- ~~~ -->+      <context name="Flowchart_LinkInvisible" attribute="Link"+               lineEndContext="Flowchart_LinkEnd_PipeOrNoLink"+               fallthroughContext="Flowchart_LinkEnd_PipeOrNoLink">+        <StringDetect String="~" attribute="Link"/>+      </context>+++      <!-- A ===| note | B+                ~+      -->+      <context name="Flowchart_LinkEnd_PipeOrNoLink" attribute="Error"+               fallthroughContext="#pop#pop#pop">+        <DetectSpaces attribute="Normal"/>+        <StringDetect String="|" attribute="Link Text Delimiter"+                      context="#pop#pop#pop!Flowchart_LinkPipe!Flowchart_QText"/>+        <IncludeRules context="Flowchart_LinkEnd_NoLink"/>+      </context>++      <!-- A ==x==>-+                   ~ Error+      -->+      <context name="Flowchart_LinkEnd_NoLink" attribute="Error"+               fallthroughContext="#pop#pop#pop">+        <DetectSpaces attribute="Normal"/>++        <StringDetect String="--" attribute="Error" context="#pop#pop!Flowchart_LinkLine"/>+        <StringDetect String="o--" attribute="Error" context="#pop#pop!Flowchart_LinkLine"/>+        <StringDetect String="x--" attribute="Error" context="#pop#pop!Flowchart_LinkLine"/>+        <StringDetect String="&lt;--" attribute="Error" context="#pop#pop!Flowchart_LinkLine"/>++        <StringDetect String="o==" attribute="Error" context="#pop#pop!Flowchart_LinkThick"/>+        <StringDetect String="x==" attribute="Error" context="#pop#pop!Flowchart_LinkThick"/>+        <StringDetect String="&lt;==" attribute="Error" context="#pop#pop!Flowchart_LinkThick"/>++        <StringDetect String="-." attribute="Error" context="#pop#pop!Flowchart_LinkDotted"/>+        <StringDetect String="o-." attribute="Error" context="#pop#pop!Flowchart_LinkDotted"/>+        <StringDetect String="x-." attribute="Error" context="#pop#pop!Flowchart_LinkDotted"/>+        <StringDetect String="&lt;-." attribute="Error" context="#pop#pop!Flowchart_LinkDotted"/>++        <StringDetect String="~~~" attribute="Error" context="#pop#pop!Flowchart_LinkInvisible"/>+        <!-- only one '-' is not a link but a node name -->+        <AnyChar String="=~" attribute="Error" context="#pop#pop#pop"/>++      </context>++      <!-- A ===| note | B+                  ~~~~~~+      -->+      <context name="Flowchart_LinkPipe" attribute="Link Text"+               fallthroughContext="Flowchart_LinkPipe_Special">+        <StringDetect String="|" attribute="Link Text Delimiter" context="#pop"/>+        <IncludeRules context="Find_Comment_InText"/>+        <RegExpr String='([^|{}[]()"&md_syms;]++|&md_sym_no_md;|\\(?=\|))++'+                 attribute="Link Text" context="Flowchart_LinkPipe_Special"/>+      </context>+      <context name="Flowchart_LinkPipe_Special" attribute="Link Text"+               lineEndContext="#pop">+        <StringDetect String="|" attribute="Link Text Delimiter" context="#pop#pop"/>+        <IncludeRules context="EmptyQuotedText_ThenPop"/>+        <AnyChar String='{}[]()"' attribute="Error" context="#pop#pop"/>+        <!-- https://github.com/mermaid-js/mermaid/issues/7003 -->+        <IncludeRules context="Find_Md_Syms_ThenPop"/>+        <IncludeRules context="Find_Md_Html_Text_ThenPop"/>+      </context>++      <!-- A == note === B (and other link)+               ~+      -->+      <context name="Flowchart_LinkText_Q" attribute="Link Text"+               fallthroughContext="#pop!Flowchart_QText">+        <IncludeRules context="Find_Comment_InText"/>+      </context>+      <!--+      @} Link+      -->+++      <!-- node["..."] node["`...`"]+                ~~~~~       ~~~~~~~+      -->+      <context name="Flowchart_QText" attribute="Text" lineEndContext="#pop"+               fallthroughContext="#pop">+        <IncludeRules context="EmptyQuotedText"/>+        <!-- https://github.com/mermaid-js/mermaid/issues/7014 -->+        <IncludeRules context="Flowchart_Find_MdText_ThenPop"/>+        <IncludeRules context="Flowchart_Find_UnicodeText_ThenPop"/>+      </context>++      <!-- node[...]+                ~~~+      Neither Quoted Text nor Markdown Formatting+      -->+      <context name="Flowchart_TextNode_Text" attribute="Text"+               fallthroughContext="Flowchart_TextNode_Text_Special">+        <AnyChar String='{}[]()"|@' context="#pop" lookAhead="1"/>+        <IncludeRules context="Find_Comment_InText"/>+        <RegExpr String='([^{}\[\]()"|@&md_syms;]++|&flowchart_node_nospecial;|\\(?=\]))++'+                 attribute="Text" context="Flowchart_TextNode_Text_Special"/>+      </context>+      <context name="Flowchart_TextNode_Text_Special" attribute="Text"+               lineEndContext="#pop">+        <IncludeRules context="EmptyQuotedText_ThenPop"/>+        <AnyChar String='{}[]()"|@' context="#pop#pop" lookAhead="1"/>+        <!-- https://github.com/mermaid-js/mermaid/issues/7014 -->+        <IncludeRules context="Find_Md_Syms_ThenPop"/>+        <IncludeRules context="Find_Md_Html_Text_ThenPop"/>+      </context>++      <!-- node[/.../] (or /...\ or \.../ or \...\)+                 ~~~+      Neither Quoted Text nor Markdown Formatting+      -->+      <context name="Flowchart_TextNode_Text[//]" attribute="Text"+               fallthroughContext="Flowchart_TextNode_Text[//]_Special">+        <IncludeRules context="Flowchart_TextNode_EndCommon"/>+        <IncludeRules context="Find_Comment_InText"/>+        <StringDetect String="\]" attribute="Shape" context="#pop#pop!Flowchart_AfterNode"/>+        <StringDetect String="/]" attribute="Shape" context="#pop#pop!Flowchart_AfterNode"/>+        <RegExpr String='([^{}\[\]()"|@/&md_syms;]++|&flowchart_node_nospecial;|\\(?=[/\\]\])|/(?!\]))++'+                 attribute="Text" context="Flowchart_TextNode_Text[//]_Special"/>+      </context>+      <context name="Flowchart_TextNode_Text[//]_Special" attribute="Text"+               lineEndContext="#pop">+        <StringDetect String="\]" attribute="Shape" context="#pop#pop#pop!Flowchart_AfterNode"/>+        <StringDetect String="/]" attribute="Shape" context="#pop#pop#pop!Flowchart_AfterNode"/>+        <IncludeRules context="EmptyQuotedText_ThenPop"/>+        <AnyChar String='{}[]()"|@' attribute="Error"+                 context="#pop#pop#pop!Flowchart_AfterNode"/>+        <!-- https://github.com/mermaid-js/mermaid/issues/7014 -->+        <IncludeRules context="Find_Md_Syms_ThenPop"/>+        <IncludeRules context="Find_Md_Html_Text[//]_ThenPop"/>+      </context>+++      <!--+      @{ end text node: node[...], node((...)), etc+                                ~           ~~+      -->+      <context name="Flowchart_TextNode_EndCommon" attribute="Normal">+        <AnyChar String='{}[]()"|@' attribute="Error" context="#pop#pop!Flowchart_AfterNode"/>+      </context>++      <context name="Flowchart_TextNode_End[]" attribute="Normal">+        <StringDetect String="]" attribute="Shape" context="#pop#pop!Flowchart_AfterNode"/>+        <IncludeRules context="Flowchart_TextNode_EndCommon"/>+      </context>++      <context name="Flowchart_TextNode_End[[]]" attribute="Normal">+        <StringDetect String="]]" attribute="Shape" context="#pop#pop!Flowchart_AfterNode"/>+        <IncludeRules context="Flowchart_TextNode_EndCommon"/>+      </context>++      <context name="Flowchart_TextNode_End[()]" attribute="Normal">+        <StringDetect String=")]" attribute="Shape" context="#pop#pop!Flowchart_AfterNode"/>+        <IncludeRules context="Flowchart_TextNode_EndCommon"/>+      </context>++      <context name="Flowchart_TextNode_End()" attribute="Normal">+        <StringDetect String=")" attribute="Shape" context="#pop#pop!Flowchart_AfterNode"/>+        <IncludeRules context="Flowchart_TextNode_EndCommon"/>+      </context>++      <context name="Flowchart_TextNode_End(())" attribute="Normal">+        <StringDetect String="))" attribute="Shape" context="#pop#pop!Flowchart_AfterNode"/>+        <IncludeRules context="Flowchart_TextNode_EndCommon"/>+      </context>++      <context name="Flowchart_TextNode_End((()))" attribute="Normal">+        <StringDetect String=")))" attribute="Shape" context="#pop#pop!Flowchart_AfterNode"/>+        <IncludeRules context="Flowchart_TextNode_EndCommon"/>+      </context>++      <context name="Flowchart_TextNode_End([])" attribute="Normal">+        <StringDetect String="])" attribute="Shape" context="#pop#pop!Flowchart_AfterNode"/>+        <IncludeRules context="Flowchart_TextNode_EndCommon"/>+      </context>++      <context name="Flowchart_TextNode_End{{}}" attribute="Normal">+        <StringDetect String="}}" attribute="Shape" context="#pop#pop!Flowchart_AfterNode"/>+        <IncludeRules context="Flowchart_TextNode_EndCommon"/>+      </context>++      <context name="Flowchart_TextNode_End{}" attribute="Normal">+        <StringDetect String="}" attribute="Shape" context="#pop#pop!Flowchart_AfterNode"/>+        <IncludeRules context="Flowchart_TextNode_EndCommon"/>+      </context>+      <!--+      @} end text node+      -->+++      <!--+      @{ new shape syntax+      -->+      <!-- A@{ shape: manual-file, label: "File Handling"}+             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+      -->+      <context name="Flowchart_NewShape" attribute="Error">+        <StringDetect String="{" attribute="Curly Bracket Block Delimiter"+                      context="Flowchart_NewShape_Prop"/>+        <IncludeRules context="CharErrorAndPop"/>+      </context>+      <context name="Flowchart_NewShape_Prop" attribute="Error">+        <!-- https://github.com/mermaid-js/mermaid/issues/7044 -->+        <StringDetect String=": " attribute="Property Separator"+                      context="Flowchart_NewShape_PropValue"/>+        <LineContinue char=":" attribute="Property Separator"+                      context="Flowchart_NewShape_PropValue"/>+        <IncludeRules context="Find_DQuote_NoSpecial"/>+        <StringDetect String="}" attribute="Curly Bracket Block Delimiter" context="#pop#pop"/>+        <IncludeRules context="Find_Prop"/>+      </context>+      <context name="Find_Prop" attribute="Error">+        <DetectSpaces attribute="Normal"/>+        <DetectIdentifier attribute="Property"/>+        <!-- <StringDetect String="-" attribute="Property"/> -->+        <!-- <Int attribute="Property"/> -->+        <IncludeRules context="Find_Comment"/>+      </context>+      <!-- A@{ prop: value }+                    ~~~~~~+      -->+      <context name="Flowchart_NewShape_PropValue" attribute="Error"+               fallthroughContext="Flowchart_NewShape_PropValue_Text">+        <StringDetect String='"' attribute="Quoted Text Delimiter"+                      context="Flowchart_NewShape_QEnd!Flowchart_NewShape_PropValue_DQ"/>+        <!-- https://github.com/mermaid-js/mermaid/issues/7037 -->+        <StringDetect String="'" attribute="Quoted Text Delimiter"+                      context="Flowchart_NewShape_QEnd!Flowchart_NewShape_PropValue_SQ"/>+        <DetectSpaces attribute="Normal"/>+        <Int attribute="Property Number"+             weakDeliminator="&new_shape_syms;" context="Flowchart_NewShape_PropValue_Text"/>+        <WordDetect String="true" attribute="Property Boolean"+                    weakDeliminator="&new_shape_syms;" context="Flowchart_NewShape_PropValue_Text"/>+        <WordDetect String="false" attribute="Property Boolean"+                    weakDeliminator="&new_shape_syms;" context="Flowchart_NewShape_PropValue_Text"/>+        <!-- https://github.com/mermaid-js/mermaid/issues/7044 -->+        <AnyChar String="`*#%@|&gt;" attribute="Error"+                 context="Flowchart_NewShape_PropValue_Text"/>+      </context>+      <!-- A@{ prop: value }+                     ~~~~~~~+      -->+      <context name="Flowchart_NewShape_PropValue_Text" attribute="Text"+               fallthroughContext="Flowchart_NewShape_PropValue_Text_Special">+        <StringDetect String="}" attribute="Curly Bracket Block Delimiter"+                      context="#pop#pop#pop#pop"/>+        <StringDetect String="," attribute="List Separator" context="#pop#pop"/>+        <IncludeRules context="Find_Comment_InText"/>+        <!-- https://github.com/mermaid-js/mermaid/issues/7044 for '[]^', ': ', ' #' -->+        <RegExpr String='([^"{}\[\]^ :,&md_syms;]++|&flowchart_node_nospecial;|:(?! )| (?=$|[^#]|&mmd_ent;))++'+                 attribute="Text" context="Flowchart_NewShape_PropValue_Text_Special"/>+      </context>+      <context name="Flowchart_NewShape_PropValue_Text_Special" attribute="Text"+               lineEndContext="#pop">+        <StringDetect String="}" attribute="Curly Bracket Block Delimiter"+                      context="#pop#pop#pop#pop#pop"/>+        <StringDetect String="," attribute="List Separator" context="#pop#pop#pop"/>+        <!-- https://github.com/mermaid-js/mermaid/issues/7044 for '[]^' -->+        <AnyChar String='"{[]^' attribute="Error" context="#pop"/>+        <!-- https://github.com/mermaid-js/mermaid/issues/7044 -->+        <StringDetect String=": " attribute="Error" context="#pop"/>+        <!-- https://github.com/mermaid-js/mermaid/issues/7044 -->+        <StringDetect String=" #" attribute="Error" context="#pop"/>+        <!-- https://github.com/mermaid-js/mermaid/issues/7014 -->+        <IncludeRules context="Find_Md_Syms_ThenPop"/>+        <IncludeRules context="Find_Md_Html_NewShape_ThenPop"/>+      </context>+      <!-- A@{ prop: "value" }+                      ~~~~~~~~+      -->+      <context name="Flowchart_NewShape_PropValue_DQ" attribute="Quoted Text">+        <IncludeRules context="Flowchart_UnicodeText"/>+        <StringDetect String="\" attribute="Error"/>+      </context>+      <!-- A@{ prop: 'value' }+                      ~~~~~~~~+      mix of Mermaid Text and Yaml+      https://github.com/mermaid-js/mermaid/issues/7044+      -->+      <context name="Flowchart_NewShape_PropValue_SQ" attribute="Text"+               fallthroughContext="Flowchart_NewShape_PropValue_SQ_Special">+        <StringDetect String="''" attribute="Special Text Char"/>+        <StringDetect String="'" attribute="Quoted Text Delimiter" context="#pop"/>+        <IncludeRules context="Find_Comment_InText"/>+        <RegExpr String="([^'&quot;}&md_syms;]++|&md_sym_no_md;)++"+                 attribute="Text" context="Flowchart_NewShape_PropValue_SQ_Special"/>+      </context>+      <context name="Flowchart_NewShape_PropValue_SQ_Special" attribute="Text"+               lineEndContext="#pop">+        <StringDetect String="''" attribute="Special Text Char" context="#pop"/>+        <StringDetect String="'" attribute="Quoted Text Delimiter" context="#pop#pop"/>+        <StringDetect String="}" attribute="Error" context="#pop#pop#pop#pop#pop#pop"/>+        <StringDetect String='"' attribute="Error" context="#pop"/>+        <!-- https://github.com/mermaid-js/mermaid/issues/7003 -->+        <IncludeRules context="Find_Md_Syms_ThenPop"/>+        <IncludeRules context="Find_Md_Html_NewShapeSQ_ThenPop"/>+      </context>+      <!-- A@{ prop: 'value' }+                            ~+      -->+      <context name="Flowchart_NewShape_QEnd" attribute="Error">+        <StringDetect String="}" attribute="Curly Bracket Block Delimiter"+                      context="#pop#pop#pop#pop"/>+        <StringDetect String="," attribute="List Separator" context="#pop#pop"/>+        <DetectSpaces attribute="Normal"/>+        <IncludeRules context="Find_Comment"/>+      </context>+      <!--+      @} new shape syntax+      -->+++      <!--+      @{ direction+      -->+      <context name="Flowchart_KwDirection" attribute="Normal" lineEndContext="#pop"+               fallthroughContext="#pop!FakeComment">+        <DetectSpaces/>+        <!-- insensitive except for Flowchart -->+        <StringDetect String="TB" attribute="Keyword Parameter" context="#pop!FakeComment" insensitive="1"/>+        <StringDetect String="TD" attribute="Keyword Parameter" context="#pop!FakeComment" insensitive="1"/>+        <StringDetect String="BT" attribute="Keyword Parameter" context="#pop!FakeComment" insensitive="1"/>+        <StringDetect String="RL" attribute="Keyword Parameter" context="#pop!FakeComment" insensitive="1"/>+        <StringDetect String="LR" attribute="Keyword Parameter" context="#pop!FakeComment" insensitive="1"/>+      </context>+      <!--+      @} direction+      -->+++      <!--+      @{ click+      -->+      <!-- click D href "https://www.github.com" "Open this in a new tab" _blank -->+      <context name="Flowchart_KwClick" attribute="Normal" lineEndContext="#pop">+        <DetectSpaces/>+        <StringDetect String=";" attribute="Symbol Separator" context="#pop"/>+        <RegExpr String="&flowchart_node;" attribute="Node" context="Flowchart_KwClick_Param"/>+      </context>+      <context name="Flowchart_KwClick_Param" attribute="Normal" lineEndContext="#pop#pop">+        <DetectSpaces/>+        <IncludeRules context="Flowchart_Find_UnicodeText"/>+        <StringDetect String=";" attribute="Symbol Separator" context="#pop#pop"/>+        <WordDetect String="_self" attribute="Keyword Parameter"/>+        <WordDetect String="_blank" attribute="Keyword Parameter"/>+        <WordDetect String="_parent" attribute="Keyword Parameter"/>+        <WordDetect String="_top" attribute="Keyword Parameter"/>+        <WordDetect String="href" attribute="Keyword Parameter"/>+        <WordDetect String="call" attribute="Keyword Parameter"/>+        <DetectIdentifier/>+      </context>+      <!--+      @} click+      -->+++      <!--+      @{ style, linkStyle, classDef and class+      -->+      <!-- linkStyle 1,2,7 stroke:#ff3,stroke-width:4px,color:red; -->+      <context name="Flowchart_KwLinkStyle" attribute="Error" lineEndContext="#pop">+        <DetectSpaces attribute="Normal" context="Flowchart_KwLinkStyle_Idx"/>+        <StringDetect String=";" attribute="Symbol Separator" context="#pop"/>+      </context>+      <context name="Flowchart_KwLinkStyle_Idx" attribute="Error" lineEndContext="#pop#pop"+               fallthroughContext="#pop#pop!Flowchart_CSSProp">+        <DetectSpaces attribute="Normal" context="#pop#pop!Flowchart_CSSProp"/>+        <Int attribute="ID"/>+        <StringDetect String="," attribute="List Separator"/>+      </context>++      <!-- style id1 fill:#f9f,stroke:#333,stroke-width:4px; -->+      <context name="Flowchart_KwStyle" attribute="Error" lineEndContext="#pop">+        <DetectSpaces attribute="Normal" context="Flowchart_KwStyle_Node"/>+        <StringDetect String=";" attribute="Symbol Separator" context="#pop"/>+      </context>+      <!-- https://github.com/mermaid-js/mermaid/issues/7041 -->+      <context name="Flowchart_KwStyle_Node" attribute="Error" lineEndContext="#pop#pop"+               fallthroughContext="#pop#pop!Flowchart_CSSProp">+        <RegExpr String="&flowchart_node;" attribute="Node" context="#pop#pop!Flowchart_CSSProp"/>+      </context>++      <!-- classDef firstClassName,secondClassName fill:#f9f,stroke:#333,stroke-width:4px; -->+      <context name="Flowchart_KwClassDef" attribute="Error" lineEndContext="#pop">+        <DetectSpaces attribute="Normal" context="Flowchart_KwClassDef_Default"/>+        <StringDetect String=";" attribute="Symbol Separator" context="#pop"/>+      </context>+      <!-- classDef default fill:#f9f -->+      <context name="Flowchart_KwClassDef_Default" attribute="Error" lineEndContext="#pop#pop"+               fallthroughContext="#pop!Flowchart_KwClassDef_ClassName">+        <StringDetect String="default " attribute="Keyword Parameter"+                      context="#pop#pop!Flowchart_CSSProp"/>+      </context>+      <context name="Flowchart_KwClassDef_ClassName" attribute="Error"+               lineEndContext="#pop#pop" fallthroughContext="#pop#pop!Flowchart_CSSProp">+        <DetectSpaces attribute="Normal" context="#pop#pop!Flowchart_CSSProp"/>+        <StringDetect String="," attribute="List Separator"/>+        <RegExpr String="&css_class_name;" attribute="Class Name"/>+      </context>++      <!-- class nodeId1,nodeId2 className; -->+      <context name="Flowchart_KwClass" attribute="Error" lineEndContext="#pop">+        <DetectSpaces attribute="Normal" context="Flowchart_KwClass_Node"/>+        <StringDetect String=";" attribute="Symbol Separator" context="#pop"/>+      </context>+      <context name="Flowchart_KwClass_Node" attribute="Normal" lineEndContext="#pop#pop">+        <DetectSpaces attribute="Normal" context="Flowchart_KwClass_ClassName"/>+        <StringDetect String="," attribute="List Separator"/>+        <StringDetect String=";" attribute="Symbol Separator" context="#pop#pop"/>+        <RegExpr String="&flowchart_node_no_comma;" attribute="Node"/>+      </context>+      <!-- https://github.com/mermaid-js/mermaid/issues/7043 -->+      <context name="Flowchart_KwClass_ClassName" attribute="Error"+               lineEndContext="#pop#pop#pop">+        <StringDetect String=";" attribute="Symbol Separator" context="#pop#pop#pop"/>+        <DetectIdentifier attribute="Class Name"/>+        <RegExpr String="&css_class_name;" attribute="Class Name"/>+      </context>++      <!-- @{ inline CSS -->+      <context name="Flowchart_CSSProp" attribute="Normal" lineEndContext="#pop"+               fallthroughContext="Flowchart_CSSValue">+        <DetectSpaces/>+        <StringDetect String=":" attribute="Style Property Separator"+                      context="Flowchart_CSSValue"/>+        <StringDetect String="-" attribute="Style Property"/>+        <StringDetect String=";" attribute="Symbol Separator" context="#pop"/>+        <StringDetect String="," attribute="Error"/>+        <DetectIdentifier attribute="Style Property"/>+        <StringDetect String="/*" attribute="Comment" context="Flowchart_CSSComment"/>+      </context>+      <context name="Flowchart_CSSValue" attribute="Style Value"+               lineEndContext="#pop#pop">+        <StringDetect String="," attribute="List Separator" context="#pop"/>+        <StringDetect String=";" attribute="Symbol Separator" context="#pop#pop"/>+        <StringDetect String="\," attribute="Special Text Char"/>+        <DetectIdentifier/>+        <DetectSpaces/>+        <RegExpr String="[-+]?([0-9]+(\.[0-9]+)?|\.[0-9]+)([eE][+-]?[0-9]+)?(?![-+])"+                 attribute="Number" context="Flowchart_CSSUnit"/>+        <!-- https://github.com/mermaid-js/mermaid/issues/5498+        conflict with Entity codes:+        https://mermaid.js.org/syntax/flowchart.html#entity-codes-to-escape-characters -->+        <RegExpr String="#[a-zA-Z0-9]{3}([a-zA-Z0-9]([a-zA-Z0-9]{2}([a-zA-Z0-9]{2})?+)?+)?+(?![a-zA-Z0-9]*;)"+                 attribute="Style Hexadeximal Color"/>+        <RegExpr String="#[a-zA-Z0-9]+;" attribute="Error" context="#pop#pop"/>+        <StringDetect String="/*" attribute="Comment" context="Flowchart_CSSComment"/>+      </context>+      <context name="Flowchart_CSSUnit" attribute="Normal"+               lineEndContext="#pop#pop#pop" fallthroughContext="#pop">+        <StringDetect String="%" attribute="Style Unit" context="#pop"/>+        <DetectIdentifier attribute="Style Unit" context="#pop"/>+      </context>+      <context name="Flowchart_CSSComment" attribute="Normal" lineEndContext="#pop">+        <AnyChar String=",;" context="#pop" lookAhead="1"/>+        <StringDetect String="*/" attribute="Comment" context="#pop"/>+        <!-- Yes... And that's not the only problem -->+        <StringDetect String=" */" attribute="Error" context="#pop"/>+      </context>+      <!-- @} inline CSS -->+      <!--+      @} style, linkStyle, classDef and class+      -->+++      <!--+      @{ Quoted Text + Markdown Formatting+      -->+      <context name="EmptyQuotedText" attribute="Text" fallthroughContext="#pop">+        <StringDetect String='""' attribute="Comment"/>+        <StringDetect String='"``"' attribute="Comment"/>+      </context>+      <context name="EmptyQuotedText_ThenPop" attribute="Text" fallthroughContext="#pop">+        <StringDetect String='""' attribute="Comment" context="#pop"/>+        <StringDetect String='"``"' attribute="Comment" context="#pop"/>+      </context>++      <!-- "..." -->+      <context name="Flowchart_Find_UnicodeText" attribute="Text" fallthroughContext="#pop">+        <StringDetect String='"' attribute="Quoted Text Delimiter"+                      context="Flowchart_UnicodeText"/>+      </context>+      <context name="Flowchart_Find_UnicodeText_ThenPop" attribute="Text">+        <StringDetect String='"' attribute="Quoted Text Delimiter"+                      context="#pop!Flowchart_UnicodeText"/>+      </context>+      <context name="Flowchart_Find_UnicodeText_ThenPop2" attribute="Text">+        <StringDetect String='"' attribute="Quoted Text Delimiter"+                      context="#pop#pop!Flowchart_UnicodeText"/>+      </context>++      <!-- "..."+            ~~~~ -->+      <context name="Flowchart_UnicodeText" attribute="Quoted Text"+               fallthroughContext="Flowchart_UnicodeText_Special">+        <StringDetect String='"' attribute="Quoted Text Delimiter" context="#pop"/>+        <IncludeRules context="Find_Comment_InText"/>+        <RegExpr String="&flowchart_qtext;" attribute="Quoted Text"+                 context="Flowchart_UnicodeText_Special"/>+      </context>+      <context name="Flowchart_UnicodeText_Special" attribute="Text" lineEndContext="#pop"+               fallthroughContext="#pop">+        <StringDetect String='"' attribute="Quoted Text Delimiter" context="#pop#pop"/>+        <!-- https://github.com/mermaid-js/mermaid/issues/7003 -->+        <IncludeRules context="Find_Md_Syms_ThenPop"/>+        <IncludeRules context="Find_Md_Html_DQ_ThenPop"/>+      </context>++      <!-- "`...`" -->+      <context name="Flowchart_Find_MdText" attribute="Text" fallthroughContext="#pop">+        <StringDetect String='"`' attribute="Markdown Text Delimiter"+                      context="Flowchart_MdText"/>+      </context>+      <context name="Flowchart_Find_MdText_ThenPop" attribute="Text">+        <StringDetect String='"`' attribute="Markdown Text Delimiter"+                      context="#pop!Flowchart_MdText"/>+      </context>++      <!-- "`...`"+             ~~~~~ -->+      <context name="Flowchart_MdText" attribute="Markdown Text"+               fallthroughContext="Flowchart_MdText_Special">+        <StringDetect String='`"' attribute="Markdown Text Delimiter" context="#pop"/>+        <AnyChar String='`"' attribute="Error" context="#pop"/>+        <IncludeRules context="Find_Comment_InText"/>+        <RegExpr String="&flowchart_mdtext;" attribute="Markdown Text"+                 context="Flowchart_MdText_Special"/>+      </context>+      <context name="Flowchart_MdText_Special" attribute="Text" lineEndContext="#pop"+               fallthroughContext="#pop">+        <StringDetect String='`"' attribute="Markdown Text Delimiter" context="#pop#pop"/>+        <AnyChar String='`"' attribute="Error" context="#pop#pop"/>+        <IncludeRules context="Find_Md_Syms_ThenPop"/>+        <IncludeRules context="Find_Md_Html_Md_ThenPop"/>+      </context>++      <!--+      @{ Html+      -->++      <!-- special parser for HTML, because the quotes do not close the string inside -->++      <!-- A["<tag attr="...">"]+        stop on " (except attribute)+      -->+      <context name="Find_Md_Html_DQ_ThenPop" attribute="Normal">+        <RegExpr String="&prefix_html_tag;" attribute="HTML Tag" context="#pop!Html_DQ"/>+      </context>++      <context name="Html_DQ" attribute="HTML Tag">+        <StringDetect String="/" context="Html_DQ_Close"/>+        <DetectIdentifier context="Html_DQ_Attrs" attribute="HTML Tag"/>+      </context>+      <context name="Html_DQ_Attrs" attribute="HTML Attribute">+        <StringDetect String='="' context="Html_DQ_AttrValue"/>+        <IncludeRules context="Html_DQ_Close"/>+      </context>+      <context name="Html_DQ_AttrValue" attribute="HTML Attribute">+        <DetectIdentifier/>+        <StringDetect String='"' context="#pop"/>+        <StringDetect String=">" attribute="Error" context="#pop#pop#pop"/>+        <StringDetect String="/>" attribute="Error" context="#pop#pop#pop"/>+        <!-- https://github.com/mermaid-js/mermaid/issues/7011 -->+        <IncludeRules context="Find_Comment"/>+        <IncludeRules context="Find_Entities"/>+      </context>+      <context name="Html_DQ_Close" attribute="HTML Tag">+        <IncludeRules context="Html_Close_Tag"/>+        <StringDetect String='"' attribute="Error" context="#pop#pop"/>+        <IncludeRules context="Html_Find_Elem"/>+      </context>++      <!-- html close -->+      <context name="Html_Close_Tag" attribute="HTML Tag">+        <StringDetect String=">" attribute="HTML Tag" context="#pop#pop"/>+        <StringDetect String="/>" attribute="HTML Tag" context="#pop#pop"/>+      </context>+      <context name="Html_Find_Elem" attribute="HTML Tag">+        <DetectIdentifier/>+        <DetectSpaces/>+        <!-- https://github.com/mermaid-js/mermaid/issues/7011 -->+        <IncludeRules context="Find_Comment"/>+      </context>++      <!-- A["<tag attr="...">"]+        stop on " (except attribute), newline+      -->+      <context name="Find_Md_Html_DQ_SingleLine_ThenPop" attribute="Normal">+        <RegExpr String="&prefix_html_tag;" attribute="HTML Tag" context="#pop!Html_DQ_SingleLine"/>+      </context>++      <context name="Html_DQ_SingleLine" attribute="HTML Tag">+        <StringDetect String="/" context="Html_DQ_SingleLine_Close"/>+        <DetectIdentifier context="Html_DQ_SingleLine_Attrs" attribute="HTML Tag"/>+      </context>+      <context name="Html_DQ_SingleLine_Attrs" attribute="HTML Attribute"+               lineEndContext="#pop#pop">+        <StringDetect String='="' context="Html_DQ_SingleLine_AttrValue"/>+        <IncludeRules context="Html_DQ_SingleLine_Close"/>+      </context>+      <context name="Html_DQ_SingleLine_AttrValue" attribute="HTML Attribute"+               lineEndContext="#pop#pop#pop">+        <DetectIdentifier/>+        <StringDetect String='"' context="#pop"/>+        <StringDetect String=">" attribute="Error" context="#pop#pop#pop"/>+        <StringDetect String="/>" attribute="Error" context="#pop#pop#pop"/>+        <IncludeRules context="Find_Entities"/>+      </context>+      <context name="Html_DQ_SingleLine_Close" attribute="HTML Tag" lineEndContext="#pop#pop">+        <IncludeRules context="Html_Close_Tag"/>+        <StringDetect String='"' attribute="Error" context="#pop#pop"/>+        <DetectIdentifier/>+        <DetectSpaces/>+      </context>++      <!-- A[<tag attr="...">]+        stop on " (except attribute), {, }, [, ], (, ), |, @+      -->+      <context name="Find_Md_Html_Text_ThenPop" attribute="Normal">+        <RegExpr String="&prefix_html_tag;" attribute="HTML Tag" context="#pop!Html_Text"/>+      </context>++      <context name="Html_Text" attribute="HTML Tag">+        <StringDetect String="/" context="Html_Text_Close"/>+        <DetectIdentifier context="Html_Text_Attrs" attribute="HTML Tag"/>+      </context>+      <context name="Html_Text_Attrs" attribute="HTML Attribute">+        <StringDetect String='="' context="Html_Text_AttrValue"/>+        <IncludeRules context="Html_Text_Close"/>+      </context>+      <context name="Html_Text_AttrValue" attribute="HTML Attribute">+        <AnyChar String='{}[]()|@' context="#pop#pop#pop" lookAhead="1"/>+        <IncludeRules context="Html_DQ_AttrValue"/>+      </context>+      <context name="Html_Text_Close" attribute="HTML Tag">+        <IncludeRules context="Html_Close_Tag"/>+        <AnyChar String='{}[]()"|@' context="#pop#pop" lookAhead="1"/>+        <IncludeRules context="Html_Find_Elem"/>+      </context>++      <!-- A[/<tag attr="...">/]+        stop on {, }, [, ], (, ), /], \]+      -->+      <context name="Find_Md_Html_Text[//]_ThenPop" attribute="Normal">+        <RegExpr String="&prefix_html_tag;" attribute="HTML Tag" context="#pop!Html_Text[//]"/>+      </context>++      <context name="Html_Text[//]" attribute="HTML Tag">+        <StringDetect String="/]" context="#pop" lookAhead="1"/>+        <StringDetect String="\]" context="#pop" lookAhead="1"/>+        <StringDetect String="/" context="Html_Text[//]_Close"/>+        <DetectIdentifier context="Html_Text[//]_Attrs" attribute="HTML Tag"/>+      </context>+      <context name="Html_Text[//]_Attrs" attribute="HTML Attribute">+        <StringDetect String='="' context="Html_Text[//]_AttrValue"/>+        <IncludeRules context="Html_Text[//]_Close"/>+      </context>+      <context name="Html_Text[//]_AttrValue" attribute="HTML Attribute">+        <AnyChar String='{}[]()' context="#pop#pop#pop" lookAhead="1"/>+        <IncludeRules context="Html_DQ_AttrValue"/>+      </context>+      <context name="Html_Text[//]_Close" attribute="HTML Tag">+        <StringDetect String="/]" context="#pop#pop" lookAhead="1"/>+        <IncludeRules context="Html_Close_Tag"/>+        <StringDetect String="\]" context="#pop#pop" lookAhead="1"/>+        <AnyChar String='{}[]()' context="#pop#pop" lookAhead="1"/>+        <IncludeRules context="Html_Find_Elem"/>+      </context>++      <!-- A["`<tag attr="...">`"]+        stop on {, }, [, ], (, ), `+      -->+      <context name="Find_Md_Html_Md_ThenPop" attribute="Normal">+        <RegExpr String="&prefix_html_tag;" attribute="HTML Tag" context="#pop!Html_Md"/>+      </context>++      <context name="Html_Md" attribute="HTML Tag">+        <StringDetect String="/" context="Html_Md_Close"/>+        <DetectIdentifier context="Html_Md_Attrs" attribute="HTML Tag"/>+      </context>+      <context name="Html_Md_Attrs" attribute="HTML Attribute">+        <StringDetect String='="' context="Html_Md_AttrValue"/>+        <IncludeRules context="Html_Md_Close"/>+      </context>+      <context name="Html_Md_AttrValue" attribute="HTML Attribute">+        <AnyChar String='{}[]()`' context="#pop#pop#pop" lookAhead="1"/>+        <IncludeRules context="Html_DQ_AttrValue"/>+      </context>+      <context name="Html_Md_Close" attribute="HTML Tag">+        <IncludeRules context="Html_Close_Tag"/>+        <AnyChar String='{}[]()"`' context="#pop#pop" lookAhead="1"/>+        <IncludeRules context="Html_Find_Elem"/>+      </context>++      <!-- A[`<tag attr="...">`]+        stop on `+      -->+      <context name="Find_Md_Html_Backtick_ThenPop" attribute="Normal">+        <RegExpr String="&prefix_html_tag;" attribute="HTML Tag" context="#pop!Html_Backtick"/>+      </context>++      <context name="Html_Backtick" attribute="HTML Tag">+        <StringDetect String="/" context="Html_Backtick_Close"/>+        <DetectIdentifier context="Html_Backtick_Attrs" attribute="HTML Tag"/>+      </context>+      <context name="Html_Backtick_Attrs" attribute="HTML Attribute">+        <StringDetect String='="' context="Html_Backtick_AttrValue"/>+        <IncludeRules context="Html_Backtick_Close"/>+      </context>+      <context name="Html_Backtick_AttrValue" attribute="HTML Attribute">+        <StringDetect String="`" context="#pop#pop#pop" lookAhead="1"/>+        <IncludeRules context="Html_DQ_AttrValue"/>+      </context>+      <context name="Html_Backtick_Close" attribute="HTML Tag">+        <IncludeRules context="Html_Close_Tag"/>+        <StringDetect String="`" context="#pop#pop" lookAhead="1"/>+        <IncludeRules context="Html_Find_Elem"/>+      </context>++      <!-- A -x B : <tag attr="...">+        stop on newline, ;, :, &+      -->+      <context name="Find_Md_Html_ClassLabel_ThenPop" attribute="Normal">+        <RegExpr String="&prefix_html_tag;" attribute="HTML Tag" context="#pop!Html_ClassLabel"/>+      </context>++      <context name="Html_ClassLabel" attribute="HTML Tag">+        <StringDetect String="/" context="Html_ClassLabel_Close"/>+        <DetectIdentifier context="Html_ClassLabel_Attrs" attribute="HTML Tag"/>+      </context>+      <context name="Html_ClassLabel_Attrs" attribute="HTML Attribute"+               lineEndContext="#pop#pop">+        <StringDetect String='="' context="Html_ClassLabel_AttrValue"/>+        <IncludeRules context="Html_ClassLabel_Close"/>+      </context>+      <context name="Html_ClassLabel_AttrValue" attribute="HTML Attribute"+               lineEndContext="#pop#pop#pop">+        <DetectIdentifier/>+        <StringDetect String='"' context="#pop"/>+        <AnyChar String="&class_syms_no_label;" context="#pop#pop#pop" lookAhead="1"/>+      </context>+      <context name="Html_ClassLabel_Close" attribute="HTML Tag" lineEndContext="#pop#pop">+        <IncludeRules context="Html_Close_Tag"/>+        <DetectIdentifier/>+        <DetectSpaces/>+        <AnyChar String="&class_syms_no_label;" context="#pop#pop" lookAhead="1"/>+      </context>++      <!-- s1 - -> s2 : <tag attr="...">+        stop on newline, :+      -->+      <context name="Find_Md_Html_StateText_ThenPop" attribute="Normal">+        <RegExpr String="&prefix_html_tag;" attribute="HTML Tag" context="#pop!Html_StateText"/>+      </context>++      <context name="Html_StateText" attribute="HTML Tag">+        <StringDetect String="/" context="Html_StateText_Close"/>+        <DetectIdentifier context="Html_StateText_Attrs" attribute="HTML Tag"/>+      </context>+      <context name="Html_StateText_Attrs" attribute="HTML Attribute"+               lineEndContext="#pop#pop">+        <StringDetect String='="' context="Html_StateText_AttrValue"/>+        <IncludeRules context="Html_StateText_Close"/>+      </context>+      <context name="Html_StateText_AttrValue" attribute="HTML Attribute"+               lineEndContext="#pop#pop#pop">+        <DetectIdentifier/>+        <StringDetect String='"' context="#pop"/>+        <AnyChar String=":" attribute="Error" context="#pop#pop#pop"/>+      </context>+      <context name="Html_StateText_Close" attribute="HTML Tag" lineEndContext="#pop#pop">+        <IncludeRules context="Html_Close_Tag"/>+        <DetectIdentifier/>+        <DetectSpaces/>+        <AnyChar String=":" attribute="Error" context="#pop#pop"/>+      </context>++      <!-- A@{label: <tag attr="...">}+        stop on " (except attribute), {, }, [, ]+      -->+      <context name="Find_Md_Html_NewShape_ThenPop" attribute="Normal">+        <RegExpr String="&prefix_html_tag;" attribute="HTML Tag" context="#pop!Html_NewShape"/>+      </context>++      <context name="Html_NewShape" attribute="HTML Tag">+        <StringDetect String="/" context="Html_NewShape_Close"/>+        <DetectIdentifier context="Html_NewShape_Attrs" attribute="HTML Tag"/>+      </context>+      <context name="Html_NewShape_Attrs" attribute="HTML Attribute">+        <StringDetect String='="' context="Html_NewShape_AttrValue"/>+        <IncludeRules context="Html_NewShape_Close"/>+      </context>+      <context name="Html_NewShape_AttrValue" attribute="HTML Attribute">+        <AnyChar String='{}[]' context="#pop#pop#pop" lookAhead="1"/>+        <IncludeRules context="Html_DQ_AttrValue"/>+      </context>+      <context name="Html_NewShape_Close" attribute="HTML Tag">+        <IncludeRules context="Html_Close_Tag"/>+        <AnyChar String='{}[]"' context="#pop#pop" lookAhead="1"/>+        <IncludeRules context="Html_Find_Elem"/>+      </context>++      <!-- A@{label: '<tag attr="...">'}+        stop on " (except attribute), {, }, [, ], '+      -->+      <context name="Find_Md_Html_NewShapeSQ_ThenPop" attribute="Normal">+        <RegExpr String="&prefix_html_tag;" attribute="HTML Tag"+                 context="#pop!Html_NewShapeSQ"/>+      </context>++      <context name="Html_NewShapeSQ" attribute="HTML Tag">+        <StringDetect String="/" context="Html_NewShapeSQ_Close"/>+        <DetectIdentifier context="Html_NewShapeSQ_Attrs" attribute="HTML Tag"/>+      </context>+      <context name="Html_NewShapeSQ_Attrs" attribute="HTML Attribute">+        <IncludeRules context="Html_NewShapeSQ_Close"/>+        <IncludeRules context="Find_Entities"/>+      </context>+      <context name="Html_NewShapeSQ_Close" attribute="HTML Tag">+        <IncludeRules context="Html_Close_Tag"/>+        <AnyChar String="{}[]'&quot;" context="#pop#pop" lookAhead="1"/>+        <IncludeRules context="Html_Find_Elem"/>+      </context>++      <!-- A - - <tag attr="..."> - - - B+        stop on - -+      -->+      <context name="Find_Md_Html_LinkLine_ThenPop" attribute="Normal">+        <RegExpr String="&prefix_html_tag;" attribute="HTML Tag" context="#pop!Html_LinkLine"/>+      </context>++      <context name="Html_LinkLine" attribute="HTML Tag">+        <StringDetect String="/" context="Html_LinkLine_Close"/>+        <DetectIdentifier context="Html_LinkLine_Attrs" attribute="HTML Tag"/>+      </context>+      <context name="Html_LinkLine_Attrs" attribute="HTML Attribute">+        <StringDetect String='="' context="Html_LinkLine_AttrValue"/>+        <IncludeRules context="Html_LinkLine_Close"/>+      </context>+      <context name="Html_LinkLine_AttrValue" attribute="HTML Attribute">+        <IncludeRules context="Html_DQ_AttrValue"/>+        <StringDetect String="--" attribute="Error"+                      context="#pop#pop#pop#pop#pop!Flowchart_LinkLine_TextEnd"/>+      </context>+      <context name="Html_LinkLine_Close" attribute="HTML Tag">+        <IncludeRules context="Html_DQ_Close"/>+        <StringDetect String="--" attribute="Error"+                      context="#pop#pop#pop#pop!Flowchart_LinkLine_TextEnd"/>+      </context>++      <!-- A == <tag attr="..."> ==> B+        stop on =+      -->+      <context name="Find_Md_Html_LinkThick_ThenPop" attribute="Normal">+        <RegExpr String="&prefix_html_tag;" attribute="HTML Tag" context="#pop!Html_LinkThick"/>+      </context>++      <context name="Html_LinkThick" attribute="HTML Tag">+        <StringDetect String="/" context="Html_LinkThick_Close"/>+        <DetectIdentifier context="Html_LinkThick_Attrs" attribute="HTML Tag"/>+      </context>+      <context name="Html_LinkThick_Attrs" attribute="HTML Attribute">+        <IncludeRules context="Html_LinkThick_Close"/>+      </context>+      <context name="Html_LinkThick_Close" attribute="HTML Tag">+        <IncludeRules context="Html_DQ_Close"/>+        <StringDetect String="=" lookAhead="1" context="#pop#pop"/>+      </context>++      <!-- A -. <tag attr="..."> .- B+        stop on .+      -->+      <context name="Find_Md_Html_LinkDotted_ThenPop" attribute="Normal">+        <RegExpr String="&prefix_html_tag;" attribute="HTML Tag" context="#pop!Html_LinkDotted"/>+      </context>++      <context name="Html_LinkDotted" attribute="HTML Tag">+        <StringDetect String="/" context="Html_LinkDotted_Close"/>+        <DetectIdentifier context="Html_LinkDotted_Attrs" attribute="HTML Tag"/>+      </context>+      <context name="Html_LinkDotted_Attrs" attribute="HTML Attribute">+        <StringDetect String='="' context="Html_LinkDotted_AttrValue"/>+        <IncludeRules context="Html_LinkDotted_Close"/>+      </context>+      <context name="Html_LinkDotted_AttrValue" attribute="HTML Attribute">+        <IncludeRules context="Html_DQ_AttrValue"/>+        <StringDetect String="." attribute="Error"+                      context="#pop#pop#pop#pop#pop!Flowchart_LinkDotted_TextEnd"/>+      </context>+      <context name="Html_LinkDotted_Close" attribute="HTML Tag">+        <IncludeRules context="Html_DQ_Close"/>+        <StringDetect String="." attribute="Error"+                      context="#pop#pop#pop#pop!Flowchart_LinkDotted_TextEnd"/>+      </context>+      <!--+      @} Html+      -->+      <!--+      @} Quoted Text + Markdown Formatting+      -->++      <!--+      @} Flowchart+      -->+++      <!--+      @{ Sequence Diagram+      -->++      <context name="SequenceDiag" attribute="Error" lineEndContext="SequenceDiag_Body">+        <DetectSpaces attribute="Normal"/>+        <StringDetect String=";" attribute="Symbol Separator" context="SequenceDiag_Body"/>+      </context>++      <context name="SequenceDiag_Body" attribute="Error">+        <DetectSpaces attribute="Normal"/>+        <StringDetect String=":" attribute="Property Separator" context="SequenceDiag_Text"/>++        <RegExpr String="(\(\))?(--?(>>?|[x)]|[|][\\/]|//|\\\\)|&lt;&lt;--?>>|([\\/][|]|//|\\\\)--?)(\(\))?"+                 attribute="Link" context="SequenceDiag_AfterNode"/>++        <StringDetect String=";" attribute="Symbol Separator"/>+        <IncludeRules context="Find_Comment"/>++        <AnyChar String="&lt;&gt;+-()#," attribute="Error"/>++        <RegExpr String="&seq_node;" attribute="Node"/>++        <WordDetect String="end" attribute="Keyword" endRegion="kwblock"/>+        <WordDetect String="participant" attribute="Keyword"+                    context="SequenceDiag_KwParticipant"/>+        <WordDetect String="box" attribute="Keyword" beginRegion="kwblock"+                    context="SequenceDiag_Text!SequenceDiag_Color"/>+        <WordDetect String="link" attribute="Keyword" context="SequenceDiag_KwLink"/>+        <WordDetect String="links" attribute="Keyword" context="SequenceDiag_KwLinks"/>+        <WordDetect String="create" attribute="Keyword" context="SequenceDiag_KwCreate"/>+        <WordDetect String="destroy" attribute="Keyword" context="SequenceDiag_Node"/>+        <WordDetect String="activate" attribute="Keyword" context="SequenceDiag_Node"/>+        <WordDetect String="deactivate" attribute="Keyword" context="SequenceDiag_Node"/>+        <WordDetect String="Note" attribute="Keyword" context="SequenceDiag_KwNote"/>+        <WordDetect String="loop" attribute="Keyword" context="SequenceDiag_Text"+                    beginRegion="kwblock"/>+        <WordDetect String="alt" attribute="Keyword" context="SequenceDiag_Text"+                    beginRegion="kwblock"/>+        <WordDetect String="opt" attribute="Keyword" context="SequenceDiag_Text"+                    beginRegion="kwblock"/>+        <WordDetect String="else" attribute="Keyword" context="SequenceDiag_Text"+                    beginRegion="kwblock" endRegion="kwblock"/>+        <WordDetect String="par" attribute="Keyword" context="SequenceDiag_Text"+                    beginRegion="kwblock"/>+        <WordDetect String="and" attribute="Keyword" context="SequenceDiag_Text"+                    beginRegion="kwblock" endRegion="kwblock"/>+        <WordDetect String="critical" attribute="Keyword" context="SequenceDiag_Text"+                    beginRegion="kwblock"/>+        <WordDetect String="option" attribute="Keyword" context="SequenceDiag_Text"+                    beginRegion="kwblock" endRegion="kwblock"/>+        <WordDetect String="break" attribute="Keyword" context="SequenceDiag_Text"+                    beginRegion="kwblock"/>+        <WordDetect String="rect" attribute="Keyword" beginRegion="kwblock"+                    context="SequenceDiag_Text!SequenceDiag_Color"/>+        <WordDetect String="autonumber" attribute="Keyword"/>++        <IncludeRules context="Find_Accessibility"/>++        <!-- because mermaid... -->+        <StringDetect String="sequenceDiagram" attribute="Error" context="#pop"/>+      </context>++      <context name="SequenceDiag_AfterNode" attribute="Normal" lineEndContext="#pop"+               fallthroughContext="#pop">+        <DetectSpaces/>+        <StringDetect String=";" attribute="Symbol Separator" context="#pop"/>+        <AnyChar String="+-" attribute="Keyword" context="#pop"/>+      </context>++      <context name="SequenceDiag_Text" attribute="Text" lineEndContext="#pop">+        <StringDetect String=";" attribute="Symbol Separator" context="#pop"/>+        <IncludeRules context="SequenceDiag_Find_Text"/>+      </context>+      <context name="SequenceDiag_Find_Text" attribute="Text" lineEndContext="#pop">+        <DetectIdentifier/>+        <DetectSpaces/>+        <Int/>+        <StringDetect String="$$" attribute="Math Delimiter"/>+        <IncludeRules context="Find_Entity"/>+        <StringDetect String="#" attribute="Error"/>+        <IncludeRules context="Find_HTML_br"/>+      </context>++      <!--+      @{ participant+      -->+      <context name="SequenceDiag_KwParticipant" attribute="Node">+        <StringDetect String="@" lookAhead="1" context="SequenceDiag_MaybeYAMLConfig"/>+        <StringDetect String=" as " attribute="Keyword" context="#pop!SequenceDiag_Text"/>+        <IncludeRules context="SequenceDiag_Text"/>+      </context>+      <!--+      @} participant+      -->+++      <!--+      @{ color+      -->+      <context name="SequenceDiag_Color" attribute="Normal" lineEndContext="#pop"+               fallthroughContext="#pop">+        <DetectSpaces/>+        <StringDetect String="rgb("  attribute="Style Value" context="#pop!SequenceDiag_Rgb"/>+        <StringDetect String="rgba(" attribute="Style Value" context="#pop!SequenceDiag_Rgb"/>+        <DetectIdentifier attribute="Style Value" context="#pop"/>+      </context>++      <!-- box rgb(from hwb(120deg 10% 20%) r g calc(b + 200)) bla bla+                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+      -->+      <context name="SequenceDiag_Rgb" attribute="Style Value" lineEndContext="#pop#pop">+        <DetectSpaces/>+        <Int attribute="Number" context="Flowchart_CSSUnit"/>+        <StringDetect String="#" attribute="Error"/>+        <StringDetect String="(" attribute="Style Value" context="SequenceDiag_Rgb"/>+        <StringDetect String=")" attribute="Style Value" context="#pop"/>+        <StringDetect String=";" lookAhead="1" context="#pop"/>+        <DetectIdentifier/>+      </context>+      <!--+      @} color+      -->+++      <!--+      @{ link <actor>: <link-label> @ <link-url>+      -->+      <context name="SequenceDiag_KwLink" attribute="Node" lineEndContext="#pop">+        <StringDetect String=":" attribute="Node Separator"+                      context="SequenceDiag_KwLink_Label"/>+        <StringDetect String=";" attribute="Symbol Separator" context="#pop"/>+      </context>+      <context name="SequenceDiag_KwLink_Label" attribute="Text" lineEndContext="#pop#pop">+        <StringDetect String="@" attribute="ID Separator"+                      context="SequenceDiag_KwLink_URL"/>+        <StringDetect String=";" attribute="Symbol Separator" context="#pop#pop"/>+        <DetectSpaces/>+        <DetectIdentifier/>+      </context>+      <context name="SequenceDiag_KwLink_URL" attribute="Normal" lineEndContext="#pop#pop#pop">+        <StringDetect String=";" attribute="Symbol Separator" context="#pop#pop#pop"/>+      </context>+      <!--+      @} link+      -->+++      <!--+      @{ links <actor>: <json-formatted link-name link-url pairs>+      -->+      <context name="SequenceDiag_KwLinks" attribute="Node" lineEndContext="#pop">+        <StringDetect String=":" attribute="Node Separator" context="SequenceDiag_JSON"/>+        <StringDetect String=";" attribute="Symbol Separator" context="#pop"/>+      </context>+      <!--+      @} links+      -->+++      <!--+      @{ JSON+      -->+      <!-- only string value -->+      <context name="SequenceDiag_JSON" attribute="Error" lineEndContext="#pop#pop">+        <DetectSpaces attribute="Normal"/>+        <StringDetect String='"' attribute="Quoted Text Delimiter"+                      context="SequenceDiag_JSON_Str"/>+        <StringDetect String=":" attribute="Property Separator"/>+        <StringDetect String="{" attribute="Curly Bracket Block Delimiter"/>+        <StringDetect String="}" attribute="Curly Bracket Block Delimiter" context="#pop#pop"/>+        <StringDetect String="," attribute="List Separator"/>+        <StringDetect String=";" attribute="Symbol Separator" context="#pop#pop"/>+      </context>+      <context name="SequenceDiag_JSON_Str" attribute="Quoted Text"+               lineEndContext="#pop#pop#pop">+        <StringDetect String='"' attribute="Quoted Text Delimiter" context="#pop"/>+        <StringDetect String=";" attribute="Symbol Separator" context="#pop#pop#pop"/>+      </context>+      <!--+      @} JSON+      -->+++      <!--+      @{ create participant Carl as dsidisidsid+      -->+      <context name="SequenceDiag_KwCreate" attribute="Normal" lineEndContext="#pop"+               fallthroughContext="SequenceDiag_KwCreate_Node">+        <DetectSpaces/>+        <WordDetect String="actor" attribute="Keyword Parameter"/>+        <WordDetect String="participant" attribute="Keyword Parameter"/>+      </context>+      <context name="SequenceDiag_KwCreate_Node" attribute="Node" lineEndContext="#pop#pop">+        <StringDetect String=" as " attribute="Keyword" context="#pop#pop!SequenceDiag_Text"/>+        <StringDetect String=";" attribute="Symbol Separator" context="#pop#pop"/>+        <IncludeRules context="SequenceDiag_Find_Text"/>+      </context>+      <!--+      @} create+      -->+++      <!--+      @{ node+      -->+      <context name="SequenceDiag_Node" attribute="Node" lineEndContext="#pop">+        <IncludeRules context="SequenceDiag_Text"/>+      </context>+      <!--+      @} node+      -->+++      <!--+      @{ Note right of John: Text in note+      -->+      <context name="SequenceDiag_KwNote" attribute="Normal" lineEndContext="#pop"+               fallthroughContext="SequenceDiag_KwNote_Actors">+        <DetectSpaces/>+        <WordDetect String="right of" attribute="Keyword Parameter"+                    context="SequenceDiag_KwNote_Actors"/>+        <WordDetect String="left of" attribute="Keyword Parameter"+                    context="SequenceDiag_KwNote_Actors"/>+        <WordDetect String="over" attribute="Keyword Parameter"+                    context="SequenceDiag_KwNote_Actors"/>+      </context>+      <!-- Note right of Alice,John: Text in note+                        ~~~~~~~~~~~~~~~~~~~~~~~~~+      -->+      <context name="SequenceDiag_KwNote_Actors" attribute="Node" lineEndContext="#pop">+        <StringDetect String=":" attribute="Node Separator"+                      context="#pop#pop!SequenceDiag_Text"/>+        <StringDetect String="," attribute="List Separator"/>+        <StringDetect String=";" attribute="Symbol Separator" context="#pop#pop"/>+      </context>+      <!--+      @} Note+      -->+++      <!--+      @{ JSONConfig+      participant Alice@{type: boundary}+                       ~~~~~~~~~~~~~~~~~+      -->+      <context name="SequenceDiag_MaybeYAMLConfig" attribute="Normal">+        <RegExpr String="(?&lt;=[^\s])@(?=[^:]*:)" attribute="Node Separator"+                 context="SequenceDiag_YAMLConfig"/>+        <StringDetect String="@" context="#pop"/>+      </context>++      <context name="SequenceDiag_YAMLConfig" attribute="Normal">+        <StringDetect String="{" attribute="Curly Bracket Block Delimiter"+                      context="SequenceDiag_YAMLConfig_Prop"/>+        <RegExpr String="." attribute="Error" context="#pop#pop#pop"/>+      </context>+      <!-- YAML with a single property without any special character -->+      <context name="SequenceDiag_YAMLConfig_Prop" attribute="Error">+        <!-- https://github.com/mermaid-js/mermaid/issues/7044 -->+        <StringDetect String=": " attribute="Property Separator"+                      context="SequenceDiag_YAMLConfig_PropValue"/>+        <LineContinue char=":" attribute="Property Separator"+                      context="SequenceDiag_YAMLConfig_PropValue"/>+        <IncludeRules context="Find_DQuote_NoSpecial"/>+        <StringDetect String="}" attribute="Curly Bracket Block Delimiter"+                      context="#pop#pop#pop#pop"/>+        <IncludeRules context="Find_Prop"/>+      </context>+      <!-- participant Alice@{ type: value }+                                    ~~~~~~~~+      -->+      <context name="SequenceDiag_YAMLConfig_PropValue" attribute="Error">+        <DetectSpaces attribute="Text"/>+        <StringDetect String="}" attribute="Curly Bracket Block Delimiter"+                      context="#pop#pop#pop#pop#pop"/>+        <DetectIdentifier attribute="Text"/>+        <IncludeRules context="Find_DQuote_NoSpecial"/>+        <!-- https://github.com/mermaid-js/mermaid/issues/7037 -->+        <IncludeRules context="Find_SQuote_NoSpecial"/>+        <IncludeRules context="Find_Comment"/>+      </context>+      <!--+      @} JSONConfig+      -->++      <!--+      @} Sequence Diagram+      -->+++      <!--+      @{ Class Diagram+      -->++      <context name="ClassDiag" attribute="Error">+        <DetectSpaces attribute="Normal"/>+        <StringDetect String=":" attribute="Property Separator" context="ClassDiag_Class_Mem"/>++        <StringDetect String="--"      attribute="Link" context="ClassDiag_RelationType_Right"/>+        <StringDetect String="&lt;--"  attribute="Link" context="ClassDiag_RelationType_Right"/>+        <StringDetect String="*--"     attribute="Link" context="ClassDiag_RelationType_Right"/>+        <StringDetect String="o--"     attribute="Link" context="ClassDiag_RelationType_Right"/>+        <StringDetect String=">--"     attribute="Link" context="ClassDiag_RelationType_Right"/>+        <StringDetect String="&lt;|--" attribute="Link" context="ClassDiag_RelationType_Right"/>+        <StringDetect String="|&gt;--" attribute="Link" context="ClassDiag_RelationType_Right"/>+        <StringDetect String="()--"    attribute="Link" context="ClassDiag_RelationType_Right"/>++        <StringDetect String=".."      attribute="Link" context="ClassDiag_RelationType_Right"/>+        <StringDetect String="&lt;.."  attribute="Link" context="ClassDiag_RelationType_Right"/>+        <StringDetect String="*.."     attribute="Link" context="ClassDiag_RelationType_Right"/>+        <StringDetect String="o.."     attribute="Link" context="ClassDiag_RelationType_Right"/>+        <StringDetect String=">.."     attribute="Link" context="ClassDiag_RelationType_Right"/>+        <StringDetect String="&lt;|.." attribute="Link" context="ClassDiag_RelationType_Right"/>+        <StringDetect String="|&gt;.." attribute="Link" context="ClassDiag_RelationType_Right"/>+        <StringDetect String="().."    attribute="Link" context="ClassDiag_RelationType_Right"/>++        <StringDetect String="&lt;&lt;" attribute="Annotation Delimiter"+                      context="ClassDiag_KwClass_Name!ClassDiag_Annotation"/>++        <StringDetect String="{" attribute="Curly Bracket Block Delimiter" beginRegion="block"/>+        <StringDetect String="}" attribute="Curly Bracket Block Delimiter" endRegion="block"/>++        <IncludeRules context="Find_Comment"/>+        <IncludeRules context="Flowchart_Find_UnicodeText"/>++        <AnyChar String="&lt;&gt;+()#,;" attribute="Error"/>++        <WordDetect String="class" attribute="Keyword" context="ClassDiag_KwClass"/>+        <IncludeRules context="ClassDiag_Name"/>++        <WordDetect String="namespace" attribute="Keyword"/>++        <!-- TODO Flowchart uses ';' as separator, but should be an error with ClassDiag -->+        <WordDetect String="note for"  attribute="Keyword" context="ClassDiag_KwNoteFor"/>+        <WordDetect String="note"      attribute="Keyword" context="ClassDiag_KwNote"/>+        <WordDetect String="click"     attribute="Keyword" context="Flowchart_KwClick"/>+        <WordDetect String="callback"  attribute="Keyword" context="Flowchart_KwClick"/>+        <WordDetect String="link"      attribute="Keyword" context="Flowchart_KwClick"/>+        <WordDetect String="classDef"  attribute="Keyword" context="Flowchart_KwClassDef"/>+        <WordDetect String="cssClass"  attribute="Keyword" context="ClassDiag_KwCssClass"/>+        <WordDetect String="style"     attribute="Keyword" context="Flowchart_KwStyle"/>+        <WordDetect String="direction" attribute="Keyword" context="Flowchart_KwDirection"/>++        <IncludeRules context="Find_Accessibility"/>++        <!-- because mermaid... -->+        <StringDetect String="classDiagram" attribute="Error"/>+      </context>++      <context name="ClassDiag_Name" attribute="Node" lineEndContext="#pop">+        <RegExpr String="&class_node;" attribute="Node"/>+      </context>+++      <!-- A ..> B+               ~~~+      -->+      <context name="ClassDiag_RelationType_Right" attribute="Link" lineEndContext="#pop"+               fallthroughContext="ClassDiag_AfterLink">+        <StringDetect String="&lt;|"  attribute="Link" context="ClassDiag_AfterLink"/>+        <AnyChar String="*o&lt;&gt;"  attribute="Link" context="ClassDiag_AfterLink"/>+        <StringDetect String="|>"  attribute="Link" context="ClassDiag_AfterLink"/>+        <StringDetect String="()"  attribute="Link" context="ClassDiag_AfterLink"/>+      </context>++      <!-- A ..> B : LabelText+                ~~~~~~~~~~~~~~+      -->+      <context name="ClassDiag_AfterLink" attribute="Node" lineEndContext="#pop#pop"+               fallthroughContext="#pop#pop">+        <DetectSpaces attribute="Normal"/>+        <StringDetect String=":" attribute="Link Text Separator" context="ClassDiag_LabelText"/>+        <StringDetect String='"' attribute="Quoted Text Delimiter"+                      context="#pop#pop!Flowchart_UnicodeText"/>+        <IncludeRules context="ClassDiag_Name"/>+      </context>+      <!-- A ..> B : LabelText+                    ~~~~~~~~~~+      -->+      <context name="ClassDiag_LabelText" attribute="Link Text" lineEndContext="#pop#pop#pop"+               fallthroughContext="ClassDiag_LabelText_Special">+        <RegExpr String='([^&md_mmd_syms;&class_syms_no_label;]++|&md_mmd_no_md;)++'+                 attribute="Link Text" context="ClassDiag_LabelText_Special"/>+      </context>+      <context name="ClassDiag_LabelText_Special" attribute="Special Text Char"+               lineEndContext="#pop#pop#pop#pop">+        <AnyChar String="&class_syms_no_label;" attribute="Error" context="#pop#pop#pop#pop"/>+        <IncludeRules context="Find_Md_Syms_ThenPop"/>+        <IncludeRules context="Find_Md_Html_ClassLabel_ThenPop"/>+      </context>+++      <!--+      @{ Shape : +draw()+                ~~~~~~~~+      -->+      <context name="ClassDiag_Class_Mem" attribute="Normal" lineEndContext="#pop"+               fallthroughContext="ClassDiag_Class_Field">+        <AnyChar String="+-#~" attribute="Keyword" context="ClassDiag_Class_Field"/>+        <DetectSpaces/>+      </context>+      <context name="ClassDiag_Class_Field" attribute="Member"+               lineEndContext="#pop#pop">+        <StringDetect String=")" attribute="Member"+                      context="#pop#pop!ClassDiag_Class_ReturnType"/>+        <IncludeRules context="ClassDiag_Class_Mem_Common"/>+      </context>+      <context name="ClassDiag_Class_ReturnType" attribute="Member Type" lineEndContext="#pop">+        <IncludeRules context="ClassDiag_Class_Mem_Common"/>+        <StringDetect String=":" attribute="Error"/>+      </context>++      <context name="ClassDiag_Class_Mem_Common" attribute="Member" lineEndContext="#pop">+        <DetectSpaces/>+        <DetectIdentifier/>+        <StringDetect String="$$" lookAhead="1"+                      context="ClassDiag_Class_Mem_AmbiguousMathClassifier"/>+        <StringDetect String="~" attribute="Generic Type Symbol"/>+        <LineContinue char="$" attribute="Keyword" context="#pop"/>+        <LineContinue char="*" attribute="Keyword" context="#pop"/>+      </context>+      <context name="ClassDiag_Class_Mem_AmbiguousMathClassifier" attribute="Normal">+        <RegExpr String="\$\$(?!$)" attribute="Math Delimiter" context="#pop"/>+        <StringDetect String="$" context="#pop"/>+      </context>+      <!--+      @} Shape : +draw()+      -->+++      <!--+      @{ class Name+      -->+      <context name="ClassDiag_KwClass" attribute="Node" lineEndContext="#pop"+               fallthroughContext="#pop">+        <StringDetect String="{" attribute="Curly Bracket Block Delimiter"+                      context="ClassDiag_KwClass_Block" beginRegion="block"/>+        <DetectSpaces attribute="Node"/>+        <IncludeRules context="ClassDiag_KwClass_Name"/>+        <StringDetect String="~" attribute="Generic Type Symbol"/>+        <StringDetect String=":::" attribute="Class Name Delimiter"+                      context="ClassDiag_ClassName"/>+        <StringDetect String="`" attribute="Quoted Text Delimiter"+                      context="ClassDiag_KwClass_BacktickName"/>+        <StringDetect String="[" attribute="Shape"+                      context="ClassDiag_KwClass_BoxedName"/>+      </context>+      <context name="ClassDiag_KwClass_Name" attribute="Node" lineEndContext="#pop"+               fallthroughContext="#pop">+        <DetectIdentifier attribute="Node"/>+        <Int attribute="Node"/>+        <StringDetect String="--" lookAhead="1" context="#pop"/>+        <StringDetect String=".." lookAhead="1" context="#pop"/>+        <AnyChar String="-." attribute="Node"/>+      </context>+      <!--+      class `Name`+             ~~~~~+      -->+      <context name="ClassDiag_KwClass_BacktickName" attribute="Quoted Text"+               fallthroughContext="ClassDiag_KwClass_BacktickName_Special">+        <StringDetect String="`" attribute="Quoted Text Delimiter" context="#pop"/>+        <IncludeRules context="Find_Comment_InText"/>+        <RegExpr String="([^`&md_syms;]++|&md_sym_no_md;)++"+                 attribute="Quoted Text" context="ClassDiag_KwClass_BacktickName_Special"/>+      </context>+      <context name="ClassDiag_KwClass_BacktickName_Special" attribute="Quoted Text"+               lineEndContext="#pop">+        <StringDetect String="`" attribute="Quoted Text Delimiter" context="#pop#pop"/>+        <IncludeRules context="Find_Md_Syms_ThenPop"/>+        <IncludeRules context="Find_Md_Html_Backtick_ThenPop"/>+      </context>+      <!--+      class ["Name"]+             ~~~~~~~+      -->+      <context name="ClassDiag_KwClass_BoxedName" attribute="Error" fallthroughContext="#pop">+        <StringDetect String="]" attribute="Shape" context="#pop"/>+        <DetectSpaces attribute="Normal"/>+        <IncludeRules context="EmptyQuotedText"/>+        <StringDetect String='"' attribute="Quoted Text Delimiter"+                      context="ClassDiag_KwClass_BoxedName_End!Flowchart_UnicodeText"/>+      </context>+      <!--+      class [ "Name" ]+                    ~~+      -->+      <context name="ClassDiag_KwClass_BoxedName_End" attribute="Error"+               fallthroughContext="#pop#pop">+        <StringDetect String="]" attribute="Shape" context="#pop#pop"/>+        <DetectSpaces attribute="Normal"/>+        <IncludeRules context="EmptyQuotedText"/>+      </context>+      <!--+      class Name { ... }+                  ~~~~~~+      -->+      <context name="ClassDiag_KwClass_Block" attribute="Member"+               fallthroughContext="ClassDiag_KwClass_Mem">+        <DetectSpaces attribute="Member"/>+        <AnyChar String="+-#~" attribute="Keyword" context="ClassDiag_KwClass_Mem"/>+        <StringDetect String="&lt;&lt;" attribute="Annotation Delimiter"+                      context="ClassDiag_KwClass_Mem!ClassDiag_Annotation"/>+        <IncludeRules context="Find_Comment"/>+        <StringDetect String="}" attribute="Curly Bracket Block Delimiter"+                      context="#pop#pop" endRegion="block"/>+      </context>++      <context name="ClassDiag_KwClass_Mem" attribute="Member" lineEndContext="#pop">+        <StringDetect String=")" attribute="Member"+                      context="#pop!ClassDiag_KwClass_ReturnType"/>+        <IncludeRules context="ClassDiag_KwClass_ReturnType"/>+      </context>+      <context name="ClassDiag_KwClass_ReturnType" attribute="Member Type"+               lineEndContext="#pop">+        <IncludeRules context="ClassDiag_Class_Mem_Common"/>+        <StringDetect String="}" attribute="Curly Bracket Block Delimiter"+                      context="#pop#pop#pop" endRegion="block"/>+      </context>+      <!--+      @} class+      -->+++      <!--+      @{ note "bla bla"+      -->+      <context name="ClassDiag_KwNote" attribute="Normal" lineEndContext="#pop"+               fallthroughContext="#pop">+        <IncludeRules context="Flowchart_Find_UnicodeText_ThenPop"/>+        <DetectSpaces attribute="Normal"/>+        <IncludeRules context="CharErrorAndPop"/>+      </context>+      <!-- note for className "bla bla" -->+      <context name="ClassDiag_KwNoteFor" attribute="Normal" lineEndContext="#pop"+               fallthroughContext="#pop">+        <IncludeRules context="Flowchart_Find_UnicodeText_ThenPop"/>+        <DetectSpaces attribute="Normal"/>+        <IncludeRules context="ClassDiag_KwClass_Name"/>+        <IncludeRules context="CharErrorAndPop"/>+      </context>+      <!--+      @} note+      -->+++      <!--+      @{ cssClass "nodeId1,nodeId2" className+      -->+      <context name="ClassDiag_KwCssClass" attribute="Normal" lineEndContext="#pop"+               fallthroughContext="#pop">+        <StringDetect String='"' attribute="Quoted Text Delimiter"+                      context="ClassDiag_KwCssClass_Classes"/>+        <DetectSpaces attribute="Normal"/>+        <RegExpr String="&css_class_name;" attribute="Class Name"/>+      </context>+      <context name="ClassDiag_KwCssClass_Classes" attribute="Node">+        <StringDetect String='"' attribute="Quoted Text Delimiter" context="#pop"/>+        <StringDetect String="," attribute="Node Separator"/>+        <DetectIdentifier/>+      </context>+      <!--+      @} cssClass+      -->+++      <!-- <<annotation>>+             ~~~~~~~~~~~~+      -->+      <context name="ClassDiag_Annotation" attribute="Annotation" fallthroughContext="#pop">+        <DetectIdentifier attribute="Annotation"/>+        <StringDetect String=">>" attribute="Annotation Delimiter" context="#pop"/>+      </context>+++      <!-- class Name:::classname+                        ~~~~~~~~~+      -->+      <context name="ClassDiag_ClassName" attribute="Class Name" lineEndContext="#pop"+               fallthroughContext="ClassDiag_ClassName2">+        <DetectSpaces context="ClassDiag_ClassName2"/>+      </context>+      <context name="ClassDiag_ClassName2" attribute="Class Name" lineEndContext="#pop#pop"+               fallthroughContext="#pop#pop">+        <DetectIdentifier/>+        <Int/>+      </context>++      <!--+      @} Class Diagram+      -->+++      <!--+      @{ State Diagram+      -->++      <context name="StateDiag" attribute="Error">+        <DetectSpaces attribute="Normal"/>++        <StringDetect String="&lt;&lt;" attribute="Annotation Delimiter"+                      context="ClassDiag_Annotation"/>++        <StringDetect String="-->" attribute="Link"/>+        <StringDetect String="--" attribute="Concurrency"/>++        <StringDetect String=":::" attribute="Class Name Delimiter"+                      context="ClassDiag_ClassName"/>+        <StringDetect String=":" attribute="Link Text Separator" context="StateDiag_LinkText"/>++        <StringDetect String="{" attribute="Curly Bracket Block Delimiter" beginRegion="block"/>+        <StringDetect String="}" attribute="Curly Bracket Block Delimiter" endRegion="block"/>++        <AnyChar String='-"' attribute="Error"/>++        <!-- https://github.com/mermaid-js/mermaid/issues/7090 -->+        <StringDetect String="%" attribute="Comment" context="Comment"/>++        <RegExpr String="&state_node;" attribute="Node"/>++        <WordDetect String="note" attribute="Keyword" context="StateDiag_KwNote"/>+        <WordDetect String="state" attribute="Keyword" context="StateDiag_KwState"/>+        <WordDetect String="class" attribute="Keyword" context="StateDiag_KwClass"/>+        <WordDetect String="classDef"  attribute="Keyword" context="Flowchart_KwClassDef"/>+        <WordDetect String="direction" attribute="Keyword" context="Flowchart_KwDirection"/>++        <IncludeRules context="Find_Accessibility"/>++        <!-- because mermaid... -->+        <StringDetect String="stateDiagram" attribute="Error"/>+      </context>++      <!-- s1 - -> s2 : EvScrollLockPressed+                       ~~~~~~~~~~~~~~~~~~~~+      -->+      <context name="StateDiag_LinkText" attribute="Link Text" lineEndContext="#pop"+               fallthroughContext="StateDiag_LinkText_Text">+        <!-- https://github.com/mermaid-js/mermaid/issues/7090 -->+        <StringDetect String="%%" context="#pop!Comment"/>+      </context>+      <context name="StateDiag_LinkText_Text" attribute="Link Text" lineEndContext="#pop#pop"+               fallthroughContext="StateDiag_LinkText_Text_Special">+        <RegExpr String='([^&md_mmd_syms;;:]++|&md_mmd_no_md;)++'+                 attribute="Link Text" context="StateDiag_LinkText_Text_Special"/>+      </context>+      <context name="StateDiag_LinkText_Text_Special" attribute="Special Text Char"+               lineEndContext="#pop#pop#pop">+        <StringDetect String=";" context="#pop#pop#pop" lookAhead="1"/>+        <StringDetect String=":" attribute="Error" context="#pop"/>+        <IncludeRules context="Find_Md_Syms_ThenPop"/>+        <IncludeRules context="Find_Md_Html_StateText_ThenPop"/>+      </context>+++      <!--+      @{ state s1 { ... } / state "..." as s1+      -->+      <context name="StateDiag_KwState" attribute="Node"+               fallthroughContext="StateDiag_KwState_State">+        <DetectSpaces attribute="Normal"/>+        <StringDetect String='"' lookAhead="1"+                      context="StateDiag_KwState_As!StateDiag_KwState_State_EmptyDQ!Flowchart_Find_UnicodeText!StateDiag_KwState_State_EmptyDQ"/>+        <StringDetect String="{" attribute="Curly Bracket Block Delimiter" beginRegion="block"+                      context="#pop"/>+        <StringDetect String="}" attribute="Error" beginRegion="block" context="#pop"/>+        <StringDetect String="&lt;&lt;" attribute="Annotation Delimiter"+                      context="StateDiag_KwState_StateEnd!ClassDiag_Annotation"/>+        <RegExpr String="&mmd_ent;" attribute="Entity" context="StateDiag_KwState_State"/>+        <!-- https://github.com/mermaid-js/mermaid/issues/7105 -->+        <StringDetect String="#" attribute="Error"/>+      </context>+      <!-- state s1 { ... }+                 ~~~~+      -->+      <context name="StateDiag_KwState_State" attribute="Node" lineEndContext="#pop#pop">+        <AnyChar String="123456789-"/>+        <DetectIdentifier/>+        <DetectSpaces attribute="Normal" context="#pop!StateDiag_KwState_StateEnd"/>+        <StringDetect String="{" attribute="Curly Bracket Block Delimiter" beginRegion="block"+                      context="#pop#pop"/>+        <StringDetect String="}" attribute="Error" beginRegion="block" context="#pop#pop"/>+        <StringDetect String="&lt;&lt;" attribute="Annotation Delimiter"+                      context="#pop!StateDiag_KwState_StateEnd!ClassDiag_Annotation"/>+        <RegExpr String="&lt;(/[a-z]+|[a-z]+/?)>&gt;" attribute="HTML Tag"/>+      </context>+      <context name="StateDiag_KwState_StateEnd" attribute="Error"+               lineEndContext="#pop#pop" fallthroughContext="#pop#pop">+        <DetectSpaces attribute="Normal"/>+        <DetectIdentifier attribute="Error" context="#pop#pop"/>+        <StringDetect String="{" attribute="Curly Bracket Block Delimiter" beginRegion="block"+                      context="#pop#pop"/>+        <StringDetect String="}" attribute="Error" beginRegion="block" context="#pop#pop"/>+        <StringDetect String="&lt;&lt;" attribute="Annotation Delimiter"+                      context="ClassDiag_Annotation"/>+      </context>+      <!-- state "" "..." "" as s1+                 ~~       ~~+      -->+      <context name="StateDiag_KwState_State_EmptyDQ" attribute="Node"+               lineEndContext="#pop" fallthroughContext="#pop">+        <StringDetect String='""' attribute="Comment"/>+        <DetectSpaces attribute="Normal"/>+      </context>+      <!-- state "..." as s1+                      ~~~+      -->+      <context name="StateDiag_KwState_As" attribute="Node" lineEndContext="#pop#pop"+               fallthroughContext="#pop#pop">+        <DetectSpaces attribute="Normal"/>+        <WordDetect String="as" attribute="Keyword Parameter" context="#pop#pop"/>+        <!-- https://github.com/mermaid-js/mermaid/issues/7090 -->+        <StringDetect String="%" attribute="Error" context="#pop#pop"/>+      </context>+      <!--+      @} state+      -->+++      <!--+      @{ note right of State bla bla end note / note left of State : bla bla+              ~~~~~~~~~                              ~~~~~~~~+      -->+      <context name="StateDiag_KwNote" attribute="Node"+               fallthroughContext="StateDiag_KwNote_State!Spaces">+        <DetectSpaces attribute="Normal"/>+        <WordDetect String="right of" attribute="Keyword Parameter"+                    context="StateDiag_KwNote_State!Spaces"/>+        <WordDetect String="left of" attribute="Keyword Parameter"+                    context="StateDiag_KwNote_State!Spaces"/>+      </context>+      <!-- note right of State bla bla end note+                         ~~~~~+      -->+      <context name="StateDiag_KwNote_State" attribute="Text"+               fallthroughContext="StateDiag_KwNote_Note">+        <RegExpr String="&state_node;" attribute="Node" context="StateDiag_KwNote_Note"/>+      </context>+      <!-- note right of State bla bla end note / note right of State : bla bla+                              ~                                      ~~+      -->+      <context name="StateDiag_KwNote_Note" attribute="Text"+               fallthroughContext="StateDiag_KwNote_Block">+        <DetectSpaces attribute="Normal"/>+        <StringDetect String=":" attribute="Text Separator" context="StateDiag_KwNote_Inline"/>+      </context>+      <!-- note right of State bla bla end note+                               ~~~~~~~~~~~~~~~~+      -->+      <context name="StateDiag_KwNote_Block" attribute="Text"+               fallthroughContext="StateDiag_KwNote_Block_Special">+        <IncludeRules context="Find_Comment_InText"/>+        <!-- end note: https://github.com/mermaid-js/mermaid/issues/7089 -->+        <RegExpr String='([^&md_syms;e]++|e(?!nd note\b)|&md_sym_no_md;)++'+                 attribute="Text" context="StateDiag_KwNote_Block_Special"/>+      </context>+      <context name="StateDiag_KwNote_Block_Special" attribute="Text" lineEndContext="#pop">+        <!-- https://github.com/mermaid-js/mermaid/issues/7089 -->+        <StringDetect String="end note" attribute="Keyword" context="#pop#pop#pop#pop#pop"/>+        <IncludeRules context="Find_Md_Syms_ThenPop"/>+        <IncludeRules context="Find_Md_Html_DQ_ThenPop"/>+      </context>+      <!-- note right of State : bla bla+                                ~~~~~~~~+      -->+      <context name="StateDiag_KwNote_Inline" attribute="Text"+               lineEndContext="#pop#pop#pop#pop"+               fallthroughContext="StateDiag_KwNote_Inline_Special">+        <RegExpr String='([^&md_syms;:]++|&md_sym_no_md;)++'+                 attribute="Text" context="StateDiag_KwNote_Block_Special"/>+      </context>+      <context name="StateDiag_KwNote_Inline_Special" attribute="Text"+               lineEndContext="#pop#pop#pop#pop#pop">+        <StringDetect String=":" attribute="Error" context="#pop"/>+        <IncludeRules context="Find_Md_Syms_ThenPop"/>+        <IncludeRules context="Find_Md_Html_DQ_ThenPop"/>+      </context>+      <!--+      @} note+      -->+++      <!-- @{ class nodeId1,nodeId2 className; -->+      <context name="StateDiag_KwClass" attribute="Error" lineEndContext="#pop">+        <DetectSpaces attribute="Normal" context="StateDiag_KwClass_Node"/>+        <StringDetect String=";" attribute="Symbol Separator" context="#pop"/>+      </context>+      <context name="StateDiag_KwClass_Node" attribute="Normal" lineEndContext="#pop#pop">+        <DetectSpaces attribute="Normal" context="Flowchart_KwClass_ClassName"/>+        <StringDetect String="," attribute="List Separator"/>+        <StringDetect String=";" attribute="Symbol Separator" context="#pop#pop"/>+        <DetectIdentifier attribute="Node"/>+      </context>+      <!-- @} class -->++      <!--+      @} State Diagram+      -->+++      <!--+      @{ Entity Relationship Diagram+      -->++      <context name="erDiag" attribute="Error">+        <DetectSpaces attribute="Normal"/>++        <StringDetect String=":::" attribute="Class Name Delimiter" context="erDiag_ClassName"/>+        <StringDetect String=":" attribute="Link Text Separator" context="erDiag_LinkText"/>+        <StringDetect String="[" attribute="Shape" context="erDiag_NameAlias"/>++        <StringDetect String="{" attribute="Curly Bracket Block Delimiter" beginRegion="block"+                      context="erDiag_Attr"/>+        <StringDetect String='"' attribute="Quoted Text Delimiter" context="erDiag_QuotedText"/>++        <IncludeRules context="Find_Comment"/>++        <RegExpr String="&er_link;" attribute="Link" insensitive="1"/>+        <RegExpr String="&er_node;" attribute="Node" insensitive="1"/>++        <StringDetect String="one or zero"  attribute="Cardinality Text" insensitive="1"/>+        <StringDetect String="zero or one"  attribute="Cardinality Text" insensitive="1"/>+        <StringDetect String="one or many"  attribute="Cardinality Text" insensitive="1"/>+        <StringDetect String="many(1)"      attribute="Cardinality Text" insensitive="1"/>+        <StringDetect String="1+"           attribute="Cardinality Text" insensitive="1"/>+        <StringDetect String="zero or more" attribute="Cardinality Text" insensitive="1"/>+        <StringDetect String="zero or many" attribute="Cardinality Text" insensitive="1"/>+        <StringDetect String="many(0)"      attribute="Cardinality Text" insensitive="1"/>+        <StringDetect String="0+"           attribute="Cardinality Text" insensitive="1"/>+        <StringDetect String="only one"     attribute="Cardinality Text" insensitive="1"/>+        <!-- https://github.com/mermaid-js/mermaid/issues/7093 -->+        <StringDetect String="one"          attribute="Cardinality Text" insensitive="1"/>+        <!-- https://github.com/mermaid-js/mermaid/issues/7093 -->+        <AnyChar String="uU1"               attribute="Cardinality Text"/>++        <StringDetect String="to"            attribute="Relationship Text" insensitive="1"/>+        <StringDetect String="optionally to" attribute="Relationship Text" insensitive="1"/>++        <StringDetect String="style" attribute="Keyword" context="Flowchart_KwStyle"+                      insensitive="1"/>+        <StringDetect String="classDef" attribute="Keyword" context="Flowchart_KwClassDef"+                      insensitive="1"/>+        <StringDetect String="direction" attribute="Keyword" context="Flowchart_KwDirection"+                      insensitive="1"/>++        <IncludeRules context="Find_Accessibility_Insensitive"/>++        <!-- because mermaid... -->+        <!-- <StringDetect String="erDiagram" attribute="Error"/> -->++        <DetectIdentifier attribute="Error"/>+      </context>++      <!-- AAA ||..|| BBB : bla bla+                           ~~~~~~~~+      -->+      <context name="erDiag_LinkText" attribute="Link Text"+               fallthroughContext="erDiag_LinkText_Text">+        <DetectSpaces/>+        <IncludeRules context="Find_Comment"/>+        <!-- https://github.com/mermaid-js/mermaid/issues/5093 -->+        <RegExpr String="&er_kw;" lookAhead="1" context="#pop"/>+      </context>+      <context name="erDiag_LinkText_Text" attribute="Link Text" lineEndContext="#pop#pop"+               fallthroughContext="#pop#pop">+        <StringDetect String="*" attribute="Special Text Char"/>+        <RegExpr String="([^][&lt;&gt;/\\|`~%&amp;:';.{}$()=+?&quot;,@^|#*_\s]+|&md_no_underscore;)+"/>+        <StringDetect String="_" attribute="Special Text Char"/>+      </context>++      <!-- AAA[text] / AAA["text"]+               ~~~~~       ~~~~~~~+      -->+      <context name="erDiag_NameAlias" attribute="Normal" lineEndContext="#pop"+               fallthroughContext="erDiag_NameAlias_UnquotedText">+        <StringDetect String='"' attribute="Quoted Text Delimiter"+                      context="erDiag_NameAlias_End!erDiag_QuotedText"/>+        <IncludeRules context="erDiag_LinkText"/>+      </context>+      <!-- AAA[text]+               ~~~~~+      -->+      <context name="erDiag_NameAlias_UnquotedText" attribute="Text" lineEndContext="#pop#pop"+               fallthroughContext="#pop!erDiag_NameAlias_End">+        <StringDetect String="]" attribute="Shape" context="#pop#pop"/>+        <IncludeRules context="erDiag_LinkText_Text"/>+      </context>+      <!-- AAA[ text ]+                    ~~+      -->+      <context name="erDiag_NameAlias_End" attribute="Error" lineEndContext="#pop#pop">+        <DetectSpaces attribute="Normal"/>+        <StringDetect String="]" attribute="Shape" context="#pop#pop"/>+        <IncludeRules context="CharErrorAndPop2"/>+      </context>++      <!-- "text"+            ~~~~~+      -->+      <context name="erDiag_QuotedText" attribute="Quoted Text" lineEndContext="#pop"+               fallthroughContext="erDiag_QuotedText_Special">+        <StringDetect String='"' attribute="Quoted Text Delimiter" context="#pop"/>+        <StringDetect String="~" attribute="Special Text Char"/>+        <IncludeRules context="Find_Comment_InText"/>+        <RegExpr String='([^&flowchart_qtext_syms;~]++|&flowchart_qtext_no_md;)++'+                 attribute="Quoted Text" context="erDiag_QuotedText_Special"/>+      </context>+      <context name="erDiag_QuotedText_Special" attribute="Quoted Text"+               lineEndContext="#pop#pop">+        <StringDetect String="~" attribute="Special Text Char" context="#pop"/>+        <IncludeRules context="Flowchart_UnicodeText_Special"/>+      </context>++      <!-- Ent:::classname,classname+                 ~~~~~~~~~~~~~~~~~~~+      -->+      <context name="erDiag_ClassName" attribute="Class Name" lineEndContext="#pop"+               fallthroughContext="erDiag_ClassName2">+        <DetectSpaces context="erDiag_ClassName2"/>+        <StringDetect String="," attribute="List Separator"/>+      </context>+      <context name="erDiag_ClassName2" attribute="Class Name" lineEndContext="#pop#pop"+               fallthroughContext="#pop#pop">+        <DetectIdentifier/>+        <AnyChar String="-"/>+        <Int/>+        <StringDetect String="," attribute="List Separator" context="#pop"/>+        <DetectSpaces context="#pop"/>+      </context>++      <!-- @{ Attribute -->+      <!-- Ent { string(ds) productCode PK "Dsds" }+                ~~~~~~~~~~~+      -->+      <context name="erDiag_Attr" attribute="Error">+        <DetectSpaces attribute="Member Type"/>+        <AnyChar String="*-[]()0123456789" attribute="Member Type"+                 context="#pop!erDiag_Attr_Type"/>+        <IncludeRules context="erDiag_Attr_NotIdent"/>+        <DetectIdentifier attribute="Member Type" context="#pop!erDiag_Attr_Type"/>+      </context>+      <context name="erDiag_Attr_NotIdent" attribute="Error">+        <IncludeRules context="erDiag_Attr_IdentEnd"/>+        <IncludeRules context="Find_Comment"/>+        <WordDetect String="PK" attribute="Keyword Parameter" context="erDiag_Attr_Key"+                    additionalDeliminator='-"' insensitive="1"/>+        <WordDetect String="FK" attribute="Keyword Parameter" context="erDiag_Attr_Key"+                    additionalDeliminator='-"' insensitive="1"/>+      </context>+      <context name="erDiag_Attr_IdentEnd" attribute="Error">+        <StringDetect String="}" attribute="Curly Bracket Block Delimiter" beginRegion="block"+                      context="#pop"/>+        <StringDetect String='"' attribute="Quoted Text Delimiter"+                      context="#pop!erDiag_Attr!erDiag_QuotedText"/>+        <StringDetect String=',' attribute="List Separator" context="erDiag_Attr_Key"/>+      </context>+      <!-- Ent { string(ds) productCode PK "Dsds" }+                 ~~~~~~~~~~+      -->+      <context name="erDiag_Attr_Type" attribute="Error"+               lineEndContext="#pop!erDiag_Attr_Name"+               fallthroughContext="#pop!erDiag_Attr_Name">+        <DetectSpaces attribute="Member Type" context="#pop!erDiag_Attr_Name"/>+        <DetectIdentifier attribute="Member Type"/>+        <AnyChar String="*-[]()0123456789" attribute="Member Type"/>+        <IncludeRules context="erDiag_Attr_IdentEnd"/>+      </context>+      <!-- Ent { string(ds) productCode PK "Dsds" }+                           ~~~~~~~~~~~~+      -->+      <context name="erDiag_Attr_Name" attribute="Error">+        <DetectSpaces attribute="Member"/>+        <AnyChar String="*-[]()0123456789" attribute="Member"+                 context="#pop!erDiag_Attr_Name2"/>+        <IncludeRules context="erDiag_Attr_NotIdent"/>+        <DetectIdentifier attribute="Member" context="#pop!erDiag_Attr_Name2"/>+      </context>+      <!-- Ent { string(ds) productCode PK "Dsds" }+                            ~~~~~~~~~~~+      -->+      <context name="erDiag_Attr_Name2" attribute="Error"+               lineEndContext="erDiag_Attr_Key"+               fallthroughContext="erDiag_Attr_Key">+        <DetectSpaces attribute="Member" context="erDiag_Attr_Key"/>+        <DetectIdentifier attribute="Member"/>+        <AnyChar String="*-[]()0123456789" attribute="Member"/>+        <IncludeRules context="erDiag_Attr_IdentEnd"/>+      </context>+      <!-- Ent { string(ds) productCode PK "Dsds" }+                                       ~~~~+      -->+      <context name="erDiag_Attr_Key" attribute="Normal"+               fallthroughContext="#pop#pop!erDiag_Attr">+        <DetectSpaces attribute="Normal"/>+        <StringDetect String=',' attribute="List Separator"/>+        <StringDetect String='"' attribute="Quoted Text Delimiter"+                      context="#pop#pop!erDiag_Attr!erDiag_QuotedText"/>+        <StringDetect String="}" attribute="Curly Bracket Block Delimiter" endRegion="block"+                      context="#pop#pop"/>+        <WordDetect String="PK" attribute="Keyword Parameter" additionalDeliminator='-"'+                    insensitive="1"/>+        <WordDetect String="FK" attribute="Keyword Parameter" additionalDeliminator='-"'+                    insensitive="1"/>+      </context>+      <!-- @} Attribute -->++      <!--+      @} Entity Relationship Diagram+      -->+++      <!--+      @{ User Journey Diagram+      -->++      <context name="Journey" attribute="Normal">+        <DetectSpaces attribute="Normal"/>++        <StringDetect String=":" attribute="Symbol Separator" context="Journey_Task_Score"/>+        <StringDetect String=";" attribute="Error"/>+        <!-- https://github.com/mermaid-js/mermaid/issues/7090 -->+        <StringDetect String="%" attribute="Comment" context="Comment"/>++        <RegExpr String="&journey_task;" attribute="Node" insensitive="1"+                 context="Journey_Task"/>++        <WordDetect String="section" attribute="Keyword" insensitive="1"+                    context="Journey_KwSection!SpacesOrNewLine"/>+        <WordDetect String="title" attribute="Keyword" insensitive="1"+                    context="Journey_KwTitle!SpacesOrNewLine"/>++        <IncludeRules context="Find_Accessibility_Insensitive"/>++        <!-- because mermaid... -->+        <StringDetect String="journey" attribute="Error"/>++        <RegExpr String="&mmd_ent;" attribute="Entity" context="Journey_Task"/>+        <!-- https://github.com/mermaid-js/mermaid/issues/7105 -->+        <StringDetect String="#" attribute="Error"/>+      </context>++      <!-- task name : score : text+             ~~~~~~~~~~~~~~~~~~~~~~+      task name is partially consumed if there # or ;+      -->+      <context name="Journey_Task" attribute="Node" lineEndContext="#pop">+        <StringDetect String=":" attribute="Symbol Separator"+                      context="#pop!Journey_Task_Score"/>+        <IncludeRules context="Journey_KwSection"/>+      </context>+      <context name="Journey_Task_Score" attribute="Error" lineEndContext="#pop">+        <AnyChar String="-+0123456789." attribute="Number"/>+        <StringDetect String=":" attribute="Symbol Separator" context="Journey_Task_Text"/>+        <DetectSpaces attribute="Normal"/>+      </context>+      <context name="Journey_Task_Text" attribute="ID" lineEndContext="#pop#pop">+        <StringDetect String="," attribute="ID Separator"/>+        <IncludeRules context="Journey_KwSection"/>+      </context>++      <!-- section text+                   ~~~~+      -->+      <context name="Journey_KwSection" attribute="Section Text" lineEndContext="#pop">+        <DetectIdentifier/>+        <DetectSpaces/>+        <Int/>+        <IncludeRules context="Find_Entity"/>+        <!-- # -> https://github.com/mermaid-js/mermaid/issues/7105 -->+        <AnyChar String=";:#" attribute="Error"/>+      </context>++      <!-- title text+                 ~~~~+      -->+      <context name="Journey_KwTitle" attribute="Text" lineEndContext="#pop">+        <StringDetect String=":" attribute="Text"/>+        <IncludeRules context="Journey_KwSection"/>+        <StringDetect String="&lt;" attribute="Special Text Char"/>+      </context>++      <!--+      @} User Journey Diagram+      -->+++      <!--+      @{ Gantt Diagram+      -->++      <context name="Gantt" attribute="Normal" fallthroughContext="Gantt_Task">+        <DetectSpaces attribute="Normal"/>++        <!-- https://github.com/mermaid-js/mermaid/issues/7090 -->+        <AnyChar String="%" attribute="Comment" context="Comment"/>++        <RegExpr String="&gantt_task;" attribute="Node" insensitive="1"+                 context="Gantt_Task"/>++        <StringDetect String="section" attribute="Keyword" insensitive="1"+                      context="Gantt_KwSection!SpacesOrNewLine"/>+        <StringDetect String="excludes" attribute="Keyword" insensitive="1"+                      context="Gantt_KwExcludes!SpacesOrNewLine"/>+        <StringDetect String="axisFormat" attribute="Keyword" insensitive="1"+                      context="Text_NoSpecial!SpacesOrNewLine"/>+        <StringDetect String="dateFormat" attribute="Keyword" insensitive="1"+                      context="Text_NoSpecial!SpacesOrNewLine"/>+        <StringDetect String="tickInterval" attribute="Keyword" insensitive="1"+                      context="Gantt_KwTickInterval!SpacesOrNewLine"/>+        <StringDetect String="weekday" attribute="Keyword" insensitive="1"+                      context="Gantt_KwWeekday!SpacesOrNewLine"/>+        <StringDetect String="title" attribute="Keyword" insensitive="1"+                      context="Text_Simple!SpacesOrNewLine"/>+        <StringDetect String="weekend" attribute="Keyword" insensitive="1"+                      context="Gantt_KwWeekend!SpacesOrNewLine"/>+        <StringDetect String="todayMarker" attribute="Keyword" insensitive="1"+                      context="Gantt_KwTodayMarker!SpacesOrNewLine"/>++        <IncludeRules context="Find_Accessibility_Insensitive"/>++        <!-- because mermaid... -->+        <StringDetect String="gantt" attribute="Error"/>+      </context>++      <!-- my task : metadata, id, date, date+             ~~~~~~~+      task name is partially consumed if there '#'+      -->+      <context name="Gantt_Task" attribute="Node" lineEndContext="#pop">+        <StringDetect String=":" attribute="Symbol Separator" context="Gantt_Task_Metadata"/>+        <DetectSpaces/>+        <DetectIdentifier/>+        <Int/>+        <IncludeRules context="Find_Entity"/>+      </context>+      <!-- my task : metadata, id, date, date+                    ~~~~~~~~~~+      -->+      <context name="Gantt_Task_Metadata" attribute="Normal" lineEndContext="#pop#pop"+               fallthroughContext="Gantt_Task_ID">+        <DetectSpaces/>+        <StringDetect String="," attribute="List Separator" context="Gantt_Task_Date1"/>+        <WordDetect String="active" attribute="Keyword Parameter" context="Gantt_MetaSep"/>+        <WordDetect String="done" attribute="Keyword Parameter" context="Gantt_MetaSep"/>+        <WordDetect String="crit" attribute="Keyword Parameter" context="Gantt_MetaSep"/>+        <WordDetect String="milestone" attribute="Keyword Parameter" context="Gantt_MetaSep"/>+        <WordDetect String="vert" attribute="Keyword Parameter" context="Gantt_MetaSep"/>+      </context>+      <context name="Gantt_MetaSep" attribute="Normal" lineEndContext="#pop#pop#pop"+               fallthroughContext="#pop!Gantt_Task_ID">+        <DetectSpaces/>+        <StringDetect String="," attribute="List Separator" context="#pop"/>+      </context>+      <!-- my task : metadata, id, date, date+                              ~~~~+      -->+      <context name="Gantt_Task_ID" attribute="Normal" lineEndContext="#pop#pop#pop"+               fallthroughContext="#pop!Gantt_Task_Date1">+        <DetectSpaces/>+        <StringDetect String="," attribute="List Separator" context="#pop!Gantt_Task_Date1"/>+        <RegExpr String="[^,]+(?=,[^,]*,[^,]*)" attribute="ID"/>+      </context>+      <!-- my task : metadata, id, date, date+                                  ~~~~~~+      -->+      <context name="Gantt_Task_Date1" attribute="Normal" lineEndContext="#pop#pop#pop"+               fallthroughContext="Gantt_Task_Date1_Text">+        <DetectSpaces/>+        <WordDetect String="after" attribute="Keyword Parameter" context="Gantt_Task_Date1_Id"+                    insensitive="1"/>+        <WordDetect String="until" attribute="Keyword Parameter" context="Gantt_Task_Date2_Id"+                    insensitive="1"/>+      </context>+      <context name="Gantt_Task_Date1_Text" attribute="Normal"+               lineEndContext="#pop#pop#pop#pop">+        <Int context="Gantt_Task_Date_Suffix"/>+        <StringDetect String="," attribute="List Separator" context="Gantt_Task_Date2"/>+      </context>+      <context name="Gantt_Task_Date1_Id" attribute="ID" lineEndContext="#pop#pop#pop#pop">+        <DetectSpaces attribute="Normal"/>+        <StringDetect String="," attribute="List Separator" context="Gantt_Task_Date2"/>+      </context>+      <context name="Gantt_Task_Date_Suffix" attribute="Normal"+               lineEndContext="#pop#pop#pop#pop#pop" fallthroughContext="#pop">+        <StringDetect String="ms" attribute="Style Unit" context="#pop"/>+        <AnyChar String="smhdwMy" attribute="Style Unit" context="#pop"/>+      </context>+      <!-- my task : metadata, id, date, date+                                       ~~~~~~+      -->+      <context name="Gantt_Task_Date2" attribute="Normal" lineEndContext="#pop#pop#pop#pop#pop"+               fallthroughContext="Gantt_Task_Date2_Text">+        <DetectSpaces/>+        <WordDetect String="until" attribute="Keyword Parameter" insensitive="1"+                    context="#pop#pop!Gantt_Task_Date2_Id"/>+      </context>+      <context name="Gantt_Task_Date2_Text" attribute="Normal"+               lineEndContext="#pop#pop#pop#pop#pop#pop">+        <Int context="Gantt_Task_Date_Suffix"/>+        <StringDetect String="," attribute="Error"+                      context="#pop#pop#pop#pop#pop#pop!LineError"/>+      </context>+      <context name="Gantt_Task_Date2_Id" attribute="ID" lineEndContext="#pop#pop#pop#pop">+        <DetectSpaces attribute="Normal"/>+        <StringDetect String="," attribute="Error" context="#pop#pop#pop#pop!LineError"/>+      </context>++      <!-- section text+                   ~~~~+      -->+      <context name="Gantt_KwSection" attribute="Section Text" lineEndContext="#pop">+        <DetectIdentifier/>+        <DetectSpaces/>+        <Int/>+        <IncludeRules context="Find_Entity"/>+        <IncludeRules context="Find_HTML_br"/>+      </context>++      <!-- excludes date sunday+                    ~~~~~~~~~~~+      -->+      <context name="Gantt_KwExcludes" attribute="Normal" lineEndContext="#pop">+        <Int/>+        <AnyChar String="-:/"/>+        <StringDetect String="," attribute="List Separator" context="Gantt_Task_Date1"/>+        <DetectSpaces/>+        <WordDetect String="weekends"  attribute="Keyword Parameter" insensitive="1"/>+        <IncludeRules context="Gantt_KwWeekday"/>+        <DetectIdentifier/>+      </context>++      <!-- weekend friday+                   ~~~~~~+      -->+      <context name="Gantt_KwWeekend" attribute="Normal" fallthroughContext="#pop">+        <DetectSpaces/>+        <WordDetect String="friday"   attribute="Keyword Parameter" insensitive="1"/>+        <WordDetect String="saturday" attribute="Keyword Parameter" insensitive="1"/>+        <DetectIdentifier attribute="Error" context="#pop"/>+      </context>++      <!-- weekday monday+                   ~~~~~~+      -->+      <context name="Gantt_KwWeekday" attribute="Normal" lineEndContext="#pop">+        <WordDetect String="monday"    attribute="Keyword Parameter" insensitive="1"/>+        <WordDetect String="tuesday"   attribute="Keyword Parameter" insensitive="1"/>+        <WordDetect String="wednesday" attribute="Keyword Parameter" insensitive="1"/>+        <WordDetect String="thursday"  attribute="Keyword Parameter" insensitive="1"/>+        <WordDetect String="friday"    attribute="Keyword Parameter" insensitive="1"/>+        <WordDetect String="saturday"  attribute="Keyword Parameter" insensitive="1"/>+        <WordDetect String="sunday"    attribute="Keyword Parameter" insensitive="1"/>+      </context>++      <!-- title text+                 ~~~~+      -->+      <context name="Gantt_KwTodayMarker" attribute="Text" lineEndContext="#pop"+               fallthroughContext="#pop!Flowchart_CSSProp">+        <WordDetect String="off" attribute="Keyword Parameter"/>+      </context>++      <!-- tickInterval 1day+                        ~~~~+      -->+      <context name="Gantt_KwTickInterval" attribute="Error" lineEndContext="#pop"+               fallthroughContext="#pop!LineError">+        <DetectSpaces attribute="Normal"/>+        <Int context="Gantt_KwTickInterval_Unit" attribute="Number"/>+      </context>+      <context name="Gantt_KwTickInterval_Unit" attribute="Normal" lineEndContext="#pop#pop"+               fallthroughContext="#pop">+        <WordDetect String="millisecond" attribute="Style Unit" context="#pop" additionalDeliminator="0123456789"/>+        <WordDetect String="second"      attribute="Style Unit" context="#pop" additionalDeliminator="0123456789"/>+        <WordDetect String="minute"      attribute="Style Unit" context="#pop" additionalDeliminator="0123456789"/>+        <WordDetect String="hour"        attribute="Style Unit" context="#pop" additionalDeliminator="0123456789"/>+        <WordDetect String="day"         attribute="Style Unit" context="#pop" additionalDeliminator="0123456789"/>+        <WordDetect String="week"        attribute="Style Unit" context="#pop" additionalDeliminator="0123456789"/>+        <WordDetect String="month"       attribute="Style Unit" context="#pop" additionalDeliminator="0123456789"/>+      </context>++      <!--+      @} Gantt Diagram+      -->+++      <!--+      @{ Pie chart diagrams+      -->++      <context name="Pie" attribute="Normal" lineEndContext="Pie_Body"+               fallthroughContext="Pie_Body">+        <DetectSpaces attribute="Normal"/>+        <WordDetect String="showData" attribute="Keyword Parameter" context="Pie_Body"/>+      </context>++      <context name="Pie_Body" attribute="Normal">+        <DetectSpaces attribute="Normal"/>++        <AnyChar String=":" attribute="Node Separator" context="Pie_Number"/>+        <IncludeRules context="Find_Quote_Simple"/>+        <IncludeRules context="Find_Comment"/>++        <AnyChar String="%.+-" attribute="Error"/>++        <StringDetect String="title" attribute="Keyword" context="Text_Simple!SpacesOrError"/>++        <IncludeRules context="Find_Accessibility_Insensitive"/>++        <Int/>+        <DetectIdentifier/>+      </context>++      <context name="Pie_Number" attribute="Error" lineEndContext="#pop">+        <DetectSpaces attribute="Normal"/>+        <RegExpr String="[0-9]+([.][0-9]+)?" attribute="Number" context="#pop!LineError!Spaces"/>+      </context>++      <!--+      @} Pie chart diagrams+      -->+++      <!--+      @{ Quadrant Chart+      -->++      <context name="Quadrant" attribute="Error">+        <DetectSpaces attribute="Normal"/>++        <StringDetect String=":::" attribute="Class Name Delimiter"+                      context="Quadrant_Point_ClassName"/>+        <StringDetect String=":" attribute="Node Separator" context="Quadrant_Point_XY"/>+        <IncludeRules context="Find_Any_Comment"/>+        <StringDetect String='"' attribute="Quoted Text Delimiter"+                      context="Quadrant_Point_Name!Quadrant_Text_Q"/>+        <StringDetect String=";" attribute="Symbol Separator"/>+        <StringDetect String="-->" attribute="Link" context="Quadrant_Text"/>++        <RegExpr String="&quadrant_text;" attribute="Node" insensitive="1"+                 context="Quadrant_Point_Name"/>++        <StringDetect String="classDef" attribute="Keyword" context="Quadrant_KwClassDef"+                      insensitive="1"/>+        <StringDetect String="quadrantChart" attribute="Error" insensitive="1"/>+        <StringDetect String="quadrant-1" attribute="Keyword" context="Quadrant_Text"+                      insensitive="1"/>+        <StringDetect String="quadrant-2" attribute="Keyword" context="Quadrant_Text"+                      insensitive="1"/>+        <StringDetect String="quadrant-3" attribute="Keyword" context="Quadrant_Text"+                      insensitive="1"/>+        <StringDetect String="quadrant-4" attribute="Keyword" context="Quadrant_Text"+                      insensitive="1"/>+        <StringDetect String="x-axis" attribute="Keyword" context="Quadrant_Text"+                      insensitive="1"/>+        <StringDetect String="y-axis" attribute="Keyword" context="Quadrant_Text"+                      insensitive="1"/>+        <StringDetect String="title" attribute="Keyword" context="Text_Simple" insensitive="1"/>++        <IncludeRules context="Find_Accessibility_Insensitive"/>+      </context>++      <context name="Quadrant_Text" attribute="Text" lineEndContext="#pop"+               fallthroughContext="#pop!Quadrant_Text_U">+        <DetectSpaces attribute="Normal"/>+        <StringDetect String='"' attribute="Quoted Text Delimiter"+                      context="#pop!Quadrant_Text_U!Quadrant_Text_Q"/>+      </context>+      <!-- in "..." -->+      <context name="Quadrant_Text_Q" attribute="Quoted Text">+        <StringDetect String='"' attribute="Quoted Text Delimiter" context="#pop"/>+        <StringDetect String="&lt;" attribute="Special Text Char"/>+        <IncludeRules context="Find_Entity"/>+      </context>+      <!-- outside or after "..." -->+      <context name="Quadrant_Text_U" attribute="Text" lineEndContext="#pop">+        <StringDetect String="-->" attribute="Link" context="#pop!Quadrant_Text"/>+        <IncludeRules context="Find_Any_Comment"/>+        <StringDetect String=";" attribute="Symbol Separator" context="#pop"/>+        <AnyChar String="&quadrant_invalid_char;" attribute="Error"/>+        <RegExpr String="&quadrant_text;" insensitive="1"/>+        <StringDetect String="classDef" attribute="Keyword" insensitive="1"/>+        <StringDetect String="quadrantChart" attribute="Error" insensitive="1"/>+        <StringDetect String="quadrant-1" attribute="Keyword" insensitive="1"/>+        <StringDetect String="quadrant-2" attribute="Keyword" insensitive="1"/>+        <StringDetect String="quadrant-3" attribute="Keyword" insensitive="1"/>+        <StringDetect String="quadrant-4" attribute="Keyword" insensitive="1"/>+        <StringDetect String="x-axis" attribute="Keyword" insensitive="1"/>+        <StringDetect String="y-axis" attribute="Keyword" insensitive="1"/>+        <StringDetect String="title" attribute="Keyword" insensitive="1"/>+      </context>++      <!-- Point A:::class: [0.9, 0.0] radius: 12+             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+      -->+      <context name="Quadrant_Point_Name" attribute="Node" lineEndContext="#pop">+        <StringDetect String=":::" attribute="Class Name Delimiter"+                      context="#pop!Quadrant_Point_ClassName"/>+        <StringDetect String=":" attribute="Node Separator" context="#pop!Quadrant_Point_XY"/>+        <IncludeRules context="Quadrant_Text_U"/>+      </context>+      <!-- Point A:::class: [0.9, 0.0] radius: 12+                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~+      -->+      <context name="Quadrant_Point_ClassName" attribute="Error" lineEndContext="#pop">+        <AnyChar String=":[" attribute="Error" context="#pop!Quadrant_Point_XY"/>+        <DetectIdentifier attribute="Class Name" context="Quadrant_Point_AfterClassName"/>+        <StringDetect String=";" attribute="Error" context="#pop"/>+      </context>+      <context name="Quadrant_Point_AfterClassName" attribute="Error" lineEndContext="#pop#pop">+        <StringDetect String=":" attribute="Node Separator"+                      context="#pop#pop!Quadrant_Point_XY"/>+        <DetectSpaces attribute="Normal"/>+        <StringDetect String=";" attribute="Error" context="#pop#pop"/>+        <RegExpr String="." attribute="Error" context="#pop#pop!Quadrant_Point_XY"/>+      </context>++      <!-- Point A:::class: [0.9, 0.0] radius: 12+                           ~~~~~~~~~~~~~~~~~~~~~~+      -->+      <context name="Quadrant_Point_XY" attribute="Normal" lineEndContext="#pop">+        <DetectSpaces attribute="Normal"/>+        <Float attribute="Number"/>+        <AnyChar String="01" attribute="Number"/>+        <StringDetect String="[" attribute="Shape"/>+        <StringDetect String="," attribute="List Separator"/>+        <StringDetect String="]" attribute="Shape" context="Quadrant_CSS"/>+        <StringDetect String=";" attribute="Error" context="#pop"/>+      </context>++      <!-- classDef class1 color: #109060+                   ~~~~~~~~~~~~~~~~~~~~~~+      -->+      <context name="Quadrant_KwClassDef" attribute="Error" lineEndContext="#pop">+        <DetectSpaces attribute="Normal"/>+        <DetectIdentifier attribute="Class Name" context="Quadrant_CSS"/>+      </context>++      <!-- Point A:::class: [0.9, 0.0] radius: 12 / classDef class1 color: #109060+                                      ~~~~~~~~~~~                  ~~~~~~~~~~~~~~~+      -->+      <context name="Quadrant_CSS" attribute="Normal" lineEndContext="#pop#pop">+        <DetectSpaces attribute="Normal"/>+        <WordDetect String="color" attribute="Style Property"/>+        <WordDetect String="radius" attribute="Style Property"/>+        <WordDetect String="stroke-width" attribute="Style Property"/>+        <WordDetect String="stroke-color" attribute="Style Property"/>+        <StringDetect String=":" attribute="Style Property Separator"+                      context="Quadrant_CSSValue"/>+        <StringDetect String=";" attribute="Symbol Separator" context="#pop#pop"/>+      </context>+      <context name="Quadrant_CSSValue" attribute="Error"+               lineEndContext="#pop#pop#pop">+        <DetectSpaces attribute="Normal"/>+        <StringDetect String="," attribute="List Separator" context="#pop"/>+        <Float attribute="Number" context="Flowchart_CSSUnit"/>+        <Int attribute="Number" context="Flowchart_CSSUnit"/>+        <RegExpr String="#[a-zA-Z0-9]{3}([a-zA-Z0-9]{3})?(?!;)"+                 attribute="Style Hexadeximal Color"/>+        <StringDetect String=";" attribute="Symbol Separator" context="#pop#pop#pop"/>+      </context>++      <!--+      @} Quadrant Chart+      -->+++      <!--+      @{ Requirement Diagram+      -->++      <context name="Requirement" attribute="Error" lineEndContext="Requirement_Body">+      </context>++      <context name="Requirement_Body" attribute="Error">+        <DetectSpaces attribute="Normal"/>++        <StringDetect String="{" attribute="Curly Bracket Block Delimiter" beginRegion="block"+                      context="Requirement_Element_Mem!SpacesAsError"/>+        <StringDetect String=":::" attribute="Class Name Delimiter"+                      context="Requirement_ClassName!Requirement_ClassName_Special!Requirement_Consume_PartialNode"/>+        <IncludeRules context="Flowchart_Find_UnicodeText"/>+        <StringDetect String="->" attribute="Link"/>+        <StringDetect String="&lt;-" attribute="Link"+                      context="Requirement_Link_LeftEnd!Requirement_Relationship"/>+        <StringDetect String="-" attribute="Link"+                      context="Requirement_Link_RightEnd!Requirement_Relationship"/>++        <IncludeRules context="Requirement_Find_Comment"/>++        <AnyChar String="*$\#&amp;}&lt;>:%=," attribute="Error"/>+        <StringDetect String="_" attribute="Special Text Char"+                      context="Requirement_Node!Md_bi"/>+        <RegExpr String="&requirement_node;" attribute="Node" insensitive="1"+                 context="Requirement_Node!Requirement_Node_Special"/>++        <StringDetect String="element" attribute="Keyword" insensitive="1"+                      context="Requirement_Node!Requirement_Node_Special!Requirement_Consume_PartialNode"/>+        <StringDetect String="requirement" attribute="Keyword" insensitive="1"+                      context="Requirement_KwRequirement!Requirement_Node_Special!Requirement_Consume_PartialNode"/>+        <StringDetect String="functionalRequirement" attribute="Keyword" insensitive="1"+                      context="Requirement_KwRequirement!Requirement_Node_Special!Requirement_Consume_PartialNode"/>+        <StringDetect String="performanceRequirement" attribute="Keyword" insensitive="1"+                      context="Requirement_KwRequirement!Requirement_Node_Special!Requirement_Consume_PartialNode"/>+        <StringDetect String="interfaceRequirement" attribute="Keyword" insensitive="1"+                      context="Requirement_KwRequirement!Requirement_Node_Special!Requirement_Consume_PartialNode"/>+        <StringDetect String="physicalRequirement" attribute="Keyword" insensitive="1"+                      context="Requirement_KwRequirement!Requirement_Node_Special!Requirement_Consume_PartialNode"/>+        <StringDetect String="designConstraint" attribute="Keyword" insensitive="1"+                      context="Requirement_KwRequirement!Requirement_Node_Special!Requirement_Consume_PartialNode"/>++        <StringDetect String="classDef" attribute="Keyword" insensitive="1"+                      context="Flowchart_CSSProp!Requirement_ClassList!Requirement_ClassList_Special!Requirement_Consume_PartialRef"/>+        <StringDetect String="style" attribute="Keyword" insensitive="1"+                      context="Flowchart_CSSProp!Requirement_NodeList!Requirement_NodeList_Special!Requirement_Consume_PartialRef"/>+        <StringDetect String="class" attribute="Keyword" insensitive="1"+                      context="Requirement_ClassList!Requirement_ClassList_Special!Requirement_Consume_PartialRef!Requirement_NoCssSep!Requirement_NodeList!Requirement_NodeList_Special!Requirement_Consume_PartialRef"/>++        <IncludeRules context="Find_Accessibility_Insensitive"/>++        <DetectIdentifier attribute="Error"/>+      </context>++      <!-- mermaid bug: comment is not %% -->+      <context name="Requirement_Find_Comment" attribute="Node">+        <StringDetect String="%" attribute="Comment" context="Comment" firstNonSpace="1"/>+      </context>++      <!--+      node:::classname+      node - bla -> node+      node <- bla - node+        ~~+      -->+      <context name="Requirement_Node" attribute="Node" lineEndContext="#pop"+               fallthroughContext="Requirement_Node_Special">+        <StringDetect String="{" attribute="Curly Bracket Block Delimiter" beginRegion="block"+                      context="#pop!Requirement_Element_Mem!SpacesAsError"/>+        <StringDetect String=":::" attribute="Class Name Delimiter"+                      context="Requirement_ClassName!Requirement_ClassName_Special!Requirement_Consume_PartialNode"/>+        <AnyChar String=":=," attribute="Error"/>+        <RegExpr String="&requirement_node_in_node;" attribute="Node" insensitive="1"+                 context="Requirement_Node_Special"/>+      </context>++      <context name="Requirement_Node_Special" attribute="Node" lineEndContext="#pop#pop"+               fallthroughContext="#pop">+        <AnyChar String="{:" lookAhead="1" context="#pop"/>+        <StringDetect String="->" attribute="Link" context="#pop#pop"/>+        <StringDetect String="&lt;-" attribute="Link"+                      context="#pop#pop!Requirement_Link_LeftEnd!Requirement_Relationship"/>+        <StringDetect String="-" attribute="Link"+                      context="#pop#pop!Requirement_Link_RightEnd!Requirement_Relationship"/>+        <AnyChar String="=,-&lt;>:{" attribute="Error" context="#pop"/>+        <IncludeRules context="Find_Md_Syms_ThenPop"/>+      </context>++      <context name="Requirement_Consume_PartialNode" attribute="Normal"+               lineEndContext="#pop#pop#pop">+        <DetectSpaces attribute="Normal"/>+        <IncludeRules context="Flowchart_Find_UnicodeText_ThenPop2"/>+        <StringDetect String="{" context="#pop#pop" lookAhead="1"/>+        <StringDetect String="_" attribute="Special Text Char" context="#pop#pop!Md_bi"/>+        <AnyChar String="*$\#&amp;}%:=," attribute="Error" context="#pop#pop"/>+        <RegExpr String="&requirement_node;" insensitive="1" context="#pop"/>+        <DetectIdentifier attribute="Error" context="#pop#pop"/>+        <IncludeRules context="CharErrorAndPop2"/>+      </context>++      <!-- node:::classname+                  ~~~~~~~~~+      -->+      <context name="Requirement_ClassName" attribute="Class Name"+               lineEndContext="#pop" fallthroughContext="Requirement_ClassName_Special">+        <StringDetect String="{" lookAhead="1" context="#pop"/>+        <StringDetect String=":" attribute="Error"/>+        <RegExpr String="&requirement_node_in_node;" attribute="Node" insensitive="1"+                 context="Requirement_ClassName_Special"/>+      </context>+      <context name="Requirement_ClassName_Special" attribute="Class Name"+               lineEndContext="#pop#pop" fallthroughContext="#pop">+        <IncludeRules context="Requirement_Node_Special"/>+      </context>++      <!-- node - type -> node+                 ~~~~~+      -->+      <context name="Requirement_Relationship" attribute="Text" lineEndContext="#pop"+               fallthroughContext="#pop">+        <DetectSpaces attribute="Normal"/>+        <WordDetect String="contains" attribute="Keyword Parameter" context="#pop"/>+        <WordDetect String="copies" attribute="Keyword Parameter" context="#pop"/>+        <WordDetect String="derives" attribute="Keyword Parameter" context="#pop"/>+        <WordDetect String="satisfies" attribute="Keyword Parameter" context="#pop"/>+        <WordDetect String="verifies" attribute="Keyword Parameter" context="#pop"/>+        <WordDetect String="refines" attribute="Keyword Parameter" context="#pop"/>+        <WordDetect String="traces" attribute="Keyword Parameter" context="#pop"/>+      </context>++      <!-- node - type -> node+                      ~~~+      -->+      <context name="Requirement_Link_RightEnd" attribute="Error" lineEndContext="#pop">+        <DetectSpaces attribute="Normal"/>+        <StringDetect String="->" attribute="Link" context="#pop"/>+        <AnyChar String="&lt;-" attribute="Error" context="#pop"/>+        <DetectIdentifier/>+      </context>++      <!-- node <- type - node+                       ~~+      -->+      <context name="Requirement_Link_LeftEnd" attribute="Error" lineEndContext="#pop">+        <DetectSpaces attribute="Normal"/>+        <StringDetect String="->" attribute="Error" context="#pop"/>+        <StringDetect String="-" attribute="Link" context="#pop"/>+        <StringDetect String="&lt;-" attribute="Error" context="#pop"/>+        <DetectIdentifier/>+      </context>++      <!-- element ... { type: blabla+                        ~~~~~~~~~~~~~+      -->+      <context name="Requirement_Element_Mem" attribute="Error">+        <DetectSpaces attribute="Normal"/>+        <StringDetect String=":" attribute="Property Separator" context="Requirement_Mem_Text"/>+        <StringDetect String="}" attribute="Curly Bracket Block Delimiter" endRegion="block"+                      context="#pop"/>+        <IncludeRules context="Requirement_Find_Comment"/>+        <WordDetect String="docref" attribute="Property" insensitive="1"/>+        <WordDetect String="type" attribute="Property" insensitive="1"/>+      </context>+      <!-- element ... { type: blabla+                              ~~~~~~~+      -->+      <context name="Requirement_Mem_Text" attribute="Error" lineEndContext="#pop">+        <DetectSpaces attribute="Normal"/>+        <IncludeRules context="Flowchart_Find_UnicodeText_ThenPop"/>+        <StringDetect String="_" attribute="Special Text Char"+                      context="Requirement_Mem_InText!Md_bi"/>+        <RegExpr String="&requirement_node;" attribute="Text" insensitive="1"+                 context="Requirement_Mem_InText!Requirement_Text_Special"/>+        <DetectIdentifier attribute="Error" context="Requirement_Mem_InText"/>+      </context>+      <context name="Requirement_Mem_InText" attribute="Error"+               lineEndContext="#pop#pop" fallthroughContext="Requirement_Text_Special">+        <AnyChar String="-&lt;>:{=," attribute="Error"/>+        <RegExpr String="&requirement_node_in_node;" attribute="Text" insensitive="1"+                 context="Requirement_Text_Special"/>+      </context>+      <context name="Requirement_Text_Special" attribute="Node" lineEndContext="#pop#pop"+               fallthroughContext="#pop">+        <AnyChar String="=,-&lt;>:{" attribute="Error" context="#pop"/>+        <IncludeRules context="Find_MdText_Syms_ThenPop"/>+      </context>++      <!-- requirement ... {+                        ~~~+      -->+      <context name="Requirement_KwRequirement" attribute="Node" lineEndContext="#pop"+               fallthroughContext="Requirement_Node_Special">+        <StringDetect String="{" attribute="Curly Bracket Block Delimiter" beginRegion="block"+                      context="#pop!Requirement_Requirement_Mem!SpacesAsError"/>+        <IncludeRules context="Requirement_Node"/>+      </context>++      <!-- requirement ... { type: blabla+                            ~~~~~~~~~~~~~+      -->+      <context name="Requirement_Requirement_Mem" attribute="Error">+        <DetectSpaces attribute="Normal"/>+        <StringDetect String=":" attribute="Property Separator" context="Requirement_Mem_Text"/>+        <StringDetect String="}" attribute="Curly Bracket Block Delimiter" endRegion="block"+                      context="#pop"/>+        <IncludeRules context="Requirement_Find_Comment"/>+        <WordDetect String="id" attribute="Property" insensitive="1"/>+        <WordDetect String="text" attribute="Property" insensitive="1"/>+        <WordDetect String="risk" attribute="Property" insensitive="1"+                    context="Requirement_KwRequirement_Risk!Requirement_Consume_Prop"/>+        <WordDetect String="verifymethod" attribute="Property" insensitive="1"+                    context="Requirement_KwRequirement_VerifyMethod!Requirement_Consume_Prop"/>+      </context>+      <!-- requirement ... { type: blabla+                                 ~+      -->+      <context name="Requirement_Consume_Prop" attribute="Error" fallthroughContext="#pop#pop">+        <DetectSpaces attribute="Normal"/>+        <StringDetect String=":" attribute="Property Separator" context="#pop"/>+      </context>+      <!-- requirement ... { risk: kw+                                  ~~~+      -->+      <context name="Requirement_KwRequirement_Risk" attribute="Error"+               lineEndContext="#pop" fallthroughContext="#pop!LineError">+        <DetectSpaces attribute="Normal"/>+        <WordDetect String="Low" attribute="Keyword Parameter" insensitive="1"+                    context="#pop!LineError"/>+        <WordDetect String="Medium" attribute="Keyword Parameter" insensitive="1"+                    context="#pop!LineError"/>+        <WordDetect String="High" attribute="Keyword Parameter" insensitive="1"+                    context="#pop!LineError"/>+      </context>+      <!-- requirement ... { verifymethod: kw+                                          ~~~+      -->+      <context name="Requirement_KwRequirement_VerifyMethod" attribute="Error"+               lineEndContext="#pop" fallthroughContext="#pop!LineError">+        <DetectSpaces attribute="Normal"/>+        <WordDetect String="Analysis" attribute="Keyword Parameter" insensitive="1"+                    context="#pop!LineError"/>+        <WordDetect String="Inspection" attribute="Keyword Parameter" insensitive="1"+                    context="#pop!LineError"/>+        <WordDetect String="Test" attribute="Keyword Parameter" insensitive="1"+                    context="#pop!LineError"/>+        <WordDetect String="Demonstration" attribute="Keyword Parameter" insensitive="1"+                    context="#pop!LineError"/>+      </context>++      <!-- style className,"className" fill:#314+                ~~~~~~~~~~~~~~~~~~~~~~~+      -->+      <context name="Requirement_NodeList" attribute="Node" lineEndContext="#pop#pop"+               fallthroughContext="Requirement_NodeList_Special">+        <StringDetect String="," attribute="List Separator"+                      context="Requirement_NodeList_Special!Requirement_Consume_PartialRef"/>+        <IncludeRules context="Requirement_Style_Common"/>+        <RegExpr String="&requirement_node_in_ref;" attribute="Node" insensitive="1"+                 context="Requirement_NodeList_Special"/>+      </context>+      <context name="Requirement_Style_Common" attribute="Node">+        <DetectSpaces attribute="Normal" context="Requirement_NodeListOrPop"/>+        <StringDetect String=":" lookAhead="1" context="#pop"/>+        <AnyChar String="=-&lt;>{" attribute="Error"/>+      </context>++      <context name="Requirement_NodeList_Special" attribute="Node"+               lineEndContext="#pop#pop#pop" fallthroughContext="#pop">+        <AnyChar String=":," lookAhead="1" context="#pop"/>+        <IncludeRules context="Requirement_Text_Special"/>+      </context>++      <context name="Requirement_NodeListOrPop" attribute="Node" lineEndContext="#pop#pop#pop"+               fallthroughContext="#pop#pop">+        <StringDetect String="," context="#pop" lookAhead="1"/>+      </context>+      <context name="Requirement_QNodeListOrPop" attribute="Node"+               lineEndContext="#pop#pop#pop#pop#pop"+               fallthroughContext="#pop#pop#pop#pop">+        <DetectSpaces attribute="Normal"/>+        <StringDetect String="," attribute="List Separator" context="#pop"/>+      </context>++      <context name="Requirement_Consume_PartialRef" attribute="Normal"+               lineEndContext="#pop#pop#pop#pop">+        <DetectSpaces attribute="Normal"/>+        <StringDetect String='"' attribute="Quoted Text Delimiter"+                      context="Requirement_QNodeListOrPop!Flowchart_UnicodeText"/>+        <StringDetect String="," attribute="List Separator"/>+        <StringDetect String=":" context="#pop#pop" lookAhead="1"/>+        <StringDetect String="_" attribute="Special Text Char" context="#pop#pop!Md_bi"/>+        <AnyChar String="*$\#&amp;}%={" attribute="Error" context="#pop#pop"/>+        <RegExpr String="&requirement_ref;" insensitive="1" context="#pop"/>+        <DetectIdentifier attribute="Error" context="#pop#pop"/>+        <IncludeRules context="CharErrorAndPop2"/>+      </context>++      <!-- classDef className,"className" fill:#f9f+                    ~~~~~~~~~~~~~~~~~~~~~+      -->+      <context name="Requirement_ClassList" attribute="Class Name" lineEndContext="#pop#pop"+               fallthroughContext="Requirement_ClassList_Special">+        <StringDetect String="," attribute="List Separator"+                      context="Requirement_ClassList_Special!Requirement_Consume_PartialRef"/>+        <IncludeRules context="Requirement_Style_Common"/>+        <RegExpr String="&requirement_node_in_ref;" attribute="Class Name" insensitive="1"+                 context="Requirement_ClassList_Special"/>+      </context>++      <context name="Requirement_ClassList_Special" attribute="Class Name"+               lineEndContext="#pop#pop#pop" fallthroughContext="#pop">+        <AnyChar String=":," lookAhead="1" context="#pop"/>+        <IncludeRules context="Requirement_Text_Special"/>+      </context>++      <!-- class : ...+                 ~+      -->+      <context name="Requirement_NoCssSep" attribute="Error" lineEndContext="#pop#pop#pop#pop"+               fallthroughContext="#pop">+        <StringDetect String=":" attribute="Error"+                      context="Requirement_NodeList!Requirement_NodeList_Special!Requirement_Consume_PartialRef"/>+      </context>++      <!--+      @} Requirement Diagram+      -->+++      <!--+      @{ GitGraph Diagram+      -->++      <context name="Git" attribute="Error" lineEndContext="Git_Body"+               fallthroughContext="Git_Body">+        <DetectSpaces attribute="Normal"/>+        <StringDetect String=":" attribute="Property Separator" context="Git_Body"/>+        <WordDetect String="LR" attribute="Keyword Parameter"/>+        <WordDetect String="TB" attribute="Keyword Parameter"/>+        <WordDetect String="BT" attribute="Keyword Parameter"/>+        <IncludeRules context="Find_Any_Comment"/>+      </context>++      <context name="Git_Body" attribute="Error">+        <DetectSpaces attribute="Normal"/>+        <IncludeRules context="Find_Any_Comment"/>+        <IncludeRules context="Find_Quote_Simple"/>++        <WordDetect String="commit" attribute="Keyword" context="Git_KwCommit"/>+        <WordDetect String="branch" attribute="Keyword" context="Git_KwBranch"+                    additionalDeliminator="&quot;'"/>+        <WordDetect String="switch" attribute="Keyword" context="Git_KwSwitch"+                    additionalDeliminator="&quot;'"/>+        <WordDetect String="checkout" attribute="Keyword" context="Git_KwSwitch"+                    additionalDeliminator="&quot;'"/>+        <WordDetect String="merge" attribute="Keyword" context="Git_KwMerge"+                    additionalDeliminator="&quot;'"/>+        <WordDetect String="cherry-pick" attribute="Keyword" context="Git_KwCherryPick"/>++        <IncludeRules context="Find_Accessibility"/>+        <DetectIdentifier attribute="Error"/>+      </context>++      <!-- commit id:"ash" tag:"v1.0.0" type: REVERSE -->+      <context name="Git_KwCommit" attribute="Error" lineEndContext="#pop">+        <DetectSpaces attribute="Normal"/>+        <StringDetect String=":" attribute="Property Separator"/>+        <IncludeRules context="Find_Quote_Simple"/>+        <IncludeRules context="Find_Any_Comment"/>+        <WordDetect String="id" attribute="Property"/>+        <WordDetect String="tag" attribute="Property"/>+        <WordDetect String="type" attribute="Property"/>+        <WordDetect String="NORMAL" attribute="Keyword Parameter"/>+        <WordDetect String="REVERSE" attribute="Keyword Parameter"/>+        <WordDetect String="HIGHLIGHT" attribute="Keyword Parameter"/>+        <DetectIdentifier/>+      </context>++      <!-- branch"develop" / branch develop order: 3 -->+      <context name="Git_KwBranch" attribute="Error" lineEndContext="#pop">+        <DetectSpaces attribute="Normal"/>+        <StringDetect String='"' attribute="Quoted Text Delimiter"+                      context="Git_KwBranchOrder!DQuote_Simple"/>+        <StringDetect String="'" attribute="Quoted Text Delimiter"+                      context="Git_KwBranchOrder!SQuote_Simple"/>+        <IncludeRules context="Find_Any_Comment"/>+        <IncludeRules context="Git_Kw_Error"/>+        <IncludeRules context="Git_Value_Error"/>+        <DetectIdentifier context="Git_KwBranchOrder!Git_TextIdent" attribute="Text"/>+      </context>+      <context name="Git_KwBranchOrder" attribute="Error" lineEndContext="#pop#pop"+               fallthroughContext="Git_EndLine">+        <DetectSpaces attribute="Normal"/>+        <WordDetect String="order" attribute="Property"/>+        <StringDetect String=":" attribute="Property Separator"/>+        <Int attribute="Keyword Parameter"/>+        <DetectIdentifier attribute="Error"/>+      </context>++      <!-- switch"develop" / checkout develop -->+      <context name="Git_KwSwitch" attribute="Error" lineEndContext="#pop">+        <DetectSpaces attribute="Normal"/>+        <IncludeRules context="Find_Quote_Simple"/>+        <IncludeRules context="Find_Any_Comment"/>+        <IncludeRules context="Git_Kw_Error"/>+        <IncludeRules context="Git_Value_Error"/>+        <DetectIdentifier context="Git_EndLine!Git_TextIdent" attribute="Text"/>+      </context>++      <!-- merge develop id: "my_custom_id" tag: "my_custom_tag" type: REVERSE -->+      <context name="Git_KwMerge" attribute="Error" lineEndContext="#pop">+        <DetectSpaces attribute="Normal"/>+        <StringDetect String='"' attribute="Quoted Text Delimiter"+                      context="#pop!Git_KwCommit!DQuote_Simple"/>+        <StringDetect String="'" attribute="Quoted Text Delimiter"+                      context="#pop!Git_KwCommit!SQuote_Simple"/>+        <IncludeRules context="Find_Quote_Simple"/>+        <IncludeRules context="Find_Any_Comment"/>+        <WordDetect String="id" attribute="Property" context="#pop!Git_KwCommit"/>+        <WordDetect String="tag" attribute="Property" context="#pop!Git_KwCommit"/>+        <WordDetect String="type" attribute="Property" context="#pop!Git_KwCommit"/>+        <IncludeRules context="Git_Kw_Error"/>+        <WordDetect String="NORMAL" attribute="Keyword Parameter" context="#pop!Git_KwCommit"+                    additionalDeliminator="@#$`&quot;'" weakDeliminator="-"/>+        <WordDetect String="REVERSE" attribute="Keyword Parameter" context="#pop!Git_KwCommit"+                    additionalDeliminator="@#$`&quot;'" weakDeliminator="-"/>+        <WordDetect String="HIGHLIGHT" attribute="Keyword Parameter" context="#pop!Git_KwCommit"+                    additionalDeliminator="@#$`&quot;'" weakDeliminator="-"/>+        <DetectIdentifier context="#pop!Git_KwCommit!Git_TextIdent" attribute="Text"/>+      </context>++      <!-- cherry-pick id:"MERGE" parent:"B" -->+      <context name="Git_KwCherryPick" attribute="Error" lineEndContext="#pop">+        <DetectSpaces attribute="Normal"/>+        <StringDetect String=":" attribute="Property Separator"/>+        <IncludeRules context="Find_Quote_Simple"/>+        <IncludeRules context="Find_Any_Comment"/>+        <WordDetect String="id" attribute="Property"/>+        <WordDetect String="parent" attribute="Property"/>+        <DetectIdentifier/>+      </context>++      <context name="Git_TextIdent" attribute="Error" lineEndContext="#pop#pop">+        <AnyChar String="-" attribute="Text"/>+        <Int attribute="Text"/>+        <DetectIdentifier attribute="Text"/>+        <IncludeRules context="Find_Any_Comment"/>+        <DetectSpaces attribute="Normal" context="#pop"/>+      </context>++      <context name="Git_EndLine" attribute="Error" lineEndContext="#pop#pop">+        <DetectSpaces attribute="Normal"/>+        <IncludeRules context="Find_Any_Comment"/>+      </context>++      <context name="Git_Kw_Error" attribute="Error">+        <WordDetect String="gitGraph" attribute="Error"+                    additionalDeliminator="@#$`&quot;'" weakDeliminator="-"/>+        <WordDetect String="commit" attribute="Error"+                    additionalDeliminator="@#$`&quot;'" weakDeliminator="-"/>+        <WordDetect String="branch" attribute="Error"+                    additionalDeliminator="@#$`&quot;'" weakDeliminator="-"/>+        <WordDetect String="checkout" attribute="Error"+                    additionalDeliminator="@#$`&quot;'" weakDeliminator="-"/>+        <WordDetect String="switch" attribute="Error"+                    additionalDeliminator="@#$`&quot;'" weakDeliminator="-"/>+        <WordDetect String="merge" attribute="Error"+                    additionalDeliminator="@#$`&quot;'" weakDeliminator="-"/>+        <WordDetect String="cherry-pick" attribute="Error"+                    additionalDeliminator="@#$`&quot;'" weakDeliminator="-"/>+      </context>+      <context name="Git_Value_Error" attribute="Error">+        <WordDetect String="NORMAL" attribute="Error"+                    additionalDeliminator="@#$`&quot;'" weakDeliminator="-"/>+        <WordDetect String="REVERSE" attribute="Error"+                    additionalDeliminator="@#$`&quot;'" weakDeliminator="-"/>+        <WordDetect String="HIGHLIGHT" attribute="Error"+                    additionalDeliminator="@#$`&quot;'" weakDeliminator="-"/>+      </context>++      <!--+      @} GitGraph Diagram+      -->+++      <!--+      @{ Mindmap+      -->++      <context name="Mindmap" attribute="Error" fallthroughContext="Mindmap_Node">+        <DetectSpaces attribute="Normal"/>+        <IncludeRules context="Find_Comment"/>+        <StringDetect String=":::" attribute="Class Name Delimiter" context="Mindmap_Class"/>+        <StringDetect String="::icon(" attribute="Annotation Delimiter" context="Mindmap_Icon"/>+        <WordDetect String="mindmap" attribute="Error" insensitive="1"+                    additionalDeliminator="@#$`&quot;'" context="Mindmap_Node"/>+      </context>++      <context name="Mindmap_Node" attribute="Node" lineEndContext="#pop"+               fallthroughContext="Mindmap_Node_Special">+        <DetectSpaces/>+        <RegExpr String="([^&md_syms;{}\[\]()]++|&md_sym_no_md;)++" attribute="Node"+                 context="Mindmap_Node_Special"/>+      </context>+      <context name="Mindmap_Node_Special" attribute="Text" lineEndContext="#pop">+        <StringDetect String="[" attribute="Shape"+                      context="Mindmap_Text[]!Mindmap_End[]!Mindmap_QText"/>+        <StringDetect String="((" attribute="Shape"+                      context="Mindmap_Text(())!Mindmap_End(())!Mindmap_QText"/>+        <StringDetect String="))" attribute="Shape"+                      context="Mindmap_Text))((!Mindmap_End))((!Mindmap_QText"/>+        <StringDetect String="(" attribute="Shape"+                      context="Mindmap_Text()!Mindmap_End()!Mindmap_QText"/>+        <StringDetect String=")" attribute="Shape"+                      context="Mindmap_Text)(!Mindmap_End)(!Mindmap_QText"/>+        <StringDetect String="{{" attribute="Shape"+                      context="Mindmap_Text{{}}!Mindmap_End{{}}!Mindmap_QText"/>+        <AnyChar String="(){}[]" attribute="Error"/>+        <IncludeRules context="Find_Md_Syms_ThenPop"/>+        <IncludeRules context="Find_Md_Html_Text_ThenPop"/>+      </context>++      <context name="Mindmap_QText" attribute="Text" lineEndContext="#pop#pop"+               fallthroughContext="#pop#pop">+        <IncludeRules context="Flowchart_QText"/>+      </context>++      <context name="Mindmap_Text_Common" attribute="Text">+        <AnyChar String="()}]" attribute="Error"/>+        <IncludeRules context="Find_Comment_InText"/>+        <RegExpr String="([^&md_syms;}\]()]++|&md_sym_no_md;)++" attribute="Text"+                 context="Mindmap_Text_Common_Special"/>+      </context>+      <context name="Mindmap_Text_Common_Special" attribute="Text">+        <AnyChar String="()}]" lookAhead="1" context="#pop"/>+        <IncludeRules context="Find_Md_Syms_ThenPop"/>+        <IncludeRules context="Find_Md_Html_Text_ThenPop"/>+      </context>++      <context name="Mindmap_TextEnd_Common" attribute="Text">+        <DetectSpaces attribute="Error" context="Mindmap_TextEnd_SymOrReset"/>+        <DetectIdentifier attribute="Error" context="#pop#pop"/>+        <Int attribute="Error" context="#pop#pop"/>+        <AnyChar String="(){}[]" context="#pop#pop" lookAhead="1"/>+      </context>+      <context name="Mindmap_TextEnd_SymOrReset" attribute="Text"+               lineEndContext="#pop#pop#pop"+               fallthroughContext="#pop#pop#pop">+        <AnyChar String="()}]" context="#pop" lookAhead="1"/>+      </context>+++      <!-- id[I am a square]+              ~~~~~~~~~~~~~~ -->+      <context name="Mindmap_Text[]" attribute="Text">+        <StringDetect String="]" attribute="Shape" context="Mindmap_AfterNode"/>+        <IncludeRules context="Mindmap_Text_Common"/>+      </context>+      <!-- id["I am a square"]+                             ~ -->+      <context name="Mindmap_End[]" attribute="Text" fallthroughContext="#pop#pop#pop#pop">+        <StringDetect String="]" attribute="Shape" context="#pop!Mindmap_AfterNode"/>+        <IncludeRules context="Mindmap_TextEnd_Common"/>+      </context>++      <!-- id(I am a rounded square)+              ~~~~~~~~~~~~~~~~~~~~~~ -->+      <context name="Mindmap_Text()" attribute="Text">+        <StringDetect String=")" attribute="Shape" context="Mindmap_AfterNode"/>+        <IncludeRules context="Mindmap_Text_Common"/>+      </context>+      <!-- id(I am a rounded square)+              ~~~~~~~~~~~~~~~~~~~~~~ -->+      <context name="Mindmap_End()" attribute="Text" fallthroughContext="#pop#pop#pop#pop">+        <StringDetect String=")" attribute="Shape" context="#pop!Mindmap_AfterNode"/>+        <IncludeRules context="Mindmap_TextEnd_Common"/>+      </context>++      <!-- id((I am a circle))+              ~~~~~~~~~~~~~~~~ -->+      <context name="Mindmap_Text(())" attribute="Text">+        <StringDetect String="))" attribute="Shape" context="Mindmap_AfterNode"/>+        <IncludeRules context="Mindmap_Text_Common"/>+      </context>+      <!-- id((I am a circle))+              ~~~~~~~~~~~~~~~~ -->+      <context name="Mindmap_End(())" attribute="Text" fallthroughContext="#pop#pop#pop#pop">+        <StringDetect String="))" attribute="Shape" context="#pop!Mindmap_AfterNode"/>+        <IncludeRules context="Mindmap_TextEnd_Common"/>+      </context>++      <!-- id)I am a cloud(+              ~~~~~~~~~~~~~ -->+      <context name="Mindmap_Text)(" attribute="Text">+        <StringDetect String="(" attribute="Shape" context="Mindmap_AfterNode"/>+        <IncludeRules context="Mindmap_Text_Common"/>+      </context>+      <!-- id)I am a cloud(+              ~~~~~~~~~~~~~ -->+      <context name="Mindmap_End)(" attribute="Text" fallthroughContext="#pop#pop#pop#pop">+        <StringDetect String="(" attribute="Shape" context="#pop!Mindmap_AfterNode"/>+        <IncludeRules context="Mindmap_TextEnd_Common"/>+      </context>++      <!-- id))I am a bang((+              ~~~~~~~~~~~~~~ -->+      <context name="Mindmap_Text))((" attribute="Text">+        <StringDetect String="((" attribute="Shape" context="Mindmap_AfterNode"/>+        <IncludeRules context="Mindmap_Text_Common"/>+      </context>+      <!-- id))I am a bang((+              ~~~~~~~~~~~~~~ -->+      <context name="Mindmap_End))((" attribute="Text" fallthroughContext="#pop#pop#pop#pop">+        <StringDetect String="((" attribute="Shape" context="#pop!Mindmap_AfterNode"/>+        <IncludeRules context="Mindmap_TextEnd_Common"/>+      </context>++      <!-- id{{I am a hexagon}}+              ~~~~~~~~~~~~~~~~~ -->+      <context name="Mindmap_Text{{}}" attribute="Text">+        <StringDetect String="}}" attribute="Shape" context="Mindmap_AfterNode"/>+        <IncludeRules context="Mindmap_Text_Common"/>+      </context>+      <!-- id{{I am a hexagon}}+              ~~~~~~~~~~~~~~~~~ -->+      <context name="Mindmap_End{{}}" attribute="Text" fallthroughContext="#pop#pop#pop#pop">+        <StringDetect String="}}" attribute="Shape" context="#pop!Mindmap_AfterNode"/>+        <IncludeRules context="Mindmap_TextEnd_Common"/>+      </context>+++      <!-- id[I am a square]+                            ~~~ -->+      <context name="Mindmap_AfterNode" attribute="Error" lineEndContext="#pop#pop#pop#pop">+        <DetectSpaces attribute="Normal"/>+        <IncludeRules context="Find_Comment"/>+        <DetectIdentifier attribute="Error" context="#pop#pop"/>+        <Int attribute="Error" context="#pop#pop"/>+        <AnyChar String="(){}[]" context="#pop#pop" lookAhead="1"/>+      </context>++      <!-- :::class1 class2 -->+      <context name="Mindmap_Class" attribute="Class Name" lineEndContext="#pop">+      </context>++      <!-- :::class1 class2 -->+      <context name="Mindmap_Icon" attribute="Annotation">+        <StringDetect String=")" attribute="Annotation Delimiter" context="#pop"/>+      </context>++      <!--+      @} Mindmap+      -->+++      <!--+      @{ Timeline Diagram+      -->++      <context name="Timeline" attribute="Normal" fallthroughContext="Timeline_Period">+        <DetectSpaces attribute="Normal"/>+        <StringDetect String=": " attribute="Node Separator" context="Timeline_Event"/>+        <StringDetect String=":" attribute="Error"/>+        <!-- https://github.com/mermaid-js/mermaid/issues/7090 -->+        <StringDetect String="%" attribute="Comment" context="Comment" firstNonSpace="1"/>++        <WordDetect String="title" attribute="Keyword" context="Text_NoSpecial"+                    insensitive="1" weakDeliminator="!%&amp;()*+,-./:;&lt;=>?[\]^{|}~"/>+        <StringDetect String="section :" context="Timeline_Period" lookAhead="1"+                      insensitive="1" />+        <WordDetect String="section" attribute="Keyword" context="Timeline_KwSection"+                    weakDeliminator="!%&amp;()*+,-./:;&lt;=>?[\]^{|}~" insensitive="1"/>+      </context>++      <!-- {time period} : {event} : {event} -->+      <context name="Timeline_Period" attribute="Node" lineEndContext="#pop">+        <StringDetect String=": " attribute="Node Separator" context="#pop!Timeline_Event"/>+        <StringDetect String=":" attribute="Error"/>+        <IncludeRules context="Find_HTML_simple_br"/>+        <IncludeRules context="Find_Entity"/>+      </context>++      <context name="Timeline_Event" attribute="Text" lineEndContext="#pop">+        <IncludeRules context="Timeline_Period"/>+      </context>++      <context name="Timeline_KwSection" attribute="Section Text" lineEndContext="#pop">+        <IncludeRules context="Timeline_Period"/>+      </context>++      <!--+      @} Timeline Diagram+      -->+++      <!--+      @{ ZenUML+      -->++      <!-- help !!! https://github.com/mermaid-js/mermaid/issues/7154 -->+      <context name="ZenUML" attribute="Normal" fallthroughContext="Timeline_Period">+        <DetectSpaces attribute="Normal"/>++        <StringDetect String=":" attribute="Node Separator" context="ZenUML_LinkText"/>+        <StringDetect String="." attribute="Link" context="ZenUML_Method"/>+        <StringDetect String="(" attribute="Link" context="ZenUML_Message"/>+        <StringDetect String="->" attribute="Link"/>+        <StringDetect String="{" attribute="Curly Bracket Block Delimiter" beginRegion="block"/>+        <StringDetect String="}" attribute="Curly Bracket Block Delimiter" endRegion="block"/>+        <StringDetect String="//" attribute="Diagram Comment" context="ZenUML_Comment"/>+        <StringDetect String="@" attribute="Annotation" context="ZenUML_Actor"/>++        <RegExpr String="&zenuml_node;" attribute="Node"/>+        <StringDetect String="return" attribute="Keyword" context="Text_Simple"/>+        <StringDetect String="if" attribute="Keyword"/>+        <StringDetect String="else" attribute="Keyword"/>+        <StringDetect String="while" attribute="Keyword"/>+        <StringDetect String="opt" attribute="Keyword"/>+        <StringDetect String="par" attribute="Keyword"/>+        <StringDetect String="new" attribute="Keyword"/>+        <StringDetect String="try" attribute="Keyword"/>+        <StringDetect String="catch" attribute="Keyword"/>+        <StringDetect String="finally" attribute="Keyword"/>+        <StringDetect String="as" attribute="Keyword Parameter"/>+        <StringDetect String="title" attribute="Keyword" context="Text_Simple"/>+      </context>++      <context name="ZenUML_Actor" attribute="Normal" fallthroughContext="#pop">+        <DetectIdentifier attribute="Annotation" context="#pop"/>+        <Int attribute="Annotation"/>+      </context>++      <context name="ZenUML_LinkText" attribute="Link Text" lineEndContext="#pop">+      </context>++      <context name="ZenUML_Method" attribute="Link Text" lineEndContext="#pop">+        <AnyChar String="{}" context="#pop" lookAhead="1"/>+      </context>++      <context name="ZenUML_Message" attribute="Link Text" lineEndContext="#pop">+        <StringDetect String=")" attribute="Link" context="#pop"/>+        <AnyChar String="(){}" context="#pop" lookAhead="1"/>+      </context>++      <context name="ZenUML_Comment" attribute="Diagram Comment" lineEndContext="#pop"+               fallthroughContext="ZenUML_Comment_Special">+        <RegExpr String="&md_strict_text;" attribute="Diagram Comment"+                 context="ZenUML_Comment_Special"/>+      </context>+      <context name="ZenUML_Comment_Special" attribute="Diagram Comment"+               lineEndContext="#pop#pop">+        <IncludeRules context="Find_MdText_Syms_ThenPop"/>+        <IncludeRules context="Find_Md_Html_DQ_SingleLine_ThenPop"/>+      </context>++      <!--+      @} ZenUML+      -->+++      <!--+      @{ Sankey diagram+      -->++      <context name="Sankey" attribute="Error" lineEndContext="Sankey_Body">+      </context>++      <context name="Sankey_Body" attribute="Normal" fallthroughContext="Sankey_Node1">+        <DetectSpaces attribute="Normal"/>+        <IncludeRules context="Find_Comment"/>+      </context>++      <!-- Pumped ds heat,"Heating and cooling, ""commercial""",70.672 -->+      <context name="Sankey_Node1" attribute="Normal" lineEndContext="#pop"+               fallthroughContext="Sankey_Node2!Sankey_Node">+        <StringDetect String='"' attribute="Quoted Text Delimiter"+                      context="Sankey_Node2!Sankey_QNode" column="0"/>+      </context>+      <context name="Sankey_Node2" attribute="Normal" lineEndContext="#pop#pop"+               fallthroughContext="Sankey_Value!Sankey_Node">+        <StringDetect String='"' attribute="Quoted Text Delimiter"+                      context="Sankey_Value!Sankey_QNode"/>+      </context>+      <context name="Sankey_Value" attribute="Error" lineEndContext="#pop#pop#pop">+        <AnyChar String="0123456789." attribute="Number"/>+        <DetectSpaces attribute="Normal"/>+      </context>++      <context name="Sankey_Node" attribute="Node" lineEndContext="#pop">+        <StringDetect String=',' attribute="List Separator" context="#pop"/>+        <StringDetect String='"' attribute="Error"/>+      </context>++      <context name="Sankey_QNode" attribute="Quoted Text">+        <StringDetect String='""' attribute="Special Text Char"/>+        <StringDetect String='"' attribute="Quoted Text Delimiter" context="Sankey_QNode_End"/>+      </context>++      <context name="Sankey_QNode_End" attribute="Error" lineEndContext="#pop#pop#pop">+        <StringDetect String=',' attribute="List Separator" context="#pop#pop"/>+      </context>++      <!--+      @} Sankey diagram+      -->+++      <!--+      @{ XY Chart+      -->++      <context name="XYChart" attribute="Error" lineEndContext="XYChart_Body"+               fallthroughContext="XYChart_Body">+        <DetectSpaces attribute="Normal"/>+        <WordDetect String="vertical" attribute="Keyword Parameter" context="XYChart_Body"+                    insensitive="1"/>+        <WordDetect String="horizontal" attribute="Keyword Parameter" context="XYChart_Body"+                    insensitive="1"/>+      </context>++      <context name="XYChart_Body" attribute="Error">+        <DetectSpaces attribute="Normal"/>+        <IncludeRules context="Find_Comment"/>+        <StringDetect String="[" attribute="Normal"+                      context="XYChart_XAxis!XYChart_XAxis_Legend!XYChart_XAxis_Legend_Label!XYChart_Text!Spaces"/>+        <StringDetect String='"' attribute="Quoted Text Delimiter" context="DQuote_NoSpecial"/>+        <StringDetect String="title" attribute="Keyword" insensitive="1"+                      context="XYChart_Text!XYChart_QText!XYChart_IdentError3"/>+        <StringDetect String="x-axis" attribute="Keyword" insensitive="1"+                      context="XYChart_XAxis!XYChart_IdentError2"/>+        <StringDetect String="y-axis" attribute="Keyword" insensitive="1"+                      context="XYChart_YAxis!XYChart_IdentError2"/>+        <StringDetect String="bar" attribute="Keyword" insensitive="1"+                      context="XYChart_Bar!XYChart_IdentError2"/>+        <StringDetect String="line" attribute="Keyword" insensitive="1"+                      context="XYChart_Bar!XYChart_IdentError2"/>+        <IncludeRules context="Find_Accessibility_Insensitive"/>++        <DetectIdentifier/>+        <Int/>+      </context>++      <!-- keywordXXX+                  ~~~ #pop * 2 -->+      <context name="XYChart_IdentError2" attribute="Text" lineEndContext="#pop#pop"+               fallthroughContext="#pop">+        <DetectSpaces attribute="Normal" context="#pop"/>+        <DetectIdentifier attribute="Error" context="#pop#pop"/>+        <Int attribute="Error"/>+      </context>++      <!-- keywordXXX+                  ~~~ #pop * 3 -->+      <context name="XYChart_IdentError3" attribute="Text" lineEndContext="#pop#pop#pop"+               fallthroughContext="#pop">+        <DetectSpaces attribute="Normal" context="#pop"/>+        <DetectIdentifier attribute="Error" context="#pop#pop#pop"/>+        <Int attribute="Error"/>+      </context>++      <!-- y-axis title min - -> max -->+      <context name="XYChart_YAxis" attribute="Text" lineEndContext="#pop"+               fallthroughContext="XYChart_YAxis_MinMax!XYChart_Axis_Title">+        <StringDetect String='"' attribute="Quoted Text Delimiter"+                      context="XYChart_YAxis_MinMax!DQuote_NoSpecial"/>+      </context>++      <context name="XYChart_YAxis_MinMax" attribute="Normal" lineEndContext="#pop#pop"+               fallthroughContext="#pop#pop">+        <DetectSpaces attribute="Normal"/>+        <Int attribute="Number"/>+        <StringDetect String="-->" attribute="Link"/>+        <AnyChar String="-." attribute="Number"/>+      </context>++      <!--+      x-axis title min - -> max+      x-axis "title with space" [cat1, "cat2 with space", cat3]+      -->+      <context name="XYChart_XAxis" attribute="Text" lineEndContext="#pop"+               fallthroughContext="XYChart_XAxis_Legend!XYChart_Axis_Title">+        <StringDetect String='"' attribute="Quoted Text Delimiter"+                      context="XYChart_XAxis_Legend!DQuote_NoSpecial"/>+      </context>++      <context name="XYChart_XAxis_Legend" attribute="Normal" lineEndContext="#pop#pop"+               fallthroughContext="#pop!XYChart_YAxis_MinMax">+        <DetectSpaces attribute="Normal"/>+        <StringDetect String="[" attribute="Normal"+                      context="XYChart_XAxis_Legend_Label!XYChart_Text!XYChart_QText!Spaces"/>+      </context>++      <!-- x-axis "title with space" [cat1, "cat2 with space", cat3]+                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+      -->+      <context name="XYChart_XAxis_Legend_Label" attribute="Error">+        <DetectSpaces attribute="Normal"/>+        <StringDetect String="," attribute="List Separator"+                      context="XYChart_Text!XYChart_QText!Spaces"/>+        <StringDetect String="]" attribute="Normal" context="#pop#pop#pop"/>+        <StringDetect String='"' attribute="Quoted Text Delimiter" context="DQuote_NoSpecial"/>+        <DetectIdentifier attribute="Error" context="XYChart_Text!XYChart_QText!Spaces"/>+        <RegExpr String="." attribute="Error" context="XYChart_Text!XYChart_QText!Spaces"/>+      </context>++      <!-- bar [2.3, 45, .98, -3.4]+              ~~ -->+      <context name="XYChart_Bar" attribute="Normal" lineEndContext="#pop"+               fallthroughContext="#pop">+        <StringDetect String="[" attribute="Normal"+                      context="XYChart_Bar_Values"/>+      </context>++      <!-- bar [2.3, 45, .98, -3.4]+                ~~~~~~~~~~~~~~~~~~~ -->+      <context name="XYChart_Bar_Values" attribute="Normal">+        <DetectSpaces attribute="Normal"/>+        <Int attribute="Number"/>+        <AnyChar String="-." attribute="Number"/>+        <StringDetect String="," attribute="List Separator"/>+        <StringDetect String="]" attribute="Normal" context="#pop#pop"/>+      </context>++      <!-- y-axis title+                 ~~~~~~ -->+      <context name="XYChart_Axis_Title" attribute="Normal" lineEndContext="#pop#pop"+               fallthroughContext="#pop">+        <RegExpr String="&xy_title;" attribute="Text" context="#pop" insensitive="1"/>+      </context>++      <!-- title text  /  x-axis title [cat1, "cat2 with space", cat3]+                 ~~~~                  ~~~~                     ~~~~ -->+      <context name="XYChart_Text" attribute="Text" lineEndContext="#pop">+        <RegExpr String="&xy_text;" attribute="Text" context="#pop" insensitive="1"/>+      </context>++      <!-- title "text"  /  x-axis title [cat1, "cat2 with space", cat3]+                 ~~~~~~                         ~~~~~~~~~~~~~~~~~ -->+      <context name="XYChart_QText" attribute="Text" lineEndContext="#pop#pop"+               fallthroughContext="#pop">+        <StringDetect String='"' attribute="Quoted Text Delimiter"+                      context="#pop#pop!DQuote_NoSpecial"/>+      </context>++      <!--+      @} XY Chart+      -->+++      <!--+      @{ Block Diagram+      -->++      <context name="Block" attribute="Error" fallthroughContext="Block_Node!Block_Node_Spe">+        <DetectSpaces attribute="Normal"/>++        <AnyChar String='([&lt;>{-:' lookAhead="1" context="Block_Node!Block_Node_Spe"/>+        <StringDetect String='"' attribute="Quoted Text Delimiter" context="Block_QString"/>+        <AnyChar String="})" attribute="Error"/>++        <IncludeRules context="Find_Comment"/>++        <RegExpr String="&block_node;++" attribute="Node" context="Block_Node!Block_Node_Spe"/>++        <StringDetect String="space" attribute="Keyword"/>+        <StringDetect String="columns" attribute="Keyword" context="Block_KwColumns"/>+        <StringDetect String="block" attribute="Keyword" beginRegion="block"/>+        <StringDetect String="end" attribute="Keyword" endRegion="block"/>+        <StringDetect String="style" attribute="Keyword" context="Flowchart_KwStyle"/>+        <StringDetect String="classDef" attribute="Keyword" context="Flowchart_KwClassDef"/>+        <StringDetect String="class" attribute="Keyword" context="Flowchart_KwClass"/>++        <!-- no Find_Accessibility -->+      </context>+++      <context name="Block_Node" attribute="Error" lineEndContext="#pop"+               fallthroughContext="Block_Node_Spe">+        <RegExpr String="&block_in_node;++&block_node;*+" attribute="Node"+                 context="Block_Node_Spe"/>+      </context>++      <!-- columns 2 -->+      <context name="Block_QString" attribute="Quoted Text"+               fallthroughContext="Block_QString_Special">+        <StringDetect String='"' attribute="Quoted Text Delimiter" context="#pop"/>+        <IncludeRules context="Find_Any_Comment"/>+        <RegExpr String='([^&lt;&amp;#"]++|&prefix_ent_no_ent;|&prefix_html_tag_no_tag;)++'+                 attribute="Quoted Text" context='Block_QString_Special'/>+      </context>+      <context name="Block_QString_Special" attribute="Quoted Text">+        <StringDetect String='"' attribute="Quoted Text Delimiter" context="#pop#pop"/>+        <IncludeRules context="Find_Entities"/>+        <IncludeRules context="Find_Md_Html_DQ_SingleLine_ThenPop"/>+      </context>++      <context name="Block_Node_Spe" attribute="Error" lineEndContext="#pop#pop">+        <DetectSpaces attribute="Normal" context="#pop#pop"/>++        <StringDetect String="---" attribute="Link" context="#pop#pop"/>+        <StringDetect String="-->" attribute="Link" context="#pop#pop"/>+        <StringDetect String="--" attribute="Link" context="#pop#pop"/>++        <StringDetect String="([" attribute="Shape" context="Block_Shape([])!Block_InShape"/>+        <StringDetect String="(((" attribute="Shape" context="Block_Shape((()))!Block_InShape"/>+        <StringDetect String="((" attribute="Shape" context="Block_Shape(())!Block_InShape"/>+        <StringDetect String="(" attribute="Shape" context="Block_Shape()!Block_InShape"/>+        <StringDetect String="[[" attribute="Shape" context="Block_Shape[[]]!Block_InShape"/>+        <StringDetect String="[(" attribute="Shape" context="Block_Shape[()]!Block_InShape"/>+        <StringDetect String="[/" attribute="Shape" context="Block_Shape[//]!Block_InShape"/>+        <StringDetect String="[\" attribute="Shape" context="Block_Shape[//]!Block_InShape"/>+        <AnyChar String="[>" attribute="Shape" context="Block_Shape[]!Block_InShape"/>+        <StringDetect String="{{" attribute="Shape" context="Block_Shape{{}}!Block_InShape"/>+        <StringDetect String="{" attribute="Shape" context="Block_Shape{}!Block_InShape"/>+        <StringDetect String="&lt;[" attribute="Shape"+                      context="Block_Shape&lt;[]>!Block_InShape"/>++        <StringDetect String=":" attribute="Keyword Property Separator"+                      context="#pop#pop!Block_Size"/>+        <StringDetect String='"' attribute="Quoted Text Delimiter"+                      context="#pop#pop!Block_QString"/>+        <AnyChar String="-&lt;)}" attribute="Error" context="#pop#pop"/>+        <IncludeRules context="Find_Entities_ThenPop"/>+        <IncludeRules context="CharErrorAndPop2"/>+      </context>+++      <!-- id(["..."])+               ~ -->+      <context name="Block_InShape" attribute="Error" fallthroughContext="#pop">+        <StringDetect String='"' attribute="Quoted Text Delimiter"+                      context="#pop!Block_QString"/>+        <DetectSpaces attribute="Error"/>+      </context>++      <context name="Block_Shape_Common" attribute="Error">+        <DetectSpaces attribute="Error"/>+        <AnyChar String="}])" attribute="Error" context="#pop#pop#pop"/>+      </context>++      <!-- id(["..."])+                    ~~ -->+      <context name="Block_Shape([])" attribute="Error" lineEndContext="#pop#pop#pop"+               fallthroughContext="#pop#pop#pop">+        <StringDetect String="])" attribute="Shape" context="#pop#pop#pop"/>+        <IncludeRules context="Block_Shape_Common"/>+      </context>++      <!-- id((("...")))+                     ~~~ -->+      <context name="Block_Shape((()))" attribute="Error" lineEndContext="#pop#pop#pop"+               fallthroughContext="#pop#pop#pop">+        <StringDetect String=")))" attribute="Shape" context="#pop#pop#pop"/>+        <IncludeRules context="Block_Shape_Common"/>+      </context>++      <!-- id(("..."))+                    ~~ -->+      <context name="Block_Shape(())" attribute="Error" lineEndContext="#pop#pop#pop"+               fallthroughContext="#pop#pop#pop">+        <StringDetect String="))" attribute="Shape" context="#pop#pop#pop"/>+        <IncludeRules context="Block_Shape_Common"/>+      </context>++      <!-- id("...")+                   ~ -->+      <context name="Block_Shape()" attribute="Error" lineEndContext="#pop#pop#pop"+               fallthroughContext="#pop#pop#pop">+        <StringDetect String=")" attribute="Shape" context="#pop#pop#pop"/>+        <IncludeRules context="Block_Shape_Common"/>+      </context>++      <!-- id[["..."]]+                    ~~ -->+      <context name="Block_Shape[[]]" attribute="Error" lineEndContext="#pop#pop#pop"+               fallthroughContext="#pop#pop#pop">+        <StringDetect String="]]" attribute="Shape" context="#pop#pop#pop"/>+        <IncludeRules context="Block_Shape_Common"/>+      </context>++      <!-- id[("...")]+                    ~~ -->+      <context name="Block_Shape[()]" attribute="Error" lineEndContext="#pop#pop#pop"+               fallthroughContext="#pop#pop#pop">+        <StringDetect String=")]" attribute="Shape" context="#pop#pop#pop"/>+        <IncludeRules context="Block_Shape_Common"/>+      </context>++      <!-- id([/"..."/]+                     ~~ -->+      <context name="Block_Shape[//]" attribute="Error" lineEndContext="#pop#pop#pop"+               fallthroughContext="#pop#pop#pop">+        <StringDetect String="/]" attribute="Shape" context="#pop#pop#pop"/>+        <StringDetect String="\]" attribute="Shape" context="#pop#pop#pop"/>+        <IncludeRules context="Block_Shape_Common"/>+      </context>++      <!-- id["..."]+                   ~ -->+      <context name="Block_Shape[]" attribute="Error" lineEndContext="#pop#pop#pop"+               fallthroughContext="#pop#pop#pop">+        <StringDetect String="]" attribute="Shape" context="#pop#pop#pop"/>+        <IncludeRules context="Block_Shape_Common"/>+      </context>++      <!-- id{{"..."}}+                    ~~ -->+      <context name="Block_Shape{{}}" attribute="Error" lineEndContext="#pop#pop#pop"+               fallthroughContext="#pop#pop#pop">+        <StringDetect String="}}" attribute="Shape" context="#pop#pop#pop"/>+        <IncludeRules context="Block_Shape_Common"/>+      </context>++      <!-- id{"..."}+                    ~~ -->+      <context name="Block_Shape{}" attribute="Error" lineEndContext="#pop#pop#pop"+               fallthroughContext="#pop#pop#pop">+        <StringDetect String="}" attribute="Shape" context="#pop#pop#pop"/>+        <IncludeRules context="Block_Shape_Common"/>+      </context>++      <!-- id<["..."]>(x,down)+                    ~~ -->+      <context name="Block_Shape&lt;[]>" attribute="Error" lineEndContext="#pop#pop#pop"+               fallthroughContext="#pop#pop#pop">+        <StringDetect String="]>" attribute="Shape" context="Block_ArrowDir"/>+        <IncludeRules context="Block_Shape_Common"/>+      </context>+      <!-- id<["..."]>(x,down)+                      ~ -->+      <context name="Block_ArrowDir" attribute="Error" fallthroughContext="#pop#pop#pop#pop">+        <DetectSpaces attribute="Normal"/>+        <StringDetect String="(" attribute="Shape" context="Block_ArrowDir_Kw"/>+      </context>+      <!-- id<["..."]>(x,down)+                       ~ -->+      <context name="Block_ArrowDir_Kw" attribute="Error" lineEndContext="#pop#pop#pop#pop#pop"+               fallthroughContext="#pop#pop#pop#pop#pop">+        <StringDetect String=")" attribute="Shape" context="#pop#pop#pop#pop#pop"/>+        <StringDetect String="," attribute="List Separator" context="Spaces"/>+        <AnyChar String="xy" attribute="Text"/>+        <StringDetect String="left" attribute="Text"/>+        <StringDetect String="right" attribute="Text"/>+        <StringDetect String="down" attribute="Text"/>+        <StringDetect String="up" attribute="Text"/>+        <DetectIdentifier attribute="Error"/>+        <DetectSpaces attribute="Error"/>+      </context>+++      <!-- columns 2 -->+      <context name="Block_KwColumns" attribute="Error" lineEndContext="#pop"+               fallthroughContext="#pop">+        <DetectSpaces attribute="Normal"/>+        <Int attribute="Number" context="#pop"/>+      </context>++      <!-- block:group1:2 ... end+                        ~ -->+      <context name="Block_Size" attribute="Error" lineEndContext="#pop"+               fallthroughContext="#pop">+        <Int attribute="Number" context="#pop"/>+      </context>++      <!--+      @} Block Diagram+      -->+++      <!--+      @{ Packet Diagram+      -->++      <!-- 16-31: "Destination Port"  /  +31: "Destination Port" -->+      <context name="Packet" attribute="Error">+        <DetectSpaces attribute="Normal"/>++        <AnyChar String='+-' attribute="Normal"/>+        <Int attribute="Node"/>+        <StringDetect String=":" attribute="Node Separator"/>+        <IncludeRules context="Find_Quote_Simple"/>++        <IncludeRules context="Find_Any_Comment"/>++        <WordDetect String="title" attribute="Keyword" context="Packet_KwTitle"/>+        <IncludeRules context="Find_Accessibility"/>+      </context>++      <!-- title bla bla -->+      <context name="Packet_KwTitle" attribute="Text" lineEndContext="#pop">+        <DetectSpaces attribute="Text" context="Packet_KwTitle_Text"/>+        <IncludeRules context="Find_Any_Comment"/>+        <RegExpr String="." attribute="Error" context="Packet_KwTitle_Text"/>+      </context>+      <context name="Packet_KwTitle_Text" attribute="Text" lineEndContext="#pop#pop">+        <DetectSpaces/>+        <DetectIdentifier/>+        <Int/>+        <AnyChar String="&lt;&gt;&amp;" attribute="Special Text Char"/>+        <IncludeRules context="Find_Any_Comment"/>+        <IncludeRules context="Find_Entity"/>+      </context>++      <!--+      @} Packet Diagram+      -->+++      <!--+      @{ Kanban Diagram+      -->++      <context name="Kanban" attribute="Error" fallthroughContext="Kanban_Node!Kanban_Node_Spe">+        <DetectSpaces attribute="Normal"/>+        <AnyChar String="[(" attribute="Shape" context="Kanban_Box"/>+        <StringDetect String="@{" attribute="Annotation Delimiter" context="Kanban_Annotation"/>+        <StringDetect String="{" attribute="Error" context="Kanban_Annotation"/>+        <AnyChar String=")]}@" attribute="Error"/>+        <IncludeRules context="Find_Comment"/>+        <IncludeRules context="EmptyQuotedText"/>+        <IncludeRules context="Flowchart_Find_MdText"/>+        <IncludeRules context="Flowchart_Find_UnicodeText"/>+        <RegExpr String="(?!kanban\b)&kanban_node;" attribute="Node"+                 context="Kanban_Node!Kanban_Node_Spe"/>+        <!-- no Find_Accessibility -->+      </context>++      <context name="Kanban_Node" attribute="Node" lineEndContext="#pop">+        <AnyChar String="[(" attribute="Shape" context="#pop!Kanban_Box"/>+        <AnyChar String="[({})]@" lookAhead="1" context="#pop"/>+        <DetectSpaces attribute="Normal"/>+        <IncludeRules context="Find_Comment"/>+        <RegExpr String="&kanban_node;" attribute="Node" context="Kanban_Node_Spe"/>+      </context>++      <context name="Kanban_Node_Spe" attribute="Text" lineEndContext="#pop#pop">+        <AnyChar String="[(" attribute="Shape" context="#pop#pop!Kanban_Box"/>+        <AnyChar String="[({})]@" lookAhead="1" context="#pop#pop"/>+        <IncludeRules context="Find_Md_Syms_ThenPop"/>+        <IncludeRules context="Find_Md_Html_Text_ThenPop"/>+      </context>++      <!-- id["..."] / id[...]+              ~~~~~       ~~~ -->+      <context name="Kanban_Box" attribute="Text" fallthroughContext="Kanban_Box_Text">+        <StringDetect String='"' lookAhead="1" context="Kanban_Box_End!Flowchart_QText"/>+      </context>+      <!-- id[...]+              ~~~ -->+      <context name="Kanban_Box_Text" attribute="Text" fallthroughContext="Kanban_Text_Spe">+        <AnyChar String=")]" attribute="Shape" context="#pop#pop"/>+        <DetectSpaces attribute="Normal"/>+        <IncludeRules context="Find_Comment"/>+        <RegExpr String="&kanban_qtext;" context="Kanban_Text_Spe"/>+      </context>+      <context name="Kanban_Text_Spe" attribute="Text" lineEndContext="#pop">+        <AnyChar String=")]" attribute="Shape" context="#pop#pop#pop"/>+        <AnyChar String="}@" attribute="Error" context="#pop#pop#pop"/>+        <AnyChar String="([" attribute="Error" context="#pop#pop"/>+        <IncludeRules context="Find_Md_Syms_ThenPop"/>+        <IncludeRules context="Find_Md_Html_Text_ThenPop"/>+      </context>++      <context name="Kanban_Box_End" attribute="Text" lineEndContext="#pop">+        <AnyChar String=")]" attribute="Shape" context="#pop#pop"/>+        <DetectSpaces attribute="Error"/>+        <AnyChar String="[({})]@&md_syms;" lookAhead="1" context="#pop#pop"/>+        <IncludeRules context="CharErrorAndPop2"/>+      </context>++      <!-- id[...]@{...}+                    ~~~~ -->+      <context name="Kanban_Annotation" attribute="Error" lineEndContext="#pop">+        <StringDetect String="}" attribute="Annotation Delimiter" context="#pop"/>+        <DetectSpaces attribute="Normal"/>+        <StringDetect String="," attribute="List Separator"/>+        <StringDetect String=": " attribute="Property Separator"+                      context="Kanban_Annotation_Value"/>+        <IncludeRules context="Find_SQuote_NoSpecial"/>+        <IncludeRules context="Find_DQuote_NoSpecial"/>+        <WordDetect String="assigned" attribute="Keyword"/>+        <WordDetect String="ticket" attribute="Keyword"/>+        <WordDetect String="priority" attribute="Keyword" context="Kanban_Annotation_Priority"/>+      </context>+      <context name="Kanban_Annotation_Value" attribute="Text" lineEndContext="#pop#pop"+               fallthroughContext="Kanban_Annotation_Text">+        <DetectSpaces attribute="Normal"/>+        <StringDetect String="'" attribute="Quoted Text Delimiter"+                      context="#pop!SQuote_NoSpecial"/>+        <StringDetect String='"' attribute="Quoted Text Delimiter"+                      context="#pop!DQuote_NoSpecial"/>+      </context>+      <context name="Kanban_Annotation_Text" attribute="Text" lineEndContext="#pop#pop#pop">+        <AnyChar String=',"[]{}' lookAhead="1" context="#pop#pop"/>+        <StringDetect String=": " attribute="Property Separator" context="#pop"/>+      </context>++      <!-- @{priority: ...}+                     ~~~~~ -->+      <context name="Kanban_Annotation_Priority" attribute="Error" lineEndContext="#pop#pop"+               fallthroughContext="#pop">+        <StringDetect String=": " attribute="Property Separator"+                      context="Kanban_Annotation_Priority_Value"/>+        <DetectSpaces attribute="Normal"/>+      </context>+      <context name="Kanban_Annotation_Priority_Value" attribute="Error"+               lineEndContext="#pop#pop#pop" fallthroughContext="#pop#pop">+        <DetectSpaces attribute="Normal"/>+        <AnyChar String=',[]{}' lookAhead="1" context="#pop#pop"/>+        <StringDetect String="'" attribute="Quoted Text Delimiter"+                      context="Kanban_Annotation_Priority_SQValue"/>+        <StringDetect String='"' attribute="Quoted Text Delimiter"+                      context="Kanban_Annotation_Priority_DQValue"/>+        <IncludeRules context="Kanban_Annotation_Priority_KwValue"/>+      </context>+      <context name="Kanban_Annotation_Priority_SQValue" attribute="Error"+               lineEndContext="#pop#pop#pop#pop">+        <StringDetect String="'" attribute="Quoted Text Delimiter" context="#pop#pop#pop"/>+        <IncludeRules context="Kanban_Annotation_Priority_KwValue"/>+      </context>+      <context name="Kanban_Annotation_Priority_DQValue" attribute="Error"+               lineEndContext="#pop#pop#pop#pop">+        <StringDetect String='"' attribute="Quoted Text Delimiter" context="#pop#pop#pop"/>+        <IncludeRules context="Kanban_Annotation_Priority_KwValue"/>+      </context>+      <context name="Kanban_Annotation_Priority_KwValue" attribute="Error">+        <StringDetect String="Very High" attribute="Keyword Parameter"/>+        <StringDetect String="High" attribute="Keyword Parameter"/>+        <StringDetect String="Very Low" attribute="Keyword Parameter"/>+        <StringDetect String="Low" attribute="Keyword Parameter"/>+        <DetectIdentifier attribute="Error"/>+      </context>++      <!--+      @} Kanban Diagram+      -->+++      <!--+      @{ Architecture Diagram+      -->++      <context name="Archi" attribute="Error" fallthroughContext="Kanban_Node!Kanban_Node_Spe">+        <DetectSpaces attribute="Normal"/>+        <IncludeRules context="Find_Any_Comment"/>++        <StringDetect String=":" attribute="Symbol Separator" context="Archi_EdgeDir"/>++        <StringDetect String="(" attribute="Shape" context="Archi_Icon"/>+        <StringDetect String="[" attribute="Quoted Text Delimiter" context="Archi_Text"/>+        <StringDetect String="{" attribute="Annotation Delimiter" context="Archi_Group"/>++        <StringDetect String="--" attribute="Link" context="Archi_Edge"/>+        <StringDetect String="&lt;--" attribute="Link" context="Archi_Edge"/>++        <WordDetect String="group" attribute="Keyword"/>+        <WordDetect String="in" attribute="Keyword"/>+        <WordDetect String="service" attribute="Keyword"/>+        <WordDetect String="junction" attribute="Keyword"/>++        <IncludeRules context="Find_Accessibility"/>++        <!-- https://github.com/mermaid-js/mermaid/issues/7022 -->+        <AnyChar String="LRTB" attribute="Error" context="Archi_Node"/>+        <AnyChar String="&archi_id_ch;" attribute="Node" context="Archi_Node"/>+      </context>++      <context name="Archi_Node" attribute="Node" lineEndContext="#pop"+               fallthroughContext="#pop">+        <AnyChar String="&archi_id_ch;"/>+      </context>++      <!-- id1:L - - R:id2+               ~ -->+      <context name="Archi_EdgeDir" attribute="Node" lineEndContext="#pop"+               fallthroughContext="#pop">+        <DetectSpaces attribute="Normal"/>+        <AnyChar String="LRTB" attribute="Keyword Parameter" context="#pop"/>+      </context>++      <!-- id1:L - - R:id2+                 ~~~~~~ -->+      <context name="Archi_Edge" attribute="Node" lineEndContext="#pop"+               fallthroughContext="#pop">+        <AnyChar String="LRTB" attribute="Keyword Parameter"/>+        <StringDetect String=":" attribute="Symbol Separator" context="#pop"/>+        <DetectSpaces attribute="Normal"/>+        <StringDetect String="&gt;" attribute="Link"/>+      </context>++      <!-- service db(database)[Database] in api+                      ~~~~~~~~~ -->+      <context name="Archi_Icon" attribute="Style Value" lineEndContext="#pop"+               fallthroughContext="#pop">+        <AnyChar String="&archi_id_ch;"/>+        <StringDetect String=")" attribute="Shape" context="#pop"/>+      </context>++      <!-- service db(database)[Database] in api+                                ~~~~~~~~~ -->+      <context name="Archi_Text" attribute="Text" lineEndContext="#pop"+               fallthroughContext="#pop">+        <!-- https://github.com/mermaid-js/mermaid/issues/6607 -->+        <AnyChar String="0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"/>+        <StringDetect String="_" lookAhead="1" context="Archi_Text_MaybeMd"/>+        <StringDetect String="]" attribute="Quoted Text Delimiter" context="#pop"/>+      </context>+      <context name="Archi_Text_MaybeMd" attribute="Text">+        <RegExpr String="&md_no_underscore;" context="#pop"/>+        <StringDetect String="_" attribute="Special Text Char" context="Archi_Text_Md"/>+      </context>+      <context name="Archi_Text_Md" attribute="Text" lineEndContext="#pop#pop#pop"+               fallthroughContext="#pop#pop">+        <StringDetect String="_" attribute="Special Text Char"/>+      </context>++      <!-- id1{group}:L - - L:id{group}+               ~~~~~~            ~~~~~~ -->+      <context name="Archi_Group" attribute="Annotation" lineEndContext="#pop"+               fallthroughContext="#pop">+        <StringDetect String="}" attribute="Annotation Delimiter" context="#pop"/>+        <StringDetect String="group" attribute="Annotation"/>+        <DetectIdentifier attribute="Error"/>+      </context>++      <!--+      @} Architecture Diagram+      -->+++      <!--+      @{ Radar Diagram+      -->++      <context name="Radar" attribute="Error">+        <DetectSpaces attribute="Normal"/>++        <AnyChar String="[]" attribute="Shape"/>+        <IncludeRules context="Find_Quote_Simple"/>+        <StringDetect String="{" attribute="Curly Bracket Block Delimiter"+                      context="Radar_Values" beginRegion="block"/>+        <StringDetect String="," attribute="List Separator"/>++        <IncludeRules context="Find_Any_Comment"/>++        <WordDetect String="axis" attribute="Keyword" weakDeliminator="-"/>+        <WordDetect String="curve" attribute="Keyword" weakDeliminator="-"/>+        <WordDetect String="max" attribute="Keyword" weakDeliminator="-"/>+        <WordDetect String="min" attribute="Keyword" weakDeliminator="-"/>+        <WordDetect String="graticule" attribute="Keyword" weakDeliminator="-"/>+        <WordDetect String="ticks" attribute="Keyword" weakDeliminator="-"/>+        <WordDetect String="showLegend" attribute="Keyword" weakDeliminator="-"/>+        <WordDetect String="title" attribute="Keyword" weakDeliminator="-"+                    context="Text_Simple!SpacesOrError"/>+        <WordDetect String="circle" attribute="Keyword Parameter" weakDeliminator="-"/>+        <WordDetect String="polygon" attribute="Keyword Parameter" weakDeliminator="-"/>+        <StringDetect String="true" attribute="Keyword Parameter"/>+        <StringDetect String="false" attribute="Keyword Parameter"/>++        <IncludeRules context="Find_Accessibility"/>++        <Int attribute="Number"/>++        <AnyChar String="-" attribute="Error"/>+        <AnyChar String="&radar_id_ch;" attribute="Node" context="Radar_Node"/>+      </context>++      <context name="Radar_Node" attribute="Node" lineEndContext="#pop"+               fallthroughContext="#pop">+        <AnyChar String="&radar_id_ch;"/>+      </context>+      <context name="Radar_Prop" attribute="Property" lineEndContext="#pop"+               fallthroughContext="#pop">+        <AnyChar String="&radar_id_ch;"/>+      </context>++      <context name="Radar_Values" attribute="Normal" fallthroughContext="#pop">+        <Int attribute="Number"/>+        <StringDetect String="," attribute="List Separator"/>+        <DetectSpaces attribute="Normal"/>+        <StringDetect String="." attribute="Number"/>+        <StringDetect String=":" attribute="Property Separator"/>+        <StringDetect String="}" attribute="Curly Bracket Block Delimiter"+                      context="#pop" endRegion="block"/>+        <IncludeRules context="Find_Any_Comment"/>++        <WordDetect String="axis" attribute="Error" weakDeliminator="-"/>+        <WordDetect String="curve" attribute="Error" weakDeliminator="-"/>+        <WordDetect String="max" attribute="Error" weakDeliminator="-"/>+        <WordDetect String="min" attribute="Error" weakDeliminator="-"/>+        <WordDetect String="graticule" attribute="Error" weakDeliminator="-"/>+        <WordDetect String="ticks" attribute="Error" weakDeliminator="-"/>+        <WordDetect String="showLegend" attribute="Error" weakDeliminator="-"/>+        <WordDetect String="title" attribute="Error" weakDeliminator="-"/>+        <WordDetect String="circle" attribute="Error" weakDeliminator="-"/>+        <WordDetect String="polygon" attribute="Error" weakDeliminator="-"/>+        <WordDetect String="accTitle" attribute="Error" weakDeliminator="-"/>+        <WordDetect String="accDescr" attribute="Error" weakDeliminator="-"/>+        <StringDetect String="true" attribute="Error"/>+        <StringDetect String="false" attribute="Error"/>++        <AnyChar String="-" attribute="Error"/>+        <AnyChar String="&radar_id_ch;" attribute="Property" context="Radar_Prop"/>+      </context>++      <!--+      @} Radar Diagram+      -->+++      <!--+      @{ Treemap Diagram+      -->++      <context name="Treemap" attribute="Error">+        <DetectSpaces attribute="Normal"/>+        <Int attribute="Number"/>+        <IncludeRules context="Find_Quote_Simple"/>+        <StringDetect String="." attribute="Number"/>+        <StringDetect String=":::" attribute="Class Name Delimiter"+                      context="Treemap_ClassName"/>+        <StringDetect String=":" attribute="Node Separator"/>++        <WordDetect String="classDef" attribute="Keyword" context="Flowchart_KwClassDef"/>++        <IncludeRules context="Find_Accessibility"/>+      </context>++      <context name="Treemap_ClassName" attribute="Error" lineEndContext="#pop"+               fallthroughContext="#pop">+        <DetectIdentifier attribute="Class Name" context="#pop"/>+      </context>++      <!--+      @} Treemap Diagram+      -->+++      <!-- @{ Md -->+      <!-- **xy**   __xy__   \*   \=   $$sin f$$   &lt;   #lt;+           ~~  ~~   ~~  ~~   ~~   ~    ~~     ~~   ~~~~   ~~~~ -->+      <context name="Find_Md_Syms_ThenPop" attribute="Normal" lineEndContext="#pop">+        <AnyChar String="*_" attribute="Special Text Char" context="#pop!Md_bi"/>+        <StringDetect String="\" attribute="Special Text Char" context="Md_Escape"/>+        <StringDetect String="$$" attribute="Math Delimiter" context="#pop"/>+        <IncludeRules context="Find_Entities_ThenPop"/>+      </context>+      <!-- \*+            ~ -->+      <context name="Md_Escape" attribute="Normal" lineEndContext="#pop#pop"+               fallthroughContext="#pop#pop">+        <AnyChar String="*_\" context="#pop#pop"/>+      </context>++      <!-- *xy* / _xy_ / \* / $$sin f$$ / &lt;+           ~  ~   ~  ~   ~    ~~     ~~   ~~~~ -->+      <context name="Find_MdText_Syms_ThenPop" attribute="Normal" lineEndContext="#pop">+        <AnyChar String="*_" attribute="Special Text Char" context="#pop!Md_bi"/>+        <StringDetect String="\" attribute="Special Text Char" context="MdText_Escape"/>+        <StringDetect String="$$" attribute="Math Delimiter" context="#pop"/>+        <IncludeRules context="Find_Entities_ThenPop"/>+      </context>+      <!-- \*+            ~ -->+      <context name="MdText_Escape" attribute="Normal" lineEndContext="#pop#pop"+               fallthroughContext="#pop#pop">+        <AnyChar String="*_\" attribute="Text" context="#pop#pop"/>+      </context>++      <!-- *xy* / _xy_+           ~  ~   ~  ~ -->+      <context name="Md_bi" attribute="Normal" lineEndContext="#pop" fallthroughContext="#pop">+        <AnyChar String="*_" attribute="Special Text Char"/>+      </context>+      <!-- @} Md -->+++      <!-- @{ kw (\s | \n) bla bla+                 ~~~~~~~~~+      context="BlaBla!SpacesOrNewLine"+      -->+      <context name="SpacesOrNewLine" attribute="Normal"+               lineEndContext="SpacesOrNewLine_NewLine">+        <DetectSpaces attribute="Normal" context="#pop"/>+      </context>+      <context name="SpacesOrNewLine_NewLine" attribute="Normal"+               fallthroughContext="#pop#pop"+               lineEmptyContext="#pop#pop#pop">+        <DetectSpaces attribute="Normal" context="#pop#pop"/>+      </context>+      <!-- @} kw (\s | \n) bla bla -->+++      <!-- @{ kw \s bla bla+                 ~~+      -->+      <context name="SpacesOrError" attribute="Normal" lineEndContext="#pop">+        <DetectSpaces attribute="Normal" context="#pop"/>+        <IncludeRules context="CharErrorAndPop"/>+      </context>+      <!--+      @} kw \s bla bla+      -->+++      <!-- @{ spaces -->+      <context name="Spaces" attribute="Normal" lineEndContext="#pop" fallthroughContext="#pop">+        <DetectSpaces attribute="Normal" context="#pop"/>+      </context>++      <context name="LineErrorExceptSpaces" attribute="Error" lineEndContext="#pop">+        <DetectSpaces attribute="Normal"/>+      </context>++      <context name="SpacesAsError" attribute="Normal" lineEndContext="#pop"+               fallthroughContext="#pop">+        <DetectSpaces attribute="Error" context="#pop"/>+      </context>+      <!-- @} spaces -->+++      <!-- @{ entities -->+      <!-- #lt; -->+      <context name="Find_Entity" attribute="Normal">+        <RegExpr String="(&mmd_ent;)+" attribute="Entity"/>+      </context>++      <!-- #lt; / &lt; -->+      <context name="Find_Entities" attribute="Normal">+        <RegExpr String="(&html_ent;|&mmd_ent;)+" attribute="Entity"/>+      </context>+      <context name="Find_Entities_ThenPop" attribute="Normal">+        <RegExpr String="(&html_ent;|&mmd_ent;)+" attribute="Entity" context="#pop"/>+      </context>+      <!-- @} entities -->+++      <!-- @{ <br> <br/> -->+      <context name="Find_HTML_br" attribute="Normal">+        <RegExpr String="&lt;br\s*/?>" attribute="HTML Tag"/>+      </context>++      <context name="Find_HTML_simple_br" attribute="Normal">+        <StringDetect String="&lt;br>" attribute="HTML Tag"/>+      </context>+      <!-- @} <br> <br/> -->+++      <!--+      @{ "..." / '...'+      -->+      <context name="Find_DQuote_NoSpecial" attribute="Normal">+        <StringDetect String='"' attribute="Quoted Text Delimiter" context="DQuote_NoSpecial"/>+      </context>+      <context name="DQuote_NoSpecial" attribute="Quoted Text">+        <StringDetect String='"' attribute="Quoted Text Delimiter" context="#pop"/>+      </context>++      <context name="Find_SQuote_NoSpecial" attribute="Normal">+        <StringDetect String="'" attribute="Quoted Text Delimiter" context="SQuote_NoSpecial"/>+      </context>+      <context name="SQuote_NoSpecial" attribute="Quoted Text">+        <StringDetect String="'" attribute="Quoted Text Delimiter" context="#pop"/>+      </context>++      <!-- with mermaid entity (#lt;) and escape for \ -->+      <context name="Find_Quote_Simple" attribute="Normal">+        <StringDetect String='"' attribute="Quoted Text Delimiter" context="DQuote_Simple"/>+        <StringDetect String="'" attribute="Quoted Text Delimiter" context="SQuote_Simple"/>+      </context>+      <context name="DQuote_Simple" attribute="Quoted Text">+        <StringDetect String='"' attribute="Quoted Text Delimiter" context="#pop"/>+        <IncludeRules context="Quote_Simple_Common"/>+      </context>+      <context name="SQuote_Simple" attribute="Quoted Text">+        <StringDetect String="'" attribute="Quoted Text Delimiter" context="#pop"/>+        <IncludeRules context="Quote_Simple_Common"/>+      </context>+      <context name="Quote_Simple_Common" attribute="Quoted Text">+        <DetectIdentifier/>+        <DetectSpaces/>+        <Int/>+        <IncludeRules context="Find_Comment"/>+        <LineContinue char="\" attribute="Error" context="#pop"/>+        <StringDetect String="\" attribute="Special Text Char" context="Quote_Simple_Espace"/>+        <IncludeRules context="Find_Entity"/>+      </context>+      <context name="Quote_Simple_Espace" attribute="Quoted Text" fallthroughContext="#pop">+        <AnyChar String="&quot;'\" attribute="Quoted Text" context="#pop"/>+        <AnyChar String="0" attribute="Error" context="#pop"/>+        <AnyChar String="btnvfr" attribute="Special Text Char" context="#pop"/>+      </context>+      <!--+      @} "..." / '...'+      -->+++      <!--+      @{ text+      -->+      <context name="Text_NoSpecial" attribute="Text" lineEndContext="#pop">+      </context>++      <!-- with mermaid entity (#lt;) and bad html tag -->+      <context name="Text_Simple" attribute="Text" lineEndContext="#pop">+        <DetectIdentifier/>+        <DetectSpaces/>+        <Int/>+        <StringDetect String="&lt;" attribute="Special Text Char"/>+        <IncludeRules context="Find_Entity"/>+      </context>+      <!--+      @} text+      -->+++      <!--+      @{ Comment+      -->+      <context name="Find_Comment" attribute="Comment">+        <!-- empty comment is not a comment: https://github.com/mermaid-js/mermaid/pull/7008+        this error is ignored+        -->+        <StringDetect String="%%" attribute="Comment" context="Comment" firstNonSpace="1"/>+        <!-- block comment: https://github.com/mermaid-js/mermaid/pull/7028 -->+      </context>++      <context name="Find_Comment_InText" attribute="Normal">+        <DetectSpaces/>+        <!-- https://github.com/mermaid-js/mermaid/issues/7011 -->+        <IncludeRules context="Find_Comment"/>+      </context>++      <context name="Find_Any_Comment" attribute="Normal">+        <StringDetect String="%%" attribute="Comment" context="Comment"/>+      </context>++      <context name="Comment" attribute="Comment" lineEndContext="#pop">+        <DetectSpaces/>+        <LineContinue attribute="Comment"/>+        <IncludeRules context="##Comments"/>+        <DetectIdentifier/>+      </context>++      <context name="FakeComment" attribute="Comment" lineEndContext="#pop">+      </context>+      <!--+      @} Comment+      -->+++      <!--+      @{ Error+      -->+      <context name="LineError" attribute="Error" lineEndContext="#pop">+      </context>++      <context name="CharErrorAndPop" attribute="Error" lineEndContext="#pop">+        <RegExpr String="." attribute="Error" context="#pop"/>+      </context>++      <context name="CharErrorAndPop2" attribute="Error" lineEndContext="#pop">+        <RegExpr String="." attribute="Error" context="#pop#pop"/>+      </context>+      <!--+      @} Error+      -->++    </contexts>++    <itemDatas>+      <itemData name="Normal" defStyleNum="dsNormal" spellChecking="0"/>+      <itemData name="Error" defStyleNum="dsError" spellChecking="0"/>+      <itemData name="Shape" defStyleNum="dsNormal" spellChecking="0"/>+      <itemData name="Comment" defStyleNum="dsComment"/>+      <itemData name="Keyword" defStyleNum="dsKeyword" spellChecking="0"/>+      <itemData name="Keyword Parameter" defStyleNum="dsConstant" spellChecking="0"/>+      <itemData name="Keyword Property Separator" defStyleNum="dsAttribute" spellChecking="0"/>+      <itemData name="Node" defStyleNum="dsDataType"/>+      <itemData name="Node Separator" defStyleNum="dsDataType" spellChecking="0" bold="1"/>+      <itemData name="Symbol Separator" defStyleNum="dsNormal" spellChecking="0"/>+      <itemData name="List Separator" defStyleNum="dsNormal" spellChecking="0"/>+      <itemData name="Text" defStyleNum="dsVerbatimString"/>+      <itemData name="Text Separator" defStyleNum="dsNormal"/>+      <itemData name="Quoted Text" defStyleNum="dsString"/>+      <itemData name="Quoted Text Delimiter" defStyleNum="dsString" spellChecking="0"/>+      <itemData name="Markdown Text" defStyleNum="dsString"/>+      <itemData name="Markdown Text Delimiter" defStyleNum="dsString" spellChecking="0"/>+      <itemData name="Special Text Char" defStyleNum="dsSpecialChar" spellChecking="0"/>+      <itemData name="Math Delimiter" defStyleNum="dsImport" spellChecking="0"/>+      <itemData name="HTML Tag" defStyleNum="dsSpecialChar" spellChecking="0"/>+      <itemData name="HTML Attribute" defStyleNum="dsOthers" spellChecking="0"/>+      <itemData name="Link" defStyleNum="dsPreprocessor" spellChecking="0"/>+      <itemData name="Link Text" defStyleNum="dsVerbatimString"/>+      <itemData name="Link Text Separator" defStyleNum="dsNormal" spellChecking="0"/>+      <itemData name="Link Text Delimiter" defStyleNum="dsVerbatimString" spellChecking="0" bold="1"/>+      <itemData name="Union" defStyleNum="dsKeyword" spellChecking="0"/>+      <itemData name="Entity" defStyleNum="dsDecVal" spellChecking="0"/>+      <itemData name="Class Name" defStyleNum="dsFunction" spellChecking="0"/>+      <itemData name="Class Name Delimiter" defStyleNum="dsFunction" spellChecking="0" bold="1"/>+      <itemData name="ID" defStyleNum="dsFunction" spellChecking="0"/>+      <itemData name="ID Separator" defStyleNum="dsFunction" spellChecking="0" bold="1"/>++      <itemData name="Number" defStyleNum="dsDecVal" spellChecking="0"/>+      <itemData name="Style Property" defStyleNum="dsAttribute" spellChecking="0"/>+      <itemData name="Style Property Separator" defStyleNum="dsAttribute" spellChecking="0" bold="1"/>+      <itemData name="Style Value" defStyleNum="dsNormal" spellChecking="0"/>+      <itemData name="Style Unit" defStyleNum="dsDataType" spellChecking="0"/>+      <itemData name="Style Hexadeximal Color" defStyleNum="dsImport" spellChecking="0"/>++      <itemData name="Curly Bracket Block Delimiter" defStyleNum="dsDataType" spellChecking="0" bold="1"/>+      <itemData name="Property" defStyleNum="dsAttribute" spellChecking="0"/>+      <itemData name="Property Separator" defStyleNum="dsAttribute" spellChecking="0" bold="1"/>+      <itemData name="Property Number" defStyleNum="dsVerbatimString" spellChecking="0"/>+      <itemData name="Property Boolean" defStyleNum="dsImport" spellChecking="0"/>++      <itemData name="Annotation" defStyleNum="dsAttribute" spellChecking="0"/>+      <itemData name="Annotation Delimiter" defStyleNum="dsAttribute" spellChecking="0" bold="1"/>+      <!-- gantt, journey, timeline -->+      <itemData name="Section Text" defStyleNum="dsDocumentation" spellChecking="0"/>+      <!-- classDiagram -->+      <itemData name="Generic Type Symbol" defStyleNum="dsFunction" spellChecking="0"/>+      <!-- classDiagram, erDiagram -->+      <itemData name="Member" defStyleNum="dsNormal" spellChecking="0"/>+      <itemData name="Member Type" defStyleNum="dsNormal" spellChecking="0"/>+      <!-- stateDiagram -->+      <itemData name="Concurrency" defStyleNum="dsFunction" spellChecking="0"/>+      <!-- erDiagram -->+      <itemData name="Cardinality Text" defStyleNum="dsPreprocessor" spellChecking="0"/>+      <itemData name="Relationship Text" defStyleNum="dsPreprocessor" spellChecking="0" bold="1"/>+      <!-- ZenUML -->+      <itemData name="Diagram Comment" defStyleNum="dsDocumentation"/>+    </itemDatas>+  </highlighting>+  <general>+    <comments>+      <comment name="singleLine" start="%%" position="afterwhitespace"/>+    </comments>+  </general>+</language>+<!-- kate: space-indent on; indent-width 2; replace-tabs on; -->
+ xml/meson.xml view
@@ -0,0 +1,277 @@+<?xml version="1.0" encoding="UTF-8"?>+<!DOCTYPE language>+<language name="Meson" section="Other"+	version="6" kateversion="5.0"+	extensions="meson.build;meson.options;meson_options.txt"+	mimetype="text/x-meson"+	priority="5"+	license="LGPL">++	<highlighting>+		<list name="flowControl">+			<item>if</item>+			<item>else</item>+			<item>endif</item>+			<item>foreach</item>+			<item>endforeach</item>+		</list>+		<list name="builtinfuncs">+			<item>add_global_arguments</item>+			<item>add_global_link_arguments</item>+			<item>add_languages</item>+			<item>add_project_arguments</item>+			<item>add_project_link_arguments</item>+			<item>add_test_setup</item>+			<item>alias_target</item>+			<item>assert</item>+			<item>benchmark</item>+			<item>both_libraries</item>+			<item>build_target</item>+			<item>configuration_data</item>+			<item>configure_file</item>+			<item>custom_target</item>+			<item>declare_dependency</item>+			<item>dependency</item>+			<item>disabler</item>+			<item>environment</item>+			<item>error</item>+			<item>executable</item>+			<item>files</item>+			<item>find_library</item>+			<item>find_program</item>+			<item>generator</item>+			<item>get_option</item>+			<item>get_variable</item>+			<item>import</item>+			<item>include_directories</item>+			<item>install_data</item>+			<item>install_headers</item>+			<item>install_man</item>+			<item>install_subdir</item>+			<item>is_disabler</item>+			<item>is_variable</item>+			<item>jar</item>+			<item>join_paths</item>+			<item>library</item>+			<item>message</item>+			<item>project</item>+			<item>run_command</item>+			<item>run_target</item>+			<item>set_variable</item>+			<item>shared_library</item>+			<item>shared_module</item>+			<item>static_library</item>+			<item>subdir</item>+			<item>subdir_done</item>+			<item>subproject</item>+			<item>test</item>+			<item>vcs_tag</item>+			<item>warning</item>+		</list>+		<list name="logicalOperations">+			<item>and</item>+			<item>or</item>+			<item>not</item>+		</list>+		<list name="booleans">+			<item>true</item>+			<item>false</item>+		</list>+		<list name="mesonObjet">+			<item>meson</item>+		</list>+		<list name="machineObjet">+			<item>build_machine</item>+			<item>host_machine</item>+			<item>target_machine</item>+		</list>+		<list name="mesonMembers">+			<item>add_dist_script</item>+			<item>add_install_script</item>+			<item>add_postconf_script</item>+			<item>backend</item>+			<item>build_root</item>+			<item>source_root</item>+			<item>current_build_dir</item>+			<item>current_source_dir</item>+			<item>get_cross_property</item>+			<item>get_compiler</item>+			<item>has_exe_wrapper</item>+			<item>install_dependency_manifest</item>+			<item>is_cross_build</item>+			<item>is_subproject</item>+			<item>is_unity</item>+			<item>override_find_program</item>+			<item>project_version</item>+			<item>project_license</item>+			<item>project_name</item>+			<item>version</item>+		</list>+		<list name="machineMembers">+			<item>cpu_family</item>+			<item>cpu</item>+			<item>system</item>+			<item>endian</item>+		</list>+		<list name="builtinmembers">+			<item>alignment</item>+			<item>append</item>+			<item>as_system</item>+			<item>cmd_array</item>+			<item>compiled</item>+			<item>compiles</item>+			<item>compute_int</item>+			<item>contains</item>+			<item>endswith</item>+			<item>extract_all_objects</item>+			<item>extract_objects</item>+			<item>find_library</item>+			<item>first_supported_argument</item>+			<item>first_supported_link_argument</item>+			<item>format</item>+			<item>found</item>+			<item>full_path</item>+			<item>get_argument_syntax</item>+			<item>get_configtool_variable</item>+			<item>get_define</item>+			<item>get_id</item>+			<item>get</item>+			<item>get_pkgconfig_variable</item>+			<item>get_supported_arguments</item>+			<item>get_supported_function_attributes</item>+			<item>get_supported_link_arguments</item>+			<item>get_unquoted</item>+			<item>get_variable</item>+			<item>gettext</item>+			<item>has_argument</item>+			<item>has_function_attribute</item>+			<item>has_function</item>+			<item>has_header_symbol</item>+			<item>has</item>+			<item>has_key</item>+			<item>has_link_argument</item>+			<item>has_member</item>+			<item>has_members</item>+			<item>has_multi_arguments</item>+			<item>has_multi_link_arguments</item>+			<item>has_type</item>+			<item>include_type</item>+			<item>is_even</item>+			<item>is_odd</item>+			<item>join</item>+			<item>length</item>+			<item>links</item>+			<item>merge_from</item>+			<item>name</item>+			<item>partial_dependency</item>+			<item>path</item>+			<item>pkgconfig_gen</item>+			<item>prepend</item>+			<item>private_dir_include</item>+			<item>process</item>+			<item>returncode</item>+			<item>run</item>+			<item>set10</item>+			<item>set</item>+			<item>set_quoted</item>+			<item>sizeof</item>+			<item>split</item>+			<item>startswith</item>+			<item>stderr</item>+			<item>stdout</item>+			<item>strip</item>+			<item>symbols_have_underscore_prefix</item>+			<item>to_lower</item>+			<item>to_string</item>+			<item>to_upper</item>+			<item>type_name</item>+			<item>underscorify</item>+			<item>version_compare</item>+			<item>version</item>+		</list>++		<contexts>+			<context name="Normal" attribute="Normal Text" lineEndContext="#stay">+				<keyword attribute="Flow Control Keyword" String="flowControl" context="#stay"/>+				<keyword attribute="Operator" String="logicalOperations" context="#stay"/>+				<keyword attribute="Builtin Function" String="builtinfuncs" context="#stay"/>+				<keyword attribute="Boolean Values" String="booleans" context="#stay"/>+				<keyword attribute="Builtin Objet" String="mesonObjet" context="mesonObjet"/>+				<keyword attribute="Builtin Objet" String="machineObjet" context="machineObjet"/>+				<Int attribute="Int" context="#stay"/>+				<DetectChar attribute="Comment" char="#" context="comment"/>+				<AnyChar attribute="Operator" String="+-*/=&lt;&gt;" context="#stay"/>+				<DetectChar attribute="Normal Text" char="[" context="List" beginRegion="List"/>+				<IncludeRules context="StringVariants" />+				<DetectChar attribute="Normal Text" char="." context="members"/>+			</context>++			<context name="mesonObjet" attribute="Normal Text" lineEndContext="#pop" fallthrough="1" fallthroughContext="#pop">+				<DetectChar attribute="Normal Text" char="." context="mesonMembers"/>+			</context>++			<context name="mesonMembers" attribute="Normal Text" lineEndContext="#pop#pop" fallthrough="1" fallthroughContext="#pop#pop">+				<keyword attribute="Builtin Function" String="mesonMembers" context="#pop#pop"/>+			</context>++			<context name="machineObjet" attribute="Normal Text" lineEndContext="#pop" fallthrough="1" fallthroughContext="#pop">+				<DetectChar attribute="Normal Text" char="." context="machineMembers"/>+			</context>++			<context name="machineMembers" attribute="Normal Text" lineEndContext="#pop#pop" fallthrough="1" fallthroughContext="#pop#pop">+				<keyword attribute="Builtin Function" String="machineMembers" context="#pop#pop"/>+			</context>++			<context name="members" attribute="Normal Text" lineEndContext="#pop" fallthrough="1" fallthroughContext="#pop#pop">+				<keyword attribute="Builtin Member Function" String="builtinmembers" context="#pop"/>+			</context>++			<context name="List" attribute="Normal Text" lineEndContext="#stay" noIndentationBasedFolding="true">+				<DetectSpaces/>+				<DetectChar attribute="Normal Text" char="]" context="#pop" endRegion="List"/>+				<IncludeRules context="Normal" />+			</context>++			<context name="comment" attribute="Comment" lineEndContext="#pop">+				<IncludeRules context="##Comments" />+			</context>++			<!--strings-->+			<context name="StringVariants" attribute="Normal Text" lineEndContext="#stay">+				<DetectSpaces/>+				<StringDetect attribute="String" String="'''" context="Triple A-string" beginRegion="Triple A-region"/>+				<DetectChar attribute="String" char="'" context="Single A-string"/>+			</context>+			<context name="Single A-string" attribute="String" lineEndContext="#stay">+				<HlCStringChar attribute="String Char" context="#stay"/>+				<DetectChar attribute="String" char="'" context="#pop"/>+			</context>+			<context name="Triple A-string" attribute="String" lineEndContext="#stay" noIndentationBasedFolding="true">+				<HlCStringChar attribute="String Char" context="#stay"/>+				<StringDetect attribute="String" String="'''" context="#pop" endRegion="Triple A-region"/>+			</context>+		</contexts>++		<itemDatas>+			<itemData name="Normal Text"          defStyleNum="dsNormal"   spellChecking="false"/>+			<itemData name="Operator"             defStyleNum="dsNormal"   spellChecking="false" bold="1"/>+			<itemData name="Int"                  defStyleNum="dsDecVal"   spellChecking="false"/>+			<itemData name="Flow Control Keyword" defStyleNum="dsKeyword"  spellChecking="false"/>+			<itemData name="Builtin Function"     defStyleNum="dsDataType" spellChecking="false"/>+			<itemData name="Builtin Objet"        defStyleNum="dsDataType" spellChecking="false"/>+			<itemData name="Builtin Member Function" defStyleNum="dsDataType" spellChecking="false"/>+			<itemData name="Boolean Values"       defStyleNum="dsKeyword"  spellChecking="false"/>+			<itemData name="String Char"          defStyleNum="dsChar"     spellChecking="false"/>+			<itemData name="String"               defStyleNum="dsString"/>+			<itemData name="Comment"              defStyleNum="dsComment"/>+		</itemDatas>+	</highlighting>++	<general>+		<comments>+			<comment name="singleLine" start="#"/>+		</comments>+	</general>++</language>+<!-- kate: replace-tabs off; -->
+ xml/nginx.xml view
@@ -0,0 +1,934 @@+<?xml version="1.0" encoding="UTF-8"?>+<!DOCTYPE language+[+  <!-- list of units taken from https://nginx.org/en/docs/syntax.html -->+  <!ENTITY units "([dGghKkMmswy]|ms)">+]+>+<language name="nginx Configuration" section="Configuration"+          version="3" kateversion="5.79"+          indenter="cstyle"+          extensions="nginx.conf;*.nginx"+          mimetype=""+          author="Jyrki Gadinger (nilsding@nilsding.org)" license="MIT">+  <highlighting>+    <!-- see https://nginx.org/en/docs/dirindex.html for a full list of directives -->+    <list name="directives">+      <item>absolute_redirect</item>+      <item>accept_mutex</item>+      <item>accept_mutex_delay</item>+      <item>access_log</item>+      <item>add_after_body</item>+      <item>add_before_body</item>+      <item>add_header</item>+      <item>add_trailer</item>+      <item>addition_types</item>+      <item>aio</item>+      <item>aio_write</item>+      <item>alias</item>+      <item>allow</item>+      <item>ancient_browser</item>+      <item>ancient_browser_value</item>+      <item>api</item>+      <item>auth_basic</item>+      <item>auth_basic_user_file</item>+      <item>auth_delay</item>+      <item>auth_http</item>+      <item>auth_http_header</item>+      <item>auth_http_pass_client_cert</item>+      <item>auth_http_timeout</item>+      <item>auth_jwt</item>+      <item>auth_jwt_claim_set</item>+      <item>auth_jwt_header_set</item>+      <item>auth_jwt_key_cache</item>+      <item>auth_jwt_key_file</item>+      <item>auth_jwt_key_request</item>+      <item>auth_jwt_leeway</item>+      <item>auth_jwt_require</item>+      <item>auth_jwt_type</item>+      <item>auth_request</item>+      <item>auth_request_set</item>+      <item>autoindex</item>+      <item>autoindex_exact_size</item>+      <item>autoindex_format</item>+      <item>autoindex_localtime</item>+      <item>break</item>+      <item>charset</item>+      <item>charset_map</item>+      <item>charset_types</item>+      <item>chunked_transfer_encoding</item>+      <item>client_body_buffer_size</item>+      <item>client_body_in_file_only</item>+      <item>client_body_in_single_buffer</item>+      <item>client_body_temp_path</item>+      <item>client_body_timeout</item>+      <item>client_header_buffer_size</item>+      <item>client_header_timeout</item>+      <item>client_max_body_size</item>+      <item>connect_timeout</item>+      <item>connection_pool_size</item>+      <item>create_full_put_path</item>+      <item>daemon</item>+      <item>dav_access</item>+      <item>dav_methods</item>+      <item>debug_connection</item>+      <item>debug_points</item>+      <item>default_type</item>+      <item>deny</item>+      <item>directio</item>+      <item>directio_alignment</item>+      <item>disable_symlinks</item>+      <item>empty_gif</item>+      <item>env</item>+      <item>error_log</item>+      <item>error_page</item>+      <item>etag</item>+      <item>events</item>+      <item>expires</item>+      <item>f4f</item>+      <item>f4f_buffer_size</item>+      <item>fastcgi_bind</item>+      <item>fastcgi_buffer_size</item>+      <item>fastcgi_buffering</item>+      <item>fastcgi_buffers</item>+      <item>fastcgi_busy_buffers_size</item>+      <item>fastcgi_cache</item>+      <item>fastcgi_cache_background_update</item>+      <item>fastcgi_cache_bypass</item>+      <item>fastcgi_cache_key</item>+      <item>fastcgi_cache_lock</item>+      <item>fastcgi_cache_lock_age</item>+      <item>fastcgi_cache_lock_timeout</item>+      <item>fastcgi_cache_max_range_offset</item>+      <item>fastcgi_cache_methods</item>+      <item>fastcgi_cache_min_uses</item>+      <item>fastcgi_cache_path</item>+      <item>fastcgi_cache_purge</item>+      <item>fastcgi_cache_revalidate</item>+      <item>fastcgi_cache_use_stale</item>+      <item>fastcgi_cache_valid</item>+      <item>fastcgi_catch_stderr</item>+      <item>fastcgi_connect_timeout</item>+      <item>fastcgi_force_ranges</item>+      <item>fastcgi_hide_header</item>+      <item>fastcgi_ignore_client_abort</item>+      <item>fastcgi_ignore_headers</item>+      <item>fastcgi_index</item>+      <item>fastcgi_intercept_errors</item>+      <item>fastcgi_keep_conn</item>+      <item>fastcgi_limit_rate</item>+      <item>fastcgi_max_temp_file_size</item>+      <item>fastcgi_next_upstream</item>+      <item>fastcgi_next_upstream_timeout</item>+      <item>fastcgi_next_upstream_tries</item>+      <item>fastcgi_no_cache</item>+      <item>fastcgi_param</item>+      <item>fastcgi_pass</item>+      <item>fastcgi_pass_header</item>+      <item>fastcgi_pass_request_body</item>+      <item>fastcgi_pass_request_headers</item>+      <item>fastcgi_read_timeout</item>+      <item>fastcgi_request_buffering</item>+      <item>fastcgi_send_lowat</item>+      <item>fastcgi_send_timeout</item>+      <item>fastcgi_socket_keepalive</item>+      <item>fastcgi_split_path_info</item>+      <item>fastcgi_store</item>+      <item>fastcgi_store_access</item>+      <item>fastcgi_temp_file_write_size</item>+      <item>fastcgi_temp_path</item>+      <item>flv</item>+      <item>geo</item>+      <item>geoip_city</item>+      <item>geoip_country</item>+      <item>geoip_org</item>+      <item>geoip_proxy</item>+      <item>geoip_proxy_recursive</item>+      <item>google_perftools_profiles</item>+      <item>grpc_bind</item>+      <item>grpc_buffer_size</item>+      <item>grpc_connect_timeout</item>+      <item>grpc_hide_header</item>+      <item>grpc_ignore_headers</item>+      <item>grpc_intercept_errors</item>+      <item>grpc_next_upstream</item>+      <item>grpc_next_upstream_timeout</item>+      <item>grpc_next_upstream_tries</item>+      <item>grpc_pass</item>+      <item>grpc_pass_header</item>+      <item>grpc_read_timeout</item>+      <item>grpc_send_timeout</item>+      <item>grpc_set_header</item>+      <item>grpc_socket_keepalive</item>+      <item>grpc_ssl_certificate</item>+      <item>grpc_ssl_certificate_key</item>+      <item>grpc_ssl_ciphers</item>+      <item>grpc_ssl_conf_command</item>+      <item>grpc_ssl_crl</item>+      <item>grpc_ssl_name</item>+      <item>grpc_ssl_password_file</item>+      <item>grpc_ssl_protocols</item>+      <item>grpc_ssl_server_name</item>+      <item>grpc_ssl_session_reuse</item>+      <item>grpc_ssl_trusted_certificate</item>+      <item>grpc_ssl_verify</item>+      <item>grpc_ssl_verify_depth</item>+      <item>gunzip</item>+      <item>gunzip_buffers</item>+      <item>gzip</item>+      <item>gzip_buffers</item>+      <item>gzip_comp_level</item>+      <item>gzip_disable</item>+      <item>gzip_http_version</item>+      <item>gzip_min_length</item>+      <item>gzip_proxied</item>+      <item>gzip_static</item>+      <item>gzip_types</item>+      <item>gzip_vary</item>+      <item>hash</item>+      <item>health_check</item>+      <item>health_check_timeout</item>+      <item>hls</item>+      <item>hls_buffers</item>+      <item>hls_forward_args</item>+      <item>hls_fragment</item>+      <item>hls_mp4_buffer_size</item>+      <item>hls_mp4_max_buffer_size</item>+      <item>http</item>+      <item>http2</item>+      <item>http2_body_preread_size</item>+      <item>http2_chunk_size</item>+      <item>http2_idle_timeout</item>+      <item>http2_max_concurrent_pushes</item>+      <item>http2_max_concurrent_streams</item>+      <item>http2_max_field_size</item>+      <item>http2_max_header_size</item>+      <item>http2_max_requests</item>+      <item>http2_push</item>+      <item>http2_push_preload</item>+      <item>http2_recv_buffer_size</item>+      <item>http2_recv_timeout</item>+      <item>http3</item>+      <item>http3_hq</item>+      <item>http3_max_concurrent_streams</item>+      <item>http3_stream_buffer_size</item>+      <item>if</item>+      <item>if_modified_since</item>+      <item>ignore_invalid_headers</item>+      <item>image_filter</item>+      <item>image_filter_buffer</item>+      <item>image_filter_interlace</item>+      <item>image_filter_jpeg_quality</item>+      <item>image_filter_sharpen</item>+      <item>image_filter_transparency</item>+      <item>image_filter_webp_quality</item>+      <item>imap_auth</item>+      <item>imap_capabilities</item>+      <item>imap_client_buffer</item>+      <item>include</item>+      <item>index</item>+      <item>internal</item>+      <item>internal_redirect</item>+      <item>ip_hash</item>+      <item>js_access</item>+      <item>js_body_filter</item>+      <item>js_content</item>+      <item>js_fetch_buffer_size</item>+      <item>js_fetch_ciphers</item>+      <item>js_fetch_max_response_buffer_size</item>+      <item>js_fetch_protocols</item>+      <item>js_fetch_timeout</item>+      <item>js_fetch_trusted_certificate</item>+      <item>js_fetch_verify</item>+      <item>js_fetch_verify_depth</item>+      <item>js_filter</item>+      <item>js_header_filter</item>+      <item>js_import</item>+      <item>js_include</item>+      <item>js_path</item>+      <item>js_periodic</item>+      <item>js_preload_object</item>+      <item>js_preread</item>+      <item>js_set</item>+      <item>js_shared_dict_zone</item>+      <item>js_var</item>+      <item>keepalive</item>+      <item>keepalive_disable</item>+      <item>keepalive_requests</item>+      <item>keepalive_time</item>+      <item>keepalive_timeout</item>+      <item>keyval</item>+      <item>keyval_zone</item>+      <item>large_client_header_buffers</item>+      <item>least_conn</item>+      <item>least_time</item>+      <item>limit_conn</item>+      <item>limit_conn_dry_run</item>+      <item>limit_conn_log_level</item>+      <item>limit_conn_status</item>+      <item>limit_conn_zone</item>+      <item>limit_except</item>+      <item>limit_rate</item>+      <item>limit_rate_after</item>+      <item>limit_req</item>+      <item>limit_req_dry_run</item>+      <item>limit_req_log_level</item>+      <item>limit_req_status</item>+      <item>limit_req_zone</item>+      <item>limit_zone</item>+      <item>lingering_close</item>+      <item>lingering_time</item>+      <item>lingering_timeout</item>+      <item>listen</item>+      <item>load_module</item>+      <item>location</item>+      <item>lock_file</item>+      <item>log_format</item>+      <item>log_not_found</item>+      <item>log_subrequest</item>+      <item>mail</item>+      <item>map</item>+      <item>map_hash_bucket_size</item>+      <item>map_hash_max_size</item>+      <item>master_process</item>+      <item>match</item>+      <item>max_errors</item>+      <item>max_ranges</item>+      <item>memcached_bind</item>+      <item>memcached_buffer_size</item>+      <item>memcached_connect_timeout</item>+      <item>memcached_gzip_flag</item>+      <item>memcached_next_upstream</item>+      <item>memcached_next_upstream_timeout</item>+      <item>memcached_next_upstream_tries</item>+      <item>memcached_pass</item>+      <item>memcached_read_timeout</item>+      <item>memcached_send_timeout</item>+      <item>memcached_socket_keepalive</item>+      <item>merge_slashes</item>+      <item>mgmt</item>+      <item>min_delete_depth</item>+      <item>mirror</item>+      <item>mirror_request_body</item>+      <item>modern_browser</item>+      <item>modern_browser_value</item>+      <item>mp4</item>+      <item>mp4_buffer_size</item>+      <item>mp4_limit_rate</item>+      <item>mp4_limit_rate_after</item>+      <item>mp4_max_buffer_size</item>+      <item>mp4_start_key_frame</item>+      <item>mqtt</item>+      <item>mqtt_buffers</item>+      <item>mqtt_preread</item>+      <item>mqtt_rewrite_buffer_size</item>+      <item>mqtt_set_connect</item>+      <item>msie_padding</item>+      <item>msie_refresh</item>+      <item>multi_accept</item>+      <item>ntlm</item>+      <item>open_file_cache</item>+      <item>open_file_cache_errors</item>+      <item>open_file_cache_min_uses</item>+      <item>open_file_cache_valid</item>+      <item>open_log_file_cache</item>+      <item>otel_exporter</item>+      <item>otel_service_name</item>+      <item>otel_span_attr</item>+      <item>otel_span_name</item>+      <item>otel_trace</item>+      <item>otel_trace_context</item>+      <item>output_buffers</item>+      <item>override_charset</item>+      <item>pass</item>+      <item>pcre_jit</item>+      <item>perl</item>+      <item>perl_modules</item>+      <item>perl_require</item>+      <item>perl_set</item>+      <item>pid</item>+      <item>pop3_auth</item>+      <item>pop3_capabilities</item>+      <item>port_in_redirect</item>+      <item>postpone_output</item>+      <item>preread_buffer_size</item>+      <item>preread_timeout</item>+      <item>protocol</item>+      <item>proxy_bind</item>+      <item>proxy_buffer</item>+      <item>proxy_buffer_size</item>+      <item>proxy_buffering</item>+      <item>proxy_buffers</item>+      <item>proxy_busy_buffers_size</item>+      <item>proxy_cache</item>+      <item>proxy_cache_background_update</item>+      <item>proxy_cache_bypass</item>+      <item>proxy_cache_convert_head</item>+      <item>proxy_cache_key</item>+      <item>proxy_cache_lock</item>+      <item>proxy_cache_lock_age</item>+      <item>proxy_cache_lock_timeout</item>+      <item>proxy_cache_max_range_offset</item>+      <item>proxy_cache_methods</item>+      <item>proxy_cache_min_uses</item>+      <item>proxy_cache_path</item>+      <item>proxy_cache_purge</item>+      <item>proxy_cache_revalidate</item>+      <item>proxy_cache_use_stale</item>+      <item>proxy_cache_valid</item>+      <item>proxy_connect_timeout</item>+      <item>proxy_cookie_domain</item>+      <item>proxy_cookie_flags</item>+      <item>proxy_cookie_path</item>+      <item>proxy_download_rate</item>+      <item>proxy_force_ranges</item>+      <item>proxy_half_close</item>+      <item>proxy_headers_hash_bucket_size</item>+      <item>proxy_headers_hash_max_size</item>+      <item>proxy_hide_header</item>+      <item>proxy_http_version</item>+      <item>proxy_ignore_client_abort</item>+      <item>proxy_ignore_headers</item>+      <item>proxy_intercept_errors</item>+      <item>proxy_limit_rate</item>+      <item>proxy_max_temp_file_size</item>+      <item>proxy_method</item>+      <item>proxy_next_upstream</item>+      <item>proxy_next_upstream_timeout</item>+      <item>proxy_next_upstream_tries</item>+      <item>proxy_no_cache</item>+      <item>proxy_pass</item>+      <item>proxy_pass_error_message</item>+      <item>proxy_pass_header</item>+      <item>proxy_pass_request_body</item>+      <item>proxy_pass_request_headers</item>+      <item>proxy_protocol</item>+      <item>proxy_protocol_timeout</item>+      <item>proxy_read_timeout</item>+      <item>proxy_redirect</item>+      <item>proxy_request_buffering</item>+      <item>proxy_requests</item>+      <item>proxy_responses</item>+      <item>proxy_send_lowat</item>+      <item>proxy_send_timeout</item>+      <item>proxy_session_drop</item>+      <item>proxy_set_body</item>+      <item>proxy_set_header</item>+      <item>proxy_smtp_auth</item>+      <item>proxy_socket_keepalive</item>+      <item>proxy_ssl</item>+      <item>proxy_ssl_certificate</item>+      <item>proxy_ssl_certificate_key</item>+      <item>proxy_ssl_ciphers</item>+      <item>proxy_ssl_conf_command</item>+      <item>proxy_ssl_crl</item>+      <item>proxy_ssl_name</item>+      <item>proxy_ssl_password_file</item>+      <item>proxy_ssl_protocols</item>+      <item>proxy_ssl_server_name</item>+      <item>proxy_ssl_session_reuse</item>+      <item>proxy_ssl_trusted_certificate</item>+      <item>proxy_ssl_verify</item>+      <item>proxy_ssl_verify_depth</item>+      <item>proxy_store</item>+      <item>proxy_store_access</item>+      <item>proxy_temp_file_write_size</item>+      <item>proxy_temp_path</item>+      <item>proxy_timeout</item>+      <item>proxy_upload_rate</item>+      <item>queue</item>+      <item>quic_active_connection_id_limit</item>+      <item>quic_bpf</item>+      <item>quic_gso</item>+      <item>quic_host_key</item>+      <item>quic_retry</item>+      <item>random</item>+      <item>random_index</item>+      <item>read_ahead</item>+      <item>read_timeout</item>+      <item>real_ip_header</item>+      <item>real_ip_recursive</item>+      <item>recursive_error_pages</item>+      <item>referer_hash_bucket_size</item>+      <item>referer_hash_max_size</item>+      <item>request_pool_size</item>+      <item>reset_timedout_connection</item>+      <item>resolver</item>+      <item>resolver_timeout</item>+      <item>return</item>+      <item>rewrite</item>+      <item>rewrite_log</item>+      <item>root</item>+      <item>satisfy</item>+      <item>scgi_bind</item>+      <item>scgi_buffer_size</item>+      <item>scgi_buffering</item>+      <item>scgi_buffers</item>+      <item>scgi_busy_buffers_size</item>+      <item>scgi_cache</item>+      <item>scgi_cache_background_update</item>+      <item>scgi_cache_bypass</item>+      <item>scgi_cache_key</item>+      <item>scgi_cache_lock</item>+      <item>scgi_cache_lock_age</item>+      <item>scgi_cache_lock_timeout</item>+      <item>scgi_cache_max_range_offset</item>+      <item>scgi_cache_methods</item>+      <item>scgi_cache_min_uses</item>+      <item>scgi_cache_path</item>+      <item>scgi_cache_purge</item>+      <item>scgi_cache_revalidate</item>+      <item>scgi_cache_use_stale</item>+      <item>scgi_cache_valid</item>+      <item>scgi_connect_timeout</item>+      <item>scgi_force_ranges</item>+      <item>scgi_hide_header</item>+      <item>scgi_ignore_client_abort</item>+      <item>scgi_ignore_headers</item>+      <item>scgi_intercept_errors</item>+      <item>scgi_limit_rate</item>+      <item>scgi_max_temp_file_size</item>+      <item>scgi_next_upstream</item>+      <item>scgi_next_upstream_timeout</item>+      <item>scgi_next_upstream_tries</item>+      <item>scgi_no_cache</item>+      <item>scgi_param</item>+      <item>scgi_pass</item>+      <item>scgi_pass_header</item>+      <item>scgi_pass_request_body</item>+      <item>scgi_pass_request_headers</item>+      <item>scgi_read_timeout</item>+      <item>scgi_request_buffering</item>+      <item>scgi_send_timeout</item>+      <item>scgi_socket_keepalive</item>+      <item>scgi_store</item>+      <item>scgi_store_access</item>+      <item>scgi_temp_file_write_size</item>+      <item>scgi_temp_path</item>+      <item>secure_link</item>+      <item>secure_link_md5</item>+      <item>secure_link_secret</item>+      <item>send_lowat</item>+      <item>send_timeout</item>+      <item>sendfile</item>+      <item>sendfile_max_chunk</item>+      <item>server</item>+      <item>server_name</item>+      <item>server_name_in_redirect</item>+      <item>server_names_hash_bucket_size</item>+      <item>server_names_hash_max_size</item>+      <item>server_tokens</item>+      <item>session_log</item>+      <item>session_log_format</item>+      <item>session_log_zone</item>+      <item>set</item>+      <item>set_real_ip_from</item>+      <item>slice</item>+      <item>smtp_auth</item>+      <item>smtp_capabilities</item>+      <item>smtp_client_buffer</item>+      <item>smtp_greeting_delay</item>+      <item>source_charset</item>+      <item>split_clients</item>+      <item>ssi</item>+      <item>ssi_last_modified</item>+      <item>ssi_min_file_chunk</item>+      <item>ssi_silent_errors</item>+      <item>ssi_types</item>+      <item>ssi_value_length</item>+      <item>ssl</item>+      <item>ssl_alpn</item>+      <item>ssl_buffer_size</item>+      <item>ssl_certificate</item>+      <item>ssl_certificate_key</item>+      <item>ssl_ciphers</item>+      <item>ssl_client_certificate</item>+      <item>ssl_conf_command</item>+      <item>ssl_crl</item>+      <item>ssl_dhparam</item>+      <item>ssl_early_data</item>+      <item>ssl_ecdh_curve</item>+      <item>ssl_engine</item>+      <item>ssl_handshake_timeout</item>+      <item>ssl_name</item>+      <item>ssl_ocsp</item>+      <item>ssl_ocsp_cache</item>+      <item>ssl_ocsp_responder</item>+      <item>ssl_password_file</item>+      <item>ssl_prefer_server_ciphers</item>+      <item>ssl_preread</item>+      <item>ssl_protocols</item>+      <item>ssl_reject_handshake</item>+      <item>ssl_server_name</item>+      <item>ssl_session_cache</item>+      <item>ssl_session_ticket_key</item>+      <item>ssl_session_tickets</item>+      <item>ssl_session_timeout</item>+      <item>ssl_stapling</item>+      <item>ssl_stapling_file</item>+      <item>ssl_stapling_responder</item>+      <item>ssl_stapling_verify</item>+      <item>ssl_trusted_certificate</item>+      <item>ssl_verify</item>+      <item>ssl_verify_client</item>+      <item>ssl_verify_depth</item>+      <item>starttls</item>+      <item>state</item>+      <item>status</item>+      <item>status_format</item>+      <item>status_zone</item>+      <item>sticky</item>+      <item>sticky_cookie_insert</item>+      <item>stream</item>+      <item>stub_status</item>+      <item>sub_filter</item>+      <item>sub_filter_last_modified</item>+      <item>sub_filter_once</item>+      <item>sub_filter_types</item>+      <item>subrequest_output_buffer_size</item>+      <item>tcp_nodelay</item>+      <item>tcp_nopush</item>+      <item>thread_pool</item>+      <item>timeout</item>+      <item>timer_resolution</item>+      <item>try_files</item>+      <item>types</item>+      <item>types_hash_bucket_size</item>+      <item>types_hash_max_size</item>+      <item>underscores_in_headers</item>+      <item>uninitialized_variable_warn</item>+      <item>upstream</item>+      <item>upstream_conf</item>+      <item>usage_report</item>+      <item>use</item>+      <item>user</item>+      <item>userid</item>+      <item>userid_domain</item>+      <item>userid_expires</item>+      <item>userid_flags</item>+      <item>userid_mark</item>+      <item>userid_name</item>+      <item>userid_p3p</item>+      <item>userid_path</item>+      <item>userid_service</item>+      <item>uuid_file</item>+      <item>uwsgi_bind</item>+      <item>uwsgi_buffer_size</item>+      <item>uwsgi_buffering</item>+      <item>uwsgi_buffers</item>+      <item>uwsgi_busy_buffers_size</item>+      <item>uwsgi_cache</item>+      <item>uwsgi_cache_background_update</item>+      <item>uwsgi_cache_bypass</item>+      <item>uwsgi_cache_key</item>+      <item>uwsgi_cache_lock</item>+      <item>uwsgi_cache_lock_age</item>+      <item>uwsgi_cache_lock_timeout</item>+      <item>uwsgi_cache_max_range_offset</item>+      <item>uwsgi_cache_methods</item>+      <item>uwsgi_cache_min_uses</item>+      <item>uwsgi_cache_path</item>+      <item>uwsgi_cache_purge</item>+      <item>uwsgi_cache_revalidate</item>+      <item>uwsgi_cache_use_stale</item>+      <item>uwsgi_cache_valid</item>+      <item>uwsgi_connect_timeout</item>+      <item>uwsgi_force_ranges</item>+      <item>uwsgi_hide_header</item>+      <item>uwsgi_ignore_client_abort</item>+      <item>uwsgi_ignore_headers</item>+      <item>uwsgi_intercept_errors</item>+      <item>uwsgi_limit_rate</item>+      <item>uwsgi_max_temp_file_size</item>+      <item>uwsgi_modifier1</item>+      <item>uwsgi_modifier2</item>+      <item>uwsgi_next_upstream</item>+      <item>uwsgi_next_upstream_timeout</item>+      <item>uwsgi_next_upstream_tries</item>+      <item>uwsgi_no_cache</item>+      <item>uwsgi_param</item>+      <item>uwsgi_pass</item>+      <item>uwsgi_pass_header</item>+      <item>uwsgi_pass_request_body</item>+      <item>uwsgi_pass_request_headers</item>+      <item>uwsgi_read_timeout</item>+      <item>uwsgi_request_buffering</item>+      <item>uwsgi_send_timeout</item>+      <item>uwsgi_socket_keepalive</item>+      <item>uwsgi_ssl_certificate</item>+      <item>uwsgi_ssl_certificate_key</item>+      <item>uwsgi_ssl_ciphers</item>+      <item>uwsgi_ssl_conf_command</item>+      <item>uwsgi_ssl_crl</item>+      <item>uwsgi_ssl_name</item>+      <item>uwsgi_ssl_password_file</item>+      <item>uwsgi_ssl_protocols</item>+      <item>uwsgi_ssl_server_name</item>+      <item>uwsgi_ssl_session_reuse</item>+      <item>uwsgi_ssl_trusted_certificate</item>+      <item>uwsgi_ssl_verify</item>+      <item>uwsgi_ssl_verify_depth</item>+      <item>uwsgi_store</item>+      <item>uwsgi_store_access</item>+      <item>uwsgi_temp_file_write_size</item>+      <item>uwsgi_temp_path</item>+      <item>valid_referers</item>+      <item>variables_hash_bucket_size</item>+      <item>variables_hash_max_size</item>+      <item>worker_aio_requests</item>+      <item>worker_connections</item>+      <item>worker_cpu_affinity</item>+      <item>worker_priority</item>+      <item>worker_processes</item>+      <item>worker_rlimit_core</item>+      <item>worker_rlimit_nofile</item>+      <item>worker_shutdown_timeout</item>+      <item>working_directory</item>+      <item>xclient</item>+      <item>xml_entities</item>+      <item>xslt_last_modified</item>+      <item>xslt_param</item>+      <item>xslt_string_param</item>+      <item>xslt_stylesheet</item>+      <item>xslt_types</item>+      <item>zone</item>+      <item>zone_sync</item>+      <item>zone_sync_buffers</item>+      <item>zone_sync_connect_retry_interval</item>+      <item>zone_sync_connect_timeout</item>+      <item>zone_sync_interval</item>+      <item>zone_sync_recv_buffer_size</item>+      <item>zone_sync_server</item>+      <item>zone_sync_ssl</item>+      <item>zone_sync_ssl_certificate</item>+      <item>zone_sync_ssl_certificate_key</item>+      <item>zone_sync_ssl_ciphers</item>+      <item>zone_sync_ssl_conf_command</item>+      <item>zone_sync_ssl_crl</item>+      <item>zone_sync_ssl_name</item>+      <item>zone_sync_ssl_password_file</item>+      <item>zone_sync_ssl_protocols</item>+      <item>zone_sync_ssl_server_name</item>+      <item>zone_sync_ssl_trusted_certificate</item>+      <item>zone_sync_ssl_verify</item>+      <item>zone_sync_ssl_verify_depth</item>+      <item>zone_sync_timeout</item>+    </list>++    <!-- see https://nginx.org/en/docs/varindex.html for a full list of variables -->+    <list name="variables">+      <item>$ancient_browser</item>+      <item>$args</item>+      <item>$binary_remote_addr</item>+      <item>$body_bytes_sent</item>+      <item>$bytes_received</item>+      <item>$bytes_sent</item>+      <item>$connection</item>+      <item>$connection_requests</item>+      <item>$connection_time</item>+      <item>$connections_active</item>+      <item>$connections_reading</item>+      <item>$connections_waiting</item>+      <item>$connections_writing</item>+      <item>$content_length</item>+      <item>$content_type</item>+      <item>$date_gmt</item>+      <item>$date_local</item>+      <item>$document_root</item>+      <item>$document_uri</item>+      <item>$fastcgi_path_info</item>+      <item>$fastcgi_script_name</item>+      <item>$geoip_area_code</item>+      <item>$geoip_city</item>+      <item>$geoip_city_continent_code</item>+      <item>$geoip_city_country_code</item>+      <item>$geoip_city_country_code3</item>+      <item>$geoip_city_country_name</item>+      <item>$geoip_country_code</item>+      <item>$geoip_country_code3</item>+      <item>$geoip_country_name</item>+      <item>$geoip_dma_code</item>+      <item>$geoip_latitude</item>+      <item>$geoip_longitude</item>+      <item>$geoip_org</item>+      <item>$geoip_postal_code</item>+      <item>$geoip_region</item>+      <item>$geoip_region_name</item>+      <item>$gzip_ratio</item>+      <item>$host</item>+      <item>$hostname</item>+      <item>$http2</item>+      <item>$http3</item>+      <item>$https</item>+      <item>$invalid_referer</item>+      <item>$is_args</item>+      <item>$jwt_payload</item>+      <item>$limit_conn_status</item>+      <item>$limit_rate</item>+      <item>$limit_req_status</item>+      <item>$memcached_key</item>+      <item>$modern_browser</item>+      <item>$mqtt_preread_clientid</item>+      <item>$mqtt_preread_username</item>+      <item>$msec</item>+      <item>$msie</item>+      <item>$nginx_version</item>+      <item>$otel_parent_id</item>+      <item>$otel_parent_sampled</item>+      <item>$otel_span_id</item>+      <item>$otel_trace_id</item>+      <item>$pid</item>+      <item>$pipe</item>+      <item>$protocol</item>+      <item>$proxy_add_x_forwarded_for</item>+      <item>$proxy_host</item>+      <item>$proxy_port</item>+      <item>$proxy_protocol_addr</item>+      <item>$proxy_protocol_port</item>+      <item>$proxy_protocol_server_addr</item>+      <item>$proxy_protocol_server_port</item>+      <item>$proxy_protocol_tlv_aws_vpce_id</item>+      <item>$proxy_protocol_tlv_azure_pel_id</item>+      <item>$proxy_protocol_tlv_gcp_conn_id</item>+      <item>$query_string</item>+      <item>$realip_remote_addr</item>+      <item>$realip_remote_port</item>+      <item>$realpath_root</item>+      <item>$remote_addr</item>+      <item>$remote_port</item>+      <item>$remote_user</item>+      <item>$request</item>+      <item>$request_body</item>+      <item>$request_body_file</item>+      <item>$request_completion</item>+      <item>$request_filename</item>+      <item>$request_id</item>+      <item>$request_length</item>+      <item>$request_method</item>+      <item>$request_time</item>+      <item>$request_uri</item>+      <item>$scheme</item>+      <item>$secure_link</item>+      <item>$secure_link_expires</item>+      <item>$server_addr</item>+      <item>$server_name</item>+      <item>$server_port</item>+      <item>$server_protocol</item>+      <item>$session_log_binary_id</item>+      <item>$session_log_id</item>+      <item>$session_time</item>+      <item>$slice_range</item>+      <item>$ssl_alpn_protocol</item>+      <item>$ssl_cipher</item>+      <item>$ssl_ciphers</item>+      <item>$ssl_client_cert</item>+      <item>$ssl_client_escaped_cert</item>+      <item>$ssl_client_fingerprint</item>+      <item>$ssl_client_i_dn</item>+      <item>$ssl_client_i_dn_legacy</item>+      <item>$ssl_client_raw_cert</item>+      <item>$ssl_client_s_dn</item>+      <item>$ssl_client_s_dn_legacy</item>+      <item>$ssl_client_serial</item>+      <item>$ssl_client_v_end</item>+      <item>$ssl_client_v_remain</item>+      <item>$ssl_client_v_start</item>+      <item>$ssl_client_verify</item>+      <item>$ssl_curve</item>+      <item>$ssl_curves</item>+      <item>$ssl_early_data</item>+      <item>$ssl_preread_alpn_protocols</item>+      <item>$ssl_preread_protocol</item>+      <item>$ssl_preread_server_name</item>+      <item>$ssl_protocol</item>+      <item>$ssl_server_name</item>+      <item>$ssl_session_id</item>+      <item>$ssl_session_reused</item>+      <item>$status</item>+      <item>$tcpinfo_rcv_space</item>+      <item>$tcpinfo_rtt</item>+      <item>$tcpinfo_rttvar</item>+      <item>$tcpinfo_snd_cwnd</item>+      <item>$time_iso8601</item>+      <item>$time_local</item>+      <item>$uid_got</item>+      <item>$uid_reset</item>+      <item>$uid_set</item>+      <item>$upstream_addr</item>+      <item>$upstream_bytes_received</item>+      <item>$upstream_bytes_sent</item>+      <item>$upstream_cache_status</item>+      <item>$upstream_connect_time</item>+      <item>$upstream_first_byte_time</item>+      <item>$upstream_header_time</item>+      <item>$upstream_last_server_name</item>+      <item>$upstream_queue_time</item>+      <item>$upstream_response_length</item>+      <item>$upstream_response_time</item>+      <item>$upstream_session_time</item>+      <item>$upstream_status</item>+      <item>$uri</item>+    </list>++    <list name="keywords">+      <item>on</item>+      <item>off</item>+      <item>ssl</item> <!-- listen ... ssl -->+      <item>all</item> <!-- deny all -->+    </list>++    <contexts>+      <context attribute="Normal Text" lineEndContext="#stay" name="Normal">+        <DetectSpaces/>+        <keyword attribute="Directive" context="Params" String="directives"/>+        <DetectChar attribute="Symbol" context="#stay" char="}" endRegion="Block"/>+        <IncludeRules context="Variables"/>+        <DetectChar attribute="String" context="Strings" char="'" beginRegion="String"/>+        <DetectChar attribute="Comment" context="Comment" char="#"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#stay" name="Params">+        <DetectSpaces/>+        <DetectChar attribute="Symbol" context="#pop" char=";"/>+        <DetectChar attribute="Symbol" context="#pop" char="{" beginRegion="Block"/>+        <IncludeRules context="Variables"/>+        <DetectChar attribute="String" context="Strings" char="'" beginRegion="String"/>+        <RegExpr attribute="Number" context="#stay" String="\b[0-9]+&units;?\b"/>+        <keyword attribute="Keyword" context="#stay" String="keywords"/>+        <DetectChar attribute="Comment" context="Comment" char="#"/>+      </context>++      <context attribute="Variable" lineEndContext="#pop" name="Variables">+        <keyword attribute="Variable" context="#stay" String="variables"/>+        <RegExpr attribute="Variable" String="\$[a-zA-Z_0-9]+\b" context="#stay"/>+      </context>++      <context attribute="String" lineEndContext="#stay" name="Strings">+        <IncludeRules context="Variables"/>+        <DetectChar attribute="String" context="#pop" char="'" endRegion="String"/>+      </context>++      <context name="Comment" attribute="Comment" lineEndContext="#pop">+        <DetectSpaces/>+        <IncludeRules context="##Comments"/>+      </context>+    </contexts>+    <itemDatas>+      <itemData name="Normal Text" defStyleNum="dsNormal"   spellChecking="false"/>+      <itemData name="Directive"   defStyleNum="dsDataType" spellChecking="false"/>+      <itemData name="Keyword"     defStyleNum="dsKeyword"  spellChecking="false"/>+      <itemData name="Comment"     defStyleNum="dsComment"/>+      <itemData name="Variable"    defStyleNum="dsVariable"/>+      <itemData name="Symbol"      defStyleNum="dsOperator" spellChecking="false"/>+      <itemData name="String"      defStyleNum="dsString"/>+      <itemData name="Number"      defStyleNum="dsDecVal"/>+    </itemDatas>+  </highlighting>+  <general>+    <comments>+      <comment name="singleLine" start="#" position="afterwhitespace" />+    </comments>+    <keywords casesensitive="1" />+  </general>+</language>+<!-- kate: replace-tabs on; tab-width 2; indent-width 2; -->
+ xml/ninja.xml view
@@ -0,0 +1,284 @@+<?xml version="1.0" encoding="UTF-8"?>+<!DOCTYPE language[+  <!ENTITY ident "[-_a-zA-Z0-9]+">+  <!ENTITY deplist "[^$|:]+">+]>+<language+  name="Ninja" section="Other"+  version="3" kateversion="5.0"+  extensions="*.ninja"+  author="Jonathan Poelen (jonathan.poelen@gmail.com)" license="MIT"+>+  <highlighting>+    <list name="keywords">+      <item>rule</item>+      <item>build</item>+      <item>pool</item>+      <item>default</item>+      <item>include</item>+      <item>subninja</item>+    </list>++    <list name="other keywords">+      <item>console</item>+      <item>phony</item>+      <item>depth</item>+    </list>++    <list name="topVariables">+      <item>builddir</item>+      <item>ninja_required_version</item>+    </list>++    <list name="ruleVariables">+      <item>command</item>+      <item>console</item>+      <item>depfile</item>+      <item>deps</item>+      <item>msvc_deps_prefix</item>+      <item>description</item>+      <item>dyndep</item>+      <item>generator</item>+      <item>in</item>+      <item>in_newline</item>+      <item>out</item>+      <item>pool</item>+      <item>restat</item>+      <item>rspfile</item>+      <item>rspfile_content</item>+    </list>++    <contexts>+      <context attribute="Normal" name="Normal" lineEndContext="#stay" fallthrough="1" fallthroughContext="ErrorOrComment">+        <DetectChar attribute="Comment" context="Comment" char="#"/>+        <WordDetect attribute="Keyword" context="BuildStatement" String="build"/>+        <WordDetect attribute="Keyword" context="RuleStatement" String="rule"/>+        <WordDetect attribute="Keyword" context="PoolStatement" String="pool"/>+        <keyword attribute="Keyword" context="SimpleStatement" String="keywords"/>+        <keyword attribute="Special Key" context="VariableAssignment" String="topVariables"/>+        <RegExpr attribute="Key" context="VariableAssignment" String="&ident;"/>+      </context>++      <context attribute="Normal" name="ErrorOrComment" lineEndContext="#pop" fallthrough="1" fallthroughContext="#pop!Error">+        <DetectSpaces/>+        <DetectChar attribute="Comment" context="Comment" char="#"/>+      </context>++      <context attribute="Error" name="Error" lineEndContext="#pop"/>++      <!-- rule -->++      <context attribute="Normal" name="RuleStatement" lineEndContext="#pop" fallthrough="1" fallthroughContext="Error">+        <DetectSpaces/>+        <RegExpr attribute="Normal" context="#pop!RuleKeys" String="&ident;"/>+      </context>++      <context attribute="Normal" name="RuleKeys" lineEndContext="#stay" fallthrough="1" fallthroughContext="#pop">+        <DetectSpaces context="RuleKey"/>+        <DetectChar attribute="Comment" context="Comment" char="#"/>+      </context>++      <context attribute="Normal" name="RuleKey" lineEndContext="#pop" fallthrough="1" fallthroughContext="#pop!Error">+        <DetectChar attribute="Comment" context="#pop!Comment" char="#"/>+        <WordDetect attribute="Special Key" context="#pop!PoolVariableAssignment" String="pool"/>+        <keyword attribute="Special Key" context="#pop!RuleVariableAssignment" String="ruleVariables"/>+      </context>++      <context attribute="Normal" name="RuleVariableAssignment" lineEndContext="#pop" fallthrough="1" fallthroughContext="Error">+        <DetectSpaces/>+        <DetectChar attribute="Operator" context="#pop!RuleValue" char="="/>+      </context>++      <context attribute="Normal" name="RuleValue" lineEndContext="#pop">+        <DetectSpaces/>+        <DetectChar attribute="Normal" context="RuleDollar" char="$" lookAhead="true"/>+        <AnyChar attribute="Symbol" context="#stay" String="&lt;>&amp;|=(){}[]&quot;';!%?*"/>+        <RegExpr attribute="Normal" context="#stay" String="[^&lt;>&amp;|=(){}[\]&quot;';!%?*$]"/>+      </context>++      <context attribute="Error" name="RuleDollar" lineEndContext="#pop">+        <LineContinue attribute="Line Continuation" context="#pop!LineContinuation" char="$"/>+        <Detect2Chars attribute="Special Char" context="#pop" char="$" char1=" "/>+        <Detect2Chars attribute="Special Char" context="#pop" char="$" char1="$"/>+        <Detect2Chars attribute="Special Char" context="#pop" char="$" char1=":"/>+        <Detect2Chars attribute="Variable Delimiter" context="#pop!RuleOpenVariableName" char="$" char1="{"/>+        <DetectChar attribute="Variable Delimiter" context="#pop!RuleVariableName" char="$"/>+      </context>++      <context attribute="Variable" name="RuleOpenVariableName" lineEndContext="#pop" fallthrough="1" fallthroughContext="Error">+        <DetectChar attribute="Variable Delimiter" context="#pop" char="}"/>+        <keyword attribute="Special Variable" context="#stay" String="ruleVariables"/>+        <RegExpr attribute="Variable" context="#stay" String="&ident;"/>+      </context>++      <context attribute="Variable" name="RuleVariableName" lineEndContext="#pop" fallthrough="1" fallthroughContext="Error">+        <keyword attribute="Special Variable" context="#pop" String="ruleVariables"/>+        <RegExpr attribute="Variable" context="#pop" String="&ident;"/>+      </context>++      <!-- build -->++      <context attribute="Normal" name="BuildStatement" lineEndContext="#pop">+        <DetectSpaces/>+        <DetectChar attribute="Normal" context="Dollar" char="$" lookAhead="true"/>+        <DetectChar attribute="Operator" context="#pop!BuildRuleName" char=":"/>+        <DetectChar attribute="Operator" context="#pop!ImplicitOutput" char="|"/>+        <RegExpr attribute="Normal" context="#stay" String="&deplist;"/>+      </context>++      <context attribute="Implicit Output" name="ImplicitOutput" lineEndContext="#pop">+        <DetectSpaces/>+        <DetectChar attribute="Normal" context="Dollar" char="$" lookAhead="true"/>+        <DetectChar attribute="Operator" context="#pop!BuildRuleName" char=":"/>+        <RegExpr attribute="Implicit Output" context="#stay" String="&deplist;"/>+      </context>++      <context attribute="Normal" name="BuildRuleName" lineEndContext="#pop" fallthrough="1" fallthroughContext="#pop!Error">+        <DetectSpaces/>+        <WordDetect attribute="Special Rule Name" context="#pop!BuildDependancies" String="phony"/>+        <RegExpr attribute="Rule Name" context="#pop!BuildDependancies" String="&ident;"/>+      </context>++      <context attribute="Dependancy" name="BuildDependancies" lineEndContext="#pop!BuildKeys">+        <DetectSpaces/>+        <DetectChar attribute="Normal" context="Dollar" char="$" lookAhead="true"/>+        <Detect2Chars attribute="Operator" context="#pop!ImplicitBuildDependancies" char="|" char1="@"/>+        <DetectChar attribute="Operator" context="#pop!ImplicitBuildDependancies" char="|"/>+        <DetectChar attribute="Error" context="#stay" char=":"/>+        <RegExpr attribute="Dependancy" context="#stay" String="&deplist;"/>+      </context>++      <context attribute="Implicit Dependancy" name="ImplicitBuildDependancies" lineEndContext="#pop!BuildKeys">+        <DetectSpaces/>+        <DetectChar attribute="Normal" context="Dollar" char="$" lookAhead="true"/>+        <Detect2Chars attribute="Operator" context="#stay" char="|" char1="@"/>+        <DetectChar attribute="Operator" context="#stay" char="|"/>+        <DetectChar attribute="Error" context="#stay" char=":"/>+        <RegExpr attribute="Implicit Dependancy" context="#stay" String="&deplist;"/>+      </context>++      <context attribute="Normal" name="BuildKeys" lineEndContext="#stay" fallthrough="1" fallthroughContext="#pop">+        <DetectSpaces context="BuildKey"/>+        <DetectChar attribute="Comment" context="Comment" char="#"/>+      </context>++      <context attribute="Normal" name="BuildKey" lineEndContext="#pop" fallthrough="1" fallthroughContext="#pop!Error">+        <DetectChar attribute="Comment" context="#pop!Comment" char="#"/>+        <WordDetect attribute="Special Key" context="#pop!PoolVariableAssignment" String="pool"/>+        <keyword attribute="Special Key" context="#pop!VariableAssignment" String="ruleVariables"/>+        <RegExpr attribute="Key" context="#pop!VariableAssignment" String="&ident;"/>+      </context>++      <!-- pool -->++      <context attribute="Normal" name="PoolStatement" lineEndContext="#pop" fallthrough="1" fallthroughContext="#pop!Error">+        <DetectSpaces/>+        <RegExpr attribute="Normal" context="#pop!PoolKeys" String="&ident;"/>+      </context>++      <context attribute="Normal" name="PoolKeys" lineEndContext="#stay" fallthrough="1" fallthroughContext="#pop">+        <DetectSpaces context="PoolKey"/>+        <DetectChar attribute="Comment" context="Comment" char="#"/>+      </context>++      <context attribute="Normal" name="PoolKey" lineEndContext="#pop" fallthrough="1" fallthroughContext="#pop!Error">+        <DetectChar attribute="Comment" context="#pop!Comment" char="#"/>+        <WordDetect attribute="Special Key" context="#pop!PoolVariableAssignment" String="depth"/>+      </context>++      <context attribute="Normal" name="PoolVariableAssignment" lineEndContext="#pop" fallthrough="1" fallthroughContext="Error">+        <DetectSpaces/>+        <DetectChar attribute="Operator" context="#pop!PoolValue" char="="/>+      </context>++      <context attribute="Normal" name="PoolValue" lineEndContext="#pop">+        <DetectSpaces/>+        <DetectChar attribute="Normal" context="Dollar" char="$" lookAhead="true"/>+        <WordDetect attribute="Special Value" context="BuildStatement" String="console"/>+        <RegExpr attribute="Normal" context="#stay" String="&ident;"/>+      </context>++      <!-- default, include, subninja -->++      <context attribute="Normal" name="SimpleStatement" lineEndContext="#pop" fallthrough="1" fallthroughContext="#pop!Error">+        <DetectChar attribute="Normal" context="Dollar" char="$" lookAhead="true"/>+        <RegExpr attribute="Normal" context="#stay" String="&deplist;"/>+      </context>++      <!-- Value -->++      <context attribute="Normal" name="VariableAssignment" lineEndContext="#pop" fallthrough="1" fallthroughContext="Error">+        <DetectSpaces/>+        <DetectChar attribute="Operator" context="#pop!Value" char="="/>+      </context>++      <context attribute="Normal" name="Value" lineEndContext="#pop">+        <DetectSpaces/>+        <DetectChar attribute="Normal" context="Dollar" char="$" lookAhead="true"/>+        <AnyChar attribute="Symbol" context="#stay" String="&lt;>&amp;|=(){}[]&quot;';!%?*"/>+        <RegExpr attribute="Normal" context="#stay" String="[^&lt;>&amp;|=(){}[\]&quot;';!%?*$]"/>+      </context>++      <!-- $ -->++      <context attribute="Error" name="Dollar" lineEndContext="#pop">+        <LineContinue attribute="Line Continuation" context="#pop!LineContinuation" char="$"/>+        <Detect2Chars attribute="Special Char" context="#pop" char="$" char1=" "/>+        <Detect2Chars attribute="Special Char" context="#pop" char="$" char1="$"/>+        <Detect2Chars attribute="Special Char" context="#pop" char="$" char1=":"/>+        <Detect2Chars attribute="Variable Delimiter" context="#pop!OpenVariableName" char="$" char1="{"/>+        <DetectChar attribute="Variable Delimiter" context="#pop!VariableName" char="$"/>+      </context>++      <context attribute="Variable" name="OpenVariableName" lineEndContext="#pop" fallthrough="1" fallthroughContext="Error">+        <DetectChar attribute="Variable Delimiter" context="#pop" char="}"/>+        <RegExpr attribute="Variable" context="#stay" String="&ident;"/>+      </context>++      <context attribute="Variable" name="VariableName" lineEndContext="#pop" fallthrough="1" fallthroughContext="Error">+        <RegExpr attribute="Variable" context="#pop" String="&ident;"/>+      </context>++      <context attribute="Line Continuation" name="LineContinuation" lineEndContext="#pop" fallthrough="1" fallthroughContext="#pop">+        <DetectSpaces/>+      </context>++      <!-- comment -->++      <context attribute="Comment" lineEndContext="#pop" name="Comment">+        <DetectSpaces/>+        <IncludeRules context="##Comments" />+        <DetectIdentifier attribute="Comment" />+      </context>++    </contexts>++    <itemDatas>+      <itemData name="Normal" defStyleNum="dsNormal" spellChecking="0"/>+      <itemData name="Keyword" defStyleNum="dsKeyword" spellChecking="0"/>+      <itemData name="Comment" defStyleNum="dsComment"/>+      <itemData name="Rule Name" defStyleNum="dsFunction" spellChecking="0"/>+      <itemData name="Special Rule Name" defStyleNum="dsBuiltIn" spellChecking="0"/>+      <itemData name="Dependancy" defStyleNum="dsNormal" spellChecking="0"/>+      <itemData name="Implicit Dependancy" defStyleNum="dsNormal" italic="1" spellChecking="0"/>+      <itemData name="Implicit Output" defStyleNum="dsNormal" italic="1" spellChecking="0"/>+      <itemData name="Special Key" defStyleNum="dsBuiltIn" spellChecking="0"/>+      <itemData name="Key" defStyleNum="dsVariable" spellChecking="0"/>+      <itemData name="Variable Delimiter" defStyleNum="dsOperator" spellChecking="0"/>+      <itemData name="Special Variable" defStyleNum="dsBuiltIn" spellChecking="0"/>+      <itemData name="Variable" defStyleNum="dsVariable" spellChecking="0"/>+      <itemData name="Special Value" defStyleNum="dsBuiltIn" spellChecking="0"/>+      <itemData name="Operator" defStyleNum="dsOperator" spellChecking="0"/>+      <itemData name="Line Continuation" defStyleNum="dsSpecialChar" spellChecking="0"/>+      <itemData name="Special Char" defStyleNum="dsSpecialChar" spellChecking="0"/>+      <itemData name="Symbol" defStyleNum="dsNormal" bold="1" spellChecking="0"/>+      <itemData name="Error" defStyleNum="dsError" spellChecking="0"/>+    </itemDatas>+  </highlighting>+  <general>+    <comments>+      <comment name="singleLine" start="#"/>+    </comments>+  </general>+</language>+<!-- kate: space-indent on; indent-width 2; replace-tabs on; -->
xml/nix.xml view
@@ -4,7 +4,7 @@ ]>  <!---    SPDX-FileCopyrightText: 2024 Marco Rebhan <me@dblsaiko.net>+    SPDX-FileCopyrightText: 2024-2025 Katalin Rebhan <me@dblsaiko.net>     SPDX-FileContributor: Tuan Le <webmaster@michivi.com>      SPDX-License-Identifier: MIT@@ -12,18 +12,17 @@  <language     name="Nix"-    version="4"+    version="5"     kateversion="5.79"     section="Scripts"     extensions="*.nix"     casesensitive="1"-    author="Marco Rebhan &lt;me@dblsaiko.net&gt;"+    author="Katalin Rebhan &lt;me@dblsaiko.net&gt;"     license="MIT"     priority="1" >     <highlighting>         <list name="keywords">-            <item>assert</item>             <item>rec</item>             <item>and</item>             <item>or</item>@@ -50,6 +49,7 @@                 <WordDetect String="let" attribute="Keyword" context="Let" />                 <WordDetect String="if" attribute="Keyword" context="If" />                 <WordDetect String="with" attribute="Keyword" context="With" />+                <WordDetect String="assert" attribute="Keyword" context="Assert" />                 <Detect2Chars char="/" char1="/" attribute="Operator" />                 <Detect2Chars char="?" char1="?" attribute="Operator" />                 <Detect2Chars char="+" char1="+" attribute="Operator" />@@ -259,6 +259,10 @@             </context>              <context name="With" attribute="Normal Text" lineEndContext="#stay">+                <DetectChar char=";" attribute="Symbol" context="#pop" />+                <IncludeRules context="Expression" />+            </context>+            <context name="Assert" attribute="Normal Text" lineEndContext="#stay">                 <DetectChar char=";" attribute="Symbol" context="#pop" />                 <IncludeRules context="Expression" />             </context>
xml/ocaml.xml view
@@ -18,9 +18,9 @@           extensions="*.ml;*.mli"           mimetype="text/x-ocaml"           section="Sources"-          version="11"+          version="12"           priority="10"-          kateversion="5.79"+          kateversion="6.22"           author="Glyn Webster (glynwebster@orcon.net.nz) and Vincent Hugot (vincent.hugot@gmail.com)"           license="LGPL" >
+ xml/ocamllex.xml view
@@ -0,0 +1,82 @@+<?xml version="1.0" encoding="UTF-8"?>+<!-- Kate syntax highlighting for the Objective Caml 'Ocamlllex' -->+<!DOCTYPE language+[+<!-- Regular expresion constants: -->+<!ENTITY LETTER "A-Za-z\300-\326\330-\366\370-\377">                <!-- Latin-1 letters. -->+<!ENTITY IDENT  "`?[&LETTER;_][&LETTER;0-9_']*">                    <!-- OCaml identifiers. -->+<!ENTITY ESC    "(\\[ntbr'&quot;\\]|\\[0-9]{3}|\\x[0-9A-Fa-f]{2})"> <!-- OCaml character code escapes. -->+]>+<language name="Objective Caml Ocamllex"+          section="Sources"+          extensions="*.mll"+          mimetype=""+          version="8"+          kateversion="6.22"+          priority="10"+          author="Glyn Webster (glynwebster@orcon.net.nz) and Vincent Hugot (vincent.hugot@gmail.com)"+          license="LGPL" >++  <highlighting>++    <list name="keywords">+      <item>and</item>+      <item>as</item>+      <item>eof</item>+      <item>let</item>+      <item>parse</item>+      <item>rule</item>+      <item>shortest</item>+    </list>++    <contexts>+      <context name="Rules" lineEndContext="#stay" attribute="Normal">+        <Detect2Chars char="(" char1="*"      context="Comment" attribute="Comment" beginRegion="comment" />+        <DetectChar   char="{"                context="Ocaml"   attribute="Normal"  beginRegion="code" />+        <DetectChar   char="&quot;"           context="String"  attribute="String" />+        <RegExpr      String="'(&ESC;|[^'])'" context="#stay"   attribute="Character" />+        <keyword      String="keywords"       context="#stay"   attribute="Keyword" />+        <RegExpr      String="&IDENT;"        context="#stay"   attribute="Identifier" />+        <DetectChar   char="}"                context="#stay"   attribute="Mismatched Brackets" />+        <Detect2Chars char="*" char1=")"      context="#stay"   attribute="Mismatched Brackets" />+      </context>++      <context name="Comment" lineEndContext="#stay" attribute="Comment">+        <Detect2Chars char="*" char1=")" context="#pop"    attribute="Comment" endRegion="comment" />+        <Detect2Chars char="(" char1="*" context="Comment" attribute="Comment" beginRegion="comment" />+        <DetectChar   char="&quot;"      context="String"  attribute="String" />+        <DetectSpaces />+        <IncludeRules context="##Comments" />+      </context>++      <context name="Ocaml" lineEndContext="#stay" attribute="Normal">+        <DetectChar char="}" context="#pop" attribute="Normal" endRegion="code" />+        <IncludeRules context="##Objective Caml" includeAttrib="true" />+      </context>++      <context name="String" lineEndContext="#stay" attribute="String">+        <DetectChar char="&quot;"  context="#pop"  attribute="String" />+        <RegExpr    String="&ESC;|\\$"   context="#stay" attribute="Escaped Characters" />+      </context>+    </contexts>++    <itemDatas>+      <itemData name="Normal"                  defStyleNum="dsOthers"    />+      <itemData name="Identifier"              defStyleNum="dsNormal"   />+      <itemData name="Keyword"                 defStyleNum="dsOthers" bold="true" />+      <itemData name="Character"               defStyleNum="dsChar"     />+      <itemData name="String"                  defStyleNum="dsString"   />+      <itemData name="Escaped Characters"      defStyleNum="dsChar"     />+      <itemData name="Comment"                 defStyleNum="dsComment"  />+      <itemData name="Mismatched Brackets"     defStyleNum="dsError"    />+    </itemDatas>+  </highlighting>++  <general>+    <keywords casesensitive="true" />+    <comments>+      <comment name="multiLine" start="(*" end="*)" region="comment" />+    </comments>+  </general>+</language>+<!-- kate: space-indent on; indent-width 2; replace-tabs on; -->
+ xml/ocamlyacc.xml view
@@ -0,0 +1,162 @@+<?xml version="1.0" encoding="UTF-8"?>+<!-- Kate syntax highlighting for the Objective Caml 'Ocamlllex' -->+<!DOCTYPE language+[+<!-- Regular expresion constants: -->+<!ENTITY LOWER  "a-z\300-\326\330-\337">         <!-- Lowercase Latin-1 letters. -->+<!ENTITY UPPER  "A-Z\340-\366\370-\377">         <!-- Uppercase Latin-1 letters. -->+<!ENTITY LETTER "&LOWER;&UPPER;">                <!-- All Latin-1 letters. -->+<!ENTITY LIDENT "[&LOWER;_][&LETTER;0-9_']*">    <!-- Lowercase OCaml identifiers. -->+<!ENTITY UIDENT "`?[&UPPER;][&LETTER;0-9_']*">   <!-- Uppercase OCaml identifiers. -->+<!ENTITY IDENT  "`?[&LETTER;][&LETTER;0-9_']*">  <!-- All OCaml identifiers. -->+]>+<language name="Objective Caml Ocamlyacc"+          section="Sources"+          extensions="*.mly"+          mimetype=""+          version="7"+          kateversion="6.22"+          priority="10"+          author="Glyn Webster (glynwebster@orcon.net.nz) and Vincent Hugot (vincent.hugot@gmail.com)"+          license="LGPL" >++  <highlighting>+    <list name="typed symbol list keywords">+      <item>%token</item>+      <item>%type</item>+    </list>++    <list name="symbol list keywords">+      <item>%left</item>+      <item>%right</item>+      <item>%nonassoc</item>+      <item>%start</item>+    </list>++    <list name="rule keywords">+      <item>%prec</item>+      <item>error</item>+    </list>++    <contexts>+      <!-- Note: Because the Yacc grammar is so simple I've written this so that any symbol+           that has not been specifically dealt with by a highlighting rule is an error. -->++      <!-- Declaration section: Header sections and Yacc symbol declararations. -->+      <!-- A %% marks the end of the Declaration section and the start of the rules section. -->+      <context name="Declarations" lineEndContext="#stay" attribute="Error">+        <Detect2Chars char="%" char1="{"                  context="Header"            attribute="Normal" beginRegion="header" />+        <keyword      String="typed symbol list keywords" context="Typed Symbol List" attribute="Keyword" />+        <keyword      String="symbol list keywords"       context="Symbol List"       attribute="Keyword" />+        <Detect2Chars char="%" char1="%"                  context="Rules"             attribute="Normal" />+        <IncludeRules context="General" />+      </context>++      <!-- Header section: Ocaml code in the declarations between %{ %} brackets -->+      <context name="Header" lineEndContext="#stay" attribute="Normal">+        <Detect2Chars char="%" char1="}" context="#pop" attribute="Normal" endRegion="header" />+        <IncludeRules context="##Objective Caml" includeAttrib="true" />+      </context>++      <!-- A typed symbol list: an optional Ocaml type declaration between < > brackets, followed by a symbol list. -->+        <context name="Typed Symbol List" lineEndContext="#pop" attribute="Error">+        <DetectChar char="&lt;" context="Type" attribute="Normal" />+        <RegExpr String="&UIDENT;" context="Symbol List" attribute="Uppercase Name (Token)" />+        <RegExpr String="&LIDENT;" context="Symbol List" attribute="Lowercase Name (Rule)" />+        <IncludeRules context="General" />+      </context>+      <context name="Type" lineEndContext="#stay" attribute="Normal">+        <DetectChar char="&gt;" context="#pop" attribute="Normal" />+        <IncludeRules context="##Objective Caml" includeAttrib="true" />+      </context>++      <!-- A symbol list: one line of sybmol names and option comments. -->+      <context name="Symbol List" lineEndContext="#pop" attribute="Error">+        <RegExpr String="&UIDENT;" context="#stay" attribute="Uppercase Name (Token)" />+        <RegExpr String="&LIDENT;" context="#stay" attribute="Lowercase Name (Rule)" />+        <IncludeRules context="General" />+      </context>++      <!-- Rules section:. -->+      <!-- A %% marks the end of the rules section and the start of the trailer section: -->+      <context name="Rules" lineEndContext="#stay" attribute="Error">+        <Detect2Chars char="%" char1="%" context="Trailer" attribute="Normal" />+        <RegExpr String="&IDENT;" context="Rule, Expecting Colon" attribute="Rule Definition Name" beginRegion="rule" />+        <IncludeRules context="General" />+      </context>+      <context name="Rule, Expecting Colon" lineEndContext="#stay" attribute="Error">+        <DetectChar char=":" context="Rule" attribute="Normal" />+        <!-- Incomplete rule before the start of the trailer: -->+        <Detect2Chars char="%" char1="%" context="Trailer" attribute="Error" />+        <IncludeRules context="General" />+      </context>+      <context name="Rule" lineEndContext="#stay" attribute="Error">+        <DetectChar char=";"               context="#pop#pop" attribute="Normal" endRegion="rule" />+        <DetectChar char="|"               context="#stay"    attribute="Normal" />+        <keyword    String="rule keywords" context="#stay"    attribute="Keyword" />+        <RegExpr    String="&UIDENT;"      context="#stay"    attribute="Uppercase Name (Token)" />+        <RegExpr    String="&LIDENT;"      context="#stay"    attribute="Lowercase Name (Rule)" />+        <DetectChar char="{"               context="Action"   attribute="Normal" beginRegion="action" />+        <IncludeRules context="General" />+      </context>++      <!-- A rule action: Ocaml code between { } brackets containing $1,$2,$3.. symbols. -->+      <!-- (The "Nested Action" contexts override the rules for [ ] and { } brackets in the Objective+           Caml highlighting file. They make make the $1,$2,$3.. symbols show up inside those brackets.) -->+      <context name="Action" lineEndContext="#stay" attribute="Normal">+        <DetectChar char="}" context="#pop" attribute="Normal" endRegion="action" />+        <RegExpr String="[$][0-9]+" context="#stay" attribute="Semantic Attribute" />+        <DetectChar char="{" context="Nested Action 1" />+        <DetectChar char="[" context="Nested Action 2" />+        <IncludeRules context="##Objective Caml" includeAttrib="true" />+      </context>+      <context name="Nested Action 1" lineEndContext="#stay" attribute="Normal">+        <DetectChar char="}" context="#pop" />+        <IncludeRules context="Action" includeAttrib="true" />+      </context>+      <context name="Nested Action 2" lineEndContext="#stay" attribute="Normal">+        <DetectChar char="]" context="#pop" />+        <IncludeRules context="Action" includeAttrib="true" />+      </context>++      <!-- Trailer section: Ocaml code until the end of the file. -->+      <context name="Trailer" lineEndContext="#stay" attribute="Normal">+        <IncludeRules context="##Objective Caml" includeAttrib="true" />+      </context>++      <!-- General rules for all contexts: -->+      <!-- 1) Whitespace is expected. -->+      <!-- 2) Ocamlyacc's comments are in /* */ brackets and are nestable. -->+      <context name="General" lineEndContext="#stay" attribute="Normal">+        <DetectSpaces context="#stay" attribute="Normal" />+        <Detect2Chars char="/" char1="*" context="Comment" attribute="Comment" beginRegion="comment" />+      </context>+      <context name="Comment" lineEndContext="#stay" attribute="Comment">+        <Detect2Chars char="*" char1="/" context="#pop"    attribute="Comment" endRegion="comment" />+        <Detect2Chars char="/" char1="*" context="Comment" attribute="Comment" beginRegion="comment" />+        <DetectSpaces />+        <IncludeRules context="##Comments" />+      </context>++    </contexts>++    <itemDatas>+      <itemData name="Keyword"                defStyleNum="dsOthers" bold="true" />+      <itemData name="Normal"                 defStyleNum="dsOthers" />+      <itemData name="Uppercase Name (Token)" defStyleNum="dsOthers" />+      <itemData name="Lowercase Name (Rule)"  defStyleNum="dsOthers" italic="true" />+      <itemData name="Rule Definition Name"   defStyleNum="dsOthers" italic="true" bold="true" />+      <itemData name="Semantic Attribute"     defStyleNum="dsOthers" />+      <itemData name="Comment"                defStyleNum="dsComment" />+      <itemData name="Error"                  defStyleNum="dsError"  />+    </itemDatas>+  </highlighting>++  <general>+    <keywords casesensitive="true" weakDeliminator="%" />+    <comments>+      <comment name="multiLine" start="/*" end="*/" region="comment" />+    </comments>+  </general>+</language>+<!-- kate: space-indent on; indent-width 2; replace-tabs on; -->
xml/orgmode.xml view
@@ -33,7 +33,7 @@  <!-- org syntax spec: https://orgmode.org/worg/dev/org-syntax.html --> <!-- syntax highlight: https://docs.kde.org/stable5/en/kate/katepart/highlight.html -->-<language name="Org Mode" version="8" kateversion="5.79" section="Markup" extensions="*.org" priority="15" author="Gary Wang" license="MIT">+<language name="Org Mode" version="9" kateversion="6.22" section="Markup" extensions="*.org" priority="15" author="Gary Wang" license="MIT">   <highlighting>     <list name="org-todo-keywords-todo">       <item>TODO</item>@@ -243,7 +243,7 @@         <StringDetect context="#pop" attribute="Block" String="#+END_SRC" endRegion="RegionBlock" column="0"/>         <IncludeRules context="##JSON" includeAttrib="true"/>       </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="yaml-code">+      <context attribute="Normal Text" lineEndContext="#stay" name="yaml-code" fallthroughContext="Lvl0Text##YAML">         <StringDetect context="#pop" attribute="Block" String="#+END_SRC" endRegion="RegionBlock" column="0"/>         <IncludeRules context="##YAML" includeAttrib="true"/>       </context>
xml/perl.xml view
@@ -42,7 +42,7 @@     Enhance tr/// and y/// support. -->-<language name="Perl" alternativeNames="PL" version="22" kateversion="5.0" section="Scripts" extensions="*.pl;*.PL;*.pm" mimetype="application/x-perl;text/x-perl" priority="5" author="Anders Lund (anders@alweb.dk)" license="LGPLv2">+<language name="Perl" alternativeNames="PL" version="23" kateversion="5.0" section="Scripts" extensions="*.pl;*.PL;*.pm" mimetype="application/x-perl;text/x-perl" priority="5" author="Anders Lund (anders@alweb.dk)" license="LGPLv2">   <highlighting>     <list name="control_flow">       <item>if</item>@@ -860,7 +860,7 @@   </highlighting>   <general>     <comments>-      <comment name="singleLine" start="#" />+      <comment name="singleLine" start="#" position="afterwhitespace"/>     </comments>     <keywords casesensitive="1" />   </general>
xml/php.xml view
@@ -77,7 +77,7 @@   <!ENTITY float "\b&LNUM;(\.(&LNUM;)?(&EXPONENT;)?|&EXPONENT;)|\.&LNUM;(&EXPONENT;)?"> ]> -<language name="PHP/PHP" indenter="cstyle" version="28" kateversion="5.79" section="Scripts" extensions="" priority="5" mimetype="" hidden="true">+<language name="PHP/PHP" indenter="cstyle" version="29" kateversion="5.79" section="Scripts" extensions="" priority="5" mimetype="" hidden="true">   <highlighting>     <!-- https://php.watch/versions -->     <!-- Based on 8.3 (https://php.watch/versions/8.3 and https://stitcher.io/blog/new-in-php-83) -->@@ -11329,7 +11329,7 @@       </context>       <context name="heredoc" attribute="String" lineEndContext="#stay" dynamic="true">         <IncludeRules context="doublestringvariablecommon" />-        <RegExpr attribute="Heredoc" context="#pop" String="^\s*%1(?=;?$)" dynamic="true" endRegion="Heredoc" column="0" />+        <RegExpr attribute="Heredoc" context="#pop" String="^\s*%1(?=[,;]?$)" dynamic="true" endRegion="Heredoc" column="0" />       </context>        <context name="htmlnowdoc" attribute="Normal Text" lineEndContext="#stay" dynamic="true">@@ -11349,7 +11349,7 @@         <IncludeRules context="Normal##JavaScript" />       </context>       <context name="nowdoc" attribute="String" lineEndContext="#stay" dynamic="true">-        <RegExpr attribute="Nowdoc" context="#pop" String="^%1(?=;?$)" dynamic="true" endRegion="Nowdoc" column="0" />+        <RegExpr attribute="Nowdoc" context="#pop" String="^\s*%1(?=[,;]?$)" dynamic="true" endRegion="Nowdoc" column="0" />       </context>        <context name="number" attribute="PHP Text" lineEndContext="#stay">
xml/powershell.xml view
@@ -4,7 +4,7 @@ ]> <language   name="PowerShell"-  version="15"+  version="16"   kateversion="5.79"   extensions="*.ps1;*.psm1;*.psd1"   section="Scripts"@@ -905,12 +905,17 @@         <RegExpr attribute="Number" context="NumericSuffix" String="\b(0b[01]+|0x[0-9a-fA-F]+|([0-9]+(\.[0-9]*)?|\.[0-9]+)(e([-+][0-9]+|[0-9]*))?)(?=(u?[ysl]|[und])?([kmgtp]b)?\b)" insensitive="1"/>         <RegExpr String="[-\w]+"/>       </context>-      <context attribute="Numeric Suffix" name="NumericSuffix" fallthroughContext="#pop">+      <context attribute="Numeric Suffix" name="NumericSuffix" fallthroughContext="#pop" lineEndContext="#pop">         <DetectIdentifier attribute="Numeric Suffix" context="#pop"/>       </context>        <!-- $( -->       <context attribute="Normal Text" name="VarCmd">+        <DetectChar attribute="Symbol" context="#pop" char=")"/>+        <DetectChar attribute="Symbol" context="VarCmdFuncCall" char="("/>+        <IncludeRules context="Normal"/>+      </context>+      <context attribute="Normal Text" name="VarCmdFuncCall">         <DetectChar attribute="Symbol" context="#pop" char=")"/>         <IncludeRules context="Normal"/>       </context>
xml/python.xml view
@@ -78,12 +78,19 @@ <!-- v2.07 add support for %prog and co, see bug 142832 --> <!-- v2.08 add missing overloaders, new Python 3 statements, builtins, and keywords --> <!-- v2.29 recognize escape sequenzes correctly -->-<language name="Python" alternativeNames="Py" version="32" style="python" indenter="python" kateversion="5.0" section="Scripts" extensions="*.py;*.pyw;*.pyi;SConstruct;SConscript;*.FCMacro;*.sage" mimetype="application/x-python;text/x-python;text/x-python3" casesensitive="1" author="Michael Bueker" license="">+<language name="Python" alternativeNames="Py" version="33" style="python" indenter="python" kateversion="5.0" section="Scripts" extensions="*.py;*.pyw;*.pyi;SConstruct;SConscript;*.FCMacro;*.sage" mimetype="application/x-python;text/x-python;text/x-python3" casesensitive="1" author="Michael Bueker" license=""> 	<highlighting> 		<list name="import"> 			<item>import</item> 			<item>from</item> 			<item>as</item>+			<!--+				"lazy from" and "lazy import" are added here for autocompletion.+				The actual handling is in context="kw_lazy"+				so that we won't need to add space as a weakDeliminator.+			-->+			<item>lazy from</item> <!-- 3.15 -->+			<item>lazy import</item> <!-- 3.15 --> 		</list> 		<list name="defs"> 			<item>class</item>@@ -123,7 +130,7 @@ 			<item>yield</item> 			<!-- 				"yield from" added here as a keyword for autocompletion. The actual handling-				is in context="yield" so that we won't need to add space as a weakDeliminator.+				is in context="kw_yield" so that we won't need to add space as a weakDeliminator. 			--> 			<item>yield from</item> 		</list>@@ -167,6 +174,7 @@ 			<item>filter</item> 			<item>float</item> 			<item>format</item>+			<item>frozendict</item> 			<item>frozenset</item> 			<item>getattr</item> 			<item>globals</item>@@ -235,6 +243,7 @@ 			<item>__qualname__</item> 			<item>__slots__</item> 		</list>+		<!-- Qt extension (PySide) --> 		<list name="bindings"> 			<item>SIGNAL</item> 			<item>SLOT</item>@@ -452,13 +461,15 @@ 				<keyword attribute="Operator Keyword" String="operators" context="#stay"/> 				<keyword attribute="Builtin Function" String="builtinfuncs" context="#stay"/> 				<keyword attribute="Definition Keyword" String="defs" context="#stay"/>-				<keyword attribute="Flow Control Keyword" String="flow_yield" context="yield"/>+				<keyword attribute="Flow Control Keyword" String="flow_yield" context="kw_yield"/> 				<keyword attribute="Flow Control Keyword" String="patternmatching" context="Pattern Matching" lookAhead="1" firstNonSpace="1"/> 				<keyword attribute="Import" String="import" context="#stay"/> 				<keyword attribute="Exceptions" String="exceptions" context="#stay"/> 				<keyword attribute="Overloaders" String="overloaders" context="#stay"/> 				<keyword attribute="Extensions" String="bindings" context="#stay"/> +				<WordDetect String="lazy" context="kw_lazy" lookAhead="1"/>+ 				<IncludeRules context="Number" /> 				<IncludeRules context="CommentVariants" /> 				<IncludeRules context="StringVariants" />@@ -502,9 +513,24 @@ 				<RegExpr attribute="Error" String="\w+" context="#pop#pop"/> 			</context> -			<context name="yield" attribute="Flow Control Keyword" lineEndContext="#pop" fallthrough="1" fallthroughContext="#pop">+			<!-- yield from expr+			           ~~~~ Flow Control Keyword no Import+			-->+			<context name="kw_yield" attribute="Flow Control Keyword" lineEndContext="#pop" fallthrough="1" fallthroughContext="#pop"> 				<DetectSpaces attribute="Normal Text" context="#stay"/> 				<WordDetect attribute="Flow Control Keyword" context="#pop" String="from"/>+			</context>++			<!-- lazy from ... import ...+			     ~~~~~~~~~ Import+					 lazy import ...+			     ~~~~~~~~~~~ Import+					 lazy = 2+			     ~~~~ Normal Text+			-->+			<context name="kw_lazy" attribute="Import" lineEndContext="#pop">+				<RegExpr String="lazy\s+(import|from)\b" attribute="Import" context="#pop"/>+				<DetectIdentifier attribute="Normal Text" context="#pop"/> 			</context>  			<context name="Pattern Matching" attribute="Flow Control Keyword" lineEndContext="#pop">
+ xml/q.xml view
@@ -0,0 +1,210 @@+<?xml version="1.0" encoding="UTF-8"?>+<!DOCTYPE language>+<language name="q" version="4" kateversion="5.0" section="Scripts" extensions="*.q" license="LGPLv2+" author="James Schmitz (james.schmitz@gmail.com)">+<highlighting>+    <list name="DotQ">+      <item>.Q.addmonths</item>+      <item>.Q.addr</item>+      <item>.Q.host</item>+      <item>.Q.chk</item>+      <item>.Q.cn</item>+      <item>.Q.dd</item>+      <item>.Q.dpft</item>+      <item>.Q.dsftg</item>+      <item>.Q.def</item>+      <item>.Q.en</item>+      <item>.Q.fc</item>+      <item>.Q.fk</item>+      <item>.Q.fmt</item>+      <item>.Q.fs</item>+      <item>.Q.ft</item>+      <item>.Q.fu</item>+      <item>.Q.gc</item>+      <item>.Q.hdpf</item>+      <item>.Q.ind</item>+      <item>.Q.j10</item>+      <item>.Q.x10</item>+      <item>.Q.j12</item>+      <item>.Q.x12</item>+      <item>.Q.k</item>+      <item>.Q.l</item>+      <item>.Q.opt</item>+      <item>.Q.par</item>+      <item>.Q.qp</item>+      <item>.Q.qt</item>+      <item>.Q.s</item>+      <item>.Q.ty</item>+      <item>.Q.v</item>+      <item>.Q.V</item>+      <item>.Q.view</item>+      <item>.Q.w</item>+      <item>.Q.M</item>+      <item>.Q.pf</item>+      <item>.Q.pt</item>+      <item>.Q.PD</item>+      <item>.Q.PV</item>+      <item>.Q.pd</item>+      <item>.Q.pv</item>+      <item>.Q.pn</item>+      <item>.Q.bv</item>+      <item>.Q.vp</item>+      <item>.Q.P</item>+      <item>.Q.D</item>+      <item>.Q.u</item>+    </list>+    <list name="qkeywords">+      <item>aj</item>+      <item>aj0</item>+      <item>all</item>+      <item>and</item>+      <item>any</item>+      <item>asc</item>+      <item>asof</item>+      <item>attr</item>+      <item>avgs</item>+      <item>ceiling</item>+      <item>cols</item>+      <item>cor</item>+      <item>count</item>+      <item>cov</item>+      <item>cross</item>+      <item>csv</item>+      <item>cut</item>+      <item>deltas</item>+      <item>desc</item>+      <item>dev</item>+      <item>differ</item>+      <item>distinct</item>+      <item>each</item>+      <item>ej</item>+      <item>enlist</item>+      <item>eval</item>+      <item>except</item>+      <item>fby</item>+      <item>fills</item>+      <item>first</item>+      <item>fkeys</item>+      <item>flip</item>+      <item>floor</item>+      <item>from</item>+      <item>get</item>+      <item>group</item>+      <item>gtime</item>+      <item>hclose</item>+      <item>hcount</item>+      <item>hdel</item>+      <item>hopen</item>+      <item>hsym</item>+      <item>iasc</item>+      <item>idesc</item>+      <item>ij</item>+      <item>inter</item>+      <item>inv</item>+      <item>key</item>+      <item>keys</item>+      <item>lj</item>+      <item>load</item>+      <item>lower</item>+      <item>lsq</item>+      <item>ltime</item>+      <item>ltrim</item>+      <item>mavg</item>+      <item>maxs</item>+      <item>mcount</item>+      <item>md5</item>+      <item>mdev</item>+      <item>med</item>+      <item>meta</item>+      <item>mins</item>+      <item>mmax</item>+      <item>mmin</item>+      <item>mmu</item>+      <item>mod</item>+      <item>msum</item>+      <item>neg</item>+      <item>next</item>+      <item>not</item>+      <item>null</item>+      <item>or</item>+      <item>over</item>+      <item>parse</item>+      <item>peach</item>+      <item>pj</item>+      <item>plist</item>+      <item>prds</item>+      <item>prev</item>+      <item>prior</item>+      <item>rand</item>+      <item>rank</item>+      <item>ratios</item>+      <item>raze</item>+      <item>read0</item>+      <item>read1</item>+      <item>reciprocal</item>+      <item>reverse</item>+      <item>rload</item>+      <item>rotate</item>+      <item>rsave</item>+      <item>rtrim</item>+      <item>save</item>+      <item>scan</item>+      <item>set</item>+      <item>show</item>+      <item>signum</item>+      <item>ssr</item>+      <item>string</item>+      <item>sublist</item>+      <item>sums</item>+      <item>sv</item>+      <item>system</item>+      <item>tables</item>+      <item>til</item>+      <item>trim</item>+      <item>txf</item>+      <item>type</item>+      <item>uj</item>+      <item>ungroup</item>+      <item>union</item>+      <item>update</item>+      <item>upper</item>+      <item>upsert</item>+      <item>value</item>+      <item>var</item>+      <item>view</item>+      <item>views</item>+      <item>vs</item>+      <item>where</item>+      <item>wj</item>+      <item>wj1</item>+      <item>xasc</item>+      <item>xbar</item>+      <item>xcol</item>+      <item>xcols</item>+      <item>xdesc</item>+      <item>xgroup</item>+      <item>xkey</item>+      <item>xlog</item>+      <item>xprev</item>+      <item>xrank</item>+    </list>+    <contexts>+      <context attribute="Normal Text" lineEndContext="#stay" name="Normal Text" >+        <keyword attribute="qKeyword" context="#stay" String="qkeywords" />+        <keyword attribute="DotQfunctions" context="#stay" String="DotQ" />+        <IncludeRules context="##k" />+      </context>+    </contexts>+    <itemDatas>+      <itemData name="Normal Text" defStyleNum="dsNormal" />+      <itemData name="qKeyword" defStyleNum="dsKeyword" />+      <itemData name="DotQfunctions" defStyleNum="dsKeyword" />+    </itemDatas>+  </highlighting>+  <general>+    <comments>+      <comment name="singleLine" start="/" />+    </comments>+    <keywords casesensitive="1" weakDeliminator="." additionalDeliminator="`#'@$&quot;" />+  </general>+</language>+<!-- kate: replace-tabs on; tab-width 2; indent-width 2; -->
xml/qml.xml view
@@ -4,7 +4,7 @@   <!ENTITY identifier "[a-zA-Z_$][\w$]*"> ]> <!-- Author: Milian Wolff <mail@milianw.de> -->-<language name="QML" version="13" kateversion="5.53" section="Scripts" extensions="*.qml;*.qmltypes"+<language name="QML" version="14" kateversion="5.53" section="Scripts" extensions="*.qml;*.qmltypes"           mimetype="text/x-qml;application/x-qml" indenter="cstyle"           author="Milian Wolff (mail@milianw.de)" license="MIT">   <highlighting>@@ -91,6 +91,9 @@       <item>pragma</item>       <item>readonly</item>       <item>required</item>+      <item>virtual</item>+      <item>final</item>+      <item>override</item>     </list>     <list name="types">       <!-- see: http://doc.trolltech.com/4.7-snapshot/qml-extending-types.html -->
+ xml/quarto.xml view
@@ -0,0 +1,233 @@+<?xml version="1.0" encoding="UTF-8"?>+<!DOCTYPE language+[+<!-- Replicated from "markdown.xml": -->+<!ENTITY rulerregex "\s*(?:(?:\*\s*){3,}|(?:_\s*){3,}|(?:\-\s*){3,})\s*$">+<!ENTITY indentedcodeblock "(?:\s{4}|\t).*$">+<!ENTITY listbullet "[\*\+\-]">+<!ENTITY emptyline "^\s*$">+<!ENTITY checkbox "\[[ x]\](?=\s)">+]>+<!--+  Kate highlighting module for Quarto+  (c) 2025 Thomas Friedrichsmeier (thomas.friedrichsmeier@kdemail.net)+  Heavily based on the R markdown highlighting definition, originally by:+  (c) 2014 Dirk Sarpe (dsarpe@posteo.de)++  NOTE: In fact this definition is identical to R markdown in very many parts,+        and the two should be kept in sync, except for the regions marked with+        "Quarto_specific"!++  depends on:+    Kate highlighting module for Markdown+    Kate highlighting module for R script+    Kate highlighting module for LaTeX+    Kate highlighting module for YAML+-->++<language name="Quarto"+section="Markup"+extensions="*.qmd;*.Qmd;*.QMD"+mimetype="text/x-quarto"+version="11"+kateversion="6.22"+casesensitive="true"+author="Thomas Friedrichsmeier (thomas.friedrichsmeier@kdemail.net)"+license="GPL">++  <highlighting>+    <contexts>++      <context name="Start Document" attribute="Markdown" lineEndContext="Normal Text" lineEmptyContext="Normal Text" fallthroughContext="Normal Text">+        <RegExpr String="^---$" column="0" attribute="Markdown" context="YAMLhead" beginRegion="YAMLhead block"/>+      </context>++      <context name="Normal Text" attribute="Markdown" lineEndContext="#stay" lineEmptyContext="find-code-block">+        <IncludeRules context="Common"/>+        <IncludeRules context="Overwrite Markdown Normal Text"/>+        <IncludeRules context="Normal Text##Markdown" includeAttrib="true"/>+      </context>+      <context name="find-code-block" attribute="Markdown" lineEndContext="#stay" lineEmptyContext="#stay" fallthroughContext="#pop">+        <IncludeRules context="find-code-block##Markdown" includeAttrib="true"/>+      </context>++      <context name="Common" attribute="Markdown" lineEndContext="#stay">+        <RegExpr String="```\{r.*\}" firstNonSpace="true" attribute="Structure"+                 context="R block" beginRegion="R block"/>+        <!-- BEGIN Quarto_specific: Alway require braced language sepcifier "{r}" rather than "r" at head of code blocks -->+        <RegExpr String="`\{r.*\}" attribute="Structure"+                 context="R inline"/>+        <!-- END Quarto_specific -->+        <!-- BEGIN Quarto_specific: Allow python, julia, and ojs blocks in the same was as R bloks -->+        <!-- NOTE: contrary to R, no (legacy) options seem to be allowed within the braces, for the other languages -->+        <StringDetect String="```{python}" firstNonSpace="true" attribute="Structure"+                 context="Python block" beginRegion="Python block"/>+        <StringDetect String="`{python}" attribute="Structure"+                 context="Python inline"/>+        <StringDetect String="```{julia}" firstNonSpace="true" attribute="Structure"+                 context="Julia block" beginRegion="Julia block"/>+        <StringDetect String="`{julia}" attribute="Structure"+                 context="Julia inline"/>+        <StringDetect String="```{ojs}" firstNonSpace="true" attribute="Structure"+                 context="OJS block" beginRegion="OJS block"/>+        <StringDetect String="`{ojs}" attribute="Structure"+                 context="OJS inline"/>+        <!-- END Quarto_specific -->+        <Detect2Chars char="$" char1="$" attribute="MathMode"+                      context="LaTeX equation block" beginRegion="LaTeX equation block"/>+        <DetectChar char="$" attribute="MathMode"+                    context="LaTeX inline equation"/>+        <Detect2Chars char="\" char1="$" attribute="Backslash Escape" context="#stay"/>+      </context>++      <context name="R block" attribute="Markdown" lineEndContext="#stay">+        <RegExpr String="```+(?=\s*$)" firstNonSpace="true" attribute="Structure" context="#pop"+                 endRegion="R block"/>+        <IncludeRules context="##R Script" includeAttrib="true"/>+      </context>++      <context name="R inline" attribute="Markdown" lineEndContext="#stay">+        <DetectChar char="`" attribute="Structure" context="#pop"/>+        <IncludeRules context="##R Script" includeAttrib="true"/>+      </context>++      <!-- BEGIN Quarto_specific: Allow python, julia, and ojs blocks in the same was as R bloks -->+      <context name="Python block" attribute="Markdown" lineEndContext="#stay">+        <RegExpr String="```+(?=\s*$)" firstNonSpace="true" attribute="Structure" context="#pop"+                 endRegion="Python block"/>+        <IncludeRules context="##Python" includeAttrib="true"/>+      </context>++      <context name="Python inline" attribute="Markdown" lineEndContext="#stay">+        <DetectChar char="`" attribute="Structure" context="#pop"/>+        <IncludeRules context="##Python" includeAttrib="true"/>+      </context>++      <context name="Julia block" attribute="Markdown" lineEndContext="#stay">+        <RegExpr String="```+(?=\s*$)" firstNonSpace="true" attribute="Structure" context="#pop"+                 endRegion="Julia block"/>+        <IncludeRules context="##Julia" includeAttrib="true"/>+      </context>++      <context name="Julia inline" attribute="Markdown" lineEndContext="#stay">+        <DetectChar char="`" attribute="Structure" context="#pop"/>+        <IncludeRules context="##Julia" includeAttrib="true"/>+      </context>++      <context name="OJS block" attribute="Markdown" lineEndContext="#stay">+        <RegExpr String="```+(?=\s*$)" firstNonSpace="true" attribute="Structure" context="#pop"+                 endRegion="OJS block"/>+        <IncludeRules context="Normal##JavaScript" includeAttrib="true"/>+      </context>++      <context name="OJS inline" attribute="Markdown" lineEndContext="#stay">+        <DetectChar char="`" attribute="Structure" context="#pop"/>+        <IncludeRules context="Normal##JavaScript" includeAttrib="true"/>+      </context>+      <!-- END Quarto_specific -->++      <context name="LaTeX equation block" attribute="MathMode"+               lineEndContext="#stay">+        <Detect2Chars char="$" char1="$" attribute="MathMode"+                      context="#pop" endRegion="LaTeX equation block"/>+        <IncludeRules context="MathModeDisplay##LaTeX" includeAttrib="true"/>+      </context>++      <context name="LaTeX inline equation" attribute="MathMode"+               lineEndContext="#stay">+        <DetectChar char="$" attribute="MathMode" context="#pop"/>+        <IncludeRules context="MathMode##LaTeX" includeAttrib="true"/>+      </context>++      <context name="YAMLhead" attribute="Document Headers"+               lineEndContext="#stay" fallthroughContext="Lvl0Text##YAML">+        <RegExpr String="^---$" column="0" attribute="Markdown" context="#pop"+                 endRegion="YAMLhead block"/>+        <IncludeRules context="##YAML" includeAttrib="true"/>+      </context>++      <!-- Markdown -->+      <!-- These contexts are replicated from "markdown.xml" to add the features of R Markdown. -->++      <context name="Overwrite Markdown Normal Text" attribute="Markdown" lineEndContext="#stay">+        <!-- Blockquotes -->+        <DetectChar attribute="Blockquote" context="blockquote" char="&gt;" firstNonSpace="true"/>+        <!-- Lists: avoid highlighting code blocks incorrectly, capturing indentation -->+        <RegExpr attribute="List" context="list" String="^(\s*)&listbullet;(\s+)" column="0"/>+        <RegExpr attribute="Number List" context="numlist" String="^(\s*)\d\.(\s+)" column="0"/>+        <RegExpr attribute="Number List" context="numlist2" String="^(\s*)\d\d+\.(\s+)" column="0"/>+      </context>++      <context name="list" attribute="Markdown" lineEndContext="#stay" fallthroughContext="content-list">+        <!-- Find indented code blocks, blockquotes and horizontal rules -->+        <RegExpr attribute="List: Code" String="^%1%2\s&indentedcodeblock;" column="0" dynamic="true"/>+        <RegExpr attribute="Blockquote" context="blockquote-list" String="^%1%2\s+&gt;" column="0" dynamic="true"/>+        <RegExpr attribute="List: Horizontal Rule" String="^%1%2\s+&rulerregex;" column="0" dynamic="true"/>+        <RegExpr String="&emptyline;" column="0"/>+        <!-- Text with the same indentation captured corresponds to the item list -->+        <RegExpr context="content-list" String="^%1%2\s" column="0" lookAhead="true" dynamic="true"/>+        <!-- Finish when the text has a lower indentation than the list -->+        <RegExpr context="#pop" String="^\s*\S" column="0" lookAhead="true"/>+        <!-- Highlight checkbox at the start of the item (task list) -->+        <RegExpr attribute="List: Checkbox" context="content-list" String="\s*&checkbox;"/>+      </context>+      <!-- 1. numlist (one digit) -->+      <context name="numlist" attribute="Markdown" lineEndContext="#stay" fallthroughContext="content-list">+        <RegExpr attribute="List: Code" String="^%1%2\s{2}&indentedcodeblock;" column="0" dynamic="true"/>+        <RegExpr attribute="Blockquote" context="blockquote-list" String="^%1%2\s{2,}&gt;" column="0" dynamic="true"/>+        <RegExpr attribute="List: Horizontal Rule" String="^%1%2\s{2,}&rulerregex;" column="0" dynamic="true"/>+        <RegExpr String="&emptyline;" column="0"/>+        <RegExpr context="content-list" String="^%1%2\s{2}" column="0" lookAhead="true" dynamic="true"/>+        <RegExpr context="#pop" String="^\s*\S" column="0" lookAhead="true"/>+      </context>+      <!-- 10. numlist (two or more digits) -->+      <context name="numlist2" attribute="Markdown" lineEndContext="#stay" fallthroughContext="content-list">+        <RegExpr attribute="List: Code" String="^%1%2\s{3}&indentedcodeblock;" column="0" dynamic="true"/>+        <RegExpr attribute="Blockquote" context="blockquote-list" String="^%1%2\s{3,}&gt;" column="0" dynamic="true"/>+        <RegExpr attribute="List: Horizontal Rule" String="^%1%2\s{3,}&rulerregex;" column="0" dynamic="true"/>+        <RegExpr String="&emptyline;" column="0"/>+        <RegExpr context="content-list" String="^%1%2\s{3}" column="0" lookAhead="true" dynamic="true"/>+        <RegExpr context="#pop" String="^\s*\S" column="0" lookAhead="true"/>+      </context>++      <context name="content-list" attribute="Markdown" lineEndContext="#stay" lineEmptyContext="#pop">+        <IncludeRules context="Common"/>+        <IncludeRules context="content-list##Markdown" includeAttrib="true"/>+      </context>++      <context name="blockquote" attribute="Markdown" lineEndContext="#stay" lineEmptyContext="#pop">+        <IncludeRules context="Common"/>+        <IncludeRules context="blockquote##Markdown" includeAttrib="true"/>+      </context>+      <context name="blockquote-list" attribute="Markdown" lineEndContext="#stay" lineEmptyContext="#pop">+        <IncludeRules context="Common"/>+        <IncludeRules context="blockquote-list##Markdown" includeAttrib="true"/>+      </context>++    </contexts>++    <itemDatas>+      <itemData name="Markdown" defStyleNum="dsNormal"/>+      <itemData name="Structure" defStyleNum="dsRegionMarker"/>+      <itemData name="MathMode" defStyleNum="dsRegionMarker" color="#00A000"/>+      <itemData name="Document Headers" defStyleNum="dsOthers"/>++      <itemData name="Blockquote" defStyleNum="dsAttribute" spellChecking="false"/>+      <itemData name="List" defStyleNum="dsSpecialString" bold="1" spellChecking="false"/>+      <itemData name="Number List" defStyleNum="dsSpecialString" spellChecking="false"/>+      <itemData name="List: Horizontal Rule" defStyleNum="dsNormal" bold="true" spellChecking="false"/>+      <itemData name="List: Code" defStyleNum="dsInformation"/>+      <itemData name="List: Checkbox" defStyleNum="dsVariable" spellChecking="false"/>+      <itemData name="Backslash Escape" defStyleNum="dsSpecialChar" spellChecking="false"/>+    </itemDatas>++  </highlighting>++  <general>+    <keywords additionalDeliminator="`"/>+    <comments>+      <comment name="multiLine" start="&lt;!--" end="--&gt;"/>+    </comments>+  </general>++</language>
xml/raku.xml view
@@ -73,7 +73,7 @@   <!-- <!ENTITY regadverb "(?!\()\s*(?::\w+\s*)*(?=[^\w\s])"> -->   <!ENTITY regadverb "(?!\()\s*(?=[^\p{L}\p{N}\s])"> ]>-<language name="Raku" version="9" kateversion="5.62" section="Scripts" extensions="*.raku;*.rakumod;*.rakudoc;*.rakutest;*.pl6;*.PL6;*.p6;*.pm6;*.pod6" priority="6" author="Jonathan Poelen (jonathan.poelen@gmail.com)" license="MIT">+<language name="Raku" version="10" kateversion="5.62" section="Scripts" extensions="*.raku;*.rakumod;*.rakudoc;*.rakutest;*.pl6;*.PL6;*.p6;*.pm6;*.pod6" priority="6" author="Jonathan Poelen (jonathan.poelen@gmail.com)" license="MIT">   <highlighting>      <!-- https://docs.raku.org/routines -->@@ -647,6 +647,7 @@       <context name="RegexKeyword" attribute="Normal Text" lineEndContext="#stay" fallthroughContext="#pop">         <DetectSpaces/>         <DetectChar char="{" context="#pop!RegexKeyword-Pattern{" attribute="Symbol" beginRegion="regex"/>+        <DetectChar char="(" context="SubExpression(" attribute="Normal Text"/>         <DetectChar char="#" context="StartComment" attribute="Comment"/>         <RegExpr String="&ident;"/>       </context>@@ -847,7 +848,7 @@       <!-- Pattern \... -->        <context name="PatternMetaChar" attribute="Pattern" lineEndContext="#pop">-        <RegExpr String="\\[nthvsdwNTHVSDW]|\\[xX](&unicode_hex_point;(?![0-9a-fA-F])|\[\s*&unicode_hex_point;\s*\])|\\[cC](&unicode_dec_point;(?![0-9])|\[[0-9a-zA-Z\s]+\])|[oO](&unicode_oct_point;(?![0-7])|\[\s*&unicode_oct_point;\s*\])" context="#pop" attribute="Pattern Character Class"/>+        <RegExpr String="\\[bdefhnrstvwBDEFHNRSTVW]|\\[xX](&unicode_hex_point;(?![0-9a-fA-F])|\[\s*&unicode_hex_point;\s*\])|\\[cC](&unicode_dec_point;(?![0-9])|\[[0-9a-zA-Z\s]+\])|[oO](&unicode_oct_point;(?![0-7])|\[\s*&unicode_oct_point;\s*\])" context="#pop" attribute="Pattern Character Class"/>         <RegExpr String="\\[^\p{L}\p{N}]" context="#pop" attribute="Pattern Character"/>          <StringDetect String="\x[" context="PatternMetaCharX" attribute="Pattern Character Class" insensitive="1"/>@@ -872,7 +873,7 @@       </context>        <context name="C[]" attribute="Pattern">-        <RegExpr String="\s*(\b[0-9a-zA-Z]+\s*)+"/>+        <RegExpr String="\s*(\b[0-9a-zA-Z-]+\s*)+"/>       </context>        <context name="PatternMetaCharMultipleCommon" attribute="Pattern">@@ -895,7 +896,7 @@       <context name="PatternMetaCharC" attribute="Pattern Character Class">         <IncludeRules context="PatternMetaCharMultipleCommon"/>         <IncludeRules context="C[]"/>-        <RegExpr String="[^0-9a-zA-Z\],\s]+|[0-9a-zA-Z]+|." attribute="Error"/>+        <RegExpr String="[^0-9a-zA-Z\],\s-]+|[0-9a-zA-Z]+|." attribute="Error"/>       </context>  @@ -1749,6 +1750,7 @@         <IncludeRules context="q_RawString_common"/>       </context>       <context name="q_RawString_common" attribute="String" lineEndContext="#stay">+        <Detect2Chars char="\" char1="\" context="#stay" attribute="String Special Character"/>         <Detect2Chars char="\" char1="'" context="#stay" attribute="String Special Character"/>         <RegExpr String="(?:[^\\']*|\\(?![\\']|&quotingconstruct;|$))*" context="#stay" attribute="String"/>         <Detect2Chars char="\" char1="q" context="q_QuotingForm" attribute="Operator"/>
+ xml/rdoc.xml view
@@ -0,0 +1,390 @@+<?xml version="1.0" encoding="UTF-8"?>+<!DOCTYPE language>+<language name="R documentation" version="4" section="Markup" kateversion="5.0"+          extensions="*.Rd" author="Aaron Puchert" license="MIT" >+<highlighting>+    <list name="PreprocessorOptions">+        <item>unix</item>+        <item>windows</item>+    </list>+    <list name="Formats">+        <item>example</item>+        <item>html</item>+        <item>latex</item>+        <item>text</item>+        <item>TRUE</item>+        <item>FALSE</item>+    </list>++    <list name="TopLevel-ExpectName">+        <item>\docType</item>+        <item>\encoding</item>+        <item>\keyword</item>+        <item>\name</item>+    </list>+    <list name="TopLevel-ExpectLatex">+        <item>\author</item>+        <item>\concept</item>+        <item>\description</item>+        <item>\details</item>+        <item>\format</item>+        <item>\note</item>+        <item>\references</item>+        <item>\seealso</item>+        <item>\source</item>+        <item>\title</item>+    </list>+    <list name="TopLevel-ExpectNameLatex">+        <item>\section</item>+    </list>+    <list name="TopLevel-ExpectMacroLatex">+        <item>\newcommand</item>+        <item>\renewcommand</item>+    </list>+    <list name="TopLevel-ExpectR">+        <item>\examples</item>+        <item>\usage</item>+    </list>+    <list name="TopLevel-ExpectVerbatim">+        <item>\alias</item>+        <item>\Rdversion</item>+        <item>\synopsis</item>+        <item>\RdOpts</item>+    </list>+    <list name="TopLevel-ExpectItem2List">+        <item>\arguments</item>+        <item>\value</item>+    </list>++    <!-- For now we highlight these as macros.+    <list name="Latex-Markup">+        <item>\cr</item>+        <item>\dots</item>+        <item>\ldots</item>+        <item>\R</item>+        <item>\tab</item>+    </list>+    -->+    <list name="Latex-ExpectLatex">+        <item>\acronym</item>+        <item>\bold</item>+        <item>\cite</item>+        <item>\command</item>+        <item>\dfn</item>+        <item>\dQuote</item>+        <item>\emph</item>+        <item>\file</item>+        <item>\linkS4class</item>+        <item>\pkg</item>+        <item>\sQuote</item>+        <item>\strong</item>+        <item>\var</item>+    </list>+    <list name="Latex-ExpectNameLatex">+        <item>\enc</item>+        <item>\method</item>+        <item>\S3method</item>+        <item>\S4method</item>+    </list>+    <list name="Latex-ExpectNameLatex-Section">+        <item>\subsection</item>+    </list>+    <list name="Latex-ExpectMacroLatex">+        <item>\newcommand</item>+        <item>\renewcommand</item>+    </list>+    <list name="Latex-ExpectItemList">+        <item>\enumerate</item>+        <item>\itemize</item>+    </list>+    <list name="ItemList-Item">+        <item>\item</item>+    </list>+    <list name="Latex-ExpectItem2List">+        <item>\describe</item>+    </list>+    <list name="Latex-ExpectIf">+        <item>\if</item>+        <item>\ifelse</item>+    </list>+    <list name="Latex-ExpectRLike">+        <item>\code</item>+    </list>+    <list name="Latex-ExpectVerbatim">+        <item>\email</item>+        <item>\env</item>+        <item>\kbd</item>+        <item>\option</item>+        <item>\out</item>+        <item>\preformatted</item>+        <item>\samp</item>+        <item>\url</item>+        <item>\verb</item>+        <item>\deqn</item>+        <item>\eqn</item>+    </list>+    <list name="Latex-ExpectVerbatimLatex">+        <item>\tabular</item>+        <item>\href</item>+        <item>\figure</item>+    </list>+    <list name="Latex-ExpectOptionName">+        <item>\link</item>+    </list>+    <list name="Latex-ExpectOptionR">+        <item>\Sexpr</item>+    </list>++    <list name="R-ExpectRLike">+        <item>\dontrun</item>+        <item>\special</item>+        <item>\v</item>+        <item>\var</item>+    </list>+    <list name="R-ExpectNameLatex">+        <item>\method</item>+        <item>\S3method</item>+        <item>\S4method</item>+    </list>+    <list name="R-ExpectOptionName">+        <item>\l</item>+        <item>\link</item>+    </list>+    <list name="R-ExpectR">+        <item>\dontshow</item>+        <item>\donttest</item>+        <item>\testonly</item>+    </list>++    <contexts>+        <context name="TopLevel" attribute="NormalText" lineEndContext="#stay">+            <IncludeRules context="Common"/>++            <keyword String="TopLevel-ExpectName" attribute="Section" context="ExpectName"/>+            <keyword String="TopLevel-ExpectLatex" attribute="Section" context="ExpectLatex"/>+            <keyword String="TopLevel-ExpectNameLatex" attribute="Section" context="ExpectNameLatex"/>+            <keyword String="TopLevel-ExpectMacroLatex" attribute="Markup" context="ExpectMacroLatex"/>+            <keyword String="TopLevel-ExpectR" attribute="Section" context="ExpectR"/>+            <keyword String="TopLevel-ExpectVerbatim" attribute="Section" context="ExpectVerbatim"/>+            <keyword String="TopLevel-ExpectItem2List" attribute="Section" context="ExpectItem2List"/>+        </context>++        <!-- Common rules: only included in other contexts -->+        <context name="Common" attribute="NormalText" lineEndContext="#stay">+            <DetectSpaces/>+            <DetectChar char="%" attribute="Comment" context="Comment"/>++            <Detect2Chars char="\" char1="\" attribute="Escape"/>+            <Detect2Chars char="\" char1="%" attribute="Escape"/>+            <Detect2Chars char="\" char1="{" attribute="Escape"/>+            <Detect2Chars char="\" char1="}" attribute="Escape"/>++            <StringDetect String="#ifdef" firstNonSpace="true" attribute="Preprocessor"+                            context="PreprocessorCondition" beginRegion="Preprocessor"/>+            <StringDetect String="#ifndef" firstNonSpace="true" attribute="Preprocessor"+                            context="PreprocessorCondition" beginRegion="Preprocessor"/>+            <StringDetect String="#endif" firstNonSpace="true" attribute="Preprocessor"+                            context="Comment" endRegion="Preprocessor"/>+        </context>++        <!-- Contexts where we expect certain arguments -->+        <context name="ExpectName" attribute="NormalText" lineEndContext="#stay">+            <DetectChar char="{" attribute="Brace" context="#pop!Name" beginRegion="Brace"/>+            <RegExpr String="[^{]*" attribute="Error" context="#pop"/>+        </context>+        <context name="ExpectLatex" attribute="NormalText" lineEndContext="#stay">+            <DetectChar char="{" attribute="Brace" context="#pop!Latex" beginRegion="Brace"/>+            <RegExpr String="[^{]*" attribute="Error" context="#pop"/>+        </context>+        <context name="ExpectItemList" attribute="NormalText" lineEndContext="#stay">+            <DetectChar char="{" attribute="Brace" context="#pop!ItemList" beginRegion="Brace"/>+            <RegExpr String="[^{]*" attribute="Error" context="#pop"/>+        </context>+        <context name="ExpectItem2List" attribute="NormalText" lineEndContext="#stay">+            <DetectChar char="{" attribute="Brace" context="#pop!Item2List" beginRegion="Brace"/>+            <RegExpr String="[^{]*" attribute="Error" context="#pop"/>+        </context>+        <context name="ExpectNameLatex" attribute="NormalText" lineEndContext="#stay">+            <DetectChar char="{" attribute="Brace" context="#pop!NameLatex" beginRegion="Brace"/>+            <RegExpr String="[^{]*" attribute="Error" context="#pop"/>+        </context>+        <context name="ExpectMacroLatex" attribute="NormalText" lineEndContext="#stay">+            <DetectChar char="{" attribute="Brace" context="#pop!MacroLatex" beginRegion="Brace"/>+            <RegExpr String="[^{]*" attribute="Error" context="#pop"/>+        </context>+        <context name="ExpectLatexLatex" attribute="NormalText" lineEndContext="#stay">+            <DetectChar char="{" attribute="Brace" context="#pop!LatexLatex" beginRegion="Brace"/>+            <RegExpr String="[^{]*" attribute="Error" context="#pop"/>+        </context>+        <context name="ExpectR" attribute="NormalText" lineEndContext="#stay">+            <DetectChar char="{" attribute="Brace" context="#pop!R" beginRegion="Brace"/>+            <RegExpr String="[^{]*" attribute="Error" context="#pop"/>+        </context>+        <context name="ExpectRLike" attribute="NormalText" lineEndContext="#stay">+            <DetectChar char="{" attribute="Brace" context="#pop!RLike" beginRegion="Brace"/>+            <RegExpr String="[^{]*" attribute="Error" context="#pop"/>+        </context>+        <context name="ExpectVerbatim" attribute="NormalText" lineEndContext="#stay">+            <DetectChar char="{" attribute="Brace" context="#pop!Verbatim" beginRegion="Brace"/>+            <RegExpr String="[^{]*" attribute="Error" context="#pop"/>+        </context>+        <context name="ExpectVerbatimLatex" attribute="NormalText" lineEndContext="#stay">+            <DetectChar char="{" attribute="Brace" context="#pop!VerbatimLatex" beginRegion="Brace"/>+            <RegExpr String="[^{]*" attribute="Error" context="#pop"/>+        </context>+        <context name="ExpectOptionName" attribute="Verbatim" lineEndContext="#stay">+            <IncludeRules context="Common"/>+            <DetectChar char="{" attribute="Brace" context="#pop!Name" beginRegion="Brace"/>+            <DetectChar char="[" attribute="Brace" context="#pop!OptionName" beginRegion="Bracket"/>+            <RegExpr String="[^{[]*" attribute="Error" context="#pop"/>+        </context>+        <context name="ExpectOptionR" attribute="Verbatim" lineEndContext="#stay">+            <IncludeRules context="Common"/>+            <DetectChar char="{" attribute="Brace" context="#pop!R" beginRegion="Brace"/>+            <DetectChar char="[" attribute="Brace" context="#pop!OptionR" beginRegion="Bracket"/>+            <RegExpr String="[^{[]*" attribute="Error" context="#pop"/>+        </context>+        <context name="ExpectIf" attribute="NormalText" lineEndContext="#stay">+            <IncludeRules context="Common"/>+            <DetectChar char="{" attribute="Brace" context="#pop!If" beginRegion="Brace"/>+            <RegExpr String="[^{]*" attribute="Error" context="#pop"/>+        </context>++        <!-- The actual arguments -->+        <context name="Latex" attribute="NormalText" lineEndContext="#stay">+            <IncludeRules context="Common"/>+            <DetectChar char="{" attribute="Brace" context="Latex" beginRegion="Brace"/>+            <DetectChar char="}" attribute="Brace" context="#pop" endRegion="Brace"/>++            <keyword String="Latex-ExpectLatex" attribute="Markup" context="ExpectLatex"/>+            <keyword String="Latex-ExpectNameLatex" attribute="Markup" context="ExpectNameLatex"/>+            <keyword String="Latex-ExpectNameLatex-Section" attribute="Section" context="ExpectNameLatex"/>+            <keyword String="Latex-ExpectMacroLatex" attribute="Markup" context="ExpectMacroLatex"/>+            <keyword String="Latex-ExpectItemList" attribute="Markup" context="ExpectItemList"/>+            <keyword String="Latex-ExpectItem2List" attribute="Markup" context="ExpectItem2List"/>+            <keyword String="Latex-ExpectIf" attribute="Markup" context="ExpectIf"/>+            <keyword String="Latex-ExpectRLike" attribute="Markup" context="ExpectRLike"/>+            <keyword String="Latex-ExpectVerbatim" attribute="Markup" context="ExpectVerbatim"/>+            <keyword String="Latex-ExpectVerbatimLatex" attribute="Markup" context="ExpectVerbatimLatex"/>+            <keyword String="Latex-ExpectOptionName" attribute="Markup" context="ExpectOptionName"/>+            <keyword String="Latex-ExpectOptionR" attribute="Markup" context="ExpectOptionR"/>++            <RegExpr String="\\[A-Za-z][A-Za-z0-9]*" attribute="UserDefinedMacro"/>+            <RegExpr String="#[1-9]" attribute="UserDefinedMacroArgument"/>+        </context>+        <context name="ItemList" attribute="NormalText" lineEndContext="#stay">+            <IncludeRules context="Common"/>+            <DetectChar char="{" attribute="Brace" context="Item2List" beginRegion="Brace"/>+            <DetectChar char="}" attribute="Brace" context="#pop" endRegion="Brace"/>+            <keyword String="ItemList-Item" attribute="Markup"/>+            <IncludeRules context="Latex"/>+        </context>+        <context name="Item2List" attribute="NormalText" lineEndContext="#stay">+            <IncludeRules context="Common"/>+            <keyword String="ItemList-Item" attribute="Markup" context="ExpectLatexLatex"/>+            <IncludeRules context="Latex"/>+        </context>+        <context name="Name" attribute="ItemName" lineEndContext="#stay">+            <IncludeRules context="Common"/>+            <RegExpr String="\\[A-Za-z][A-Za-z0-9]*" attribute="UserDefinedMacro"/>+            <RegExpr String="#[1-9]" attribute="UserDefinedMacroArgument"/>+            <DetectChar char="{" attribute="Brace" context="Name" beginRegion="Brace"/>+            <DetectChar char="}" attribute="Brace" context="#pop" endRegion="Brace"/>+        </context>+        <context name="NameLatex" attribute="ItemName" lineEndContext="#stay">+            <IncludeRules context="Common"/>+            <RegExpr String="\\[A-Za-z][A-Za-z0-9]*" attribute="UserDefinedMacro"/>+            <RegExpr String="#[1-9]" attribute="UserDefinedMacroArgument"/>+            <DetectChar char="{" attribute="Brace" context="Latex" beginRegion="Brace"/>+            <DetectChar char="}" attribute="Brace" context="#pop!ExpectLatex" endRegion="Brace"/>+        </context>+        <context name="MacroLatex" attribute="UserDefinedMacro" lineEndContext="#stay">+            <IncludeRules context="Common"/>+            <DetectChar char="}" attribute="Brace" context="#pop!ExpectLatex" endRegion="Brace"/>+        </context>+        <context name="LatexLatex" attribute="ItemName" lineEndContext="#stay">+            <IncludeRules context="Common"/>+            <DetectChar char="}" attribute="Brace" context="#pop!ExpectLatex" endRegion="Brace"/>+            <IncludeRules context="Latex"/>+        </context>+        <context name="R" attribute="RSource" lineEndContext="#stay">+            <IncludeRules context="Common"/>+            <DetectChar char="{" attribute="Brace" context="R" beginRegion="Brace"/>+            <DetectChar char="}" attribute="Brace" context="#pop" endRegion="Brace"/>+            <keyword String="R-ExpectR" attribute="Markup" context="ExpectR"/>+            <keyword String="R-ExpectRLike" attribute="Markup" context="ExpectRLike"/>+            <keyword String="R-ExpectNameLatex" attribute="Markup" context="ExpectNameLatex"/>+            <keyword String="R-ExpectOptionName" attribute="Markup" context="ExpectOptionName"/>+            <IncludeRules context="level0##R Script"/>+        </context>+        <context name="RLike" attribute="Verbatim" lineEndContext="#stay">+            <IncludeRules context="Common"/>+            <DetectChar char="{" attribute="Brace" context="RLike" beginRegion="Brace"/>+            <DetectChar char="}" attribute="Brace" context="#pop" endRegion="Brace"/>+            <keyword String="R-ExpectRLike" attribute="Markup" context="ExpectRLike"/>+            <keyword String="R-ExpectNameLatex" attribute="Markup" context="ExpectNameLatex"/>+            <keyword String="R-ExpectOptionName" attribute="Markup" context="ExpectOptionName"/>+        </context>+        <context name="Verbatim" attribute="Verbatim" lineEndContext="#stay">+            <IncludeRules context="Common"/>+            <DetectChar char="{" attribute="Brace" context="Verbatim" beginRegion="Brace"/>+            <DetectChar char="}" attribute="Brace" context="#pop" endRegion="Brace"/>+        </context>+        <context name="VerbatimLatex" attribute="Verbatim" lineEndContext="#stay">+            <IncludeRules context="Common"/>+            <DetectChar char="{" attribute="Brace" context="Verbatim" beginRegion="Brace"/>+            <DetectChar char="}" attribute="Brace" context="#pop!ExpectLatex" endRegion="Brace"/>+        </context>+        <context name="OptionName" attribute="Verbatim" lineEndContext="#stay">+            <IncludeRules context="Common"/>+            <DetectChar char="{" attribute="Brace" context="Verbatim" beginRegion="Brace"/>+            <DetectChar char="]" attribute="Brace" context="#pop!ExpectName" endRegion="Bracket"/>+            <DetectChar char="}" attribute="Error" context="#pop!ExpectName" endRegion="Bracket"/>+        </context>+        <context name="OptionR" attribute="Verbatim" lineEndContext="#stay">+            <IncludeRules context="Common"/>+            <DetectChar char="{" attribute="Brace" context="Verbatim" beginRegion="Brace"/>+            <DetectChar char="]" attribute="Brace" context="#pop!ExpectR" endRegion="Bracket"/>+            <DetectChar char="}" attribute="Error" context="#pop!ExpectR" endRegion="Bracket"/>+        </context>+        <context name="If" attribute="Verbatim" lineEndContext="#stay">+            <IncludeRules context="Common"/>+            <keyword String="Formats" attribute="Builtin"/>+            <DetectChar char="}" attribute="Brace" context="#pop" endRegion="Brace"/>+        </context>++        <context name="Comment" attribute="Comment" lineEndContext="#pop">+            <DetectSpaces />+            <IncludeRules context="##Comments"/>+        </context>++        <context name="PreprocessorCondition" attribute="Preprocessor" lineEndContext="#pop">+            <keyword String="PreprocessorOptions" attribute="Builtin"/>+        </context>+    </contexts>++    <itemDatas>+        <itemData name="NormalText" defStyleNum="dsNormal"/>+        <itemData name="RSource" defStyleNum="dsNormal" spellChecking="false"/>+        <itemData name="Brace" defStyleNum="dsOperator" spellChecking="false"/>+        <itemData name="Section" defStyleNum="dsControlFlow" spellChecking="false"/>+        <itemData name="Markup" defStyleNum="dsKeyword" spellChecking="false"/>+        <itemData name="UserDefinedMacro" defStyleNum="dsFunction" spellChecking="false"/>+        <itemData name="UserDefinedMacroArgument" defStyleNum="dsVariable" spellChecking="false"/>+        <itemData name="ItemName" defStyleNum="dsSpecialString" spellChecking="false"/>+        <itemData name="Escape" defStyleNum="dsSpecialChar" spellChecking="false"/>+        <itemData name="Preprocessor" defStyleNum="dsPreprocessor" spellChecking="false"/>+        <itemData name="Builtin" defStyleNum="dsBuiltIn" spellChecking="false"/>+        <itemData name="Verbatim" defStyleNum="dsVerbatimString" spellChecking="false"/>+        <itemData name="Comment" defStyleNum="dsComment"/>+        <itemData name="Error" defStyleNum="dsError" spellChecking="false"/>+    </itemDatas>+</highlighting>+<general>+    <keywords weakDeliminator="\" wordWrapDeliminator=",{}[]"/>+    <comments>+        <comment name="singleLine" start="%"/>+    </comments>+</general>+</language>+<!-- kate: replace-tabs on; tab-width 4; indent-width 4; -->
+ xml/rmarkdown.xml view
@@ -0,0 +1,175 @@+<?xml version="1.0" encoding="UTF-8"?>+<!DOCTYPE language+[+<!-- Replicated from "markdown.xml": -->+<!ENTITY rulerregex "\s*(?:(?:\*\s*){3,}|(?:_\s*){3,}|(?:\-\s*){3,})\s*$">+<!ENTITY indentedcodeblock "(?:\s{4}|\t).*$">+<!ENTITY listbullet "[\*\+\-]">+<!ENTITY emptyline "^\s*$">+<!ENTITY checkbox "\[[ x]\](?=\s)">+]>+<!--+  Kate highlighting module for R Markdown+  (c) 2014 Dirk Sarpe (dsarpe@posteo.de)++  depends on:+    Kate highlighting module for Markdown+    Kate highlighting module for R script+    Kate highlighting module for LaTeX+    Kate highlighting module for YAML+-->++<language name="R Markdown"+section="Markup"+extensions="*.rmd;*.Rmd;*.RMD"+mimetype="text/x-r-markdown"+version="11"+kateversion="6.22"+casesensitive="true"+author="Dirk Sarpe (dsarpe@posteo.de)"+license="GPL">++  <highlighting>+    <contexts>++      <context name="Start Document" attribute="Markdown" lineEndContext="Normal Text" lineEmptyContext="Normal Text" fallthroughContext="Normal Text">+        <RegExpr String="^---$" column="0" attribute="Markdown" context="YAMLhead" beginRegion="YAMLhead block"/>+      </context>++      <context name="Normal Text" attribute="Markdown" lineEndContext="#stay" lineEmptyContext="find-code-block">+        <IncludeRules context="Common"/>+        <IncludeRules context="Overwrite Markdown Normal Text"/>+        <IncludeRules context="Normal Text##Markdown" includeAttrib="true"/>+      </context>+      <context name="find-code-block" attribute="Markdown" lineEndContext="#stay" lineEmptyContext="#stay" fallthroughContext="#pop">+        <IncludeRules context="find-code-block##Markdown" includeAttrib="true"/>+      </context>++      <context name="Common" attribute="Markdown" lineEndContext="#stay">+        <RegExpr String="```+\{r.*\}" firstNonSpace="true" attribute="Structure"+                 context="R block" beginRegion="R block"/>+        <RegExpr String="`r\b" attribute="Structure"+                 context="R inline"/>+        <Detect2Chars char="$" char1="$" attribute="MathMode"+                      context="LaTeX equation block" beginRegion="LaTeX equation block"/>+        <DetectChar char="$" attribute="MathMode"+                    context="LaTeX inline equation"/>+        <Detect2Chars char="\" char1="$" attribute="Backslash Escape" context="#stay"/>+      </context>++      <context name="R block" attribute="Markdown" lineEndContext="#stay">+        <RegExpr String="```+(?=\s*$)" firstNonSpace="true" attribute="Structure" context="#pop"+                 endRegion="R block"/>+        <IncludeRules context="##R Script" includeAttrib="true"/>+      </context>++      <context name="R inline" attribute="Markdown" lineEndContext="#stay">+        <DetectChar char="`" attribute="Structure" context="#pop"/>+        <IncludeRules context="##R Script" includeAttrib="true"/>+      </context>++      <context name="LaTeX equation block" attribute="MathMode"+               lineEndContext="#stay">+        <Detect2Chars char="$" char1="$" attribute="MathMode"+                      context="#pop" endRegion="LaTeX equation block"/>+        <IncludeRules context="MathModeDisplay##LaTeX" includeAttrib="true"/>+      </context>++      <context name="LaTeX inline equation" attribute="MathMode"+               lineEndContext="#stay">+        <DetectChar char="$" attribute="MathMode" context="#pop"/>+        <IncludeRules context="MathMode##LaTeX" includeAttrib="true"/>+      </context>++      <context name="YAMLhead" attribute="Document Headers"+               lineEndContext="#stay" fallthroughContext="Lvl0Text##YAML">+        <RegExpr String="^---$" column="0" attribute="Markdown" context="#pop"+                 endRegion="YAMLhead block"/>+        <IncludeRules context="##YAML" includeAttrib="true"/>+      </context>++      <!-- Markdown -->+      <!-- These contexts are replicated from "markdown.xml" to add the features of R Markdown. -->++      <context name="Overwrite Markdown Normal Text" attribute="Markdown" lineEndContext="#stay">+        <!-- Blockquotes -->+        <DetectChar attribute="Blockquote" context="blockquote" char="&gt;" firstNonSpace="true"/>+        <!-- Lists: avoid highlighting code blocks incorrectly, capturing indentation -->+        <RegExpr attribute="List" context="list" String="^(\s*)&listbullet;(\s+)" column="0"/>+        <RegExpr attribute="Number List" context="numlist" String="^(\s*)\d\.(\s+)" column="0"/>+        <RegExpr attribute="Number List" context="numlist2" String="^(\s*)\d\d+\.(\s+)" column="0"/>+      </context>++      <context name="list" attribute="Markdown" lineEndContext="#stay" fallthroughContext="content-list">+        <!-- Find indented code blocks, blockquotes and horizontal rules -->+        <RegExpr attribute="List: Code" String="^%1%2\s&indentedcodeblock;" column="0" dynamic="true"/>+        <RegExpr attribute="Blockquote" context="blockquote-list" String="^%1%2\s+&gt;" column="0" dynamic="true"/>+        <RegExpr attribute="List: Horizontal Rule" String="^%1%2\s+&rulerregex;" column="0" dynamic="true"/>+        <RegExpr String="&emptyline;" column="0"/>+        <!-- Text with the same indentation captured corresponds to the item list -->+        <RegExpr context="content-list" String="^%1%2\s" column="0" lookAhead="true" dynamic="true"/>+        <!-- Finish when the text has a lower indentation than the list -->+        <RegExpr context="#pop" String="^\s*\S" column="0" lookAhead="true"/>+        <!-- Highlight checkbox at the start of the item (task list) -->+        <RegExpr attribute="List: Checkbox" context="content-list" String="\s*&checkbox;"/>+      </context>+      <!-- 1. numlist (one digit) -->+      <context name="numlist" attribute="Markdown" lineEndContext="#stay" fallthroughContext="content-list">+        <RegExpr attribute="List: Code" String="^%1%2\s{2}&indentedcodeblock;" column="0" dynamic="true"/>+        <RegExpr attribute="Blockquote" context="blockquote-list" String="^%1%2\s{2,}&gt;" column="0" dynamic="true"/>+        <RegExpr attribute="List: Horizontal Rule" String="^%1%2\s{2,}&rulerregex;" column="0" dynamic="true"/>+        <RegExpr String="&emptyline;" column="0"/>+        <RegExpr context="content-list" String="^%1%2\s{2}" column="0" lookAhead="true" dynamic="true"/>+        <RegExpr context="#pop" String="^\s*\S" column="0" lookAhead="true"/>+      </context>+      <!-- 10. numlist (two or more digits) -->+      <context name="numlist2" attribute="Markdown" lineEndContext="#stay" fallthroughContext="content-list">+        <RegExpr attribute="List: Code" String="^%1%2\s{3}&indentedcodeblock;" column="0" dynamic="true"/>+        <RegExpr attribute="Blockquote" context="blockquote-list" String="^%1%2\s{3,}&gt;" column="0" dynamic="true"/>+        <RegExpr attribute="List: Horizontal Rule" String="^%1%2\s{3,}&rulerregex;" column="0" dynamic="true"/>+        <RegExpr String="&emptyline;" column="0"/>+        <RegExpr context="content-list" String="^%1%2\s{3}" column="0" lookAhead="true" dynamic="true"/>+        <RegExpr context="#pop" String="^\s*\S" column="0" lookAhead="true"/>+      </context>++      <context name="content-list" attribute="Markdown" lineEndContext="#stay" lineEmptyContext="#pop">+        <IncludeRules context="Common"/>+        <IncludeRules context="content-list##Markdown" includeAttrib="true"/>+      </context>++      <context name="blockquote" attribute="Markdown" lineEndContext="#stay" lineEmptyContext="#pop">+        <IncludeRules context="Common"/>+        <IncludeRules context="blockquote##Markdown" includeAttrib="true"/>+      </context>+      <context name="blockquote-list" attribute="Markdown" lineEndContext="#stay" lineEmptyContext="#pop">+        <IncludeRules context="Common"/>+        <IncludeRules context="blockquote-list##Markdown" includeAttrib="true"/>+      </context>++    </contexts>++    <itemDatas>+      <itemData name="Markdown" defStyleNum="dsNormal"/>+      <itemData name="Structure" defStyleNum="dsRegionMarker"/>+      <itemData name="MathMode" defStyleNum="dsRegionMarker" color="#00A000"/>+      <itemData name="Document Headers" defStyleNum="dsOthers"/>++      <itemData name="Blockquote" defStyleNum="dsAttribute" spellChecking="false"/>+      <itemData name="List" defStyleNum="dsSpecialString" bold="1" spellChecking="false"/>+      <itemData name="Number List" defStyleNum="dsSpecialString" spellChecking="false"/>+      <itemData name="List: Horizontal Rule" defStyleNum="dsNormal" bold="true" spellChecking="false"/>+      <itemData name="List: Code" defStyleNum="dsInformation"/>+      <itemData name="List: Checkbox" defStyleNum="dsVariable" spellChecking="false"/>+      <itemData name="Backslash Escape" defStyleNum="dsSpecialChar" spellChecking="false"/>+    </itemDatas>++  </highlighting>++  <general>+    <keywords additionalDeliminator="`"/>+    <comments>+      <comment name="multiLine" start="&lt;!--" end="--&gt;"/>+    </comments>+  </general>++</language>
+ xml/rtf.xml view
@@ -0,0 +1,48 @@+<?xml version="1.0" encoding="UTF-8"?>+<!DOCTYPE language [ <!ENTITY number "([-]?\d+)"> ] >+<language name="Rich Text Format" version="4" kateversion="2.4" section="Markup" extensions="*.rtf" mimetype="text/rtf;application/rtf" author="Lukas Sommer" license="LGPL version 2.1, or version 3 or later versions approved by the membership of KDE e.V.; or any other license appoved by the emembership of KDE e.V.">++  <highlighting>+    +    <contexts>++      <context attribute="Text" lineEndContext="#stay" name="context_normal">+        <DetectChar char="{" attribute="Braces" beginRegion="true" />+        <DetectChar char="}" attribute="Braces" endRegion="true" />+        <DetectChar char="\" lookAhead="true" context="context_process_backslash" />+      </context>++      <context lineEndContext="#pop" fallthrough="true" fallthroughContext="#pop" attribute="Numeric parameter" name="context_process_backslash">+        <Detect2Chars char="\" char1="|" attribute="Control words" />+        <Detect2Chars char="\" char1="~" attribute="Character" />+        <Detect2Chars char="\" char1="-" attribute="Character" />+        <Detect2Chars char="\" char1="_" attribute="Character" />+        <Detect2Chars char="\" char1=":" attribute="Control words" />+        <Detect2Chars char="\" char1="*" attribute="Control words" />+        <Detect2Chars char="\" char1="\" attribute="Character" />+        <Detect2Chars char="\" char1="{" attribute="Character" />+        <Detect2Chars char="\" char1="}" attribute="Character" />+        <RegExpr String="\\u&number;|\\'[01-9a-f]{2}" attribute="Character"/>+        <RegExpr String="\\[a-zA-Z]+" attribute="Control words" context="context_functionparameter" />+        <DetectChar char="\" attribute="Error" />+      </context>++      <context attribute="Control words" lineEndContext="#pop#pop" fallthrough="true" fallthroughContext="#pop#pop" name="context_functionparameter">+        <RegExpr String="[-]?\d+" attribute="Numeric parameter" context="#pop#pop" />+        <DetectChar char="-" attribute="Error" />+      </context>++    </contexts>+    +    <itemDatas>+      <itemData name="Text" defStyleNum="dsString"/>+      <itemData name="Character" defStyleNum="dsChar"/>+      <itemData name="Braces" defStyleNum="dsKeyword"/>+      <itemData name="Control words" defStyleNum="dsFunction"/>+      <itemData name="Numeric parameter" defStyleNum="dsDecVal"/>+      <itemData name="Error" defStyleNum="dsError"/>+    </itemDatas>+    +  </highlighting>+  +</language>
xml/rust.xml view
@@ -40,7 +40,7 @@ 	<!ENTITY scope2 "::(?=[^\s\:])"> <!-- Points after keyword or group { } -->  ]>-<language name="Rust" alternativeNames="RS" version="15" kateversion="5.0" section="Sources" extensions="*.rs" mimetype="text/rust" indenter="cstyle" priority="15" license="MIT" author="The Rust Project Developers">+<language name="Rust" alternativeNames="RS" version="16" kateversion="5.0" section="Sources" extensions="*.rs" mimetype="text/rust" indenter="cstyle" priority="16" license="MIT" author="The Rust Project Developers"> <highlighting> 	<list name="fn"> 		<item>fn</item>@@ -373,6 +373,7 @@ 			<keyword String="fn" attribute="Keyword" context="Function"/> 			<keyword String="type" attribute="Keyword" context="Type"/> 			<keyword String="self" attribute="Self" context="#stay"/>+			<RegExpr String="&scope1;|&scope2;" attribute="Scope"/> 			<keyword String="keywords" attribute="Keyword" context="#stay"/> 			<keyword String="controlflow" attribute="Control Flow" context="#stay"/> 			<keyword String="types" attribute="Type" context="#stay"/>@@ -386,7 +387,6 @@ 			<RegExpr String="\b0(?:b[01_]*[^01_]|o[0-7_]*[^0-7_]|x[0-9a-fA-F_]*[^0-9a-fA-F_])\w*&rustIntSuf;\b" attribute="Error" context="#stay"/> 			<Detect2Chars char="#" char1="[" attribute="Attribute" context="Attribute" beginRegion="Attribute"/> 			<StringDetect String="#![" attribute="Attribute" context="Attribute" beginRegion="Attribute"/>-			<RegExpr String="&scope1;|&scope2;" attribute="Scope"/> 			<RegExpr String="&rustIdent;!" attribute="Macro"/> 			<RegExpr String="&apos;&rustIdent;(?!&apos;)" attribute="Lifetime"/> 			<DetectChar char="{" attribute="Symbol" context="#stay" beginRegion="Brace" />
+ xml/sas.xml view
@@ -0,0 +1,1370 @@+<?xml version='1.0' encoding='UTF-8'?>+<!DOCTYPE language [+    <!ENTITY identifier  "[A-Za-z_]\w*">+    <!ENTITY datastep    "\bdata\b(?!\s*=)">+    <!ENTITY proc_data   "\bproc\b|&datastep;">+    <!ENTITY proc_py     "\bproc\s+python\b">+    <!ENTITY proc_lua    "\bproc\s+lua\b">+    <!ENTITY run_quit    "\b(?:run|quit)\s*;">+    <!ENTITY option_name "\b&identifier;(?=\s*=)">+    <!ENTITY submit      "\b(?:submit|interactive|i)\b[^;]*;">+    <!ENTITY endsubmit   "\b(?:endsubmit|endinteractive)\s*;">+]>+<!--+    SPDX-FileCopyrightText: 2026 Michael Walshe <michael.j.t.walshe@gmail.com>+    SPDX-License-Identifier: MIT+-->+<!--+    SAS syntax highlighting for Kate+    Author: Michael Walshe+    License: MIT++    SAS syntax highlighting using VSCode or SAS products (Enterprise Guide, SAS Studio, DM, etc) relies on knowledge+    of exact options & values required by every procedure/function/statement to correctly highlight only the valid+    syntax. This is out of scope for this highlighter, which uses general heuristics (such as highlighting <option> = value+    in options statements) combined with some common SAS keywords to cover most cases.+ +    SAS Language elements implemented:+        Comments+            - Block comments        /* ... */+            - Statement comments    * ... ;+            - Macro comments        %* ... ;+        Step boundaries+            - DATA / RUN step regions (fold)+            - Generic PROC step regions (fold)+            - PROC SQL  — delegates to the SQL language definition+            - PROC PYTHON / PROC LUA — delegates to the Python / Lua definitions+                (SUBMIT / INTERACTIVE block triggers the embedded-language context)+        Keywords+            - Control flow          DO END ELSE IF SELECT THEN UNTIL WHEN WHILE ...+            - General Statements    ARRAY ATTRIB BY FORMAT INFORMAT INPUT KEEP MERGE OUTPUT PUT RENAME RETAIN SET WHERE ...+            - Functions             All SAS built in functions highlighted+            - Proc options          Procedure options and settings highlighting+            - Proc statements       Statements inside of procedures get first keyword highlighted+            - System options        OBS NODATE MPRINT SYMBOLGEN ... active only inside the OPTIONS statement+            - Dataset options       KEEP DROP RENAME WHERE OBS FIRSTOBS ... active only inside ( ) after a dataset name+            - Mnemonic operators    AND OR NOT EQ NE GT LT GE LE IN BETWEEN LIKE CONTAINS ...+            - Special/auto vars     _N_ _ERROR_ _ALL_ _NULL_  ...+        Macro language+            - %MACRO / %MEND, fold region + MacroDef colour+            - %DO / %END, fold region+            - %IF %THEN, other %keywords+            - Macro variable refs  &name  &&name. etc+            - User-defined macro calls  %name(...) +        Literals+            - Double and single-quoted strings+            - Date/datetime/time string suffixes  "..."d  "..."dt  "..."t+                coloured as Number to distinguish them from plain strings+            - Bitmask / namelit / hex suffixes    "..."b  "..."n  "..."x+                coloured as String, matching SAS EG style highlighting+            - Integer, floating-point, Hex numbers, scientific notation+            - SAS format/informat tokens DATE9.  COMMA12.2  $CHAR20., ...+        Operators+            - + - * / ** = ^= ~= >= <= <> >< || =: >: <: ^=: ~=: >=: <=: ||+        Inline data blocks+            - CARDS / DATALINES / LINES — terminated by lone ;+            - CARDS4 / DATALINES4 / LINES4 — terminated by ;;;;1+            - PARMCARDS / PARMCARDS4+-->+<language+    name="SAS" +    section="Scientific"+    extensions="*.sas;*.SAS;*.Sas"+    casesensitive="false"+    author="Michael Walshe (michael.j.t.walshe@gmail.com)"+    license="MIT"+    version="1"+    kateversion="5.79"+>+    <highlighting>+        <!-- ====+        	Keyword Lists+        	 ==== -->+        <!-- Data Step control-flow words -->+        <list name="controls">+            <item>BY</item>+            <item>DO</item>+            <item>ELSE</item>+            <item>END</item>+            <item>GOTO</item>+            <item>IF</item>+            <item>LINK</item>+            <item>OTHERWISE</item>+            <item>SELECT</item>+            <item>THEN</item>+            <item>TO</item>+            <item>UNTIL</item>+            <item>WHEN</item>+            <item>WHILE</item>+        </list>+        <!-- Mnemonic / word operators -->+        <list name="operators-word">+            <item>AND</item>+            <item>BETWEEN</item>+            <item>CONTAINS</item>+            <item>EQ</item>+            <item>EQT</item>+            <item>GE</item>+            <item>GET</item>+            <item>GT</item>+            <item>IN</item>+            <item>IS</item>+            <item>LE</item>+            <item>LET</item>+            <item>LIKE</item>+            <item>LT</item>+            <item>NE</item>+            <item>NET</item>+            <item>NOT</item>+            <item>OR</item>+            <item>SAME</item>+            <item>ALSO</item>+        </list>+        <!-- SAS automatic / special variables -->+        <list name="constants">+            <item>_ALL_</item>+            <item>_BLANKPAGE_</item>+            <item>_CHARACTER_</item>+            <item>_ERROR_</item>+            <item>_FILE_</item>+            <item>_INFILE_</item>+            <item>_IORC_</item>+            <item>_MRG_</item>+            <item>_NULL_</item>+            <item>_NUMERIC_</item>+            <item>_N_</item>+            <item>_PAGE_</item>+            <item>_TEMPORARY_</item>+        </list>+        <!-- Global SAS statements -->+        <list name="keywords">+            <item>AXIS</item>+            <item>CAS</item>+            <item>CASLIB</item>+            <item>CATNAME</item>+            <item>DECLARE</item>+            <item>ENDRSUBMIT</item>+            <item>ENDSAS</item>+            <item>FILENAME</item>+            <item>FOOTNOTE</item>+            <item>GOPTIONS</item>+            <item>KILLTASK</item>+            <item>LEGEND</item>+            <item>LIBNAME</item>+            <item>LISTTASK</item>+            <item>LOCK</item>+            <item>MISSING</item>+            <item>ODS</item>+            <item>PAGE</item>+            <item>PATTERN</item>+            <item>PROCEDURE</item>+            <item>RESETLINE</item>+            <item>RGET</item>+            <item>RSPT</item>+            <item>RSUBMIT</item>+            <item>SASFILE</item>+            <item>SIGNOFF</item>+            <item>SIGNON</item>+            <item>SKIP</item>+            <item>SYMBOL</item>+            <item>SYSECHO</item>+            <item>SYSTASK</item>+            <item>TITLE</item>+            <item>TRANTAB</item>+            <item>WAITFOR</item>+        </list>+        <!-- DATA step statement keywords (active only inside a DATA step) -->+        <list name="datastep-keywords">+            <item>ABORT</item>+            <item>ARRAY</item>+            <item>ATTRIB</item>+            <item>BY</item>+            <item>CALL</item>+            <item>CONTINUE</item>+            <item>DELETE</item>+            <item>DESCRIBE</item>+            <item>DROP</item>+            <item>ERROR</item>+            <item>EXECUTE</item>+            <item>FILE</item>+            <item>FORMAT</item>+            <item>INFILE</item>+            <item>INFORMAT</item>+            <item>INPUT</item>+            <item>KEEP</item>+            <item>LABEL</item>+            <item>LEAVE</item>+            <item>LENGTH</item>+            <item>LIST</item>+            <item>LOSTCARD</item>+            <item>MERGE</item>+            <item>MODIFY</item>+            <item>OUTPUT</item>+            <item>PUT</item>+            <item>PUTLOG</item>+            <item>REDIRECT</item>+            <item>REMOVE</item>+            <item>RENAME</item>+            <item>REPLACE</item>+            <item>RETAIN</item>+            <item>RETURN</item>+            <item>SET</item>+            <item>STOP</item>+            <item>UPDATE</item>+            <item>WHERE</item>+        </list>+        <!-- Macro statements, excluding %macro/%mend/%do/%end for folding -->+        <list name="macros">+            <item>%ABORT</item>+            <item>%COMPSTOR</item>+            <item>%COPY</item>+            <item>%DISPLAY</item>+            <item>%DQLOAD</item>+            <item>%DQPUTLOC</item>+            <item>%DQUNLOAD</item>+            <item>%ELSE</item>+            <item>%GLOBAL</item>+            <item>%GOTO</item>+            <item>%IF</item>+            <item>%INC</item>+            <item>%INCLUDE</item>+            <item>%INPUT</item>+            <item>%LABEL</item>+            <item>%LET</item>+            <item>%LIST</item>+            <item>%LOCAL</item>+            <item>%PUT</item>+            <item>%RETURN</item>+            <item>%RUN</item>+            <item>%SYMDEL</item>+            <item>%SYSMACDELETE</item>+            <item>%SYSMACEXEC</item>+            <item>%SYSEXEC</item>+            <item>%THEN</item>+            <item>%TO</item>+            <item>%TPLOT</item>+            <item>%UNTIL</item>+            <item>%WHILE</item>+            <item>%WINDOW</item>+        </list>+        <!-- Dataset options used inside (...) after dataset names -->+        <list name="dataset-options">+            <item>ALTER</item>+            <item>APPEND</item>+            <item>BUFNO</item>+            <item>BUFSIZE</item>+            <item>CASLIB</item>+            <item>CNTLLEV</item>+            <item>COMPRESS</item>+            <item>COPIES</item>+            <item>DATALIMIT</item>+            <item>DLDMGACTION</item>+            <item>DROP</item>+            <item>DUPLICATE</item>+            <item>ENCODING</item>+            <item>ENCRYPT</item>+            <item>ENCRYPTKEY</item>+            <item>EOC</item>+            <item>EXTENDOBSCOUNTER</item>+            <item>FILECLOSE</item>+            <item>FIRSTOBS</item>+            <item>GENMAX</item>+            <item>GENNUM</item>+            <item>IDXNAME</item>+            <item>IDXWHERE</item>+            <item>IN</item>+            <item>INDEX</item>+            <item>KEEP</item>+            <item>LABEL</item>+            <item>MEMTYPE</item>+            <item>OBS</item>+            <item>OBSBUF</item>+            <item>ONDEMAND</item>+            <item>ORDERBY</item>+            <item>OUTREP</item>+            <item>PARTITION</item>+            <item>POINTOBS</item>+            <item>PROMOTE</item>+            <item>PW</item>+            <item>PWREQ</item>+            <item>READ</item>+            <item>READTRANSFERSIZE</item>+            <item>RENAME</item>+            <item>REPEMPTY</item>+            <item>REPLACE</item>+            <item>REUSE</item>+            <item>ROLE</item>+            <item>RTS</item>+            <item>SCRIPT</item>+            <item>SGIO</item>+            <item>SORTEDBY</item>+            <item>SPILL</item>+            <item>TAG</item>+            <item>TEMPEXPRESS</item>+            <item>TEMPNAMES</item>+            <item>TOBSNO</item>+            <item>TRANSCODE_FAIL</item>+            <item>TRANTAB</item>+            <item>TYPE</item>+            <item>WHERE</item>+            <item>WHEREUP</item>+            <item>WRITE</item>+            <item>WRITETRANSFERSIZE</item>+        </list>+        <!-- Built-in SAS functions -->+        <list name="functions">+            <item>ABS</item>+            <item>ADDMATRIX</item>+            <item>ADDR</item>+            <item>ADDRLONG</item>+            <item>ADDROW</item>+            <item>ADD_TABLE_ATTR</item>+            <item>AIRY</item>+            <item>ALLCOMB</item>+            <item>ALLCOMBI</item>+            <item>ALLPERM</item>+            <item>ANYALNUM</item>+            <item>ANYALPHA</item>+            <item>ANYCNTRL</item>+            <item>ANYDIGIT</item>+            <item>ANYFIRST</item>+            <item>ANYGRAPH</item>+            <item>ANYLOWER</item>+            <item>ANYNAME</item>+            <item>ANYPRINT</item>+            <item>ANYPUNCT</item>+            <item>ANYSPACE</item>+            <item>ANYUPPER</item>+            <item>ANYXDIGIT</item>+            <item>ARCOS</item>+            <item>ARCOSH</item>+            <item>ARMCONV</item>+            <item>ARMEND</item>+            <item>ARMGTID</item>+            <item>ARMINIT</item>+            <item>ARMJOIN</item>+            <item>ARMPROC</item>+            <item>ARMSTOP</item>+            <item>ARMSTRT</item>+            <item>ARMUPDT</item>+            <item>ARSIN</item>+            <item>ARSINH</item>+            <item>ARTANH</item>+            <item>ASCEBC</item>+            <item>ATAN</item>+            <item>ATAN2</item>+            <item>ATTRC</item>+            <item>ATTRN</item>+            <item>BAND</item>+            <item>BETA</item>+            <item>BETAINV</item>+            <item>BLACKCLPRC</item>+            <item>BLACKPTPRC</item>+            <item>BLKSHCLPRC</item>+            <item>BLKSHPTPRC</item>+            <item>BLSHIFT</item>+            <item>BNOT</item>+            <item>BOR</item>+            <item>BQUOTE</item>+            <item>BRSHIFT</item>+            <item>BXOR</item>+            <item>BYTE</item>+            <item>CAT</item>+            <item>CATQ</item>+            <item>CATS</item>+            <item>CATT</item>+            <item>CATX</item>+            <item>CDF</item>+            <item>CEIL</item>+            <item>CEILZ</item>+            <item>CEXIST</item>+            <item>CHAR</item>+            <item>CHOL</item>+            <item>CHOOSEC</item>+            <item>CHOOSEN</item>+            <item>CINV</item>+            <item>CLIBEXIST</item>+            <item>CLOSE</item>+            <item>CMISS</item>+            <item>CMPRES</item>+            <item>CNONCT</item>+            <item>COALESCE</item>+            <item>COALESCEC</item>+            <item>COLLATE</item>+            <item>COMB</item>+            <item>COMPANION_NEXT</item>+            <item>COMPARE</item>+            <item>COMPBL</item>+            <item>COMPCOST</item>+            <item>COMPFUZZ</item>+            <item>COMPGED</item>+            <item>COMPLEV</item>+            <item>COMPOUND</item>+            <item>COMPRESS</item>+            <item>COMPSTOR</item>+            <item>CONSTANT</item>+            <item>CONVX</item>+            <item>CONVXP</item>+            <item>COS</item>+            <item>COSH</item>+            <item>COT</item>+            <item>COUNT</item>+            <item>COUNTC</item>+            <item>COUNTW</item>+            <item>CSC</item>+            <item>CSS</item>+            <item>CUMIPMT</item>+            <item>CUMPRINC</item>+            <item>CUROBS</item>+            <item>CV</item>+            <item>DACCDB</item>+            <item>DACCDBSL</item>+            <item>DACCSL</item>+            <item>DACCSYD</item>+            <item>DACCTAB</item>+            <item>DAIRY</item>+            <item>DATATYP</item>+            <item>DATDIF</item>+            <item>DATE</item>+            <item>DATEJUL</item>+            <item>DATEPART</item>+            <item>DATETIME</item>+            <item>DAY</item>+            <item>DCLOSE</item>+            <item>DCREATE</item>+            <item>DEFINE</item>+            <item>DEPDB</item>+            <item>DEPDBSL</item>+            <item>DEPSL</item>+            <item>DEPSYD</item>+            <item>DEPTAB</item>+            <item>DEQUOTE</item>+            <item>DET</item>+            <item>DEVIANCE</item>+            <item>DHMS</item>+            <item>DICTIONARY</item>+            <item>DIF</item>+            <item>DIGAMMA</item>+            <item>DIM</item>+            <item>DINFO</item>+            <item>DISCARD</item>+            <item>DIVIDE</item>+            <item>DNUM</item>+            <item>DOPEN</item>+            <item>DOPTNAME</item>+            <item>DOPTNUM</item>+            <item>DOSUBL</item>+            <item>DQCASE</item>+            <item>DQGENDER</item>+            <item>DQGENDERINFOGET</item>+            <item>DQGENDERPARSED</item>+            <item>DQIDENTIFY</item>+            <item>DQLOCALEGUESS</item>+            <item>DQLOCALEINFOGET</item>+            <item>DQLOCALEINFOLIST</item>+            <item>DQMATCH</item>+            <item>DQMATCHINFOGET</item>+            <item>DQMATCHPARSED</item>+            <item>DQPARSE</item>+            <item>DQPARSEINFOGET</item>+            <item>DQPARSETOKENGET</item>+            <item>DQPARSETOKENPUT</item>+            <item>DQPATTERN</item>+            <item>DQSCHEMEAPPLY</item>+            <item>DQSRVARCHJOB</item>+            <item>DQSRVCOPYLOG</item>+            <item>DQSRVDELETELOG</item>+            <item>DQSRVJOBSTATUS</item>+            <item>DQSRVKILLJOB</item>+            <item>DQSRVPROFJOBFILE</item>+            <item>DQSRVPROFJOBREP</item>+            <item>DQSRVUSER</item>+            <item>DQSTANDARDIZE</item>+            <item>DQTOKEN</item>+            <item>DREAD</item>+            <item>DROPNOTE</item>+            <item>DSNAME</item>+            <item>DSNCATLGD</item>+            <item>DUR</item>+            <item>DURP</item>+            <item>DYNAMIC_ARRAY</item>+            <item>EBCASC</item>+            <item>EFFRATE</item>+            <item>ELEMMULT</item>+            <item>ENTRY_FIRST</item>+            <item>ENTRY_NEXT</item>+            <item>ENVLEN</item>+            <item>ERF</item>+            <item>ERFC</item>+            <item>EUCLID</item>+            <item>EVAL</item>+            <item>EXECUTE</item>+            <item>EXIST</item>+            <item>EXISTS</item>+            <item>EXP</item>+            <item>EXPMATRIX</item>+            <item>FACT</item>+            <item>FAPPEND</item>+            <item>FCLOSE</item>+            <item>FCOL</item>+            <item>FCOPY</item>+            <item>FDELETE</item>+            <item>FETCH</item>+            <item>FETCHOBS</item>+            <item>FEXIST</item>+            <item>FGET</item>+            <item>FILEATTR</item>+            <item>FILEEXIST</item>+            <item>FILENAME</item>+            <item>FILEREF</item>+            <item>FILLMATRIX</item>+            <item>FINANCE</item>+            <item>FIND</item>+            <item>FINDC</item>+            <item>FINDFILE</item>+            <item>FINDTABLE</item>+            <item>FINDW</item>+            <item>FINFO</item>+            <item>FINV</item>+            <item>FIPNAME</item>+            <item>FIPNAMEL</item>+            <item>FIPSTATE</item>+            <item>FIRST</item>+            <item>FLOOR</item>+            <item>FLOORZ</item>+            <item>FMTINFO</item>+            <item>FNONCT</item>+            <item>FNOTE</item>+            <item>FOPEN</item>+            <item>FOPTNAME</item>+            <item>FOPTNUM</item>+            <item>FPOINT</item>+            <item>FPOS</item>+            <item>FPUT</item>+            <item>FREAD</item>+            <item>FREWIND</item>+            <item>FRLEN</item>+            <item>FSEP</item>+            <item>FUZZ</item>+            <item>FWRITE</item>+            <item>GAMINV</item>+            <item>GAMMA</item>+            <item>GARKHCLPRC</item>+            <item>GARKHPTPRC</item>+            <item>GCD</item>+            <item>GEODIST</item>+            <item>GEOMEAN</item>+            <item>GEOMEANZ</item>+            <item>GETCASURL</item>+            <item>GETDVI</item>+            <item>GETJPI</item>+            <item>GETLCASLIB</item>+            <item>GETLOG</item>+            <item>GETLSESSREF</item>+            <item>GETLTAG</item>+            <item>GETMSG</item>+            <item>GETOPTION</item>+            <item>GETQUOTA</item>+            <item>GETSESSOPT</item>+            <item>GETSYM</item>+            <item>GETTERM</item>+            <item>GETVARC</item>+            <item>GETVARN</item>+            <item>GITFN_CLONE</item>+            <item>GITFN_COMMIT</item>+            <item>GITFN_COMMITFREE</item>+            <item>GITFN_COMMIT_GET</item>+            <item>GITFN_COMMIT_LOG</item>+            <item>GITFN_CO_BRANCH</item>+            <item>GITFN_DEL_REPO</item>+            <item>GITFN_DIFF</item>+            <item>GITFN_DIFF_FREE</item>+            <item>GITFN_DIFF_GET</item>+            <item>GITFN_DIFF_IDX_F</item>+            <item>GITFN_IDX_ADD</item>+            <item>GITFN_IDX_REMOVE</item>+            <item>GITFN_MRG_BRANCH</item>+            <item>GITFN_NEW_BRANCH</item>+            <item>GITFN_PULL</item>+            <item>GITFN_PUSH</item>+            <item>GITFN_RESET</item>+            <item>GITFN_RESET_FILE</item>+            <item>GITFN_STATUS</item>+            <item>GITFN_STATUSFREE</item>+            <item>GITFN_STATUS_GET</item>+            <item>GITFN_VERSION</item>+            <item>GRAYCODE</item>+            <item>GRDSVC_ENABLE</item>+            <item>GRDSVC_GETADDR</item>+            <item>GRDSVC_GETINFO</item>+            <item>GRDSVC_GETNAME</item>+            <item>GRDSVC_NNODES</item>+            <item>HARMEAN</item>+            <item>HARMEANZ</item>+            <item>HASHING</item>+            <item>HASHING_FILE</item>+            <item>HASHING_HMAC</item>+            <item>HASHING_HMAC_FILE</item>+            <item>HASHING_HMAC_INIT</item>+            <item>HASHING_INIT</item>+            <item>HASHING_PART</item>+            <item>HASHING_TERM</item>+            <item>HBOUND</item>+            <item>HMS</item>+            <item>HOLIDAY</item>+            <item>HOLIDAYCK</item>+            <item>HOLIDAYCOUNT</item>+            <item>HOLIDAYNAME</item>+            <item>HOLIDAYNX</item>+            <item>HOLIDAYNY</item>+            <item>HOLIDAYTEST</item>+            <item>HOUR</item>+            <item>HTMLDECODE</item>+            <item>HTMLENCODE</item>+            <item>IBESSEL</item>+            <item>IDENTITY</item>+            <item>IFC</item>+            <item>IFN</item>+            <item>INDEX</item>+            <item>INDEXC</item>+            <item>INDEXW</item>+            <item>INPUT</item>+            <item>INPUTC</item>+            <item>INPUTN</item>+            <item>INSERT_CATALOG</item>+            <item>INSERT_DATASET</item>+            <item>INSERT_FDB</item>+            <item>INSERT_FILE</item>+            <item>INSERT_HTML</item>+            <item>INSERT_MDDB</item>+            <item>INSERT_PACKAGE</item>+            <item>INSERT_REF</item>+            <item>INSERT_SQLVIEW</item>+            <item>INSERT_VIEWER</item>+            <item>INT</item>+            <item>INTCINDEX</item>+            <item>INTCK</item>+            <item>INTCYCLE</item>+            <item>INTFIT</item>+            <item>INTFMT</item>+            <item>INTGET</item>+            <item>INTINDEX</item>+            <item>INTNEST</item>+            <item>INTNX</item>+            <item>INTRR</item>+            <item>INTSEAS</item>+            <item>INTSHIFT</item>+            <item>INTTEST</item>+            <item>INTZ</item>+            <item>INV</item>+            <item>INVCDF</item>+            <item>INVERSE</item>+            <item>IORCMSG</item>+            <item>IPMT</item>+            <item>IQR</item>+            <item>IRR</item>+            <item>IS8601_CONVERT</item>+            <item>ISARRAY</item>+            <item>ISBLOB</item>+            <item>ISDICTIONARY</item>+            <item>ISDOUBLE</item>+            <item>ISINTEGER</item>+            <item>ISLIST</item>+            <item>ISNULL</item>+            <item>ISSTRING</item>+            <item>ISTABLE</item>+            <item>ISTYPE</item>+            <item>JBESSEL</item>+            <item>JSONPP</item>+            <item>JULDATE</item>+            <item>JULDATE7</item>+            <item>KCOMPARE</item>+            <item>KCOMPRESS</item>+            <item>KCOUNT</item>+            <item>KINDEX</item>+            <item>KINDEXC</item>+            <item>KLEFT</item>+            <item>KLENGTH</item>+            <item>KLOWCASE</item>+            <item>KREVERSE</item>+            <item>KRIGHT</item>+            <item>KSCAN</item>+            <item>KSUBSTR</item>+            <item>KSUBSTRB</item>+            <item>KTRANSLATE</item>+            <item>KTRIM</item>+            <item>KTRUNCATE</item>+            <item>KUPCASE</item>+            <item>KUPDATE</item>+            <item>KUPDATEB</item>+            <item>KURTOSIS</item>+            <item>KVERIFY</item>+            <item>LABEL</item>+            <item>LAG</item>+            <item>LARGEST</item>+            <item>LBOUND</item>+            <item>LCM</item>+            <item>LCOMB</item>+            <item>LEFT</item>+            <item>LENGTH</item>+            <item>LENGTHC</item>+            <item>LENGTHM</item>+            <item>LENGTHN</item>+            <item>LEXCOMB</item>+            <item>LEXCOMBI</item>+            <item>LEXPERK</item>+            <item>LEXPERM</item>+            <item>LFACT</item>+            <item>LGAMMA</item>+            <item>LIBNAME</item>+            <item>LIBREF</item>+            <item>LIMMOMENT</item>+            <item>LOG</item>+            <item>LOG10</item>+            <item>LOG1PX</item>+            <item>LOG2</item>+            <item>LOGBETA</item>+            <item>LOGCDF</item>+            <item>LOGISTIC</item>+            <item>LOGPDF</item>+            <item>LOGSDF</item>+            <item>LOWCASE</item>+            <item>LPERM</item>+            <item>LPNORM</item>+            <item>MAD</item>+            <item>MARGRCLPRC</item>+            <item>MARGRPTPRC</item>+            <item>MAX</item>+            <item>MD5</item>+            <item>MDY</item>+            <item>MEAN</item>+            <item>MEDIAN</item>+            <item>MIN</item>+            <item>MINUTE</item>+            <item>MISSING</item>+            <item>MOD</item>+            <item>MODEXIST</item>+            <item>MODULE</item>+            <item>MODULEC</item>+            <item>MODULEN</item>+            <item>MODZ</item>+            <item>MONTH</item>+            <item>MOPEN</item>+            <item>MORT</item>+            <item>MSPLINT</item>+            <item>MULT</item>+            <item>MVALID</item>+            <item>N</item>+            <item>NETPV</item>+            <item>NEWTABLE</item>+            <item>NLITERAL</item>+            <item>NMISS</item>+            <item>NODENAME</item>+            <item>NOMRATE</item>+            <item>NORMAL</item>+            <item>NOTALNUM</item>+            <item>NOTALPHA</item>+            <item>NOTCNTRL</item>+            <item>NOTDIGIT</item>+            <item>NOTE</item>+            <item>NOTFIRST</item>+            <item>NOTGRAPH</item>+            <item>NOTLOWER</item>+            <item>NOTNAME</item>+            <item>NOTPRINT</item>+            <item>NOTPUNCT</item>+            <item>NOTSPACE</item>+            <item>NOTUPPER</item>+            <item>NOTXDIGIT</item>+            <item>NPV</item>+            <item>NRBQUOTE</item>+            <item>NRQUOTE</item>+            <item>NRSTR</item>+            <item>NVALID</item>+            <item>NWKDOM</item>+            <item>OPEN</item>+            <item>ORDINAL</item>+            <item>PACKAGE_BEGIN</item>+            <item>PACKAGE_DESTROY</item>+            <item>PACKAGE_END</item>+            <item>PACKAGE_FIRST</item>+            <item>PACKAGE_NEXT</item>+            <item>PACKAGE_PUBLISH</item>+            <item>PACKAGE_TERM</item>+            <item>PATHNAME</item>+            <item>PCTL</item>+            <item>PDF</item>+            <item>PEEK</item>+            <item>PEEKC</item>+            <item>PEEKCLONG</item>+            <item>PEEKLONG</item>+            <item>PERM</item>+            <item>PMF</item>+            <item>PMT</item>+            <item>POINT</item>+            <item>POISSON</item>+            <item>POKE</item>+            <item>POKELONG</item>+            <item>POWER</item>+            <item>PPMT</item>+            <item>PRINTTABLE</item>+            <item>PROBBETA</item>+            <item>PROBBNML</item>+            <item>PROBBNRM</item>+            <item>PROBCHI</item>+            <item>PROBF</item>+            <item>PROBGAM</item>+            <item>PROBHYPR</item>+            <item>PROBIT</item>+            <item>PROBMC</item>+            <item>PROBMED</item>+            <item>PROBNEGB</item>+            <item>PROBNORM</item>+            <item>PROBT</item>+            <item>PROPCASE</item>+            <item>PRXCHANGE</item>+            <item>PRXDEBUG</item>+            <item>PRXFREE</item>+            <item>PRXMATCH</item>+            <item>PRXNEXT</item>+            <item>PRXPAREN</item>+            <item>PRXPARSE</item>+            <item>PRXPOSN</item>+            <item>PRXSUBSTR</item>+            <item>PTRLONGADD</item>+            <item>PUT</item>+            <item>PUTC</item>+            <item>PUTLOG</item>+            <item>PUTN</item>+            <item>PUTSYM</item>+            <item>PVP</item>+            <item>QCMPRES</item>+            <item>QLEFT</item>+            <item>QLOWCASE</item>+            <item>QSCAN</item>+            <item>QSUBSTR</item>+            <item>QSYSFUNC</item>+            <item>QTR</item>+            <item>QTRIM</item>+            <item>QUANTILE</item>+            <item>QUOTE</item>+            <item>QUPCASE</item>+            <item>RANBIN</item>+            <item>RANCAU</item>+            <item>RANCOMB</item>+            <item>RAND</item>+            <item>RANEXP</item>+            <item>RANGAM</item>+            <item>RANGE</item>+            <item>RANK</item>+            <item>RANNOR</item>+            <item>RANPERK</item>+            <item>RANPERM</item>+            <item>RANPOI</item>+            <item>RANTBL</item>+            <item>RANTRI</item>+            <item>RANUNI</item>+            <item>READPATH</item>+            <item>READ_ARRAY</item>+            <item>RENAME</item>+            <item>REPEAT</item>+            <item>RESOLVE</item>+            <item>RETRIEVE_CATALOG</item>+            <item>RETRIEVE_DATASET</item>+            <item>RETRIEVE_FDB</item>+            <item>RETRIEVE_FILE</item>+            <item>RETRIEVE_HTML</item>+            <item>RETRIEVE_MDDB</item>+            <item>RETRIEVE_NESTED</item>+            <item>RETRIEVE_PACKAGE</item>+            <item>RETRIEVE_REF</item>+            <item>RETRIEVE_SQLVIEW</item>+            <item>RETRIEVE_VIEWER</item>+            <item>REVERSE</item>+            <item>REWIND</item>+            <item>RIGHT</item>+            <item>RMS</item>+            <item>ROUND</item>+            <item>ROUNDE</item>+            <item>ROUNDZ</item>+            <item>RUN_MACRO</item>+            <item>RUN_SASFILE</item>+            <item>RXCHANGE</item>+            <item>RXFREE</item>+            <item>RXSUBSTR</item>+            <item>SAVING</item>+            <item>SAVINGS</item>+            <item>SCAN</item>+            <item>SCANQ</item>+            <item>SDF</item>+            <item>SEC</item>+            <item>SECOND</item>+            <item>SESSFOUND</item>+            <item>SESSIONS</item>+            <item>SET</item>+            <item>SETNULL</item>+            <item>SETTERM</item>+            <item>SHA256</item>+            <item>SHA256HEX</item>+            <item>SHA256HMACHEX</item>+            <item>SIGN</item>+            <item>SIN</item>+            <item>SINH</item>+            <item>SKEWNESS</item>+            <item>SLEEP</item>+            <item>SMALLEST</item>+            <item>SOAPWEB</item>+            <item>SOAPWEBMETA</item>+            <item>SOAPWIPSERVICE</item>+            <item>SOAPWIPSRS</item>+            <item>SOAPWS</item>+            <item>SOAPWSMETA</item>+            <item>SOFTMAX</item>+            <item>SOLVE</item>+            <item>SORT</item>+            <item>SORTC</item>+            <item>SORTN</item>+            <item>SORT_REV</item>+            <item>SOUNDEX</item>+            <item>SPEDIS</item>+            <item>SQRT</item>+            <item>SQUANTILE</item>+            <item>STD</item>+            <item>STDERR</item>+            <item>STDIZE</item>+            <item>STFIPS</item>+            <item>STNAME</item>+            <item>STNAMEL</item>+            <item>STR</item>+            <item>STREAMINIT</item>+            <item>STRIP</item>+            <item>STRUCTINDEX</item>+            <item>SUBPAD</item>+            <item>SUBSTR</item>+            <item>SUBSTRN</item>+            <item>SUBTRACTMATRIX</item>+            <item>SUM</item>+            <item>SUMABS</item>+            <item>SUPERQ</item>+            <item>SYMEXIST</item>+            <item>SYMGET</item>+            <item>SYMGLOBL</item>+            <item>SYMLOCAL</item>+            <item>SYMPUT</item>+            <item>SYMPUTX</item>+            <item>SYSEVALF</item>+            <item>SYSEXIST</item>+            <item>SYSFUNC</item>+            <item>SYSGET</item>+            <item>SYSMSG</item>+            <item>SYSPARM</item>+            <item>SYSPROCESSID</item>+            <item>SYSPROCESSNAME</item>+            <item>SYSPROD</item>+            <item>SYSRC</item>+            <item>SYSTEM</item>+            <item>TABCOLUMNS</item>+            <item>TABTYPES</item>+            <item>TAN</item>+            <item>TANH</item>+            <item>TERMIN</item>+            <item>TERMOUT</item>+            <item>TIME</item>+            <item>TIMEPART</item>+            <item>TIMEVALUE</item>+            <item>TINV</item>+            <item>TNONCT</item>+            <item>TODAY</item>+            <item>TRACEBACK</item>+            <item>TRANSLATE</item>+            <item>TRANSPOSE</item>+            <item>TRANSTRN</item>+            <item>TRANWRD</item>+            <item>TRIGAMMA</item>+            <item>TRIM</item>+            <item>TRIMN</item>+            <item>TRUNC</item>+            <item>TSO</item>+            <item>TTCLOSE</item>+            <item>TTCONTRL</item>+            <item>TTOPEN</item>+            <item>TTREAD</item>+            <item>TTWRITE</item>+            <item>TYPEOF</item>+            <item>TZID</item>+            <item>TZONEID</item>+            <item>TZONENAME</item>+            <item>TZONEOFF</item>+            <item>TZONES2U</item>+            <item>TZONEU2S</item>+            <item>UNIFORM</item>+            <item>UNQUOTE</item>+            <item>UPCASE</item>+            <item>URLDECODE</item>+            <item>URLENCODE</item>+            <item>USS</item>+            <item>UUIDGEN</item>+            <item>VAR</item>+            <item>VARFMT</item>+            <item>VARINFMT</item>+            <item>VARLABEL</item>+            <item>VARLEN</item>+            <item>VARNAME</item>+            <item>VARNUM</item>+            <item>VARRAY</item>+            <item>VARRAYX</item>+            <item>VARTYPE</item>+            <item>VERIFY</item>+            <item>VFORMAT</item>+            <item>VFORMATD</item>+            <item>VFORMATDX</item>+            <item>VFORMATN</item>+            <item>VFORMATNX</item>+            <item>VFORMATW</item>+            <item>VFORMATWX</item>+            <item>VFORMATX</item>+            <item>VINARRAY</item>+            <item>VINARRAYX</item>+            <item>VINFORMAT</item>+            <item>VINFORMATD</item>+            <item>VINFORMATDX</item>+            <item>VINFORMATN</item>+            <item>VINFORMATNX</item>+            <item>VINFORMATW</item>+            <item>VINFORMATWX</item>+            <item>VINFORMATX</item>+            <item>VLABEL</item>+            <item>VLABELX</item>+            <item>VLENGTH</item>+            <item>VLENGTHX</item>+            <item>VMS</item>+            <item>VNAME</item>+            <item>VNAMEX</item>+            <item>VNEXT</item>+            <item>VTYPE</item>+            <item>VTYPEX</item>+            <item>VVALUE</item>+            <item>VVALUEX</item>+            <item>WEEK</item>+            <item>WEEKDAY</item>+            <item>WHICHC</item>+            <item>WHICHN</item>+            <item>WRITE_ARRAY</item>+            <item>WTO</item>+            <item>YEAR</item>+            <item>YIELDP</item>+            <item>YRDIF</item>+            <item>YYQ</item>+            <item>ZEROMATRIX</item>+            <item>ZIPCITY</item>+            <item>ZIPCITYDISTANCE</item>+            <item>ZIPFIPS</item>+            <item>ZIPNAME</item>+            <item>ZIPNAMEL</item>+            <item>ZIPSTATE</item>+        </list>+        <contexts>+            <!-- ====+            	Init - default file-start for comments (ensure statement comment). Fall through to Normal+            	 ==== -->+            <context attribute="Normal Text" name="Init" lineEndContext="#stay" fallthroughContext="Normal">+                <IncludeRules context="Statement"/>+            </context>+            <!-- ====+            	General - highlighting context rules for e.g. macros,+            	strings, numbers, without proc/data keywords, used via+            	IncludeRule+            	 ==== -->+            <context attribute="Normal Text" name="General" lineEndContext="#stay">+                <!-- Intra-statement comments, handle statement comments via Statement context -->+                <Detect2Chars attribute="Comment" context="BlockComment" char="/" char1="*" beginRegion="Comment"/>+                <Detect2Chars attribute="Comment" context="MacroComment" char="%" char1="*" beginRegion="Comment"/>+                <DetectChar attribute="Normal Text" context="Statement" char=";"/>+                <!-- %DO / %END folding -->+                <WordDetect attribute="MacroKeyword" context="#stay" String="%do" insensitive="true" beginRegion="macrogroup"/>+                <WordDetect attribute="MacroKeyword" context="#stay" String="%end" insensitive="true" endRegion="macrogroup"/>+                <!-- %MACRO / %MEND folding -->+                <WordDetect attribute="MacroDef" context="MacroName" String="%macro" insensitive="true" beginRegion="macrodef"/>+                <WordDetect attribute="MacroDef" context="#stay" String="%mend" endRegion="macrodef"/>+                <!-- Macro keywords (%IF %LET %PUT etc.) -->+                <keyword attribute="MacroKeyword" context="#stay" String="macros"/>+                <!-- Macro variable: &varname -->+                <DetectChar attribute="MacroVariable" context="MacroVariable" char="&amp;"/>+                <!-- Generic macro call: %name (user-defined macros or macro functions) -->+                <DetectChar attribute="MacroName" context="MacroName" char="%"/>+                <!-- OPTIONS statement -->+                <WordDetect attribute="Keywords" context="OptionsStmt" String="options" insensitive="true"/>+                <!-- Mnemonic operators -->+                <keyword attribute="Operator" context="#stay" String="operators-word"/>+                <!-- Automatic variables -->+                <keyword attribute="Constants" context="#stay" String="constants"/>+                <!-- Format specifications -->+                <RegExpr attribute="Format" context="#stay" String="(?:\$?[A-Za-z_]|\$\d+)\w*\.(?![a-zA-Z])(?:\d+)?" insensitive="true"/>+                <!-- Suffixed and regular strings -->+                <RegExpr attribute="Number" context="#stay" insensitive="true" String="&quot;(?:[^&quot;]|&quot;&quot;)*&quot;(?:dt|[dtDT])(?!\w)"/>+                <RegExpr attribute="String" context="#stay" insensitive="true" String="&quot;(?:[^&quot;]|&quot;&quot;)*&quot;[bnxBNX](?!\w)"/>+                <DetectChar attribute="String" context="StringDouble" char="&quot;"/>+                <RegExpr attribute="Number" context="#stay" insensitive="true" String="'(?:[^']|'')*'(?:dt|[dtDT])(?!\w)"/>+                <RegExpr attribute="String" context="#stay" insensitive="true" String="'(?:[^']|'')*'[bnxBNX](?!\w)"/>+                <DetectChar attribute="String" context="StringSingle" char="'"/>+                <!-- Numbers -->+                <RegExpr attribute="Number" context="#stay" insensitive="true" String="[0-9][0-9A-Fa-f]*[xX](?!\w)|(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?"/>+                <!-- Symbolic operators, multi char and single char -->+                <RegExpr attribute="Operator" context="#stay" String="\^=:|~=:|&gt;=:|&lt;=:|\*\*|\|\||\^=|~=|&gt;=|&lt;=|&lt;&gt;|&gt;&lt;|=:|&gt;:|&lt;:|=\*"/>+                <AnyChar attribute="Operator" context="#stay" String="+-*/=&lt;&gt;^~|!#@"/>+            </context>+            <!-- Statement - used to ensure ; are respected for comments. Falls through to previous context -->+            <context attribute="Normal Text" name="Statement" lineEndContext="#stay" fallthroughContext="#pop">+                <DetectSpaces attribute="Normal Text" context="#stay"/>+                <DetectChar attribute="Comment" context="StmtComment" char="*" beginRegion="Comment"/>+                <Detect2Chars attribute="Comment" context="BlockComment" char="/" char1="*" beginRegion="Comment"/>+                <Detect2Chars attribute="Comment" context="MacroComment" char="%" char1="*" beginRegion="Comment"/>+            </context>+            <!-- ====+            	Main / Normal context+            	 ==== -->+            <context attribute="Normal Text" lineEndContext="#stay" name="Normal">+                <DetectSpaces context="#stay"/>+                <!-- Proc-specific embedded-language contexts — tested before generic \bproc\b -->+                <RegExpr attribute="Step" context="ProcSQL" String="\bproc\s+(?:sql|fedsql)\b" insensitive="true" beginRegion="datastep"/>+                <RegExpr attribute="Step" context="ProcPython" String="&proc_py;" insensitive="true" beginRegion="datastep"/>+                <RegExpr attribute="Step" context="ProcLua" String="&proc_lua;" insensitive="true" beginRegion="datastep"/>+                <!-- Generic PROC <name> -->+                <RegExpr attribute="Step" context="ProcHeader" String="\bproc\s+[a-zA-Z]\w*" insensitive="true" beginRegion="datastep"/>+                <!-- DATA step — negative lookahead prevents firing on `data=` common option -->+                <RegExpr attribute="Step" context="DataBody" String="&datastep;" insensitive="true" beginRegion="datastep"/>+                <!-- RUN; or QUIT; at global scope -->+                <RegExpr attribute="Step" context="Statement" String="\brun|quit\s*;" insensitive="true" endRegion="datastep"/>+                <!-- SAS statement keywords -->+                <keyword attribute="Keywords" context="#stay" String="keywords"/>+                <IncludeRules context="General"/>+            </context>+            <!-- ====+            	ProcHeader — proc option line (proc <name> <options> ;)+            	Colours option names as SecKeyword:+            	option=value  — lookahead on = to match only the name+            	standalone option — DetectIdentifier+            	On ; transitions to ProcBody+            	 ==== -->+            <context attribute="Normal Text" lineEndContext="#stay" name="ProcHeader">+                <!-- Semicolon ends the header line; dont consume and enter ProcBody -->+                <DetectChar attribute="Normal Text" context="#pop!ProcBody" char=";" lookAhead="true"/>+                <!-- option=value - colour option name as SecKeyword, push helper to color value depending on type -->+                <RegExpr attribute="SecKeyword" context="OptValue" String="&option_name;" insensitive="true"/>+                <!-- standalone boolean option -->+                <DetectIdentifier attribute="SecKeyword" context="#stay"/>+                <!-- Dataset options inside () -->+                <DetectChar attribute="Normal Text" context="DatasetOpts" char="("/>+                <IncludeRules context="General"/>+            </context>+            <!-- ====+            	ProcBody — generic proc body, handles each statment by colouring first keyword using+                helper context (which also exits context), then colouring dataset options, then regular rules+            	 ==== -->+            <context attribute="Normal Text" lineEndContext="#stay" name="ProcBody">+                <!-- After each semicolon, colour the next identifier as a proc keyword -->+                <DetectChar attribute="Normal Text" context="ProcStmt" char=";"/>+                <!-- Dataset options inside () -->+                <DetectChar attribute="Normal Text" context="DatasetOpts" char="("/>+                <!-- All regular Normal rules -->+                <IncludeRules context="General"/>+            </context>+            <!-- ====+            	ProcStmt — after ; inside a proc body.+            	Exit when run/quit/new statement+            	Skips whitespace/comments, colours the first identifier as SecKeyword, then pops back to ProcBody.+            	 ==== -->+            <context attribute="Normal Text" lineEndContext="#stay" name="ProcStmt" fallthroughContext="#pop">+                <DetectSpaces context="#stay"/>+                <DetectChar attribute="Comment" context="StmtComment" char="*" beginRegion="Comment"/>+                <Detect2Chars attribute="Comment" context="BlockComment" char="/" char1="*" beginRegion="Comment"/>+                <Detect2Chars attribute="Comment" context="MacroComment" char="%" char1="*" beginRegion="Comment"/>+                <!-- Exit on run or quit -->+                <RegExpr attribute="Step" context="#pop#pop!Statement" String="&run_quit;" insensitive="true" endRegion="datastep"/>+                <!-- Bail out if another step starts without RUN/QUIT, dont consume and handle with main context -->+                <RegExpr attribute="Normal Text" context="#pop#pop" String="&proc_data;" firstNonSpace="true" insensitive="true" lookAhead="true"/>+                <!-- Colour the first identifier as a proc sub-statement keyword, then re-enter ProcBody for remaining rules -->+                <DetectIdentifier attribute="SecKeyword" context="#pop"/>+            </context>+            <!-- ====+            	DataBody — DATA step body+            	 ==== -->+            <context attribute="Normal Text" lineEndContext="#stay" name="DataBody">+                <DetectSpaces context="#stay"/>+                <!-- Exit on RUN; -->+                <RegExpr attribute="Step" context="#pop!Statement" String="\brun\s*;" insensitive="true" endRegion="datastep"/>+                <!-- Bail out if another step starts without RUN, dont consume and handle with main context -->+                <RegExpr attribute="Normal Text" context="#pop" String="&proc_data;" insensitive="true" lookAhead="true"/>+                <!-- Dataset options inside () -->+                <DetectChar attribute="Normal Text" context="DatasetOpts" char="("/>+                <!-- Control flow -->+                <keyword attribute="Control" context="#stay" String="controls"/>+                <!-- Built-in functions: lookahead for func( then classify in FuncCheck -->+                <RegExpr attribute="Normal Text" context="FuncCheck" String="&identifier;\s*\(" insensitive="true" lookAhead="true"/>+                <!-- Data-step statement keywords -->+                <keyword attribute="Keywords" context="#stay" String="datastep-keywords"/>+                <!-- Cards / Datalines / Parmcards -->+                <RegExpr attribute="Keywords" context="Cards4" String="\b(?:cards4|lines4|datalines4|parmcards4)\b[^;]*;" insensitive="true" beginRegion="Cards"/>+                <RegExpr attribute="Keywords" context="Cards" String="\b(?:cards|lines|datalines|parmcards)\b[^;]*;" insensitive="true" beginRegion="Cards"/>+                <!-- DO / END folding -->+                <WordDetect attribute="Control" context="#stay" String="do" insensitive="true" beginRegion="doblock"/>+                <RegExpr attribute="Control" context="#stay" String="\bend(?=\s*;)" insensitive="true" endRegion="doblock"/>+                <!-- All regular General rules -->+                <IncludeRules context="General"/>+            </context>+            <!-- ====+            	FuncCheck — classify word before ( as Function or Normal Text+            	 ==== -->+            <context attribute="Normal Text" name="FuncCheck" fallthroughContext="#pop">+                <keyword attribute="Functions" context="#pop" String="functions"/>+                <!-- If we dont match then consume identfiers to avoid popping back to same position and re-entering match  -->+                <DetectIdentifier attribute="Normal Text" context="#pop"/>+            </context>+            <!-- ====+            	DatasetOpts — inside (...) after a dataset name+            	 ==== -->+            <context attribute="Normal Text" lineEndContext="#stay" name="DatasetOpts">+                <!-- Nested data set option/value key pairs -->+                <DetectChar attribute="Normal Text" context="DatasetOpts" char="("/>+                <DetectChar attribute="Normal Text" context="#pop" char=")"/>+                <keyword attribute="SecKeyword" context="#stay" String="dataset-options"/>+                <IncludeRules context="General"/>+            </context>+            <!-- ====+            	OptionsStmt — after OPTIONS keyword, until ;+            	 ==== -->+            <context attribute="Normal Text" lineEndContext="#stay" name="OptionsStmt">+                <DetectChar attribute="Normal Text" context="#pop" char=";"/>+                <!-- option=value - colour option name as SecKeyword, push helper to color value depending on type -->+                <RegExpr attribute="SecKeyword" context="OptValue" String="&option_name;" insensitive="true"/>+                <!-- standalone boolean option -->+                <DetectIdentifier attribute="SecKeyword" context="#stay"/>+                <IncludeRules context="General"/>+            </context>+            <!-- ====+            	OptValue / OptValueAfterEq — shared by ProcHeader and+            	OptionsStmt to consume =<value> without colouring the+            	value as SecKeyword.+            	 ==== -->+            <context attribute="Normal Text" lineEndContext="#stay" name="OptValue" fallthroughContext="#pop">+                <DetectSpaces context="#stay"/>+                <DetectChar attribute="Operator" context="OptValueAfterEq" char="="/>+            </context>+            <context attribute="Normal Text" lineEndContext="#stay" name="OptValueAfterEq" fallthroughContext="#pop#pop">+                <DetectSpaces context="#stay"/>+                <!-- Identifier value (libref.member or plain): consume as Normal Text, pop both -->+                <RegExpr attribute="Normal Text" context="#pop#pop" String="&identifier;(\.&identifier;)*"/>+                <!-- Numbers, strings, other values: fall through #pop#pop — caller's General rules colour them -->+            </context>+            <!-- ====+            	Comments+            	 ==== -->+            <context attribute="Comment" name="BlockComment">+                <Detect2Chars attribute="Comment" context="#pop" char="*" char1="/" endRegion="Comment"/>+            </context>+            <context attribute="Comment" name="MacroComment">+                <DetectChar attribute="Comment" context="#pop" char=";" endRegion="Comment"/>+            </context>+            <context attribute="Comment" name="StmtComment">+                <DetectChar attribute="Comment" context="#pop" char=";" endRegion="Comment"/>+            </context>+            <!-- ====+            	Regular Strings - allow double quoting to escape+            	 ==== -->+            <context attribute="String" name="StringDouble">+                <StringDetect attribute="String" context="#stay" String="&quot;&quot;"/>+                <DetectChar attribute="String" context="#pop" char="&quot;"/>+            </context>+            <context attribute="String" name="StringSingle">+                <StringDetect attribute="String" context="#stay" String="''"/>+                <DetectChar attribute="String" context="#pop" char="'"/>+            </context>+            <!-- ====+            	Macro Names & Variables+            	 ==== -->+            <context attribute="MacroName" name="MacroName">+                <!-- Highlight macro name as in %macro <macro_name>, or as in %macro_name -->+                <DetectSpaces attribute="Normal Text" context="#stay"/>+                <DetectIdentifier attribute="MacroName" context="#pop"/>+            </context>+            <context attribute="MacroVariable" name="MacroVariable">+                <DetectIdentifier attribute="MacroVariable" context="#stay"/>+                <DetectChar attribute="MacroVariable" context="#pop" char="."/>+                <RegExpr attribute="MacroVariable" context="#pop" String="\W" lookAhead="true"/>+            </context>+            <!-- ====+            	CARDS / DATALINES inline data+            	 ==== -->+            <context attribute="Cards" name="Cards">+                <DetectChar attribute="Normal Text" context="#pop" char=";" endRegion="Cards"/>+            </context>+            <context attribute="Cards" name="Cards4">+                <StringDetect attribute="Normal Text" context="#pop" String=";;;;" endRegion="Cards"/>+            </context>+            <!-- ====+            	Embedded Language PROCS+            	 ==== -->+            <context attribute="Normal Text" name="ProcSQL">+                <!-- Add rules to jump to correct block if a proc sql block is ended - to take precedence over+                     regular SQL rules -->+                <RegExpr attribute="Step" context="#pop!Statement" String="\bquit\s*;" insensitive="true" endRegion="datastep"/>+                <RegExpr attribute="Step" context="#pop!DataBody" String="&datastep;" insensitive="true" firstNonSpace="true" beginRegion="datastep"/>+                <RegExpr attribute="Step" context="#pop!ProcSQL" String="\bproc\s+(?:sql|fedsql)\b[^;]*;" insensitive="true" firstNonSpace="true" beginRegion="datastep"/>+                <RegExpr attribute="Step" context="#pop!ProcPython" String="&proc_py;" insensitive="true" firstNonSpace="true" beginRegion="datastep"/>+                <RegExpr attribute="Step" context="#pop!ProcLua" String="&proc_lua;" insensitive="true" firstNonSpace="true" beginRegion="datastep"/>+                <RegExpr attribute="Step" context="#pop!ProcBody" String=";\s*\bproc\b" insensitive="true" firstNonSpace="true" beginRegion="datastep"/>+                <IncludeRules context="Normal##SQL"/>+            </context>+            <context attribute="Normal Text" name="ProcPython">+                <RegExpr attribute="Step" context="#pop!Statement" String="&run_quit;" insensitive="true" endRegion="datastep"/>+                <RegExpr attribute="Normal Text" context="#pop" String="&proc_data;" insensitive="true" lookAhead="true"/>+                <RegExpr attribute="Keywords" context="PythonBlock" String="&submit;" insensitive="true"/>+                <IncludeRules context="Normal"/>+            </context>+            <context attribute="Normal Text" name="PythonBlock">+                <RegExpr attribute="Keywords" context="#pop" String="&endsubmit;" insensitive="true"/>+                <IncludeRules context="Normal##Python"/>+            </context>+            <context attribute="Normal Text" name="ProcLua">+                <RegExpr attribute="Step" context="#pop!Statement" String="&run_quit;" insensitive="true" endRegion="datastep"/>+                <RegExpr attribute="Normal Text" context="#pop" String="&proc_data;" insensitive="true" lookAhead="true"/>+                <RegExpr attribute="Keywords" context="LuaBlock" String="&submit;" insensitive="true"/>+                <IncludeRules context="Normal"/>+            </context>+            <context attribute="Normal Text" name="LuaBlock">+                <RegExpr attribute="Keywords" context="#pop" String="&endsubmit;" insensitive="true"/>+                <IncludeRules context="Normal##Lua"/>+            </context>+        </contexts>+        <!-- ====+        	Style Definitions+        	 ==== -->+        <itemDatas>+            <itemData name="Normal Text" defStyleNum="dsNormal"/>+            <itemData name="Operator" defStyleNum="dsOperator"/>+            <itemData name="Keywords" defStyleNum="dsKeyword"/>+            <itemData name="SecKeyword" defStyleNum="dsBuiltIn"/>+            <itemData name="Functions" defStyleNum="dsFunction"/>+            <itemData name="Constants" defStyleNum="dsConstant"/>+            <itemData name="Format" defStyleNum="dsDataType"/>+            <itemData name="MacroDef" defStyleNum="dsPreprocessor"/>+            <itemData name="MacroKeyword" defStyleNum="dsPreprocessor"/>+            <itemData name="Control" defStyleNum="dsControlFlow"/>+            <itemData name="Step" defStyleNum="dsKeyword" bold="true"/>+            <itemData name="Comment" defStyleNum="dsComment" spellChecking="true"/>+            <itemData name="String" defStyleNum="dsString"/>+            <itemData name="Number" defStyleNum="dsFloat"/>+            <itemData name="MacroName" defStyleNum="dsExtension" italic="true"/>+            <itemData name="MacroVariable" defStyleNum="dsVariable"/>+            <itemData name="Cards" defStyleNum="dsOthers"/>+        </itemDatas>+    </highlighting>+    <general>+        <comments>+            <comment name="multiLine" start="/*" end="*/" region="Comment"/>+            <comment name="multiLine" start="*" end=";" region="Comment"/>+            <comment name="multiLine" start="%*" end=";" region="Comment"/>+        </comments>+        <keywords casesensitive="false" weakDeliminator="%"/>+    </general>+</language>
+ xml/sparql.xml view
@@ -0,0 +1,193 @@+<?xml version="1.0" encoding="UTF-8"?>+<!DOCTYPE language>+<language name="SPARQL" section="Database" version="1" kateversion="5.0"+    extensions="*.rq;*.sparql"+    mimetype="application/sparql-query"+    author="Damian Oswald (damian.oswald@protonmail.com)"+    license="MIT">+  <highlighting>+    <list name="keywords">+      <item>ADD</item>+      <item>AS</item>+      <item>ASC</item>+      <item>ASK</item>+      <item>BASE</item>+      <item>BIND</item>+      <item>BY</item>+      <item>CLEAR</item>+      <item>CONSTRUCT</item>+      <item>COPY</item>+      <item>CREATE</item>+      <item>DATA</item>+      <item>DEFAULT</item>+      <item>DELETE</item>+      <item>DESC</item>+      <item>DESCRIBE</item>+      <item>DISTINCT</item>+      <item>DROP</item>+      <item>EXISTS</item>+      <item>FILTER</item>+      <item>FROM</item>+      <item>GRAPH</item>+      <item>GROUP</item>+      <item>HAVING</item>+      <item>IN</item>+      <item>INSERT</item>+      <item>INTO</item>+      <item>LIMIT</item>+      <item>LOAD</item>+      <item>MINUS</item>+      <item>MOVE</item>+      <item>NAMED</item>+      <item>NOT</item>+      <item>OFFSET</item>+      <item>OPTIONAL</item>+      <item>ORDER</item>+      <item>PREFIX</item>+      <item>REDUCED</item>+      <item>SELECT</item>+      <item>SERVICE</item>+      <item>SILENT</item>+      <item>TO</item>+      <item>UNDEF</item>+      <item>UNION</item>+      <item>USING</item>+      <item>VALUES</item>+      <item>WHERE</item>+      <item>WITH</item>+    </list>+    <list name="functions">+      <item>ABS</item>+      <item>BNODE</item>+      <item>BOUND</item>+      <item>CEIL</item>+      <item>COALESCE</item>+      <item>CONCAT</item>+      <item>CONTAINS</item>+      <item>DATATYPE</item>+      <item>DAY</item>+      <item>ENCODE_FOR_URI</item>+      <item>FLOOR</item>+      <item>HOURS</item>+      <item>IF</item>+      <item>IRI</item>+      <item>ISBLANK</item>+      <item>ISIRI</item>+      <item>ISLITERAL</item>+      <item>ISNUMERIC</item>+      <item>ISURI</item>+      <item>LANG</item>+      <item>LANGMATCHES</item>+      <item>LCASE</item>+      <item>MD5</item>+      <item>MINUTES</item>+      <item>MONTH</item>+      <item>NOW</item>+      <item>RAND</item>+      <item>REGEX</item>+      <item>REPLACE</item>+      <item>ROUND</item>+      <item>SAMETERM</item>+      <item>SECONDS</item>+      <item>SHA1</item>+      <item>SHA256</item>+      <item>SHA384</item>+      <item>SHA512</item>+      <item>STR</item>+      <item>STRAFTER</item>+      <item>STRBEFORE</item>+      <item>STRDT</item>+      <item>STRENDS</item>+      <item>STRLANG</item>+      <item>STRLEN</item>+      <item>STRSTARTS</item>+      <item>STRUUID</item>+      <item>SUBSTR</item>+      <item>TIMEZONE</item>+      <item>TZ</item>+      <item>UCASE</item>+      <item>URI</item>+      <item>UUID</item>+      <item>YEAR</item>+    </list>+    <list name="aggregates">+      <item>AVG</item>+      <item>COUNT</item>+      <item>GROUP_CONCAT</item>+      <item>MAX</item>+      <item>MIN</item>+      <item>SAMPLE</item>+      <item>SUM</item>+    </list>+    <contexts>+      <context name="Normal" attribute="Normal Text" lineEndContext="#stay">+        <DetectSpaces/>+        <DetectChar attribute="Comment" context="Singleline Comment" char="#"/>+        <RangeDetect attribute="IRI" context="#stay" char="&lt;" char1="&gt;"/>+        <StringDetect attribute="String" context="StringTSS" String="'''"/>+        <StringDetect attribute="String" context="StringTDS" String="&quot;&quot;&quot;"/>+        <DetectChar attribute="String" context="StringS" char="'"/>+        <DetectChar attribute="String" context="StringD" char="&quot;"/>+        <HlCHex attribute="Hex" context="#stay"/>+        <Float attribute="Float" context="#stay"/>+        <Int attribute="Decimal" context="#stay"/>+        <StringDetect attribute="Variable" context="#stay" String="[\?\$]\w+"/>+        <keyword attribute="Keyword" String="keywords" context="#stay" insensitive="true"/>+        <keyword attribute="Function" String="functions" context="#stay" insensitive="true"/>+        <keyword attribute="Function" String="aggregates" context="#stay" insensitive="true"/>+        <Detect2Chars attribute="Operator" context="#stay" char="&amp;" char1="&amp;"/>+        <Detect2Chars attribute="Operator" context="#stay" char="|" char1="|"/>+        <Detect2Chars attribute="Operator" context="#stay" char="!" char1="="/>+        <Detect2Chars attribute="Operator" context="#stay" char="&lt;" char1="="/>+        <Detect2Chars attribute="Operator" context="#stay" char="&gt;" char1="="/>+        <Detect2Chars attribute="Operator" context="#stay" char="^" char1="^"/>+        <AnyChar attribute="Operator" context="#stay" String="*+-/=!&lt;&gt;()[]{},;.|^"/>+        <StringDetect attribute="Boolean" context="#stay" String="\b(true|false)\b" insensitive="true"/>+        <StringDetect attribute="Prefixed Name" context="#stay" String="\b[a-zA-Z0-9_.-]*:[a-zA-Z0-9_.-]+"/>+        <StringDetect attribute="Blank Node" context="#stay" String="_:[a-zA-Z0-9_.-]+"/>+        <StringDetect attribute="LangTag" context="#stay" String="@[a-zA-Z]+(-[a-zA-Z0-9]+)*"/>+      </context>+      <context name="StringS" attribute="String" lineEndContext="#stay">+        <HlCStringChar attribute="String Char" context="#stay"/>+        <DetectChar attribute="String" context="#pop" char="'"/>+      </context>+      <context name="StringD" attribute="String" lineEndContext="#stay">+        <HlCStringChar attribute="String Char" context="#stay"/>+        <DetectChar attribute="String" context="#pop" char="&quot;"/>+      </context>+      <context name="StringTSS" attribute="String" lineEndContext="#stay">+        <StringDetect attribute="String" context="#pop" String="'''"/>+      </context>+      <context name="StringTDS" attribute="String" lineEndContext="#stay">+        <StringDetect attribute="String" context="#pop" String="&quot;&quot;&quot;"/>+      </context>+      <context name="Singleline Comment" attribute="Comment" lineEndContext="#pop">+        <IncludeRules context="##Comments"/>+      </context>+    </contexts>+    <itemDatas>+      <itemData name="Normal Text"   defStyleNum="dsNormal" spellChecking="false"/>+      <itemData name="Keyword"       defStyleNum="dsKeyword" spellChecking="false"/>+      <itemData name="Function"      defStyleNum="dsFunction" spellChecking="false"/>+      <itemData name="Decimal"       defStyleNum="dsDecVal" spellChecking="false"/>+      <itemData name="Hex"           defStyleNum="dsBaseN" spellChecking="false"/>+      <itemData name="Float"         defStyleNum="dsFloat" spellChecking="false"/>+      <itemData name="String"        defStyleNum="dsString"/>+      <itemData name="String Char"   defStyleNum="dsChar" spellChecking="false"/>+      <itemData name="Comment"       defStyleNum="dsComment"/>+      <itemData name="Operator"      defStyleNum="dsOperator" spellChecking="false"/>+      <itemData name="Variable"      defStyleNum="dsOthers" spellChecking="false" bold="1"/>+      <itemData name="IRI"           defStyleNum="dsString" spellChecking="false"/>+      <itemData name="Prefixed Name" defStyleNum="dsDataType" spellChecking="false"/>+      <itemData name="Blank Node"    defStyleNum="dsOthers" spellChecking="false"/>+      <itemData name="LangTag"       defStyleNum="dsDataType" spellChecking="false"/>+      <itemData name="Boolean"       defStyleNum="dsConstant" spellChecking="false"/>+    </itemDatas>+  </highlighting>+  <general>+    <comments>+      <comment name="singleLine" start="#" />+    </comments>+    <keywords casesensitive="0" />+  </general>+</language>
xml/spdx-comments.xml view
@@ -6,545 +6,808 @@   ./generate-spdx-syntax.py > ../syntax/spdx-comments.xml --> <language-    version="6"-    kateversion="3.1"-    name="SPDX-Comments"-    section="Other"-    extensions=""-    mimetype=""-    author="Alex Turbov (i.zaufi@gmail.com)"-    license="MIT"-    hidden="true"-  >-  <highlighting>-    <list name="tags">-      <item>SPDX-License-Identifier:</item>-      <item>SPDX-FileContributor:</item>-      <item>SPDX-FileCopyrightText:</item>-      <item>SPDX-LicenseInfoInFile:</item>-    </list>--    <list name="operators">-      <item>AND</item>-      <item>OR</item>-      <item>WITH</item>-    </list>--    <list name="licenses">-      <item>bzip2-1.0.6</item>-      <item>Intel-ACPI</item>-      <item>XSkat</item>-      <item>CC-BY-NC-SA-2.0</item>-      <item>Plexus</item>-      <item>Giftware</item>-      <item>BitTorrent-1.0</item>-      <item>APSL-1.1</item>-      <item>UPL-1.0</item>-      <item>Caldera</item>-      <item>Zend-2.0</item>-      <item>CUA-OPL-1.0</item>-      <item>JPNIC</item>-      <item>SAX-PD</item>-      <item>CC-BY-ND-2.5</item>-      <item>eGenix</item>-      <item>LGPLLR</item>-      <item>OLDAP-2.2.2</item>-      <item>CC-BY-ND-3.0-DE</item>-      <item>IPA</item>-      <item>NCSA</item>-      <item>W3C</item>-      <item>Adobe-2006</item>-      <item>Net-SNMP</item>-      <item>CC-BY-SA-4.0</item>-      <item>YPL-1.0</item>-      <item>MITNFA</item>-      <item>PHP-3.01</item>-      <item>BSD-Source-Code</item>-      <item>CC-BY-SA-2.5</item>-      <item>Motosoto</item>-      <item>OSL-1.1</item>-      <item>NGPL</item>-      <item>CC-BY-2.5-AU</item>-      <item>Unicode-TOU</item>-      <item>BSD-3-Clause-No-Nuclear-License</item>-      <item>OPUBL-1.0</item>-      <item>CC-BY-NC-SA-2.0-UK</item>-      <item>NLOD-2.0</item>-      <item>gnuplot</item>-      <item>EPICS</item>-      <item>Info-ZIP</item>-      <item>OLDAP-2.0</item>-      <item>CERN-OHL-P-2.0</item>-      <item>BSD-3-Clause-No-Nuclear-Warranty</item>-      <item>AML</item>-      <item>MulanPSL-1.0</item>-      <item>Multics</item>-      <item>VSL-1.0</item>-      <item>RSA-MD</item>-      <item>CC-PDDC</item>-      <item>CC-BY-SA-2.1-JP</item>-      <item>LPPL-1.2</item>-      <item>Spencer-94</item>-      <item>OLDAP-1.2</item>-      <item>O-UDA-1.0</item>-      <item>OLDAP-2.7</item>-      <item>Glulxe</item>-      <item>iMatix</item>-      <item>TAPR-OHL-1.0</item>-      <item>NBPL-1.0</item>-      <item>LiLiQ-R-1.1</item>-      <item>Noweb</item>-      <item>CC0-1.0</item>-      <item>BSD-Protection</item>-      <item>CC-BY-NC-2.5</item>-      <item>Zlib</item>-      <item>GFDL-1.3-invariants-or-later</item>-      <item>CC-BY-3.0-AT</item>-      <item>LPPL-1.3c</item>-      <item>EPL-1.0</item>-      <item>GFDL-1.1-invariants-or-later</item>-      <item>ANTLR-PD-fallback</item>-      <item>OLDAP-2.4</item>-      <item>OLDAP-2.3</item>-      <item>ZPL-2.1</item>-      <item>Apache-2.0</item>-      <item>SGI-B-2.0</item>-      <item>Hippocratic-2.1</item>-      <item>CC-BY-SA-3.0-DE</item>-      <item>CC-BY-NC-SA-1.0</item>-      <item>LGPL-2.1-or-later</item>-      <item>CC-BY-3.0-US</item>-      <item>TCP-wrappers</item>-      <item>GFDL-1.2-invariants-or-later</item>-      <item>Eurosym</item>-      <item>LPPL-1.0</item>-      <item>SGI-B-1.0</item>-      <item>APL-1.0</item>-      <item>libtiff</item>-      <item>AFL-2.1</item>-      <item>CC-BY-NC-1.0</item>-      <item>GD</item>-      <item>AFL-1.1</item>-      <item>CC-BY-NC-ND-3.0-IGO</item>-      <item>Unicode-DFS-2015</item>-      <item>GFDL-1.2-only</item>-      <item>MPL-1.1</item>-      <item>GPL-2.0-only</item>-      <item>CC-BY-NC-4.0</item>-      <item>FreeImage</item>-      <item>SHL-0.51</item>-      <item>CNRI-Jython</item>-      <item>ZPL-1.1</item>-      <item>Afmparse</item>-      <item>OLDAP-2.1</item>-      <item>Rdisc</item>-      <item>Imlib2</item>-      <item>BSD-4-Clause-Shortened</item>-      <item>Sendmail</item>-      <item>CC-BY-2.5</item>-      <item>AAL</item>-      <item>MPL-2.0-no-copyleft-exception</item>-      <item>CC-BY-NC-ND-2.5</item>-      <item>CC-BY-3.0-NL</item>-      <item>LPL-1.02</item>-      <item>ECL-1.0</item>-      <item>OFL-1.0-no-RFN</item>-      <item>CC-BY-NC-SA-3.0-DE</item>-      <item>CC-BY-SA-3.0</item>-      <item>NTP</item>-      <item>MPL-2.0</item>-      <item>APSL-1.2</item>-      <item>GFDL-1.2-no-invariants-only</item>-      <item>Artistic-2.0</item>-      <item>RSCPL</item>-      <item>Sleepycat</item>-      <item>xpp</item>-      <item>CDLA-Sharing-1.0</item>-      <item>ClArtistic</item>-      <item>AGPL-1.0-only</item>-      <item>CC-BY-3.0-DE</item>-      <item>AFL-2.0</item>-      <item>Intel</item>-      <item>GFDL-1.1-no-invariants-or-later</item>-      <item>APAFML</item>-      <item>SISSL</item>-      <item>Naumen</item>-      <item>HTMLTIDY</item>-      <item>OLDAP-2.8</item>-      <item>blessing</item>-      <item>CC-BY-ND-2.0</item>-      <item>OGTSL</item>-      <item>LGPL-2.0-or-later</item>-      <item>Parity-7.0.0</item>-      <item>CC-BY-ND-1.0</item>-      <item>dvipdfm</item>-      <item>CNRI-Python</item>-      <item>BSD-4-Clause-UC</item>-      <item>NLOD-1.0</item>-      <item>MS-RL</item>-      <item>CC-BY-NC-SA-4.0</item>-      <item>HaskellReport</item>-      <item>CC-BY-1.0</item>-      <item>UCL-1.0</item>-      <item>Mup</item>-      <item>SMPPL</item>-      <item>PHP-3.0</item>-      <item>GL2PS</item>-      <item>CrystalStacker</item>-      <item>W3C-20150513</item>-      <item>NIST-PD-fallback</item>-      <item>OGL-UK-1.0</item>-      <item>CPL-1.0</item>-      <item>LGPL-2.1-only</item>-      <item>ZPL-2.0</item>-      <item>Frameworx-1.0</item>-      <item>AGPL-3.0-only</item>-      <item>DRL-1.0</item>-      <item>EFL-2.0</item>-      <item>Spencer-99</item>-      <item>CAL-1.0-Combined-Work-Exception</item>-      <item>GFDL-1.1-invariants-only</item>-      <item>TCL</item>-      <item>SHL-0.5</item>-      <item>OFL-1.0-RFN</item>-      <item>CERN-OHL-W-2.0</item>-      <item>Glide</item>-      <item>mpich2</item>-      <item>psutils</item>-      <item>SPL-1.0</item>-      <item>Apache-1.1</item>-      <item>CC-BY-ND-4.0</item>-      <item>FreeBSD-DOC</item>-      <item>SCEA</item>-      <item>Latex2e</item>-      <item>Artistic-1.0-cl8</item>-      <item>SGI-B-1.1</item>-      <item>NRL</item>-      <item>SWL</item>-      <item>Zed</item>-      <item>CERN-OHL-1.1</item>-      <item>RHeCos-1.1</item>-      <item>JasPer-2.0</item>-      <item>SSPL-1.0</item>-      <item>OLDAP-1.4</item>-      <item>libpng-2.0</item>-      <item>CNRI-Python-GPL-Compatible</item>-      <item>Aladdin</item>-      <item>CECILL-1.0</item>-      <item>Ruby</item>-      <item>NPL-1.1</item>-      <item>ImageMagick</item>-      <item>Cube</item>-      <item>GFDL-1.1-only</item>-      <item>CC-BY-2.0</item>-      <item>AFL-1.2</item>-      <item>CC-BY-SA-2.0</item>-      <item>CECILL-2.0</item>-      <item>MIT-advertising</item>-      <item>CC-BY-NC-SA-2.5</item>-      <item>Artistic-1.0</item>-      <item>OSL-3.0</item>-      <item>X11</item>-      <item>Bahyph</item>-      <item>OLDAP-2.0.1</item>-      <item>EUDatagrid</item>-      <item>MTLL</item>-      <item>GFDL-1.2-invariants-only</item>-      <item>GFDL-1.3-no-invariants-or-later</item>-      <item>curl</item>-      <item>LAL-1.3</item>-      <item>DSDP</item>-      <item>CERN-OHL-1.2</item>-      <item>TOSL</item>-      <item>CC-BY-3.0</item>-      <item>Qhull</item>-      <item>GFDL-1.3-no-invariants-only</item>-      <item>TORQUE-1.1</item>-      <item>MS-PL</item>-      <item>Apache-1.0</item>-      <item>copyleft-next-0.3.1</item>-      <item>GFDL-1.2-or-later</item>-      <item>MulanPSL-2.0</item>-      <item>FSFAP</item>-      <item>Xerox</item>-      <item>CDDL-1.0</item>-      <item>GFDL-1.3-invariants-only</item>-      <item>etalab-2.0</item>-      <item>XFree86-1.1</item>-      <item>SNIA</item>-      <item>LPPL-1.1</item>-      <item>CATOSL-1.1</item>-      <item>TU-Berlin-2.0</item>-      <item>GFDL-1.3-or-later</item>-      <item>LAL-1.2</item>-      <item>ICU</item>-      <item>FTL</item>-      <item>MirOS</item>-      <item>CC-BY-NC-ND-3.0</item>-      <item>OSET-PL-2.1</item>-      <item>CC-BY-NC-ND-2.0</item>-      <item>SISSL-1.2</item>-      <item>Wsuipa</item>-      <item>Zimbra-1.4</item>-      <item>Linux-OpenIB</item>-      <item>OLDAP-2.5</item>-      <item>AMPAS</item>-      <item>GPL-1.0-or-later</item>-      <item>BUSL-1.1</item>-      <item>Adobe-Glyph</item>-      <item>0BSD</item>-      <item>W3C-19980720</item>-      <item>FSFUL</item>-      <item>CC-BY-NC-SA-3.0</item>-      <item>DOC</item>-      <item>TMate</item>-      <item>MIT-open-group</item>-      <item>AMDPLPA</item>-      <item>Condor-1.1</item>-      <item>PolyForm-Noncommercial-1.0.0</item>-      <item>BSD-3-Clause-No-Military-License</item>-      <item>CC-BY-4.0</item>-      <item>OGL-Canada-2.0</item>-      <item>CC-BY-NC-SA-3.0-IGO</item>-      <item>EFL-1.0</item>-      <item>Newsletr</item>-      <item>copyleft-next-0.3.0</item>-      <item>GPL-3.0-or-later</item>-      <item>CDLA-Permissive-2.0</item>-      <item>CC-BY-ND-3.0</item>-      <item>C-UDA-1.0</item>-      <item>Barr</item>-      <item>Vim</item>-      <item>BitTorrent-1.1</item>-      <item>CDL-1.0</item>-      <item>CC-BY-SA-1.0</item>-      <item>ADSL</item>-      <item>PostgreSQL</item>-      <item>OFL-1.1</item>-      <item>NPL-1.0</item>-      <item>xinetd</item>-      <item>LGPL-2.0-only</item>-      <item>zlib-acknowledgement</item>-      <item>OLDAP-2.2.1</item>-      <item>APSL-1.0</item>-      <item>BSD-3-Clause-LBNL</item>-      <item>GLWTPL</item>-      <item>LGPL-3.0-only</item>-      <item>OGC-1.0</item>-      <item>Dotseqn</item>-      <item>MakeIndex</item>-      <item>GPL-3.0-only</item>-      <item>BSD-3-Clause-No-Nuclear-License-2014</item>-      <item>GPL-1.0-only</item>-      <item>IJG</item>-      <item>AGPL-1.0-or-later</item>-      <item>OFL-1.1-no-RFN</item>-      <item>BSL-1.0</item>-      <item>Libpng</item>-      <item>CC-BY-NC-3.0</item>-      <item>CC-BY-NC-2.0</item>-      <item>Unlicense</item>-      <item>LPL-1.0</item>-      <item>bzip2-1.0.5</item>-      <item>Entessa</item>-      <item>BSD-2-Clause-Patent</item>-      <item>ECL-2.0</item>-      <item>Crossword</item>-      <item>CC-BY-NC-ND-1.0</item>-      <item>OCLC-2.0</item>-      <item>CECILL-1.1</item>-      <item>CECILL-2.1</item>-      <item>OGDL-Taiwan-1.0</item>-      <item>Abstyles</item>-      <item>libselinux-1.0</item>-      <item>ANTLR-PD</item>-      <item>GPL-2.0-or-later</item>-      <item>IPL-1.0</item>-      <item>MIT-enna</item>-      <item>CPOL-1.02</item>-      <item>CC-BY-SA-3.0-AT</item>-      <item>BSD-1-Clause</item>-      <item>NTP-0</item>-      <item>SugarCRM-1.1.3</item>-      <item>MIT</item>-      <item>OFL-1.1-RFN</item>-      <item>Watcom-1.0</item>-      <item>CC-BY-NC-SA-2.0-FR</item>-      <item>ODbL-1.0</item>-      <item>FSFULLR</item>-      <item>OLDAP-1.3</item>-      <item>SSH-OpenSSH</item>-      <item>BSD-2-Clause</item>-      <item>HPND</item>-      <item>Zimbra-1.3</item>-      <item>Borceux</item>-      <item>OLDAP-1.1</item>-      <item>OFL-1.0</item>-      <item>NASA-1.3</item>-      <item>VOSTROM</item>-      <item>MIT-0</item>-      <item>ISC</item>-      <item>Unicode-DFS-2016</item>-      <item>BlueOak-1.0.0</item>-      <item>LiLiQ-Rplus-1.1</item>-      <item>NOSL</item>-      <item>SMLNJ</item>-      <item>CPAL-1.0</item>-      <item>PSF-2.0</item>-      <item>RPL-1.5</item>-      <item>MIT-Modern-Variant</item>-      <item>Nokia</item>-      <item>GFDL-1.1-no-invariants-only</item>-      <item>PDDL-1.0</item>-      <item>EUPL-1.0</item>-      <item>CDDL-1.1</item>-      <item>GFDL-1.3-only</item>-      <item>OLDAP-2.6</item>-      <item>JSON</item>-      <item>LGPL-3.0-or-later</item>-      <item>Fair</item>-      <item>OSL-2.1</item>-      <item>LPPL-1.3a</item>-      <item>NAIST-2003</item>-      <item>CC-BY-NC-ND-4.0</item>-      <item>CC-BY-NC-3.0-DE</item>-      <item>OPL-1.0</item>-      <item>HPND-sell-variant</item>-      <item>QPL-1.0</item>-      <item>EUPL-1.2</item>-      <item>GFDL-1.2-no-invariants-or-later</item>-      <item>NCGL-UK-2.0</item>-      <item>Beerware</item>-      <item>BSD-3-Clause-Open-MPI</item>-      <item>CECILL-B</item>-      <item>EPL-2.0</item>-      <item>MIT-feh</item>-      <item>RPL-1.1</item>-      <item>CDLA-Permissive-1.0</item>-      <item>Python-2.0</item>-      <item>MPL-1.0</item>-      <item>GFDL-1.1-or-later</item>-      <item>diffmark</item>-      <item>OpenSSL</item>-      <item>OSL-1.0</item>-      <item>Parity-6.0.0</item>-      <item>YPL-1.1</item>-      <item>SSH-short</item>-      <item>IBM-pibs</item>-      <item>Xnet</item>-      <item>TU-Berlin-1.0</item>-      <item>CAL-1.0</item>-      <item>AFL-3.0</item>-      <item>CECILL-C</item>-      <item>OGL-UK-3.0</item>-      <item>BSD-3-Clause-Clear</item>-      <item>BSD-3-Clause-Modification</item>-      <item>CC-BY-SA-2.0-UK</item>-      <item>Saxpath</item>-      <item>NLPL</item>-      <item>SimPL-2.0</item>-      <item>psfrag</item>-      <item>Spencer-86</item>-      <item>OCCT-PL</item>-      <item>CERN-OHL-S-2.0</item>-      <item>ErlPL-1.1</item>-      <item>MIT-CMU</item>-      <item>NIST-PD</item>-      <item>OSL-2.0</item>-      <item>APSL-2.0</item>-      <item>Leptonica</item>-      <item>PolyForm-Small-Business-1.0.0</item>-      <item>LiLiQ-P-1.1</item>-      <item>NetCDF</item>-      <item>OML</item>-      <item>AGPL-3.0-or-later</item>-      <item>OLDAP-2.2</item>-      <item>BSD-3-Clause</item>-      <item>WTFPL</item>-      <item>OGL-UK-2.0</item>-      <item>BSD-3-Clause-Attribution</item>-      <item>RPSL-1.0</item>-      <item>CC-BY-NC-ND-3.0-DE</item>-      <item>EUPL-1.1</item>-      <item>Sendmail-8.23</item>-      <item>ODC-By-1.0</item>-      <item>D-FSL-1.0</item>-      <item>BSD-4-Clause</item>-      <item>BSD-2-Clause-Views</item>-      <item>Artistic-1.0-Perl</item>-      <item>NPOSL-3.0</item>-      <item>gSOAP-1.3b</item>-      <item>Interbase-1.0</item>-    </list>--    <list name="deprecated-licenses">-      <item>GPL-1.0</item>-      <item>GPL-2.0-with-GCC-exception</item>-      <item>wxWindows</item>-      <item>Nunit</item>-      <item>GFDL-1.1</item>-      <item>GPL-2.0</item>-      <item>GFDL-1.2</item>-      <item>LGPL-2.0</item>-      <item>GPL-3.0-with-autoconf-exception</item>-      <item>GFDL-1.3</item>-      <item>BSD-2-Clause-NetBSD</item>-      <item>LGPL-3.0</item>-      <item>GPL-2.0-with-classpath-exception</item>-      <item>GPL-3.0-with-GCC-exception</item>-      <item>BSD-2-Clause-FreeBSD</item>-      <item>GPL-3.0</item>-      <item>GPL-2.0-with-font-exception</item>-      <item>eCos-2.0</item>-      <item>GPL-2.0-with-bison-exception</item>-      <item>GPL-2.0-with-autoconf-exception</item>-      <item>AGPL-1.0</item>-      <item>AGPL-3.0</item>-      <item>LGPL-2.1</item>-      <item>StandardML-NJ</item>-    </list>--    <list name="exceptions">-      <item>GPL-CC-1.0</item>-      <item>openvpn-openssl-exception</item>-      <item>WxWindows-exception-3.1</item>-      <item>GPL-3.0-linking-exception</item>-      <item>i2p-gpl-java-exception</item>-      <item>OpenJDK-assembly-exception-1.0</item>-      <item>mif-exception</item>-      <item>CLISP-exception-2.0</item>-      <item>freertos-exception-2.0</item>-      <item>Bison-exception-2.2</item>-      <item>OCCT-exception-1.0</item>-      <item>Autoconf-exception-2.0</item>-      <item>LLVM-exception</item>-      <item>GCC-exception-3.1</item>-      <item>Font-exception-2.0</item>-      <item>Libtool-exception</item>-      <item>u-boot-exception-2.0</item>-      <item>Swift-exception</item>-      <item>eCos-exception-2.0</item>-      <item>OCaml-LGPL-linking-exception</item>-      <item>Qt-GPL-exception-1.0</item>-      <item>Linux-syscall-note</item>-      <item>Bootloader-exception</item>-      <item>PS-or-PDF-font-exception-20170817</item>-      <item>Universal-FOSS-exception-1.0</item>-      <item>Classpath-exception-2.0</item>-      <item>Qwt-exception-1.0</item>-      <item>LZMA-exception</item>-      <item>Autoconf-exception-3.0</item>-      <item>DigiRule-FOSS-exception</item>-      <item>389-exception</item>-      <item>SHL-2.0</item>-      <item>GCC-exception-2.0</item>-      <item>GPL-3.0-linking-source-exception</item>-      <item>Qt-LGPL-exception-1.1</item>-      <item>Fawkes-Runtime-exception</item>-      <item>gnu-javamail-exception</item>-      <item>FLTK-exception</item>-      <item>LGPL-3.0-linking-exception</item>-      <item>SHL-2.1</item>+    version="7"+    kateversion="3.1"+    name="SPDX-Comments"+    section="Other"+    extensions=""+    mimetype=""+    author="Alex Turbov (i.zaufi@gmail.com)"+    license="MIT"+    hidden="true"+  >+  <highlighting>+    <list name="tags">+      <item>SPDX-License-Identifier:</item>+      <item>SPDX-FileContributor:</item>+      <item>SPDX-FileCopyrightText:</item>+      <item>SPDX-LicenseInfoInFile:</item>+    </list>++    <list name="operators">+      <item>AND</item>+      <item>OR</item>+      <item>WITH</item>+    </list>++    <list name="licenses">+      <item>X11</item>+      <item>HPND-export2-US</item>+      <item>OpenPBS-2.3</item>+      <item>OSL-3.0</item>+      <item>Rdisc</item>+      <item>LPD-document</item>+      <item>BSD-3-Clause-LBNL</item>+      <item>AFL-1.1</item>+      <item>HP-1989</item>+      <item>CC-BY-ND-4.0</item>+      <item>RSA-MD</item>+      <item>HPND-sell-variant</item>+      <item>threeparttable</item>+      <item>AMPAS</item>+      <item>ngrep</item>+      <item>mplus</item>+      <item>MIT-Festival</item>+      <item>HDF5</item>+      <item>Artistic-1.0-Perl</item>+      <item>BSD-4-Clause-UC</item>+      <item>SAX-PD</item>+      <item>APSL-1.1</item>+      <item>AGPL-1.0-or-later</item>+      <item>ANTLR-PD</item>+      <item>Zimbra-1.3</item>+      <item>GLWTPL</item>+      <item>Minpack</item>+      <item>OSL-2.1</item>+      <item>PolyForm-Small-Business-1.0.0</item>+      <item>DOC</item>+      <item>Cronyx</item>+      <item>LPPL-1.3c</item>+      <item>SGI-OpenGL</item>+      <item>libtiff</item>+      <item>OpenVision</item>+      <item>TrustedQSL</item>+      <item>Sun-PPP</item>+      <item>Entessa</item>+      <item>AFL-2.0</item>+      <item>Sleepycat</item>+      <item>Latex2e</item>+      <item>FDK-AAC</item>+      <item>CECILL-C</item>+      <item>ODC-By-1.0</item>+      <item>Bitstream-Charter</item>+      <item>UMich-Merit</item>+      <item>CC-BY-NC-2.5</item>+      <item>diffmark</item>+      <item>BlueOak-1.0.0</item>+      <item>Info-ZIP</item>+      <item>CC-BY-NC-ND-4.0</item>+      <item>JSON</item>+      <item>Sendmail-8.23</item>+      <item>SGI-B-1.0</item>+      <item>RPL-1.1</item>+      <item>ISC</item>+      <item>FSFUL</item>+      <item>Multics</item>+      <item>3D-Slicer-1.0</item>+      <item>Libpng</item>+      <item>LPPL-1.0</item>+      <item>NGPL</item>+      <item>Clips</item>+      <item>CC-BY-4.0</item>+      <item>GFDL-1.1-or-later</item>+      <item>GPL-1.0-or-later</item>+      <item>GFDL-1.3-invariants-only</item>+      <item>Sun-PPP-2000</item>+      <item>Glide</item>+      <item>Furuseth</item>+      <item>GFDL-1.3-no-invariants-or-later</item>+      <item>any-OSI</item>+      <item>LGPL-2.0-or-later</item>+      <item>ADSL</item>+      <item>Noweb</item>+      <item>Linux-man-pages-1-para</item>+      <item>CC-BY-SA-3.0</item>+      <item>TAPR-OHL-1.0</item>+      <item>SMLNJ</item>+      <item>OFL-1.1-RFN</item>+      <item>SL</item>+      <item>Afmparse</item>+      <item>CC-SA-1.0</item>+      <item>APSL-1.0</item>+      <item>Hippocratic-2.1</item>+      <item>UPL-1.0</item>+      <item>CC-BY-NC-SA-4.0</item>+      <item>xzoom</item>+      <item>SchemeReport</item>+      <item>Boehm-GC</item>+      <item>xinetd</item>+      <item>CC-BY-NC-ND-3.0</item>+      <item>CECILL-2.1</item>+      <item>SSLeay-standalone</item>+      <item>CATOSL-1.1</item>+      <item>NIST-PD</item>+      <item>GPL-2.0-or-later</item>+      <item>CECILL-1.1</item>+      <item>GFDL-1.2-no-invariants-only</item>+      <item>mpich2</item>+      <item>JasPer-2.0</item>+      <item>RPSL-1.0</item>+      <item>OLDAP-1.4</item>+      <item>TU-Berlin-1.0</item>+      <item>CC-BY-3.0-AT</item>+      <item>BSD-3-Clause-No-Nuclear-License</item>+      <item>Xdebug-1.03</item>+      <item>SISSL</item>+      <item>Apache-1.1</item>+      <item>HPND-DEC</item>+      <item>Unlicense-libtelnet</item>+      <item>Condor-1.1</item>+      <item>Unicode-TOU</item>+      <item>OML</item>+      <item>QPL-1.0-INRIA-2004</item>+      <item>CC-BY-ND-1.0</item>+      <item>PolyForm-Noncommercial-1.0.0</item>+      <item>man2html</item>+      <item>OLFL-1.3</item>+      <item>copyleft-next-0.3.0</item>+      <item>LGPLLR</item>+      <item>CDDL-1.1</item>+      <item>Xfig</item>+      <item>CC-BY-2.5-AU</item>+      <item>APL-1.0</item>+      <item>OpenSSL-standalone</item>+      <item>OGDL-Taiwan-1.0</item>+      <item>BSL-1.0</item>+      <item>generic-xts</item>+      <item>PHP-3.0</item>+      <item>LAL-1.2</item>+      <item>DRL-1.1</item>+      <item>LPL-1.0</item>+      <item>Leptonica</item>+      <item>CNRI-Jython</item>+      <item>DL-DE-ZERO-2.0</item>+      <item>Cube</item>+      <item>w3m</item>+      <item>TGPPL-1.0</item>+      <item>HPND-UC-export-US</item>+      <item>EFL-1.0</item>+      <item>NRL</item>+      <item>CPAL-1.0</item>+      <item>NCSA</item>+      <item>CC-BY-SA-2.1-JP</item>+      <item>PPL</item>+      <item>GPL-1.0-only</item>+      <item>ASWF-Digital-Assets-1.1</item>+      <item>NCL</item>+      <item>App-s2p</item>+      <item>BitTorrent-1.0</item>+      <item>HPND-merchantability-variant</item>+      <item>EPICS</item>+      <item>BSD-3-Clause-Attribution</item>+      <item>curl</item>+      <item>NLPL</item>+      <item>Apache-2.0</item>+      <item>BSD-Protection</item>+      <item>DEC-3-Clause</item>+      <item>MakeIndex</item>+      <item>RSCPL</item>+      <item>bcrypt-Solar-Designer</item>+      <item>OGL-UK-1.0</item>+      <item>OLDAP-2.1</item>+      <item>HPND-export-US-modify</item>+      <item>MIT-0</item>+      <item>MPL-2.0-no-copyleft-exception</item>+      <item>CERN-OHL-S-2.0</item>+      <item>TMate</item>+      <item>CMU-Mach</item>+      <item>OSL-2.0</item>+      <item>UnixCrypt</item>+      <item>Plexus</item>+      <item>MulanPSL-2.0</item>+      <item>OSET-PL-2.1</item>+      <item>DocBook-Schema</item>+      <item>CC-BY-NC-ND-3.0-DE</item>+      <item>IPA</item>+      <item>LGPL-2.1-or-later</item>+      <item>zlib-acknowledgement</item>+      <item>Zed</item>+      <item>Fair</item>+      <item>AGPL-3.0-only</item>+      <item>GFDL-1.2-invariants-only</item>+      <item>Spencer-86</item>+      <item>AMDPLPA</item>+      <item>NPOSL-3.0</item>+      <item>SWL</item>+      <item>CC-BY-SA-2.0-UK</item>+      <item>Brian-Gladman-2-Clause</item>+      <item>CC-BY-NC-SA-2.0</item>+      <item>CERN-OHL-P-2.0</item>+      <item>OFL-1.0-RFN</item>+      <item>Linux-man-pages-copyleft-var</item>+      <item>OFL-1.1-no-RFN</item>+      <item>BSD-3-Clause-flex</item>+      <item>Intel-ACPI</item>+      <item>CFITSIO</item>+      <item>Bitstream-Vera</item>+      <item>HPND</item>+      <item>HPND-UC</item>+      <item>PSF-2.0</item>+      <item>xkeyboard-config-Zinoviev</item>+      <item>mpi-permissive</item>+      <item>TORQUE-1.1</item>+      <item>CC-BY-NC-ND-2.5</item>+      <item>cve-tou</item>+      <item>Artistic-2.0</item>+      <item>ANTLR-PD-fallback</item>+      <item>CERN-OHL-W-2.0</item>+      <item>Spencer-99</item>+      <item>PHP-3.01</item>+      <item>SugarCRM-1.1.3</item>+      <item>GFDL-1.3-only</item>+      <item>SNIA</item>+      <item>HPND-sell-variant-MIT-disclaimer</item>+      <item>libpng-2.0</item>+      <item>BSD-4-Clause</item>+      <item>HPND-Intel</item>+      <item>LiLiQ-R-1.1</item>+      <item>any-OSI-perl-modules</item>+      <item>Aspell-RU</item>+      <item>LiLiQ-P-1.1</item>+      <item>HPND-INRIA-IMAG</item>+      <item>BUSL-1.1</item>+      <item>Parity-7.0.0</item>+      <item>TTYP0</item>+      <item>LOOP</item>+      <item>LiLiQ-Rplus-1.1</item>+      <item>BSD-3-Clause-No-Nuclear-License-2014</item>+      <item>BSD-3-Clause-Sun</item>+      <item>Parity-6.0.0</item>+      <item>IBM-pibs</item>+      <item>bzip2-1.0.6</item>+      <item>GFDL-1.2-no-invariants-or-later</item>+      <item>FSFULLRWD</item>+      <item>Game-Programming-Gems</item>+      <item>gnuplot</item>+      <item>X11-swapped</item>+      <item>NLOD-1.0</item>+      <item>CPOL-1.02</item>+      <item>OAR</item>+      <item>Abstyles</item>+      <item>SISSL-1.2</item>+      <item>Unicode-DFS-2015</item>+      <item>Graphics-Gems</item>+      <item>CC-BY-SA-4.0</item>+      <item>Dotseqn</item>+      <item>RHeCos-1.1</item>+      <item>BSD-3-Clause-Clear</item>+      <item>CC-BY-SA-2.0</item>+      <item>GFDL-1.2-invariants-or-later</item>+      <item>EUDatagrid</item>+      <item>libselinux-1.0</item>+      <item>FreeImage</item>+      <item>APSL-1.2</item>+      <item>Sendmail</item>+      <item>SHL-0.5</item>+      <item>Ubuntu-font-1.0</item>+      <item>BSD-4-Clause-Shortened</item>+      <item>GCR-docs</item>+      <item>GFDL-1.1-invariants-only</item>+      <item>ZPL-2.1</item>+      <item>CC-PDDC</item>+      <item>OCLC-2.0</item>+      <item>OpenSSL</item>+      <item>MS-RL</item>+      <item>BSD-3-Clause-acpica</item>+      <item>TCP-wrappers</item>+      <item>CC-BY-NC-SA-3.0-DE</item>+      <item>LPPL-1.3a</item>+      <item>OLDAP-1.2</item>+      <item>HP-1986</item>+      <item>hdparm</item>+      <item>PADL</item>+      <item>OPL-UK-3.0</item>+      <item>BSD-1-Clause</item>+      <item>MIT-CMU</item>+      <item>Mup</item>+      <item>ICU</item>+      <item>xpp</item>+      <item>Artistic-1.0-cl8</item>+      <item>CC-BY-2.5</item>+      <item>XSkat</item>+      <item>YPL-1.0</item>+      <item>W3C-20150513</item>+      <item>SGI-B-1.1</item>+      <item>LGPL-2.1-only</item>+      <item>CUA-OPL-1.0</item>+      <item>Eurosym</item>+      <item>FSFULLRSD</item>+      <item>CC-BY-NC-SA-2.0-FR</item>+      <item>X11-distribute-modifications-variant</item>+      <item>MPEG-SSG</item>+      <item>MIT-Modern-Variant</item>+      <item>CAL-1.0</item>+      <item>HPND-doc-sell</item>+      <item>Naumen</item>+      <item>Unicode-3.0</item>+      <item>Unicode-DFS-2016</item>+      <item>HIDAPI</item>+      <item>Baekmuk</item>+      <item>Kazlib</item>+      <item>HPND-MIT-disclaimer</item>+      <item>OLDAP-2.2.2</item>+      <item>AdaCore-doc</item>+      <item>0BSD</item>+      <item>ISC-Veillard</item>+      <item>CERN-OHL-1.2</item>+      <item>dvipdfm</item>+      <item>MulanPSL-1.0</item>+      <item>JPL-image</item>+      <item>FSFULLR</item>+      <item>CryptoSwift</item>+      <item>CC-BY-NC-3.0-DE</item>+      <item>BitTorrent-1.1</item>+      <item>EPL-2.0</item>+      <item>Vim</item>+      <item>Inner-Net-2.0</item>+      <item>LGPL-2.0-only</item>+      <item>Zimbra-1.4</item>+      <item>Cornell-Lossless-JPEG</item>+      <item>Knuth-CTAN</item>+      <item>OLDAP-1.1</item>+      <item>CC-BY-NC-ND-2.0</item>+      <item>Borceux</item>+      <item>DSDP</item>+      <item>Unlicense</item>+      <item>ECL-2.0</item>+      <item>HPND-Pbmplus</item>+      <item>ASWF-Digital-Assets-1.0</item>+      <item>HPND-sell-MIT-disclaimer-xserver</item>+      <item>SPL-1.0</item>+      <item>AFL-3.0</item>+      <item>OLDAP-2.6</item>+      <item>BSD-Advertising-Acknowledgement</item>+      <item>SAX-PD-2.0</item>+      <item>Crossword</item>+      <item>swrule</item>+      <item>LZMA-SDK-9.11-to-9.20</item>+      <item>MIPS</item>+      <item>CNRI-Python</item>+      <item>UCAR</item>+      <item>InnoSetup</item>+      <item>MIT-Wu</item>+      <item>CC-BY-NC-SA-2.0-DE</item>+      <item>HPND-sell-variant-MIT-disclaimer-rev</item>+      <item>CC-BY-NC-SA-3.0</item>+      <item>GL2PS</item>+      <item>Martin-Birgmeier</item>+      <item>xlock</item>+      <item>etalab-2.0</item>+      <item>OLDAP-2.8</item>+      <item>W3C-19980720</item>+      <item>CC-BY-3.0-US</item>+      <item>CPL-1.0</item>+      <item>OFFIS</item>+      <item>CC0-1.0</item>+      <item>CECILL-2.0</item>+      <item>OCCT-PL</item>+      <item>NPL-1.0</item>+      <item>magaz</item>+      <item>Soundex</item>+      <item>SOFA</item>+      <item>Frameworx-1.0</item>+      <item>check-cvs</item>+      <item>OLDAP-2.2.1</item>+      <item>Apache-1.0</item>+      <item>URT-RLE</item>+      <item>mailprio</item>+      <item>OLDAP-2.4</item>+      <item>BSD-Source-beginning-file</item>+      <item>CC-BY-SA-1.0</item>+      <item>CDL-1.0</item>+      <item>OLDAP-1.3</item>+      <item>HPND-Netrek</item>+      <item>Artistic-1.0</item>+      <item>checkmk</item>+      <item>Saxpath</item>+      <item>CMU-Mach-nodoc</item>+      <item>NCGL-UK-2.0</item>+      <item>EUPL-1.1</item>+      <item>CC-BY-ND-2.5</item>+      <item>SunPro</item>+      <item>Elastic-2.0</item>+      <item>ODbL-1.0</item>+      <item>CERN-OHL-1.1</item>+      <item>IEC-Code-Components-EULA</item>+      <item>OGL-UK-2.0</item>+      <item>Caldera-no-preamble</item>+      <item>libutil-David-Nugent</item>+      <item>ThirdEye</item>+      <item>MIT-open-group</item>+      <item>EUPL-1.0</item>+      <item>NICTA-1.0</item>+      <item>CDDL-1.0</item>+      <item>MIT-feh</item>+      <item>CC-BY-3.0-IGO</item>+      <item>OLDAP-2.3</item>+      <item>RPL-1.5</item>+      <item>OPUBL-1.0</item>+      <item>AGPL-1.0-only</item>+      <item>TOSL</item>+      <item>FTL</item>+      <item>WTFPL</item>+      <item>Intel</item>+      <item>Barr</item>+      <item>Zlib</item>+      <item>BSD-Systemics-W3Works</item>+      <item>psfrag</item>+      <item>AAL</item>+      <item>CECILL-B</item>+      <item>NTIA-PD</item>+      <item>CC-BY-NC-1.0</item>+      <item>libpng-1.6.35</item>+      <item>BSD-2-Clause</item>+      <item>NASA-1.3</item>+      <item>Mackerras-3-Clause-acknowledgment</item>+      <item>BSD-4.3RENO</item>+      <item>Pixar</item>+      <item>CC-BY-3.0-NL</item>+      <item>AMD-newlib</item>+      <item>MIT-Click</item>+      <item>AML-glslang</item>+      <item>MIT-advertising</item>+      <item>CC-BY-2.0</item>+      <item>CC-BY-NC-ND-1.0</item>+      <item>OLDAP-2.5</item>+      <item>Zend-2.0</item>+      <item>HPND-Fenneberg-Livingston</item>+      <item>DRL-1.0</item>+      <item>NIST-Software</item>+      <item>CrystalStacker</item>+      <item>BSD-Source-Code</item>+      <item>Spencer-94</item>+      <item>SimPL-2.0</item>+      <item>OSL-1.1</item>+      <item>CDLA-Permissive-1.0</item>+      <item>metamail</item>+      <item>GFDL-1.1-only</item>+      <item>CC-BY-ND-3.0</item>+      <item>CC-BY-3.0-DE</item>+      <item>HPND-export-US</item>+      <item>NBPL-1.0</item>+      <item>GPL-2.0-only</item>+      <item>NAIST-2003</item>+      <item>SSH-OpenSSH</item>+      <item>Nokia</item>+      <item>gtkbook</item>+      <item>Boehm-GC-without-fee</item>+      <item>GPL-3.0-or-later</item>+      <item>CECILL-1.0</item>+      <item>AGPL-3.0-or-later</item>+      <item>Xnet</item>+      <item>NOSL</item>+      <item>ImageMagick</item>+      <item>MITNFA</item>+      <item>APAFML</item>+      <item>Jam</item>+      <item>FBM</item>+      <item>BSD-2-Clause-Darwin</item>+      <item>HTMLTIDY</item>+      <item>W3C</item>+      <item>AFL-1.2</item>+      <item>YPL-1.1</item>+      <item>iMatix</item>+      <item>Caldera</item>+      <item>SCEA</item>+      <item>O-UDA-1.0</item>+      <item>LPPL-1.2</item>+      <item>HPND-export-US-acknowledgement</item>+      <item>GFDL-1.2-or-later</item>+      <item>McPhee-slideshow</item>+      <item>Ruby</item>+      <item>Kastrup</item>+      <item>Adobe-Glyph</item>+      <item>CC-BY-SA-3.0-AT</item>+      <item>DocBook-Stylesheet</item>+      <item>Aladdin</item>+      <item>MIT-testregex</item>+      <item>BSD-3-Clause-Modification</item>+      <item>BSD-3-Clause-No-Military-License</item>+      <item>Adobe-Display-PostScript</item>+      <item>psutils</item>+      <item>LGPL-3.0-or-later</item>+      <item>LZMA-SDK-9.22</item>+      <item>Bahyph</item>+      <item>BSD-Attribution-HPND-disclaimer</item>+      <item>Motosoto</item>+      <item>MIT-Khronos-old</item>+      <item>Ruby-pty</item>+      <item>CC-BY-NC-SA-1.0</item>+      <item>Artistic-dist</item>+      <item>IJG</item>+      <item>Linux-OpenIB</item>+      <item>ulem</item>+      <item>MIT</item>+      <item>GFDL-1.3-no-invariants-only</item>+      <item>Symlinks</item>+      <item>NPL-1.1</item>+      <item>Giftware</item>+      <item>CDLA-Permissive-2.0</item>+      <item>LAL-1.3</item>+      <item>Widget-Workshop</item>+      <item>Latex2e-translated-notice</item>+      <item>Gutmann</item>+      <item>COIL-1.0</item>+      <item>Watcom-1.0</item>+      <item>HPND-Kevlin-Henney</item>+      <item>fwlw</item>+      <item>DL-DE-BY-2.0</item>+      <item>Interbase-1.0</item>+      <item>OGTSL</item>+      <item>BSD-Inferno-Nettverk</item>+      <item>BSD-2-Clause-Views</item>+      <item>ssh-keyscan</item>+      <item>GFDL-1.1-invariants-or-later</item>+      <item>Mackerras-3-Clause</item>+      <item>TPL-1.0</item>+      <item>ErlPL-1.1</item>+      <item>LPPL-1.1</item>+      <item>BSD-2-Clause-first-lines</item>+      <item>OGL-Canada-2.0</item>+      <item>D-FSL-1.0</item>+      <item>SMAIL-GPL</item>+      <item>CC-PDM-1.0</item>+      <item>CDLA-Sharing-1.0</item>+      <item>GD</item>+      <item>GFDL-1.3-invariants-or-later</item>+      <item>Zeeff</item>+      <item>Imlib2</item>+      <item>CC-BY-NC-2.0</item>+      <item>Adobe-Utopia</item>+      <item>ZPL-2.0</item>+      <item>Beerware</item>+      <item>SUL-1.0</item>+      <item>EPL-1.0</item>+      <item>CC-BY-1.0</item>+      <item>CC-BY-NC-4.0</item>+      <item>FSFAP</item>+      <item>VSL-1.0</item>+      <item>lsof</item>+      <item>Wsuipa</item>+      <item>Unlicense-libwhirlpool</item>+      <item>NTP-0</item>+      <item>BSD-3-Clause</item>+      <item>APSL-2.0</item>+      <item>CAL-1.0-Combined-Work-Exception</item>+      <item>OGL-UK-3.0</item>+      <item>CC-BY-SA-3.0-IGO</item>+      <item>SGP4</item>+      <item>SSH-short</item>+      <item>OLDAP-2.7</item>+      <item>VOSTROM</item>+      <item>CC-BY-3.0</item>+      <item>CC-BY-NC-ND-3.0-IGO</item>+      <item>dtoa</item>+      <item>SMPPL</item>+      <item>MIT-enna</item>+      <item>Catharon</item>+      <item>SHL-0.51</item>+      <item>copyleft-next-0.3.1</item>+      <item>BSD-2-Clause-Patent</item>+      <item>FSL-1.1-ALv2</item>+      <item>Python-2.0.1</item>+      <item>CC-BY-ND-2.0</item>+      <item>MTLL</item>+      <item>OFL-1.0</item>+      <item>Qhull</item>+      <item>IPL-1.0</item>+      <item>Linux-man-pages-copyleft-2-para</item>+      <item>softSurfer</item>+      <item>snprintf</item>+      <item>GFDL-1.2-only</item>+      <item>EUPL-1.2</item>+      <item>ZPL-1.1</item>+      <item>TTWL</item>+      <item>MPL-2.0</item>+      <item>HPND-doc</item>+      <item>BSD-Systemics</item>+      <item>DocBook-DTD</item>+      <item>EFL-2.0</item>+      <item>HaskellReport</item>+      <item>BSD-3-Clause-No-Nuclear-Warranty</item>+      <item>Newsletr</item>+      <item>OFL-1.1</item>+      <item>GFDL-1.1-no-invariants-only</item>+      <item>CC-BY-ND-3.0-DE</item>+      <item>UCL-1.0</item>+      <item>OGC-1.0</item>+      <item>eGenix</item>+      <item>OPL-1.0</item>+      <item>Xerox</item>+      <item>NIST-PD-fallback</item>+      <item>SGI-B-2.0</item>+      <item>TermReadKey</item>+      <item>Sendmail-Open-Source-1.1</item>+      <item>NTP</item>+      <item>HPND-Markus-Kuhn</item>+      <item>BSD-2-Clause-pkgconf-disclaimer</item>+      <item>TCL</item>+      <item>NetCDF</item>+      <item>wwl</item>+      <item>Python-2.0</item>+      <item>FSFAP-no-warranty-disclaimer</item>+      <item>python-ldap</item>+      <item>CC-BY-SA-2.5</item>+      <item>GPL-3.0-only</item>+      <item>GFDL-1.3-or-later</item>+      <item>LGPL-3.0-only</item>+      <item>Glulxe</item>+      <item>CC-BY-NC-SA-3.0-IGO</item>+      <item>BSD-3-Clause-Open-MPI</item>+      <item>FSL-1.1-MIT</item>+      <item>Linux-man-pages-copyleft</item>+      <item>ECL-1.0</item>+      <item>jove</item>+      <item>BSD-3-Clause-HP</item>+      <item>AML</item>+      <item>FreeBSD-DOC</item>+      <item>XFree86-1.1</item>+      <item>CC-BY-3.0-AU</item>+      <item>Arphic-1999</item>+      <item>OSL-1.0</item>+      <item>OFL-1.0-no-RFN</item>+      <item>OLDAP-2.0.1</item>+      <item>JPNIC</item>+      <item>LPL-1.02</item>+      <item>OLDAP-2.0</item>+      <item>Adobe-2006</item>+      <item>CC-BY-NC-SA-2.5</item>+      <item>C-UDA-1.0</item>+      <item>Lucida-Bitmap-Fonts</item>+      <item>Ferguson-Twofish</item>+      <item>MMIXware</item>+      <item>SSPL-1.0</item>+      <item>MPL-1.0</item>+      <item>TPDL</item>+      <item>OLDAP-2.2</item>+      <item>gSOAP-1.3b</item>+      <item>TU-Berlin-2.0</item>+      <item>pkgconf</item>+      <item>CC-BY-NC-SA-2.0-UK</item>+      <item>DocBook-XML</item>+      <item>CNRI-Python-GPL-Compatible</item>+      <item>MS-LPL</item>+      <item>Brian-Gladman-3-Clause</item>+      <item>radvd</item>+      <item>MPL-1.1</item>+      <item>blessing</item>+      <item>HPND-sell-regexpr</item>+      <item>AFL-2.1</item>+      <item>CC-BY-SA-3.0-DE</item>+      <item>PDDL-1.0</item>+      <item>BSD-4.3TAHOE</item>+      <item>CC-BY-NC-3.0</item>+      <item>NLOD-2.0</item>+      <item>GFDL-1.1-no-invariants-or-later</item>+      <item>ClArtistic</item>+      <item>pnmstitch</item>+      <item>MirOS</item>+      <item>QPL-1.0</item>+      <item>IJG-short</item>+      <item>Community-Spec-1.0</item>+      <item>NCBI-PD</item>+      <item>PostgreSQL</item>+      <item>MS-PL</item>+    </list>++    <list name="deprecated-licenses">+      <item>LGPL-3.0</item>+      <item>GPL-1.0</item>+      <item>AGPL-1.0</item>+      <item>GPL-2.0-with-font-exception</item>+      <item>GPL-2.0-with-classpath-exception</item>+      <item>Nunit</item>+      <item>GFDL-1.2</item>+      <item>GPL-2.0-with-bison-exception</item>+      <item>bzip2-1.0.5</item>+      <item>AGPL-3.0</item>+      <item>wxWindows</item>+      <item>StandardML-NJ</item>+      <item>GPL-3.0</item>+      <item>GPL-2.0-with-GCC-exception</item>+      <item>BSD-2-Clause-NetBSD</item>+      <item>GFDL-1.1</item>+      <item>GPL-3.0-with-GCC-exception</item>+      <item>GPL-2.0-with-autoconf-exception</item>+      <item>BSD-2-Clause-FreeBSD</item>+      <item>Net-SNMP</item>+      <item>eCos-2.0</item>+      <item>GPL-3.0-with-autoconf-exception</item>+      <item>GFDL-1.3</item>+      <item>LGPL-2.0</item>+      <item>LGPL-2.1</item>+      <item>GPL-2.0</item>+    </list>++    <list name="exceptions">+      <item>SHL-2.1</item>+      <item>Autoconf-exception-2.0</item>+      <item>openvpn-openssl-exception</item>+      <item>GStreamer-exception-2005</item>+      <item>SHL-2.0</item>+      <item>romic-exception</item>+      <item>RRDtool-FLOSS-exception-2.0</item>+      <item>u-boot-exception-2.0</item>+      <item>i2p-gpl-java-exception</item>+      <item>CLISP-exception-2.0</item>+      <item>OpenJDK-assembly-exception-1.0</item>+      <item>PCRE2-exception</item>+      <item>erlang-otp-linking-exception</item>+      <item>GCC-exception-2.0</item>+      <item>SWI-exception</item>+      <item>Asterisk-exception</item>+      <item>OCCT-exception-1.0</item>+      <item>GPL-3.0-389-ds-base-exception</item>+      <item>libpri-OpenH323-exception</item>+      <item>GCC-exception-2.0-note</item>+      <item>Fawkes-Runtime-exception</item>+      <item>Asterisk-linking-protocols-exception</item>+      <item>freertos-exception-2.0</item>+      <item>LLGPL</item>+      <item>GCC-exception-3.1</item>+      <item>Gmsh-exception</item>+      <item>SANE-exception</item>+      <item>Bison-exception-2.2</item>+      <item>mif-exception</item>+      <item>LZMA-exception</item>+      <item>WxWindows-exception-3.1</item>+      <item>LGPL-3.0-linking-exception</item>+      <item>GPL-CC-1.0</item>+      <item>Qt-GPL-exception-1.0</item>+      <item>Font-exception-2.0</item>+      <item>389-exception</item>+      <item>Linux-syscall-note</item>+      <item>mxml-exception</item>+      <item>Qt-LGPL-exception-1.1</item>+      <item>Autoconf-exception-generic-3.0</item>+      <item>GStreamer-exception-2008</item>+      <item>OCaml-LGPL-linking-exception</item>+      <item>PS-or-PDF-font-exception-20170817</item>+      <item>KiCad-libraries-exception</item>+      <item>Independent-modules-exception</item>+      <item>cryptsetup-OpenSSL-exception</item>+      <item>Digia-Qt-LGPL-exception-1.1</item>+      <item>stunnel-exception</item>+      <item>QPL-1.0-INRIA-2004-exception</item>+      <item>Autoconf-exception-3.0</item>+      <item>Swift-exception</item>+      <item>DigiRule-FOSS-exception</item>+      <item>polyparse-exception</item>+      <item>vsftpd-openssl-exception</item>+      <item>Bison-exception-1.24</item>+      <item>x11vnc-openssl-exception</item>+      <item>GNU-compiler-exception</item>+      <item>harbour-exception</item>+      <item>Texinfo-exception</item>+      <item>eCos-exception-2.0</item>+      <item>GPL-3.0-linking-source-exception</item>+      <item>Autoconf-exception-macro</item>+      <item>gnu-javamail-exception</item>+      <item>Bootloader-exception</item>+      <item>FLTK-exception</item>+      <item>Classpath-exception-2.0</item>+      <item>GPL-3.0-linking-exception</item>+      <item>GNAT-exception</item>+      <item>Universal-FOSS-exception-1.0</item>+      <item>Libtool-exception</item>+      <item>LLVM-exception</item>+      <item>Autoconf-exception-generic</item>+      <item>CGAL-linking-exception</item>+      <item>UBDL-exception</item>+      <item>GNOME-examples-exception</item>+      <item>fmt-exception</item>+      <item>GPL-3.0-interface-exception</item>+      <item>Qwt-exception-1.0</item>     </list>      <list name="deprecated-exceptions">
xml/tcsh.xml view
@@ -9,7 +9,7 @@         <!ENTITY pathpart "([\w_@.&#37;*?+-]|\\ )">     <!-- valid character in a file name -->         <!ENTITY tab      "&#9;"> ]>-<language name="Tcsh" version="10" kateversion="5.53" section="Scripts" extensions="*.csh;*.tcsh;csh.cshrc;csh.login;.tcshrc;.cshrc;.login" mimetype="application/x-csh" casesensitive="1" author="Matthew Woehlke (mw_triad@users.sourceforge.net)" license="LGPL">+<language name="Tcsh" version="12" kateversion="5.53" section="Scripts" extensions="*.csh;*.tcsh;csh.cshrc;csh.login;.tcshrc;.cshrc;.login" mimetype="application/x-csh;text/x-csh" casesensitive="1" author="Matthew Woehlke (mw_triad@users.sourceforge.net)" license="LGPL">  <!-- (c) 2006 Matthew Woehlke (mw_triad@users.sourceforge.net)     Based on the bash highlighter by Wilbert Berendsen (wilbert@kde.nl)@@ -465,7 +465,7 @@   </highlighting>   <general>     <comments>-      <comment name="singleLine" start="#"/>+      <comment name="singleLine" start="#" position="afterwhitespace"/>     </comments>     <keywords casesensitive="1" weakDeliminator="^%#[]$._{}:-" additionalDeliminator="`"/>   </general>
+ xml/textile.xml view
@@ -0,0 +1,102 @@+<?xml version="1.0" encoding="UTF-8"?>+<!--+    Kate syntax highlight filter for Textile formatted documents++    Copyright 2012 alexander Kabakov. http://kabakov.wordpress.com/+    Licensed under GPL license.+-->++<!DOCTYPE language+            [           +            <!ENTITY strongregex "(\s|^)\*[^*]\w.*\w[^*]\*(\s|\.|,|;|:|\-|\?|$)">+            <!ENTITY strikeoutregex "(\s|^)-[^-]\w.*\w[^-]-(\s|\.|,|;|:|\-|\?|$)">+            <!ENTITY blockattrsregex "(\(\w+(#\w+)?\))?">+            <!ENTITY formatregex "(&gt;|&lt;|=|&lt;&gt;)?">+            <!ENTITY name "(?![0-9])[\w_:][\w.:_-]*">+]>+            +<language section="Markup" name="Textile" +        version="6" kateversion="5.0"+        extensions="*.textile" priority="15"+        author="Alexander Kabakov (kabakov.as@gmail.com)"+        license="LGPL" >+    <highlighting>+        <contexts>+            <context attribute="Normal Text" lineEndContext="#stay" name="Normal Text" >+                <StringDetect attribute="comment" context="comment" String="&lt;!--" beginRegion="comment" />+                <RegExpr attribute="macro" String="\{\{&name;\}\}" />+                +                <Detect2Chars context="sectiontitle_block"  char="h" char1="1" column="0" />+                <Detect2Chars context="sectionheader_block" char="h" char1="2" column="0" />                +                <Detect2Chars context="sectionheader_block" char="h" char1="3" column="0" />+                <Detect2Chars context="sectionheader_block" char="h" char1="4" column="0" />+                <Detect2Chars context="sectionheader_block" char="h" char1="5" column="0" />+                +                <RegExpr attribute="textblock" String="^(p|pre|bq|bc)&blockattrsregex;&formatregex;\." column="0" />+                <DetectChar context="image" char="!"/>+                +                <IncludeRules context="inc" />++                <RegExpr attribute="itemlist" String="^[\*\#]+\s" column="0" />+                <RegExpr attribute="htmllink" String='".*":http(s)?:[\w_/\\\d\.%\?&amp;=-]*' />+            </context>+            +            <context name="image" lineEndContext="#pop" attribute="image">+                <RegExpr String="&blockattrsregex;" attribute="blockattrs" />+                <RegExpr String="\w+\.(png|jpg|jpeg|gif|bmp)" attribute="imagefilename" />+                <DetectChar char="!" context="#pop" attribute="image"/>+            </context>+            +            <context name="sectiontitle_block" lineEndContext="#pop" attribute="sectiontitle">+                <RegExpr String="&blockattrsregex;" attribute="sectionblockattrs" />+            </context>+            +            <context name="sectionheader_block" lineEndContext="#pop" attribute="sectionheader">+                <RegExpr String="&blockattrsregex;" attribute="sectionblockattrs" />+            </context>+            +            <context name="comment" attribute="comment" lineEndContext="#stay">+                <DetectSpaces/>+                <StringDetect attribute="comment" context="#pop" String="--&gt;" endRegion="comment" />+                <IncludeRules context="##Comments" />+                <DetectIdentifier/>+            </context>+            +            <context attribute="Normal Text" name="inc" lineEndContext="#stay" >+                <RegExpr attribute="strong" String="&strongregex;" />+                <RegExpr attribute="strikeout" minimal="true" String="&strikeoutregex;"/>+            </context>+        </contexts>++        <itemDatas>+            <itemData name="Normal Text" defStyleNum="dsNormal" />+            +            <itemData name="sectiontitle" defStyleNum="dsKeyword" bold="true" />+            <itemData name="sectionheader" defStyleNum="dsFunction" bold="true" />+            <itemData name="sectionblockattrs" defStyleNum="dsComment" bold="true"/>+            <itemData name="blockattrs" defStyleNum="dsComment" />+            <itemData name="textblock"  defStyleNum="dsComment" />+            +            <itemData name="strong" defStyleNum="dsNormal" bold="true" />+            <itemData name="strikeout" defStyleNum="dsNormal" strikeOut="true" />+            +            <itemData name="itemlist" defStyleNum="dsDataType" />+            +            <itemData name="macro"  defStyleNum="dsComment" bold="true"/>+            <itemData name="comment"  defStyleNum="dsComment" />+            +            <itemData name="image"  defStyleNum="dsFloat" />+            <itemData name="imagefilename"  defStyleNum="dsKeyword" />+            <itemData name="htmllink" defStyleNum="dsDataType" />+        </itemDatas>++    </highlighting>++    <general>+        <comments>+            <comment name="multiLine" start="&lt;!--" end="--&gt;" region="comment" />+        </comments>+    </general>++</language>+<!-- kate: replace-tabs on; tab-width 4; indent-width 4; -->
+ xml/todo.xml view
@@ -0,0 +1,468 @@+<?xml version="1.0" encoding="UTF-8"?>+<!DOCTYPE language [+  <!ENTITY date "\d{4}-\d{2}-\d{2}(?=\s|$)">+  <!ENTITY tab "&#009;">+]>+<!-- http://todotxt.org/ -->+<language+  name="Todo.txt" section="Other"+  version="2" kateversion="5.62"+  extensions="todo.txt"+  author="Jonathan Poelen (jonathan.poelen@gmail.com)" license="MIT"+>+<highlighting>+  <contexts>+    <context name="Normal" attribute="Normal" lineEndContext="#stay" fallthroughContext="CompletionDate">+      <Detect2Chars attribute="Done" context="Done" char="x" char1=" "/>+      <Detect2Chars attribute="Done" context="Done" char="x" char1="&tab;"/>+      <DetectChar attribute="Normal" context="Priority" char="(" lookAhead="1"/>+    </context>++    <context name="Priority" attribute="Normal" lineEndContext="#pop" fallthroughContext="#pop!CompletionDate">+      <StringDetect attribute="Priority A" context="#pop!(A)CompletionDate" String="(A)"/>+      <StringDetect attribute="Priority B" context="#pop!(B)CompletionDate" String="(B)"/>+      <StringDetect attribute="Priority C" context="#pop!(C)CompletionDate" String="(C)"/>+      <StringDetect attribute="Priority D" context="#pop!(D)CompletionDate" String="(D)"/>+      <StringDetect attribute="Priority E" context="#pop!(E)CompletionDate" String="(E)"/>+      <StringDetect attribute="Priority F" context="#pop!(F)CompletionDate" String="(F)"/>+      <StringDetect attribute="Priority G" context="#pop!(G)CompletionDate" String="(G)"/>+      <StringDetect attribute="Priority H" context="#pop!(H)CompletionDate" String="(H)"/>+      <StringDetect attribute="Priority I" context="#pop!(I)CompletionDate" String="(I)"/>+      <StringDetect attribute="Priority J" context="#pop!(J)CompletionDate" String="(J)"/>+      <StringDetect attribute="Priority K" context="#pop!(K)CompletionDate" String="(K)"/>+      <StringDetect attribute="Priority L" context="#pop!(L)CompletionDate" String="(L)"/>+      <StringDetect attribute="Priority M" context="#pop!(M)CompletionDate" String="(M)"/>+      <StringDetect attribute="Priority N" context="#pop!(N)CompletionDate" String="(N)"/>+      <StringDetect attribute="Priority O" context="#pop!(O)CompletionDate" String="(O)"/>+      <StringDetect attribute="Priority P" context="#pop!(P)CompletionDate" String="(P)"/>+      <StringDetect attribute="Priority Q" context="#pop!(Q)CompletionDate" String="(Q)"/>+      <StringDetect attribute="Priority R" context="#pop!(R)CompletionDate" String="(R)"/>+      <StringDetect attribute="Priority S" context="#pop!(S)CompletionDate" String="(S)"/>+      <StringDetect attribute="Priority T" context="#pop!(T)CompletionDate" String="(T)"/>+      <StringDetect attribute="Priority U" context="#pop!(U)CompletionDate" String="(U)"/>+      <StringDetect attribute="Priority V" context="#pop!(V)CompletionDate" String="(V)"/>+      <StringDetect attribute="Priority W" context="#pop!(W)CompletionDate" String="(W)"/>+      <StringDetect attribute="Priority X" context="#pop!(X)CompletionDate" String="(X)"/>+      <StringDetect attribute="Priority Y" context="#pop!(Y)CompletionDate" String="(Y)"/>+      <StringDetect attribute="Priority Z" context="#pop!(Z)CompletionDate" String="(Z)"/>+    </context>++    <context name="Done" attribute="Done" lineEndContext="#pop">+    </context>++    <context name="CompletionDate" attribute="Completion Date" lineEndContext="#pop" fallthroughContext="#pop!Description">+      <DetectSpaces attribute="Normal" context="#pop!Description"/>+      <IncludeRules context="_CompletionDate"/>+    </context>++    <context name="CreationDate" attribute="Normal" lineEndContext="#pop#pop" fallthroughContext="#pop">+      <RegExpr attribute="Creation Date" context="#pop" String="\G\s+&date;"/>+    </context>++    <context name="Description" attribute="Normal" lineEndContext="#pop">+      <DetectSpaces attribute="Normal"/>+      <IncludeRules context="_Tag"/>+      <DetectIdentifier attribute="Normal"/>+    </context>++    <context name="_Tag" attribute="Normal" lineEndContext="#pop">+      <DetectChar attribute="Project Tag" context="ProjectTag" char="+" lookAhead="1"/>+      <DetectChar attribute="Context Tag" context="ContextTag" char="@" lookAhead="1"/>+      <RegExpr attribute="Metadata Key" context="MetadataValue" String="(?&lt;=\s)[^\s:]++:(?=[^\s:]++(?!:))"/>+    </context>++    <context name="ProjectTag" attribute="Project Tag" lineEndContext="#pop#pop" fallthroughContext="#pop">+      <RegExpr attribute="Project Tag" context="#pop" String="(?&lt;=\s)\+[^\s]+"/>+      <DetectChar context="#pop" char="+"/>+    </context>++    <context name="ContextTag" attribute="Context Tag" lineEndContext="#pop#pop" fallthroughContext="#pop">+      <RegExpr attribute="Context Tag" context="#pop" String="(?&lt;=\s)@[^\s]+"/>+      <DetectChar context="#pop" char="@"/>+    </context>++    <context name="MetadataValue" attribute="Metadata Value" lineEndContext="#pop#pop">+      <RegExpr attribute="Metadata Value" context="#pop" String="\G[^\s:]+"/>+    </context>++    <context name="_CompletionDate" attribute="Completion Date" lineEndContext="#pop">+      <RegExpr attribute="Completion Date" context="CreationDate" String="\G&date;"/>+    </context>++    <context name="(A)CompletionDate" attribute="Priority A" lineEndContext="#pop" fallthroughContext="#pop!(A)Description">+      <DetectSpaces attribute="Priority A" context="#pop!(A)CompletionDate2"/>+    </context>+    <context name="(A)CompletionDate2" attribute="Completion Date" lineEndContext="#pop" fallthroughContext="#pop!(A)Description">+      <DetectSpaces attribute="Priority A" context="#pop!(A)Description"/>+      <IncludeRules context="_CompletionDate"/>+    </context>+    <context name="(A)Description" attribute="Priority A" lineEndContext="#pop">+      <DetectSpaces attribute="Priority A"/>+      <IncludeRules context="_Tag"/>+      <DetectIdentifier attribute="Priority A"/>+    </context>++    <context name="(B)CompletionDate" attribute="Priority B" lineEndContext="#pop" fallthroughContext="#pop!(B)Description">+      <DetectSpaces attribute="Priority B" context="#pop!(B)CompletionDate2"/>+    </context>+    <context name="(B)CompletionDate2" attribute="Completion Date" lineEndContext="#pop" fallthroughContext="#pop!(B)Description">+      <DetectSpaces attribute="Priority B" context="#pop!(B)Description"/>+      <IncludeRules context="_CompletionDate"/>+    </context>+    <context name="(B)Description" attribute="Priority B" lineEndContext="#pop">+      <DetectSpaces attribute="Priority B"/>+      <IncludeRules context="_Tag"/>+      <DetectIdentifier attribute="Priority B"/>+    </context>++    <context name="(C)CompletionDate" attribute="Priority C" lineEndContext="#pop" fallthroughContext="#pop!(C)Description">+      <DetectSpaces attribute="Priority C" context="#pop!(C)CompletionDate2"/>+    </context>+    <context name="(C)CompletionDate2" attribute="Completion Date" lineEndContext="#pop" fallthroughContext="#pop!(C)Description">+      <DetectSpaces attribute="Priority C" context="#pop!(C)Description"/>+      <IncludeRules context="_CompletionDate"/>+    </context>+    <context name="(C)Description" attribute="Priority C" lineEndContext="#pop">+      <DetectSpaces attribute="Priority C"/>+      <IncludeRules context="_Tag"/>+      <DetectIdentifier attribute="Priority C"/>+    </context>++    <context name="(D)CompletionDate" attribute="Priority D" lineEndContext="#pop" fallthroughContext="#pop!(D)Description">+      <DetectSpaces attribute="Priority D" context="#pop!(D)CompletionDate2"/>+    </context>+    <context name="(D)CompletionDate2" attribute="Completion Date" lineEndContext="#pop" fallthroughContext="#pop!(D)Description">+      <DetectSpaces attribute="Priority D" context="#pop!(D)Description"/>+      <IncludeRules context="_CompletionDate"/>+    </context>+    <context name="(D)Description" attribute="Priority D" lineEndContext="#pop">+      <DetectSpaces attribute="Priority D"/>+      <IncludeRules context="_Tag"/>+      <DetectIdentifier attribute="Priority D"/>+    </context>++    <context name="(E)CompletionDate" attribute="Priority E" lineEndContext="#pop" fallthroughContext="#pop!(E)Description">+      <DetectSpaces attribute="Priority E" context="#pop!(E)CompletionDate2"/>+    </context>+    <context name="(E)CompletionDate2" attribute="Completion Date" lineEndContext="#pop" fallthroughContext="#pop!(E)Description">+      <DetectSpaces attribute="Priority E" context="#pop!(E)Description"/>+      <IncludeRules context="_CompletionDate"/>+    </context>+    <context name="(E)Description" attribute="Priority E" lineEndContext="#pop">+      <DetectSpaces attribute="Priority E"/>+      <IncludeRules context="_Tag"/>+      <DetectIdentifier attribute="Priority E"/>+    </context>++    <context name="(F)CompletionDate" attribute="Priority F" lineEndContext="#pop" fallthroughContext="#pop!(F)Description">+      <DetectSpaces attribute="Priority F" context="#pop!(F)CompletionDate2"/>+    </context>+    <context name="(F)CompletionDate2" attribute="Completion Date" lineEndContext="#pop" fallthroughContext="#pop!(F)Description">+      <DetectSpaces attribute="Priority F" context="#pop!(F)Description"/>+      <IncludeRules context="_CompletionDate"/>+    </context>+    <context name="(F)Description" attribute="Priority F" lineEndContext="#pop">+      <DetectSpaces attribute="Priority F"/>+      <IncludeRules context="_Tag"/>+      <DetectIdentifier attribute="Priority F"/>+    </context>++    <context name="(G)CompletionDate" attribute="Priority G" lineEndContext="#pop" fallthroughContext="#pop!(G)Description">+      <DetectSpaces attribute="Priority G" context="#pop!(G)CompletionDate2"/>+    </context>+    <context name="(G)CompletionDate2" attribute="Completion Date" lineEndContext="#pop" fallthroughContext="#pop!(G)Description">+      <DetectSpaces attribute="Priority G" context="#pop!(G)Description"/>+      <IncludeRules context="_CompletionDate"/>+    </context>+    <context name="(G)Description" attribute="Priority G" lineEndContext="#pop">+      <DetectSpaces attribute="Priority G"/>+      <IncludeRules context="_Tag"/>+      <DetectIdentifier attribute="Priority G"/>+    </context>++    <context name="(H)CompletionDate" attribute="Priority H" lineEndContext="#pop" fallthroughContext="#pop!(H)Description">+      <DetectSpaces attribute="Priority H" context="#pop!(H)CompletionDate2"/>+    </context>+    <context name="(H)CompletionDate2" attribute="Completion Date" lineEndContext="#pop" fallthroughContext="#pop!(H)Description">+      <DetectSpaces attribute="Priority H" context="#pop!(H)Description"/>+      <IncludeRules context="_CompletionDate"/>+    </context>+    <context name="(H)Description" attribute="Priority H" lineEndContext="#pop">+      <DetectSpaces attribute="Priority H"/>+      <IncludeRules context="_Tag"/>+      <DetectIdentifier attribute="Priority H"/>+    </context>++    <context name="(I)CompletionDate" attribute="Priority I" lineEndContext="#pop" fallthroughContext="#pop!(I)Description">+      <DetectSpaces attribute="Priority I" context="#pop!(I)CompletionDate2"/>+    </context>+    <context name="(I)CompletionDate2" attribute="Completion Date" lineEndContext="#pop" fallthroughContext="#pop!(I)Description">+      <DetectSpaces attribute="Priority I" context="#pop!(I)Description"/>+      <IncludeRules context="_CompletionDate"/>+    </context>+    <context name="(I)Description" attribute="Priority I" lineEndContext="#pop">+      <DetectSpaces attribute="Priority I"/>+      <IncludeRules context="_Tag"/>+      <DetectIdentifier attribute="Priority I"/>+    </context>++    <context name="(J)CompletionDate" attribute="Priority J" lineEndContext="#pop" fallthroughContext="#pop!(J)Description">+      <DetectSpaces attribute="Priority J" context="#pop!(J)CompletionDate2"/>+    </context>+    <context name="(J)CompletionDate2" attribute="Completion Date" lineEndContext="#pop" fallthroughContext="#pop!(J)Description">+      <DetectSpaces attribute="Priority J" context="#pop!(J)Description"/>+      <IncludeRules context="_CompletionDate"/>+    </context>+    <context name="(J)Description" attribute="Priority J" lineEndContext="#pop">+      <DetectSpaces attribute="Priority J"/>+      <IncludeRules context="_Tag"/>+      <DetectIdentifier attribute="Priority J"/>+    </context>++    <context name="(K)CompletionDate" attribute="Priority K" lineEndContext="#pop" fallthroughContext="#pop!(K)Description">+      <DetectSpaces attribute="Priority K" context="#pop!(K)CompletionDate2"/>+    </context>+    <context name="(K)CompletionDate2" attribute="Completion Date" lineEndContext="#pop" fallthroughContext="#pop!(K)Description">+      <DetectSpaces attribute="Priority K" context="#pop!(K)Description"/>+      <IncludeRules context="_CompletionDate"/>+    </context>+    <context name="(K)Description" attribute="Priority K" lineEndContext="#pop">+      <DetectSpaces attribute="Priority K"/>+      <IncludeRules context="_Tag"/>+      <DetectIdentifier attribute="Priority K"/>+    </context>++    <context name="(L)CompletionDate" attribute="Priority L" lineEndContext="#pop" fallthroughContext="#pop!(L)Description">+      <DetectSpaces attribute="Priority L" context="#pop!(L)CompletionDate2"/>+    </context>+    <context name="(L)CompletionDate2" attribute="Completion Date" lineEndContext="#pop" fallthroughContext="#pop!(L)Description">+      <DetectSpaces attribute="Priority L" context="#pop!(L)Description"/>+      <IncludeRules context="_CompletionDate"/>+    </context>+    <context name="(L)Description" attribute="Priority L" lineEndContext="#pop">+      <DetectSpaces attribute="Priority L"/>+      <IncludeRules context="_Tag"/>+      <DetectIdentifier attribute="Priority L"/>+    </context>++    <context name="(M)CompletionDate" attribute="Priority M" lineEndContext="#pop" fallthroughContext="#pop!(M)Description">+      <DetectSpaces attribute="Priority M" context="#pop!(M)CompletionDate2"/>+    </context>+    <context name="(M)CompletionDate2" attribute="Completion Date" lineEndContext="#pop" fallthroughContext="#pop!(M)Description">+      <DetectSpaces attribute="Priority M" context="#pop!(M)Description"/>+      <IncludeRules context="_CompletionDate"/>+    </context>+    <context name="(M)Description" attribute="Priority M" lineEndContext="#pop">+      <DetectSpaces attribute="Priority M"/>+      <IncludeRules context="_Tag"/>+      <DetectIdentifier attribute="Priority M"/>+    </context>++    <context name="(N)CompletionDate" attribute="Priority N" lineEndContext="#pop" fallthroughContext="#pop!(N)Description">+      <DetectSpaces attribute="Priority N" context="#pop!(N)CompletionDate2"/>+    </context>+    <context name="(N)CompletionDate2" attribute="Completion Date" lineEndContext="#pop" fallthroughContext="#pop!(N)Description">+      <DetectSpaces attribute="Priority N" context="#pop!(N)Description"/>+      <IncludeRules context="_CompletionDate"/>+    </context>+    <context name="(N)Description" attribute="Priority N" lineEndContext="#pop">+      <DetectSpaces attribute="Priority N"/>+      <IncludeRules context="_Tag"/>+      <DetectIdentifier attribute="Priority N"/>+    </context>++    <context name="(O)CompletionDate" attribute="Priority O" lineEndContext="#pop" fallthroughContext="#pop!(O)Description">+      <DetectSpaces attribute="Priority O" context="#pop!(O)CompletionDate2"/>+    </context>+    <context name="(O)CompletionDate2" attribute="Completion Date" lineEndContext="#pop" fallthroughContext="#pop!(O)Description">+      <DetectSpaces attribute="Priority O" context="#pop!(O)Description"/>+      <IncludeRules context="_CompletionDate"/>+    </context>+    <context name="(O)Description" attribute="Priority O" lineEndContext="#pop">+      <DetectSpaces attribute="Priority O"/>+      <IncludeRules context="_Tag"/>+      <DetectIdentifier attribute="Priority O"/>+    </context>++    <context name="(P)CompletionDate" attribute="Priority P" lineEndContext="#pop" fallthroughContext="#pop!(P)Description">+      <DetectSpaces attribute="Priority P" context="#pop!(P)CompletionDate2"/>+    </context>+    <context name="(P)CompletionDate2" attribute="Completion Date" lineEndContext="#pop" fallthroughContext="#pop!(P)Description">+      <DetectSpaces attribute="Priority P" context="#pop!(P)Description"/>+      <IncludeRules context="_CompletionDate"/>+    </context>+    <context name="(P)Description" attribute="Priority P" lineEndContext="#pop">+      <DetectSpaces attribute="Priority P"/>+      <IncludeRules context="_Tag"/>+      <DetectIdentifier attribute="Priority P"/>+    </context>++    <context name="(Q)CompletionDate" attribute="Priority Q" lineEndContext="#pop" fallthroughContext="#pop!(Q)Description">+      <DetectSpaces attribute="Priority Q" context="#pop!(Q)CompletionDate2"/>+    </context>+    <context name="(Q)CompletionDate2" attribute="Completion Date" lineEndContext="#pop" fallthroughContext="#pop!(Q)Description">+      <DetectSpaces attribute="Priority Q" context="#pop!(Q)Description"/>+      <IncludeRules context="_CompletionDate"/>+    </context>+    <context name="(Q)Description" attribute="Priority Q" lineEndContext="#pop">+      <DetectSpaces attribute="Priority Q"/>+      <IncludeRules context="_Tag"/>+      <DetectIdentifier attribute="Priority Q"/>+    </context>++    <context name="(R)CompletionDate" attribute="Priority R" lineEndContext="#pop" fallthroughContext="#pop!(R)Description">+      <DetectSpaces attribute="Priority R" context="#pop!(R)CompletionDate2"/>+    </context>+    <context name="(R)CompletionDate2" attribute="Completion Date" lineEndContext="#pop" fallthroughContext="#pop!(R)Description">+      <DetectSpaces attribute="Priority R" context="#pop!(R)Description"/>+      <IncludeRules context="_CompletionDate"/>+    </context>+    <context name="(R)Description" attribute="Priority R" lineEndContext="#pop">+      <DetectSpaces attribute="Priority R"/>+      <IncludeRules context="_Tag"/>+      <DetectIdentifier attribute="Priority R"/>+    </context>++    <context name="(S)CompletionDate" attribute="Priority S" lineEndContext="#pop" fallthroughContext="#pop!(S)Description">+      <DetectSpaces attribute="Priority S" context="#pop!(S)CompletionDate2"/>+    </context>+    <context name="(S)CompletionDate2" attribute="Completion Date" lineEndContext="#pop" fallthroughContext="#pop!(S)Description">+      <DetectSpaces attribute="Priority S" context="#pop!(S)Description"/>+      <IncludeRules context="_CompletionDate"/>+    </context>+    <context name="(S)Description" attribute="Priority S" lineEndContext="#pop">+      <DetectSpaces attribute="Priority S"/>+      <IncludeRules context="_Tag"/>+      <DetectIdentifier attribute="Priority S"/>+    </context>++    <context name="(T)CompletionDate" attribute="Priority T" lineEndContext="#pop" fallthroughContext="#pop!(T)Description">+      <DetectSpaces attribute="Priority T" context="#pop!(T)CompletionDate2"/>+    </context>+    <context name="(T)CompletionDate2" attribute="Completion Date" lineEndContext="#pop" fallthroughContext="#pop!(T)Description">+      <DetectSpaces attribute="Priority T" context="#pop!(T)Description"/>+      <IncludeRules context="_CompletionDate"/>+    </context>+    <context name="(T)Description" attribute="Priority T" lineEndContext="#pop">+      <DetectSpaces attribute="Priority T"/>+      <IncludeRules context="_Tag"/>+      <DetectIdentifier attribute="Priority T"/>+    </context>++    <context name="(U)CompletionDate" attribute="Priority U" lineEndContext="#pop" fallthroughContext="#pop!(U)Description">+      <DetectSpaces attribute="Priority U" context="#pop!(U)CompletionDate2"/>+    </context>+    <context name="(U)CompletionDate2" attribute="Completion Date" lineEndContext="#pop" fallthroughContext="#pop!(U)Description">+      <DetectSpaces attribute="Priority U" context="#pop!(U)Description"/>+      <IncludeRules context="_CompletionDate"/>+    </context>+    <context name="(U)Description" attribute="Priority U" lineEndContext="#pop">+      <DetectSpaces attribute="Priority U"/>+      <IncludeRules context="_Tag"/>+      <DetectIdentifier attribute="Priority U"/>+    </context>++    <context name="(V)CompletionDate" attribute="Priority V" lineEndContext="#pop" fallthroughContext="#pop!(V)Description">+      <DetectSpaces attribute="Priority V" context="#pop!(V)CompletionDate2"/>+    </context>+    <context name="(V)CompletionDate2" attribute="Completion Date" lineEndContext="#pop" fallthroughContext="#pop!(V)Description">+      <DetectSpaces attribute="Priority V" context="#pop!(V)Description"/>+      <IncludeRules context="_CompletionDate"/>+    </context>+    <context name="(V)Description" attribute="Priority V" lineEndContext="#pop">+      <DetectSpaces attribute="Priority V"/>+      <IncludeRules context="_Tag"/>+      <DetectIdentifier attribute="Priority V"/>+    </context>++    <context name="(W)CompletionDate" attribute="Priority W" lineEndContext="#pop" fallthroughContext="#pop!(W)Description">+      <DetectSpaces attribute="Priority W" context="#pop!(W)CompletionDate2"/>+    </context>+    <context name="(W)CompletionDate2" attribute="Completion Date" lineEndContext="#pop" fallthroughContext="#pop!(W)Description">+      <DetectSpaces attribute="Priority W" context="#pop!(W)Description"/>+      <IncludeRules context="_CompletionDate"/>+    </context>+    <context name="(W)Description" attribute="Priority W" lineEndContext="#pop">+      <DetectSpaces attribute="Priority W"/>+      <IncludeRules context="_Tag"/>+      <DetectIdentifier attribute="Priority W"/>+    </context>++    <context name="(X)CompletionDate" attribute="Priority X" lineEndContext="#pop" fallthroughContext="#pop!(X)Description">+      <DetectSpaces attribute="Priority X" context="#pop!(X)CompletionDate2"/>+    </context>+    <context name="(X)CompletionDate2" attribute="Completion Date" lineEndContext="#pop" fallthroughContext="#pop!(X)Description">+      <DetectSpaces attribute="Priority X" context="#pop!(X)Description"/>+      <IncludeRules context="_CompletionDate"/>+    </context>+    <context name="(X)Description" attribute="Priority X" lineEndContext="#pop">+      <DetectSpaces attribute="Priority X"/>+      <IncludeRules context="_Tag"/>+      <DetectIdentifier attribute="Priority X"/>+    </context>++    <context name="(Y)CompletionDate" attribute="Priority Y" lineEndContext="#pop" fallthroughContext="#pop!(Y)Description">+      <DetectSpaces attribute="Priority Y" context="#pop!(Y)CompletionDate2"/>+    </context>+    <context name="(Y)CompletionDate2" attribute="Completion Date" lineEndContext="#pop" fallthroughContext="#pop!(Y)Description">+      <DetectSpaces attribute="Priority Y" context="#pop!(Y)Description"/>+      <IncludeRules context="_CompletionDate"/>+    </context>+    <context name="(Y)Description" attribute="Priority Y" lineEndContext="#pop">+      <DetectSpaces attribute="Priority Y"/>+      <IncludeRules context="_Tag"/>+      <DetectIdentifier attribute="Priority Y"/>+    </context>++    <context name="(Z)CompletionDate" attribute="Priority Z" lineEndContext="#pop" fallthroughContext="#pop!(Z)Description">+      <DetectSpaces attribute="Priority Z" context="#pop!(Z)CompletionDate2"/>+    </context>+    <context name="(Z)CompletionDate2" attribute="Completion Date" lineEndContext="#pop" fallthroughContext="#pop!(Z)Description">+      <DetectSpaces attribute="Priority Z" context="#pop!(Z)Description"/>+      <IncludeRules context="_CompletionDate"/>+    </context>+    <context name="(Z)Description" attribute="Priority Z" lineEndContext="#pop">+      <DetectSpaces attribute="Priority Z"/>+      <IncludeRules context="_Tag"/>+      <DetectIdentifier attribute="Priority Z"/>+    </context>+  </contexts>++  <itemDatas>+    <itemData name="Normal" defStyleNum="dsNormal"/>+    <itemData name="Done" defStyleNum="dsAnnotation" spellChecking="0"/>+    <itemData name="Completion Date" defStyleNum="dsBuiltIn" spellChecking="0"/>+    <itemData name="Creation Date" defStyleNum="dsPreprocessor" spellChecking="0"/>+    <itemData name="Project Tag" defStyleNum="dsAttribute" spellChecking="0"/>+    <itemData name="Context Tag" defStyleNum="dsExtension" spellChecking="0"/>+    <itemData name="Metadata Key" defStyleNum="dsVariable" spellChecking="0"/>+    <itemData name="Metadata Value" defStyleNum="dsString" spellChecking="0"/>+    <itemData name="Priority A" defStyleNum="dsAlert"/>+    <itemData name="Priority B" defStyleNum="dsWarning"/>+    <itemData name="Priority C" defStyleNum="dsInformation"/>+    <itemData name="Priority D" defStyleNum="dsOthers"/>+    <itemData name="Priority E" defStyleNum="dsOthers"/>+    <itemData name="Priority F" defStyleNum="dsOthers"/>+    <itemData name="Priority G" defStyleNum="dsOthers"/>+    <itemData name="Priority H" defStyleNum="dsOthers"/>+    <itemData name="Priority I" defStyleNum="dsOthers"/>+    <itemData name="Priority J" defStyleNum="dsOthers"/>+    <itemData name="Priority K" defStyleNum="dsOthers"/>+    <itemData name="Priority L" defStyleNum="dsOthers"/>+    <itemData name="Priority M" defStyleNum="dsOthers"/>+    <itemData name="Priority N" defStyleNum="dsOthers"/>+    <itemData name="Priority O" defStyleNum="dsOthers"/>+    <itemData name="Priority P" defStyleNum="dsOthers"/>+    <itemData name="Priority Q" defStyleNum="dsOthers"/>+    <itemData name="Priority R" defStyleNum="dsOthers"/>+    <itemData name="Priority S" defStyleNum="dsOthers"/>+    <itemData name="Priority T" defStyleNum="dsOthers"/>+    <itemData name="Priority U" defStyleNum="dsOthers"/>+    <itemData name="Priority V" defStyleNum="dsOthers"/>+    <itemData name="Priority W" defStyleNum="dsOthers"/>+    <itemData name="Priority X" defStyleNum="dsOthers"/>+    <itemData name="Priority Y" defStyleNum="dsOthers"/>+    <itemData name="Priority Z" defStyleNum="dsOthers"/>+  </itemDatas>+</highlighting>+</language>
xml/typst.xml view
@@ -12,7 +12,7 @@ ]>  <!---    SPDX-FileCopyrightText: 2024 Marco Rebhan <me@dblsaiko.net>+    SPDX-FileCopyrightText: 2024 Katalin Rebhan <me@dblsaiko.net>      SPDX-License-Identifier: MIT -->@@ -24,7 +24,7 @@     section="Markup"     extensions="*.typ"     casesensitive="1"-    author="Marco Rebhan &lt;me@dblsaiko.net&gt;"+    author="Katalin Rebhan &lt;me@dblsaiko.net&gt;"     license="MIT"     priority="1" >
+ xml/vue.xml view
@@ -0,0 +1,251 @@+<?xml version="1.0" encoding="UTF-8"?>+<!DOCTYPE language [+<!ENTITY name "[A-Za-z_:][\w.:_-]*">+<!ENTITY attributeName "[\@A-Za-z_:*#\(\[][\)\]\w.:_-]*">+<!ENTITY entref "&amp;(?:#[0-9]+|#[xX][0-9A-Fa-f]+|&name;);">+]>+<language name="Vue" version="19" kateversion="5.79" section="Markup" extensions="*.vue" mimetype="text/html" author="James Zuccon" license="LGPL" priority="10">+  <!--+    This is a modified version of the HTML Syntax Highlighter to accommodate Vue JS template files (with some non-relevant parts removed).+    While we could take the approach of just including rules from the HTML files, this introduces some problems:+    1. Vue supports the <template> tag recursively - to support this, we would need to duplicate much of the HTML syntax file anyway.+    2. Vue has some additional attributeName patterns that are not supported by HTML (e.g. '@' prefix as shorthand for events).+    3. If we wanted to support Vue Attribute Bindings in future (e.g. :some-binded-param), we would have to duplicate much of the HTML syntax file  again.+    4. If we wanted to support Vue JS Brackets in future (e.g. {{ echoSomeContent }}, we would also have to duplicate much of the HTML syntax file again.+    If Syntax Highlighting supports over-riding third-party contexts at some point in future, it might be worth re-thinking how this file is constructed.+    But, for now, it's probably saner to use HTML as the base template.+    NOTE: We do not necessarily want to just integrate support for these features directly into the HTML syntax highlighter, as we want Vue to have its own mimetype.+          One of the major reasons for this is so that we can identify Vue files for use with an LSP (e.g. Volar) in Kate.+  -->+  <highlighting>+    <contexts>+      <context name="Start" attribute="Normal Text" lineEndContext="#stay">+        <IncludeRules context="FindHTML"/>+      </context>+      <context name="FindHTML" attribute="Normal Text" lineEndContext="#stay">+        <DetectSpaces/>+        <DetectIdentifier/>+        <StringDetect attribute="Comment" context="Comment" String="&lt;!--" beginRegion="comment"/>+        <IncludeRules context="FindElements"/>+        <IncludeRules context="FindEntityRefs"/>+      </context>+      <context name="FindElements" attribute="Other Text" lineEndContext="#pop">+        <RegExpr attribute="Element Symbols" context="ElementTagName" String="&lt;(?=(&name;))"/>+        <RegExpr attribute="Element Symbols" context="ElementTagNameClose" String="&lt;/(?=(&name;))"/>+      </context>+      <context name="ElementTagName" attribute="Other Text" lineEndContext="#pop">+        <IncludeRules context="FindHTMLTags"/>+        <IncludeRules context="FindSpecialHTMLTags"/>+        <StringDetect attribute="Element" context="#pop!El Open" String="%1" dynamic="true"/>+      </context>+      <context name="ElementTagNameClose" attribute="Other Text" lineEndContext="#pop">+        <IncludeRules context="FindHTMLTagsClose"/>+        <StringDetect attribute="Element" context="#pop!El Close" String="%1" dynamic="true"/>+      </context>+      <!-- This allows you to insert HTML tags in other syntax definitions -->+      <context name="FindSpecialHTMLTags" attribute="Normal Text" lineEndContext="#stay">+        <WordDetect attribute="Element" context="#pop!CSS" String="style" insensitive="true" beginRegion="style"/>+        <WordDetect attribute="Element" context="#pop!JS" String="script" insensitive="true" beginRegion="script"/>+      </context>+      <context name="FindHTMLTags" attribute="Normal Text" lineEndContext="#stay">+        <WordDetect attribute="Element" context="#pop!El Open" String="pre" insensitive="true" beginRegion="pre"/>+        <WordDetect attribute="Element" context="#pop!El Open" String="div" insensitive="true" beginRegion="div"/>+        <WordDetect attribute="Element" context="#pop!El Open" String="table" insensitive="true" beginRegion="table"/>+        <WordDetect attribute="Element" context="#pop!El Open" String="ul" insensitive="true" beginRegion="ul"/>+        <WordDetect attribute="Element" context="#pop!El Open" String="ol" insensitive="true" beginRegion="ol"/>+        <WordDetect attribute="Element" context="#pop!El Open" String="dl" insensitive="true" beginRegion="dl"/>+        <WordDetect attribute="Element" context="#pop!El Open" String="article" insensitive="true" beginRegion="article"/>+        <WordDetect attribute="Element" context="#pop!El Open" String="aside" insensitive="true" beginRegion="aside"/>+        <WordDetect attribute="Element" context="#pop!El Open" String="details" insensitive="true" beginRegion="details"/>+        <WordDetect attribute="Element" context="#pop!El Open" String="figure" insensitive="true" beginRegion="figure"/>+        <WordDetect attribute="Element" context="#pop!El Open" String="footer" insensitive="true" beginRegion="footer"/>+        <WordDetect attribute="Element" context="#pop!El Open" String="header" insensitive="true" beginRegion="header"/>+        <WordDetect attribute="Element" context="#pop!El Open" String="main" insensitive="true" beginRegion="main"/>+        <WordDetect attribute="Element" context="#pop!El Open" String="nav" insensitive="true" beginRegion="nav"/>+        <WordDetect attribute="Element" context="#pop!El Open" String="section" insensitive="true" beginRegion="section"/>+      </context>+      <context name="FindHTMLTagsClose" attribute="Normal Text" lineEndContext="#stay">+        <WordDetect attribute="Element" context="#pop!El Close" String="pre" insensitive="true" endRegion="pre"/>+        <WordDetect attribute="Element" context="#pop!El Close" String="div" insensitive="true" endRegion="div"/>+        <WordDetect attribute="Element" context="#pop!El Close" String="table" insensitive="true" endRegion="table"/>+        <WordDetect attribute="Element" context="#pop!El Close" String="ul" insensitive="true" endRegion="ul"/>+        <WordDetect attribute="Element" context="#pop!El Close" String="ol" insensitive="true" endRegion="ol"/>+        <WordDetect attribute="Element" context="#pop!El Close" String="dl" insensitive="true" endRegion="dl"/>+        <WordDetect attribute="Element" context="#pop!El Close" String="article" insensitive="true" endRegion="article"/>+        <WordDetect attribute="Element" context="#pop!El Close" String="aside" insensitive="true" endRegion="aside"/>+        <WordDetect attribute="Element" context="#pop!El Close" String="details" insensitive="true" endRegion="details"/>+        <WordDetect attribute="Element" context="#pop!El Close" String="figure" insensitive="true" endRegion="figure"/>+        <WordDetect attribute="Element" context="#pop!El Close" String="footer" insensitive="true" endRegion="footer"/>+        <WordDetect attribute="Element" context="#pop!El Close" String="header" insensitive="true" endRegion="header"/>+        <WordDetect attribute="Element" context="#pop!El Close" String="main" insensitive="true" endRegion="main"/>+        <WordDetect attribute="Element" context="#pop!El Close" String="nav" insensitive="true" endRegion="nav"/>+        <WordDetect attribute="Element" context="#pop!El Close" String="section" insensitive="true" endRegion="section"/>+      </context>+      <context name="FindEntityRefs" attribute="Other Text" lineEndContext="#stay">+        <RegExpr attribute="EntityRef" context="#stay" String="&entref;"/>+        <AnyChar attribute="Error" context="#stay" String="&amp;&lt;"/>+      </context>+      <context name="FindAttributes" attribute="Other Text" lineEndContext="#stay">+        <DetectChar attribute="Attribute Separator" context="Value" char="="/>+        <RegExpr attribute="Attribute" context="#stay" String="(^|\s+)&attributeName;(\s+&attributeName;)*\s*|\s+"/>+      </context>+      <context name="Comment" attribute="Comment" lineEndContext="#stay">+        <DetectSpaces/>+        <StringDetect attribute="Comment" context="#pop" String="--&gt;" endRegion="comment"/>+        <IncludeRules context="##Comments"/>+        <DetectIdentifier/>+      </context>+      <context name="El Open" attribute="Error" lineEndContext="#stay">+        <Detect2Chars attribute="Element Symbols" context="#pop" char="/" char1="&gt;"/>+        <DetectChar attribute="Element Symbols" context="#pop" char="&gt;"/>+        <IncludeRules context="FindAttributes"/>+      </context>+      <context name="El Close" attribute="Error" lineEndContext="#stay">+        <DetectChar attribute="Element Symbols" context="#pop" char="&gt;"/>+        <DetectSpaces attribute="Other Text"/>+      </context>+      <context name="CSS" attribute="Error" lineEndContext="#stay">+        <RegExpr attribute="Attribute" context="Style-Type" String="(?:\s+|^)lang(?=\=|\s|$)" insensitive="true"/>+        <Detect2Chars attribute="Element Symbols" context="#pop" char="/" char1="&gt;" endRegion="style"/>+        <DetectChar attribute="Element Symbols" context="CSS content" char="&gt;"/>+        <IncludeRules context="FindAttributes"/>+      </context>+      <context name="DefaultCSS" attribute="Other Text" lineEndContext="#stay">+        <Detect2Chars attribute="Element Symbols" context="#pop" char="/" char1="&gt;" endRegion="style"/>+        <DetectChar attribute="Attribute Separator" context="Value" char="="/>+        <RegExpr attribute="Attribute" context="#stay" String="(^|\s+)&attributeName;|\s+"/>+      </context>+      <context name="CSS content" attribute="Other Text" lineEndContext="#stay">+        <RegExpr attribute="Element Symbols" context="StyleTagClose" String="&lt;/(?=style\b)" insensitive="true"/>+        <IncludeRules context="##CSS" includeAttrib="true"/>+      </context>+      <context name="Default CSS content" attribute="Other Text" lineEndContext="#stay">+        <IncludeRules context="FindStyleTagClose"/>+      </context>+      <context name="FindStyleTagClose" attribute="Other Text" lineEndContext="#stay">+        <RegExpr attribute="Element Symbols" context="StyleTagClose" String="&lt;/(?=style\b)" insensitive="true"/>+      </context>+      <context name="StyleTagClose" attribute="Other Text" lineEndContext="#stay">+        <DetectIdentifier attribute="Element" context="#pop#pop#pop!El Close" endRegion="style"/>+      </context>+      <context name="JS" attribute="Error" lineEndContext="#stay">+        <RegExpr attribute="Attribute" context="Script-Type" String="(?:\s+|^)lang(?=\=|\s|$)" insensitive="true"/>+        <DetectChar attribute="Element Symbols" context="JS content" char="&gt;"/>+        <IncludeRules context="DefaultJS"/>+      </context>+      <context name="DefaultJS" attribute="Other Text" lineEndContext="#stay">+        <Detect2Chars attribute="Element Symbols" context="#pop" char="/" char1="&gt;" endRegion="script"/>+        <DetectChar attribute="Attribute Separator" context="Value" char="="/>+        <RegExpr attribute="Attribute" context="#stay" String="(^|\s+)&attributeName;|\s+"/>+      </context>+      <context name="JS content" attribute="Other Text" lineEndContext="#stay">+        <IncludeRules context="Default JS content"/>+        <IncludeRules context="Normal##JavaScript" includeAttrib="true"/>+      </context>+      <context name="Default JS content" attribute="Other Text" lineEndContext="#stay">+        <IncludeRules context="FindScriptTagClose"/>+        <RegExpr attribute="Comment" context="JS comment close" String="//(?=.*&lt;/script\b)" insensitive="true"/>+      </context>+      <context name="FindScriptTagClose" attribute="Other Text" lineEndContext="#stay">+        <RegExpr attribute="Element Symbols" context="ScriptTagClose" String="&lt;/(?=script\b)" insensitive="true"/>+      </context>+      <context name="ScriptTagClose" attribute="Other Text" lineEndContext="#stay">+        <DetectIdentifier attribute="Element" context="#pop#pop#pop!El Close" endRegion="script"/>+      </context>+      <context name="JS comment close" attribute="Comment" lineEndContext="#pop">+        <RegExpr attribute="Element Symbols" context="#pop!ScriptTagClose" String="&lt;/(?=script\b)" insensitive="true"/>+        <DetectSpaces/>+        <IncludeRules context="##Comments"/>+      </context>+      <context name="Value" attribute="Other Text" lineEndContext="#stay" fallthroughContext="Value NQ">+        <DetectChar attribute="Value" context="Value DQ" char="&quot;"/>+        <DetectChar attribute="Value" context="Value SQ" char="'"/>+        <DetectSpaces/>+      </context>+      <context name="Value NQ" attribute="Other Text" lineEndContext="#pop#pop" fallthroughContext="#pop#pop">+        <!-- '{' and '}' are valid, but used with twig -->+        <RegExpr attribute="Value" String="[^&gt;&lt;&quot;'&amp;\s=`{}]+"/>+        <IncludeRules context="FindEntityRefs"/>+        <AnyChar attribute="Error" String="&quot;'`="/>+        <AnyChar attribute="Value" String="{}"/>+      </context>+      <context name="Value DQ" attribute="Value" lineEndContext="#stay">+        <DetectChar attribute="Value" context="#pop#pop" char="&quot;"/>+        <IncludeRules context="FindEntityRefs"/>+      </context>+      <context name="Value SQ" attribute="Value" lineEndContext="#stay">+        <DetectChar attribute="Value" context="#pop#pop" char="'"/>+        <IncludeRules context="FindEntityRefs"/>+      </context>+      <!-- Read content from the "lang" attribute to change the language to+       highlight in the <style> tag. The default language is CSS. -->+      <context name="Style-Type" attribute="Other Text" lineEndContext="#stay" fallthroughContext="#pop">+        <DetectSpaces/>+        <DetectChar attribute="Attribute" context="#pop!Style-Type Value" char="="/>+      </context>+      <context name="Style-Type Value" attribute="Other Text" lineEndContext="#stay" fallthroughContext="#pop!Value">+        <DetectSpaces/>+        <!-- SASS -->+        <StringDetect attribute="Value" context="#pop#pop!SASS" String="&quot;sass&quot;"/>+        <StringDetect attribute="Value" context="#pop#pop!SASS" String="'sass'"/>+        <!-- SCSS -->+        <StringDetect attribute="Value" context="#pop#pop!SCSS" String="&quot;scss&quot;"/>+        <StringDetect attribute="Value" context="#pop#pop!SCSS" String="'scss'"/>+      </context>+      <context name="SASS" attribute="Error" lineEndContext="#stay">+        <DetectChar attribute="Element Symbols" context="SASS content" char="&gt;"/>+        <IncludeRules context="DefaultCSS"/>+      </context>+      <context name="SASS content" attribute="Other Text" lineEndContext="#stay">+        <IncludeRules context="Default CSS content"/>+        <IncludeRules context="##SASS" includeAttrib="true"/>+      </context>+      <context name="SCSS" attribute="Error" lineEndContext="#stay">+        <DetectChar attribute="Element Symbols" context="SCSS content" char="&gt;"/>+        <IncludeRules context="DefaultCSS"/>+      </context>+      <context name="SCSS content" attribute="Other Text" lineEndContext="#stay">+        <IncludeRules context="Default CSS content"/>+        <IncludeRules context="##SCSS" includeAttrib="true"/>+      </context>+      <!-- Read content from the "lang" attribute to change the language to+       highlight in the <script> tag. The default language is JavaScript. -->+      <context name="Script-Type" attribute="Other Text" lineEndContext="#stay" fallthroughContext="#pop">+        <DetectSpaces/>+        <DetectChar attribute="Attribute" context="#pop!Script-Type Value" char="="/>+      </context>+      <context name="Script-Type Value" attribute="Other Text" lineEndContext="#stay" fallthroughContext="#pop!Value">+        <DetectSpaces/>+        <!-- TypeScript -->+        <StringDetect attribute="Value" context="#pop#pop!TypeScript" String="&quot;ts&quot;"/>+        <StringDetect attribute="Value" context="#pop#pop!TypeScript" String="'ts'"/>+      </context>+      <context name="TypeScript" attribute="Error" lineEndContext="#stay">+        <DetectChar attribute="Element Symbols" context="TypeScript content" char="&gt;"/>+        <IncludeRules context="DefaultJS"/>+      </context>+      <context name="TypeScript content" attribute="Other Text" lineEndContext="#stay">+        <IncludeRules context="Default JS content"/>+        <IncludeRules context="Normal##TypeScript" includeAttrib="true"/>+      </context>+    </contexts>+    <itemDatas>+      <itemData name="Normal Text" defStyleNum="dsNormal"/>+      <itemData name="Other Text" defStyleNum="dsNormal" spellChecking="false"/>+      <itemData name="Comment" defStyleNum="dsComment"/>+      <itemData name="Element" defStyleNum="dsKeyword" spellChecking="false"/>+      <itemData name="Element Symbols" defStyleNum="dsDataType" spellChecking="false"/>+      <itemData name="Attribute" defStyleNum="dsOthers" spellChecking="false"/>+      <itemData name="Attribute Separator" defStyleNum="dsOperator" spellChecking="false"/>+      <itemData name="Value" defStyleNum="dsString" spellChecking="false"/>+      <itemData name="EntityRef" defStyleNum="dsDecVal" spellChecking="false"/>+      <itemData name="Error" defStyleNum="dsError" spellChecking="false"/>+    </itemDatas>+  </highlighting>+  <general>+    <comments>+      <comment name="multiLine" start="&lt;!--" end="--&gt;" region="comment"/>+    </comments>+  </general>+</language>+<!-- kate: replace-tabs on; tab-width 2; indent-width 2; -->
xml/yaml.xml view
@@ -1,640 +1,820 @@ <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE language [-  <!ENTITY null "(?:null|Null|NULL|~)">-  <!ENTITY bool "(?:y|Y|yes|Yes|YES|n|N|no|No|NO|true|True|TRUE|false|False|FALSE|on|On|ON|off|Off|OFF)">--  <!ENTITY int         "(?:0|[\-\+]?[1-9][0-9_]*)">-  <!ENTITY intOther    "[\-\+]?0(?:x_*[0-9a-fA-F][0-9a-fA-F_]*|o?_*[0-7][0-7_]*|b_*[01][01_]*)"> <!-- Hex, Octal, Binary -->-  <!ENTITY intBase60   "[\-\+]?[1-9][0-9_]*(?:\:[0-5]?[0-9])+">-  <!ENTITY allInt      "(?:&intBase60;|&intOther;|&int;)">--  <!ENTITY float       "[\-\+]?(?:[0-9][0-9_]*\.[0-9\._]*|\._*[0-9][0-9\._]*)(?:[eE][\-\+]?[0-9]+)?">-  <!ENTITY floatExp    "[\-\+]?[0-9][0-9_]*[eE][\-\+]?[0-9]+">-  <!ENTITY floatBase60 "[\-\+]?[0-9][0-9_]*(?:\:[0-5]?[0-9])+\.[0-9_]*">-  <!ENTITY inf         "[\-\+]?\.(?:inf|Inf|INF)\b">-  <!ENTITY nan         "\.(?:nan|NaN|NAN)\b">-  <!ENTITY allFloat    "(?:&float;|&floatExp;|&floatBase60;|&inf;|&nan;)">--  <!ENTITY endValue       "(?:\s*$|\s+#)">-  <!ENTITY endValueInline "\s*[:,\[\]\{\}]">-  <!ENTITY space          "[ ]">--  <!-- Key quoted -->-  <!ENTITY keyDQ          "&quot;(?:\\.|[^&quot;])+&quot;\s*">-  <!ENTITY keySQ          "'(?:[^']|'')+'\s*">-  <!-- Literal/folded operator -->-  <!ENTITY literalOp      "[\|&gt;][\-\+]?">-  <!-- Key after "?" or "-", used to detect literal/folded operator -->-  <!ENTITY keyAfterOp     "(?:[^&quot;'#\-\?\s][^:#]*|\-(?:[^\s:#][^:#]*)?|&keyDQ;|&keySQ;)">--  <!ENTITY dataTypes      "!!\S+">-  <!ENTITY alias          "&amp;\S+">-  <!ENTITY reference      "\*\S+">--  <!ENTITY dpointsHashAttrPreInline1 "[^\s&quot;'#\-,\}\s][^:#,\}]*(?=\:(?:\s|$))">-  <!ENTITY dpointsHashAttrPreInline2 "\-(?:[^\s:#,\}][^:#,\}]*)?(?=\:(?:\s|$))">-  <!ENTITY dpointsHashAttrPreInline3 "&keyDQ;(?=\:(?:\s|$))">-  <!ENTITY dpointsHashAttrPreInline4 "&keySQ;(?=\:(?:\s|$))">--  <!ENTITY dpointsListAttrPreInline1 "[^&quot;'#\-,\]\s][^:#,\]]*(?=\:(?:\s|$))">-  <!ENTITY dpointsListAttrPreInline2 "\-(?:[^\s:#,\]][^:#,\]]*)?(?=\:(?:\s|$))">-  <!ENTITY dpointsListAttrPreInline3 "&keyDQ;(?=\:(?:\s|$))">-  <!ENTITY dpointsListAttrPreInline4 "&keySQ;(?=\:(?:\s|$))">--  <!ENTITY dpointsAttrPre1 "[^&quot;'#\-\s][^:#]*(?=\:(?:\s|$))">-  <!ENTITY dpointsAttrPre2 "\-(?:[^\s:#][^:#]*)?(?=\:(?:\s|$))">-  <!ENTITY dpointsAttrPre3 "&keyDQ;(?=\:(?:\s|$))">-  <!ENTITY dpointsAttrPre4 "&keySQ;(?=\:(?:\s|$))">--]>--<!-- Author: Dr Orlovsky MA <maxim@orlovsky.info> //-->-<!-- Modifications (YAML 1.2), values & support for literal/folded style:-       Nibaldo González S. <nibgonz@gmail.com>-       These modifications are under the MIT license. //-->-<language name="YAML" alternativeNames="YML" version="13" kateversion="5.0" section="Markup"-          extensions="*.yaml;*.yml;.clang-format;.clang-tidy" mimetype="text/yaml" priority="9"-          author="Dr Orlovsky MA (dr.orlovsky@gmail.com), Nibaldo González (nibgonz@gmail.com)" license="LGPL">-  <highlighting>-    <contexts>-      <context attribute="Attribute" lineEndContext="#stay" name="normal" >-        <StringDetect attribute="Document Header" context="header" String="---" column="0"/>-        <RegExpr attribute="End of Document" context="EOD" String="^\.\.\.$" column="0"/>-        <DetectChar attribute="Directive" context="directive" char="%" column="0"/>--        <RegExpr attribute="Comment" context="comment" String="(?:^|\s+)#" />--        <!-- Literal/Folded Style -->-        <IncludeRules context="find-literal-block" />--        <RegExpr attribute="Operator" firstNonSpace="true" context="dash" String="\-(?=\s|$)" />-        <DetectChar attribute="Operator" firstNonSpace="true" context="mapping-key" char="?" />--        <DetectChar attribute="Operator" firstNonSpace="true" context="list" char="[" beginRegion="List" />-        <DetectChar attribute="Operator" firstNonSpace="true" context="hash" char="{" beginRegion="Hash" />--        <RegExpr attribute="Data Types" firstNonSpace="true" context="after-data" String="&dataTypes;" />-        <RegExpr attribute="Alias" firstNonSpace="true" context="after-data" String="&alias;" />-        <RegExpr attribute="Reference" firstNonSpace="true" context="after-data" String="&reference;" />--        <RegExpr attribute="Key" context="dpoints-attribute-pre" String="&dpointsAttrPre1;|&dpointsAttrPre2;|&dpointsAttrPre3;|&dpointsAttrPre4;"/>-        <RegExpr attribute="Key Points Operator" context="attribute-pre" String=":(?=\s|$)"/>--        <DetectChar attribute="String" firstNonSpace="true" context="string" char="'" beginRegion="String" />-        <DetectChar attribute="String" firstNonSpace="true" context="stringx" char="&quot;" beginRegion="String" />-        <IncludeRules context="values-firstnonspace" />-        <DetectSpaces/>-      </context>--      <context attribute="Normal Text" lineEndContext="#pop" name="mapping-key" fallthrough="true" fallthroughContext="#pop">-        <RegExpr attribute="Comment" context="#pop!comment" String="(?:^|\s+)#" />-        <DetectSpaces />-        <RegExpr attribute="Operator" context="#pop!dash" String="\-(?=\s|$)" />-        <RegExpr attribute="Data Types" context="#pop!after-data" String="&dataTypes;" />-        <RegExpr attribute="Alias" context="#pop!after-data" String="&alias;" />-        <RegExpr attribute="Reference" context="#pop!after-data" String="&reference;" />--        <DetectChar attribute="Operator" context="#pop!list" char="[" beginRegion="List" />-        <DetectChar attribute="Operator" context="#pop!hash" char="{" beginRegion="Hash" />-        <DetectChar attribute="String" context="#pop!string" char="'" beginRegion="String" />-        <DetectChar attribute="String" context="#pop!stringx" char="&quot;" beginRegion="String" />-      </context>--      <context attribute="Normal Text" lineEndContext="#pop" name="dash" fallthrough="true" fallthroughContext="#pop">-        <RegExpr attribute="Comment" context="comment" String="(?:^|\s+)#" />-        <DetectSpaces/>-        <RegExpr attribute="Data Types" context="#stay" String="&dataTypes;" />-        <RegExpr attribute="Alias" context="#stay" String="&alias;" />-        <RegExpr attribute="Reference" context="#stay" String="&reference;" />-        <IncludeRules context="values" />-        <DetectChar attribute="Operator" context="#pop!mapping-key" char="?" />-        <RegExpr attribute="Operator" context="#stay" String="\-(?=\s|$)" />--        <DetectChar attribute="Operator" context="#pop!list" char="[" beginRegion="List" />-        <DetectChar attribute="Operator" context="#pop!hash" char="{" beginRegion="Hash" />-        <DetectChar attribute="String" context="#pop!string" char="'" beginRegion="String" />-        <DetectChar attribute="String" context="#pop!stringx" char="&quot;" beginRegion="String" />-      </context>--      <!-- Highlight lists, hashes and strings after a data type, reference or alias -->-      <context attribute="Normal Text" lineEndContext="#pop" name="after-data" fallthrough="true" fallthroughContext="#pop">-        <RegExpr attribute="Comment" context="#pop!comment" String="(?:^|\s+)#" />-        <DetectSpaces />-        <RegExpr attribute="Data Types" context="#stay" String="&dataTypes;" />-        <RegExpr attribute="Alias" context="#stay" String="&alias;" />-        <RegExpr attribute="Reference" context="#stay" String="&reference;" />--        <DetectChar attribute="Operator" context="list" char="[" beginRegion="List" />-        <DetectChar attribute="Operator" context="hash" char="{" beginRegion="Hash" />-        <DetectChar attribute="String" context="string" char="'" beginRegion="String" />-        <DetectChar attribute="String" context="stringx" char="&quot;" beginRegion="String" />-      </context>--      <context attribute="Document Header" lineEndContext="#pop" name="header">-        <RegExpr attribute="Comment" context="comment" String="(?:^|\s+)#" />-        <RegExpr attribute="Literal/Folded Operator" context="header-literal-operator" String="\s&literalOp;(?=&endValue;)" lookAhead="true" />-      </context>-      <context attribute="Document Header" lineEndContext="#pop#pop" name="header-literal-operator" fallthrough="true" fallthroughContext="#pop">-        <DetectSpaces />-        <RegExpr attribute="Literal/Folded Operator" context="#pop#pop!literal-block-simple" String="&literalOp;" beginRegion="Literal" />-      </context>--      <context attribute="End of Document" lineEndContext="#stay" name="EOD">-      </context>--      <context attribute="Directive" lineEndContext="#pop" name="directive">-      </context>--      <context attribute="Attribute" lineEndContext="#pop#pop" name="attribute">-        <RegExpr attribute="Comment" context="comment" String="(?:^|\s+)#" />-      </context>--      <context attribute="Attribute" lineEndContext="#stay" name="list-attribute-inline">-        <AnyChar attribute="Operator" context="#pop#pop" lookAhead="true" String=",]" />-        <RegExpr attribute="Comment" context="comment" String="(?:^|\s+)#" />-      </context>-      <context attribute="Attribute" lineEndContext="#stay" name="hash-attribute-inline">-        <AnyChar attribute="Operator" context="#pop#pop" lookAhead="true" String=",}" />-        <RegExpr attribute="Comment" context="comment" String="(?:^|\s+)#" />-      </context>--      <!-- Attribute -->-      <context attribute="Attribute" lineEndContext="#pop" name="dpoints-attribute-pre" fallthrough="true" fallthroughContext="#pop!attribute-pre">-        <DetectChar attribute="Key Points Operator" context="#pop!attribute-pre" char=":" /> <!-- Highlight two points after Key -->-      </context>-      <context attribute="Attribute" lineEndContext="#pop" name="attribute-pre" fallthrough="true" fallthroughContext="attribute">-        <RegExpr attribute="Comment" context="comment" String="(?:^|\s+)#" />-        <DetectSpaces/>-        <DetectChar attribute="Operator" context="#stay" char="?" />-        <RegExpr attribute="Data Types" context="#stay" String="&dataTypes;" />-        <DetectChar attribute="Operator" context="list" char="[" beginRegion="List" />-        <DetectChar attribute="Operator" context="hash" char="{" beginRegion="Hash" />-        <DetectChar attribute="String" context="attribute-string" char="'" beginRegion="String" />-        <DetectChar attribute="String" context="attribute-stringx" char="&quot;" beginRegion="String" />-        <RegExpr attribute="Alias" context="#stay" String="&alias;(?=\s+[\[\{])" />-        <RegExpr attribute="Reference" context="#stay" String="&reference;(?=\s+[\[\{])" />-        <RegExpr attribute="Alias" context="attribute" String="&alias;" />-        <RegExpr attribute="Reference" context="attribute" String="&reference;" />-        <IncludeRules context="values" />-        <RegExpr attribute="Literal/Folded Operator" context="#stay" String="&literalOp;(?=&endValue;)" />-      </context>--      <context attribute="Attribute" lineEndContext="#pop" name="default-attribute-pre-inline">-        <RegExpr attribute="Comment" context="comment" String="(?:^|\s+)#" />-        <DetectSpaces/>--        <DetectChar attribute="Operator" context="#stay" char="?" />-        <RegExpr attribute="Data Types" context="#stay" String="&dataTypes;" />-        <DetectChar attribute="Operator" context="list" char="[" beginRegion="List" />-        <DetectChar attribute="Operator" context="hash" char="{" beginRegion="Hash" />-        <DetectChar attribute="String" context="attribute-string-inline" char="'" beginRegion="String" />-        <DetectChar attribute="String" context="attribute-stringx-inline" char="&quot;" beginRegion="String" />-        <RegExpr attribute="Alias" context="#stay" String="&alias;(?=\s+[\[\{])" />-        <RegExpr attribute="Reference" context="#stay" String="&reference;(?=\s+[\[\{])" />-      </context>--      <!-- Attribute Inline, Within List -->-      <context attribute="Attribute" lineEndContext="#pop" name="dpoints-list-attribute-pre-inline" fallthrough="true" fallthroughContext="#pop!list-attribute-pre-inline">-        <DetectChar attribute="Key Points Operator" context="#pop!list-attribute-pre-inline" char=":" /> <!-- Highlight two points after Key -->-      </context>-      <context attribute="Attribute" lineEndContext="#pop" name="list-attribute-pre-inline" fallthrough="true" fallthroughContext="list-attribute-inline">-        <IncludeRules context="default-attribute-pre-inline" />-        <RegExpr attribute="Alias" context="list-attribute-inline" String="&alias;" />-        <RegExpr attribute="Reference" context="list-attribute-inline" String="&reference;" />--        <AnyChar attribute="Operator" context="#pop" lookAhead="true" String=",]" />-        <IncludeRules context="values-inline" />-      </context>--      <!-- Attribute Inline, Within Hash -->-      <context attribute="Attribute" lineEndContext="#pop" name="dpoints-hash-attribute-pre-inline" fallthrough="true" fallthroughContext="#pop!hash-attribute-pre-inline">-        <DetectChar attribute="Key Points Operator" context="#pop!hash-attribute-pre-inline" char=":" /> <!-- Highlight two points after Key -->-      </context>-      <context attribute="Attribute" lineEndContext="#pop" name="hash-attribute-pre-inline" fallthrough="true" fallthroughContext="hash-attribute-inline">-        <IncludeRules context="default-attribute-pre-inline" />-        <RegExpr attribute="Alias" context="hash-attribute-inline" String="&alias;" />-        <RegExpr attribute="Reference" context="hash-attribute-inline" String="&reference;" />--        <AnyChar attribute="Operator" context="#pop" lookAhead="true" String=",}" />-        <IncludeRules context="values-inline" />-      </context>--      <!-- List -->-      <!-- Context "find-values-list" highlights values and then sends to "list-element" -->-      <context attribute="List" lineEndContext="#stay" name="list" fallthrough="true" fallthroughContext="#pop!find-values-list" noIndentationBasedFolding="true">-        <RegExpr attribute="Comment" context="comment" String="(?:^|\s+)#" />-        <DetectSpaces />-        <DetectChar attribute="Operator" context="#pop!find-values-list" char="?" />-      </context>-      <context attribute="List" lineEndContext="#stay" name="list-element" noIndentationBasedFolding="true">-        <RegExpr attribute="Comment" context="comment" String="(?:^|\s+)#" />--        <DetectChar attribute="Operator" context="#pop" char="]" endRegion="List" />-        <DetectChar attribute="Operator" context="list" char="[" beginRegion="List" />-        <DetectChar attribute="Operator" context="hash" char="{" beginRegion="Hash" />--        <RegExpr attribute="Key" context="dpoints-list-attribute-pre-inline" String="&dpointsListAttrPreInline1;|&dpointsListAttrPreInline2;|&dpointsListAttrPreInline3;|&dpointsListAttrPreInline4;"/>-        <RegExpr attribute="Key Points Operator" context="list-attribute-pre-inline" String=":(?=\s|$)" firstNonSpace="true" />--        <RegExpr attribute="Data Types" context="#stay" String="&dataTypes;" />-        <RegExpr attribute="Alias" context="#stay" String="&alias;" />-        <RegExpr attribute="Reference" context="#stay" String="&reference;" />-        <DetectChar attribute="String" context="string" char="'" beginRegion="String" />-        <DetectChar attribute="String" context="stringx" char="&quot;" beginRegion="String" />--        <DetectChar attribute="Operator" context="#pop!list" char="," />-        <IncludeRules context="values-list" />-      </context>--      <!-- Hash -->-      <context attribute="Hash" lineEndContext="#stay" name="hash" fallthrough="true" fallthroughContext="#pop!hash-element" noIndentationBasedFolding="true">-        <RegExpr attribute="Comment" context="comment" String="(?:^|\s+)#" />-        <DetectSpaces />-        <DetectChar attribute="Operator" context="#pop!hash-element" char="?" />-      </context>-      <context attribute="Hash" lineEndContext="#stay" name="hash-element" noIndentationBasedFolding="true">-        <RegExpr attribute="Comment" context="comment" String="(?:^|\s+)#" />-        <DetectSpaces/>--        <RegExpr attribute="Key" context="dpoints-hash-attribute-pre-inline" String="&dpointsHashAttrPreInline1;|&dpointsHashAttrPreInline2;|&dpointsHashAttrPreInline3;|&dpointsHashAttrPreInline4;"/>-        <RegExpr attribute="Key Points Operator" context="hash-attribute-pre-inline" String=":(?=\s|$)"/>--        <DetectChar attribute="Operator" context="#pop" char="}" endRegion="Hash" />-        <DetectChar attribute="Operator" context="#pop!hash" char="," />--        <!-- This improves highlighting in keys with multiple lines -->-        <RegExpr attribute="Data Types" context="#stay" String="&dataTypes;" />-        <RegExpr attribute="Alias" context="#stay" String="&alias;" />-        <RegExpr attribute="Reference" context="#stay" String="&reference;" />-        <DetectChar attribute="String" context="string" char="'" beginRegion="String" />-        <DetectChar attribute="String" context="stringx" char="&quot;" beginRegion="String" />-      </context>--      <!-- Strings -->-      <context attribute="String" lineEndContext="#stay" name="attribute-string" noIndentationBasedFolding="true">-        <DetectIdentifier />-        <IncludeRules context="escaped-char-singleq" />-        <DetectChar attribute="String" context="attribute-end" char="'" endRegion="String" />-      </context>--      <context attribute="String" lineEndContext="#stay" name="attribute-stringx" noIndentationBasedFolding="true">-        <DetectIdentifier />-        <IncludeRules context="escaped-char-doubleq" />-        <DetectChar attribute="String" context="attribute-end" char="&quot;" endRegion="String" />-      </context>--      <context attribute="String" lineEndContext="#stay" name="attribute-string-inline" noIndentationBasedFolding="true">-          <DetectIdentifier />-          <IncludeRules context="escaped-char-singleq" />-          <DetectChar attribute="String" context="attribute-end-inline" char="'" endRegion="String" />-      </context>--      <context attribute="String" lineEndContext="#stay" name="attribute-stringx-inline" noIndentationBasedFolding="true">-          <DetectIdentifier />-          <IncludeRules context="escaped-char-doubleq" />-          <DetectChar attribute="String" context="attribute-end-inline" char="&quot;" endRegion="String" />-      </context>--      <context attribute="Error" lineEndContext="#pop#pop#pop" name="attribute-end">-          <RegExpr attribute="Comment" context="comment" String="(?:^|\s+)#" />-          <DetectSpaces attribute="Normal Text" context="#stay"/>-      </context>--      <context attribute="Error" lineEndContext="#pop#pop#pop" name="attribute-end-inline">-          <RegExpr attribute="Comment" context="comment" String="(?:^|\s+)#" />-          <DetectSpaces attribute="Normal Text" context="#stay"/>-          <AnyChar context="#pop#pop#pop" lookAhead="true" String="}],"/>-      </context>--      <context attribute="String" lineEndContext="#stay" name="string" noIndentationBasedFolding="true">-        <DetectIdentifier />-        <IncludeRules context="escaped-char-singleq" />-        <DetectChar attribute="String" context="#pop" char="'" endRegion="String" />-      </context>--      <context attribute="String" lineEndContext="#stay" name="stringx" noIndentationBasedFolding="true">-        <DetectIdentifier />-        <IncludeRules context="escaped-char-doubleq" />-        <DetectChar attribute="String" context="#pop" char="&quot;" endRegion="String" />-      </context>--      <context attribute="Normal Text" lineEndContext="#stay" name="escaped-char-doubleq">-        <RegExpr attribute="Escaped Character" context="#stay" String="\\(?:[\s0abtnvfre&quot;/\\N_Lp]|x[a-fA-F0-9]{2}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{8})"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#stay" name="escaped-char-singleq">-        <Detect2Chars attribute="Escaped Character" context="#stay" char="'" char1="'" />-      </context>--      <context attribute="Comment" lineEndContext="#pop" name="comment">-        <DetectSpaces />-        <IncludeRules context="##Comments" />-      </context>--      <!-- Values -->-      <context attribute="Normal Text" lineEndContext="#stay" name="values">-        <RegExpr attribute="Null" context="#stay" String="&null;(?=&endValue;)"/>-        <RegExpr attribute="Boolean" context="#stay" String="&bool;(?=&endValue;)"/>-        <RegExpr attribute="Float" context="#stay" String="&allFloat;(?=&endValue;)"/>-        <RegExpr attribute="Integer" context="#stay" String="&allInt;(?=&endValue;)"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="values-firstnonspace">-        <RegExpr attribute="Null" firstNonSpace="true" context="#stay" String="&null;(?=&endValue;)"/>-        <RegExpr attribute="Boolean" firstNonSpace="true" context="#stay" String="&bool;(?=&endValue;)"/>-        <RegExpr attribute="Float" firstNonSpace="true" context="#stay" String="&allFloat;(?=&endValue;)"/>-        <RegExpr attribute="Integer" firstNonSpace="true" context="#stay" String="&allInt;(?=&endValue;)"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="values-inline">-        <RegExpr attribute="Null" context="#stay" String="&null;(?=&endValueInline;|&endValue;)"/>-        <RegExpr attribute="Boolean" context="#stay" String="&bool;(?=&endValueInline;|&endValue;)"/>-        <RegExpr attribute="Float" context="#stay" String="&allFloat;(?=&endValueInline;|&endValue;)"/>-        <RegExpr attribute="Integer" context="#stay" String="&allInt;(?=&endValueInline;|&endValue;)"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#stay" name="values-list">-        <RegExpr attribute="Null" context="#stay" String="(?:\s|^)&null;(?=&endValueInline;|&endValue;)"/>-        <RegExpr attribute="Boolean" context="#stay" String="(?:\s|^)&bool;(?=&endValueInline;|&endValue;)"/>-        <RegExpr attribute="Float" context="#stay" String="(?:\s|^)&allFloat;(?=&endValueInline;|&endValue;)"/>-        <RegExpr attribute="Integer" context="#stay" String="(?:\s|^)&allInt;(?=&endValueInline;|&endValue;)"/>-      </context>-      <!-- If the value is found immediately at the beginning of the list item -->-      <context attribute="Normal Text" lineEndContext="#pop!list-element" name="find-values-list" fallthrough="true" fallthroughContext="#pop!list-element">-        <RegExpr attribute="Null" context="#pop!list-element" String="&null;(?=&endValueInline;|&endValue;)"/>-        <RegExpr attribute="Boolean" context="#pop!list-element" String="&bool;(?=&endValueInline;|&endValue;)"/>-        <RegExpr attribute="Float" context="#pop!list-element" String="&allFloat;(?=&endValueInline;|&endValue;)"/>-        <RegExpr attribute="Integer" context="#pop!list-element" String="&allInt;(?=&endValueInline;|&endValue;)"/>-      </context>--      <!-- Literal/Folded Style: http://yaml.org/spec/1.2/spec.html#id2795688 -->--      <context attribute="Normal Text" lineEndContext="#stay" name="find-literal-block">-        <!-- Do not allow indentation with tabs: -->-        <RegExpr attribute="Alert" context="#stay" column="0"-                 String="^&space;*\t+\s*(?=(?:(?:&keyDQ;|&keySQ;|[^#])*[^#\w\|&lt;&gt;&quot;'])?&literalOp;&endValue;)" />--        <!-- CASE 1: The literal/folded operator is the first character of a line.-             The text after a space is considered literal.-             Ex:-             > |-             >  ^Start the literal text-        -->-        <RegExpr attribute="Literal/Folded Operator" context="literal-block-simple" column="0"-                 String="^&literalOp;(?=&endValue;)" beginRegion="Literal" />--        <!-- CASE 2: Only the literal/folded operator is present in a line, after a space (the indentation-             is captured). The text with the same indentation of the operator will be highlighted as literal.-             Ex:-             >  key:-             >    |-             >    ^Start the literal text--             However, in this case, the correct way is to use the indentation of the block, not the-             indentation of the the operator. The problem is that it is difficult to capture.-             >  key1:-             >   key2:-             >    key3:-             >          |-             >     ^Block indentation (correct literal text)-        -->-        <RegExpr attribute="Literal/Folded Operator" context="literal-block-only-operator" column="0"-                 String="^(&space;+)&literalOp;(?=&endValue;)" beginRegion="Literal" />--        <!-- CASE 3: There is a Key before the literal/folded operator (Key indentation is captured).-             The text with the Key's indentation plus a space is considered literal.-             Ex:-             >    key: |-             >     ^Start the literal text-             >  key: !!type >--             >   ^Start the folded text-        -->-        <RegExpr attribute="Key Points Operator" context="literal-block-key" column="0"-                 String="^(&space;*)\:(?=\s+(?:(?:&keyDQ;|&keySQ;|[^#])*[^#\w\|&lt;&gt;&quot;'])?&literalOp;&endValue;)" />-        <RegExpr attribute="Key" context="literal-block-key" column="0"-                 String="^(&space;*)(?:[^&quot;'#\-\?\s][^:#]*|\-(?:[^\s:#][^:#]*)?|&keyDQ;|&keySQ;)(?=\:\s+(?:(?:&keyDQ;|&keySQ;|[^#])*[^#\w\|&lt;&gt;&quot;'])?&literalOp;&endValue;)" />--        <!-- CASE 4: Is there an operator "?" or "-" at the beginning of the line.-             NOTE: Nested characters "-" and "?" are considered as part of the indentation.-             Therefore, the indentation of the Key or the last operator "?" or "-" is captured.-             Ex:-             >  ? |-             >   ^Start the literal Text-             >  ? - - |-             >       ^Start the literal text-             >  - Key: |-             >     ^Start the literal text-             >  ? - - - - Key: |-             >             ^Start the literal text-        -->-        <RegExpr context="start-literal-block-withdash" lookAhead="true" column="0"-                 String="^&space;*(?:\?&space;*|\-&space;+){1,6}(?:(?:&keyDQ;|&keySQ;|[^#\-\?\s]|\-[^\s#])(?:(?:&keyDQ;|&keySQ;|[^#])*[^#\w\|&lt;&gt;&quot;'])?)?&literalOp;&endValue;" />--        <!-- CASE 5: Literal/folded operator after a data type or other content.-             Ex:-             >  !!type |-             >   ^Start the literal text-             >  key1:-             >   key2:-             >    !!type |-             >    ^Start the literal text-        -->-        <RegExpr context="start-literal-block-other" lookAhead="true" column="0"-                 String="^&space;*(?:(?:[&amp;\*]|!!)\S+\s+)+&literalOp;&endValue;" />-      </context>--      <!-- If the line with the literal operator starts with the "-" or "?" operator.-           NOTE: The indentation capture is limited to 6 nested operators. -->-      <context attribute="Normal Text" lineEndContext="#pop" name="start-literal-block-withdash" noIndentationBasedFolding="true">-        <!-- With Key: Capture the Key indentation -->-        <RegExpr attribute="Operator" context="#pop!literal-block-key-withdash-s2" String="^(&space;*)[\?\-](&space;*)(?=&keyAfterOp;:\s)" column="0"/>-        <RegExpr attribute="Operator" context="#pop!literal-block-key-withdash-s3" String="^(&space;*)[\?\-](&space;*)[\?\-](&space;*)(?=&keyAfterOp;:\s)" column="0"/>-        <RegExpr attribute="Operator" context="#pop!literal-block-key-withdash-s4" String="^(&space;*)[\?\-](&space;*)[\?\-](&space;*)[\?\-](&space;*)(?=&keyAfterOp;:\s)" column="0"/>-        <RegExpr attribute="Operator" context="#pop!literal-block-key-withdash-s5" String="^(&space;*)[\?\-](&space;*)[\?\-](&space;*)[\?\-](&space;*)[\?\-](&space;*)(?=&keyAfterOp;:\s)" column="0"/>-        <RegExpr attribute="Operator" context="#pop!literal-block-key-withdash-s6" String="^(&space;*)[\?\-](&space;*)[\?\-](&space;*)[\?\-](&space;*)[\?\-](&space;*)[\?\-](&space;*)(?=&keyAfterOp;:\s)" column="0"/>-        <RegExpr attribute="Operator" context="#pop!literal-block-key-withdash-s7" String="^(&space;*)[\?\-](&space;*)[\?\-](&space;*)[\?\-](&space;*)[\?\-](&space;*)[\?\-](&space;*)[\?\-](&space;*)(?=&keyAfterOp;:\s)" column="0"/>-        <!-- Without Key: Capture the indentation of the last operator "?" or "-" -->-        <RegExpr attribute="Operator" context="#pop!literal-block-withdash-s1" String="^(&space;*)[\?\-]\s*(?=[^#\-\?\s]|\-[^\s#])" column="0"/>-        <RegExpr attribute="Operator" context="#pop!literal-block-withdash-s2" String="^(&space;*)[\?\-](&space;*)[\?\-]\s*(?=[^#\-\?\s]|\-[^\s#])" column="0"/>-        <RegExpr attribute="Operator" context="#pop!literal-block-withdash-s3" String="^(&space;*)[\?\-](&space;*)[\?\-](&space;*)[\?\-]\s*(?=[^#\-\?\s]|\-[^\s#])" column="0"/>-        <RegExpr attribute="Operator" context="#pop!literal-block-withdash-s4" String="^(&space;*)[\?\-](&space;*)[\?\-](&space;*)[\?\-](&space;*)[\?\-]\s*(?=[^#\-\?\s]|\-[^\s#])" column="0"/>-        <RegExpr attribute="Operator" context="#pop!literal-block-withdash-s5" String="^(&space;*)[\?\-](&space;*)[\?\-](&space;*)[\?\-](&space;*)[\?\-](&space;*)[\?\-]\s*(?=[^#\-\?\s]|\-[^\s#])" column="0"/>-        <RegExpr attribute="Operator" context="#pop!literal-block-withdash-s6" String="^(&space;*)[\?\-](&space;*)[\?\-](&space;*)[\?\-](&space;*)[\?\-](&space;*)[\?\-](&space;*)[\?\-]\s*(?=[^#\-\?\s]|\-[^\s#])" column="0"/>-      </context>-      <!-- Capture the indentation of data type, reference or alias  -->-      <context attribute="Normal Text" lineEndContext="#pop" name="start-literal-block-other" noIndentationBasedFolding="true">-        <!-- The text with the same indentation will be considered literal -->-        <RegExpr attribute="Data Types" context="#pop!literal-block-after-data" String="^(&space;+)&dataTypes;" column="0" />-        <RegExpr attribute="Alias" context="#pop!literal-block-after-data" String="^(&space;+)&alias;" column="0" />-        <RegExpr attribute="Reference" context="#pop!literal-block-after-data" String="^(&space;+)&reference;" column="0" />-        <!-- The text after a space will be considered literal (empty text is captured) -->-        <RegExpr attribute="Data Types" context="#pop!literal-block-withdash-s1" String="^()&dataTypes;" column="0" />-        <RegExpr attribute="Alias" context="#pop!literal-block-withdash-s1" String="^()&alias;" column="0" />-        <RegExpr attribute="Reference" context="#pop!literal-block-withdash-s1" String="^()&reference;" column="0" />-      </context>--      <!-- Highlight data/attribute before the literal operator (Note that if there is a line-           break within a string or bracket, the literal line will not be highlighted). -->-      <context attribute="Attribute" lineEndContext="#pop#pop" name="before-literal-operator" noIndentationBasedFolding="true">-        <RegExpr attribute="Literal/Folded Operator" context="#pop!end-literal-operator" String="&literalOp;(?=&endValue;)" beginRegion="Literal" />--        <RegExpr attribute="Error" context="#pop#pop" String="(?:[&amp;\*]|!!)\S*&literalOp;(?=&endValue;)" />-        <RegExpr attribute="Data Types" context="#stay" String="&dataTypes;" />-        <RegExpr attribute="Alias" context="#stay" String="&alias;" />-        <RegExpr attribute="Reference" context="#stay" String="&reference;" />--        <DetectChar attribute="Operator" context="list" char="[" beginRegion="List" />-        <DetectChar attribute="Operator" context="hash" char="{" beginRegion="Hash" />-        <DetectChar attribute="String" context="string" char="'" beginRegion="String" />-        <DetectChar attribute="String" context="stringx" char="&quot;" beginRegion="String" />-      </context>--      <context attribute="Normal Text" lineEndContext="#pop#pop" name="dpoints-key-before-literal-operator" fallthrough="true" fallthroughContext="#pop#pop" noIndentationBasedFolding="true">-        <DetectChar attribute="Key Points Operator" context="#pop!key-before-literal-operator" char=":" />-      </context>-      <context attribute="Attribute" lineEndContext="#pop#pop" name="key-before-literal-operator" noIndentationBasedFolding="true">-        <IncludeRules context="before-literal-operator" />-        <DetectChar attribute="Operator" context="#stay" char="?" />-      </context>-      <context attribute="Attribute" lineEndContext="#pop" name="end-literal-operator" noIndentationBasedFolding="true">-        <RegExpr attribute="Comment" context="#pop!comment" String="(?:^|\s+)#" />-      </context>--      <!-- Common rules for the content of the literal blocks -->-      <context attribute="Normal Text" lineEndContext="#stay" name="literal-block-default" noIndentationBasedFolding="true">-        <!-- End literal/folded block -->-        <RegExpr attribute="Normal Text" context="#pop" String="^\s*\S" lookAhead="true" column="0" endRegion="Literal" />-        <!-- Find literal/folded operator -->-        <RegExpr context="before-literal-operator" String="\S" lookAhead="true" />-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="literal-block-key-default" noIndentationBasedFolding="true">-        <!-- End literal/folded block -->-        <RegExpr attribute="Normal Text" context="#pop" String="^\s*\S" lookAhead="true" column="0" endRegion="Literal" />-        <!-- Detect Key before the literal/folded operator -->-        <RegExpr attribute="Key" context="dpoints-key-before-literal-operator" String="&keyAfterOp;(?=:\s)" />-        <RegExpr attribute="Normal Text" context="#pop" String="\S" lookAhead="true" endRegion="Literal" />-      </context>--      <!-- Content of the literal block: -->--      <!-- If the literal operator is starting the line (after a space, use block indentation) -->-      <context attribute="Normal Text" lineEndContext="#stay" name="literal-block-only-operator" dynamic="true" noIndentationBasedFolding="true">-        <RegExpr attribute="Literal/Folded Block" context="#stay" String="^%1.*$" dynamic="true" column="0" />--        <RegExpr attribute="Normal Text" context="#pop" String="^\s*\S" lookAhead="true" column="0" endRegion="Literal" />-        <RegExpr attribute="Comment" context="comment" String="(?:^|\s)#" />-        <RegExpr context="#pop" String="\S" lookAhead="true" endRegion="Literal" />-      </context>-      <!-- If the literal operator is the first character of a line (or after header) -->-      <context attribute="Normal Text" lineEndContext="#stay" name="literal-block-simple" noIndentationBasedFolding="true">-        <RegExpr attribute="Literal/Folded Block" context="#stay" String="^\s.*$" column="0" />--        <RegExpr attribute="Normal Text" context="#pop" String="^\s*\S" lookAhead="true" column="0" endRegion="Literal" />-        <RegExpr attribute="Comment" context="comment" String="(?:^|\s)#" />-      </context>-      <!-- If there is a data type or other content before the liretal operator (use block indentation) -->-      <context attribute="Normal Text" lineEndContext="#stay" name="literal-block-after-data" dynamic="true" noIndentationBasedFolding="true">-        <RegExpr attribute="Literal/Folded Block" context="#stay" String="^%1.*$" dynamic="true" column="0" />--        <RegExpr attribute="Normal Text" context="#pop" String="^\s*\S" lookAhead="true" column="0" endRegion="Literal" />-        <RegExpr context="before-literal-operator" String="\S" lookAhead="true" />-      </context>-      <!-- If there is a key before the literal operator -->-      <context attribute="Normal Text" lineEndContext="#stay" name="literal-block-key" dynamic="true" noIndentationBasedFolding="true">-        <RegExpr attribute="Literal/Folded Block" context="#stay" String="^%1\s.*$" dynamic="true" column="0" />--        <RegExpr attribute="Normal Text" context="#pop" String="^\s*\S" lookAhead="true" column="0" endRegion="Literal" />-        <!-- Attribute of the Key (the Key was previously highlighted) -->-        <RegExpr attribute="Key Points Operator" context="key-before-literal-operator" String=":\s" />-        <RegExpr context="key-before-literal-operator" String="\S" lookAhead="true" />-      </context>--      <!-- If there are dashes/"?" before the literal operator -->-      <context attribute="Normal Text" lineEndContext="#stay" name="literal-block-withdash-s1" dynamic="true" noIndentationBasedFolding="true">-        <RegExpr attribute="Literal/Folded Block" context="#stay" String="^%1\s.*$" dynamic="true" column="0" />-        <IncludeRules context="literal-block-default" />-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="literal-block-withdash-s2" dynamic="true" noIndentationBasedFolding="true">-        <RegExpr attribute="Literal/Folded Block" context="#stay" String="^%1%2&space;\s.*$" dynamic="true" column="0" />-        <IncludeRules context="literal-block-default" />-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="literal-block-withdash-s3" dynamic="true" noIndentationBasedFolding="true">-        <RegExpr attribute="Literal/Folded Block" context="#stay" String="^%1%2%3&space;{2}\s.*$" dynamic="true" column="0" />-        <IncludeRules context="literal-block-default" />-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="literal-block-withdash-s4" dynamic="true" noIndentationBasedFolding="true">-        <RegExpr attribute="Literal/Folded Block" context="#stay" String="^%1%2%3%4&space;{3}\s.*$" dynamic="true" column="0" />-        <IncludeRules context="literal-block-default" />-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="literal-block-withdash-s5" dynamic="true" noIndentationBasedFolding="true">-        <RegExpr attribute="Literal/Folded Block" context="#stay" String="^%1%2%3%4%5&space;{4}\s.*$" dynamic="true" column="0" />-        <IncludeRules context="literal-block-default" />-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="literal-block-withdash-s6" dynamic="true" noIndentationBasedFolding="true">-        <RegExpr attribute="Literal/Folded Block" context="#stay" String="^%1%2%3%4%5%6&space;{5}\s.*$" dynamic="true" column="0" />-        <IncludeRules context="literal-block-default" />-      </context>-      <!-- If there are dashes/"?" and a Key before the literal operator -->-      <context attribute="Normal Text" lineEndContext="#stay" name="literal-block-key-withdash-s2" dynamic="true" noIndentationBasedFolding="true">-        <RegExpr attribute="Literal/Folded Block" context="#stay" String="^%1%2&space;\s.*$" dynamic="true" column="0" />-        <IncludeRules context="literal-block-key-default" />-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="literal-block-key-withdash-s3" dynamic="true" noIndentationBasedFolding="true">-        <RegExpr attribute="Literal/Folded Block" context="#stay" String="^%1%2%3&space;{2}\s.*$" dynamic="true" column="0" />-        <IncludeRules context="literal-block-key-default" />-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="literal-block-key-withdash-s4" dynamic="true" noIndentationBasedFolding="true">-        <RegExpr attribute="Literal/Folded Block" context="#stay" String="^%1%2%3%4&space;{3}\s.*$" dynamic="true" column="0" />-        <IncludeRules context="literal-block-key-default" />-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="literal-block-key-withdash-s5" dynamic="true" noIndentationBasedFolding="true">-        <RegExpr attribute="Literal/Folded Block" context="#stay" String="^%1%2%3%4%5&space;{4}\s.*$" dynamic="true" column="0" />-        <IncludeRules context="literal-block-key-default" />-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="literal-block-key-withdash-s6" dynamic="true" noIndentationBasedFolding="true">-        <RegExpr attribute="Literal/Folded Block" context="#stay" String="^%1%2%3%4%5%6&space;{5}\s.*$" dynamic="true" column="0" />-        <IncludeRules context="literal-block-key-default" />-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="literal-block-key-withdash-s7" dynamic="true" noIndentationBasedFolding="true">-        <RegExpr attribute="Literal/Folded Block" context="#stay" String="^%1%2%3%4%5%6%7&space;{6}\s.*$" dynamic="true" column="0" />-        <IncludeRules context="literal-block-key-default" />-      </context>-    </contexts>--    <itemDatas>-      <itemData name="Normal Text" defStyleNum="dsAttribute" />-      <itemData name="Attribute" defStyleNum="dsAttribute" />-      <itemData name="List" defStyleNum="dsAttribute" />-      <itemData name="Hash" defStyleNum="dsAttribute" />-      <itemData name="Comment" defStyleNum="dsComment" />-      <itemData name="End of Document" defStyleNum="dsComment" />-      <itemData name="Document Header" defStyleNum="dsPreprocessor" />-      <itemData name="Data Types" defStyleNum="dsOthers" />-      <itemData name="Alias" defStyleNum="dsOthers" />-      <itemData name="Reference" defStyleNum="dsOthers" />-      <itemData name="Key" defStyleNum="dsFunction" bold="1" />-      <itemData name="Directive" defStyleNum="dsPreprocessor" />-      <itemData name="Key Points Operator" defStyleNum="dsKeyword" />-      <itemData name="Operator" defStyleNum="dsKeyword" />-      <itemData name="String" defStyleNum="dsString" />-      <itemData name="Escaped Character" defStyleNum="dsSpecialChar" />-      <itemData name="Literal/Folded Operator" defStyleNum="dsChar" bold="1" />-      <itemData name="Literal/Folded Block" defStyleNum="dsNormal" />-      <itemData name="Null" defStyleNum="dsChar" />-      <itemData name="Boolean" defStyleNum="dsChar" />-      <itemData name="Integer" defStyleNum="dsDecVal" />-      <itemData name="Float" defStyleNum="dsFloat" />-      <itemData name="Error" defStyleNum="dsError" />-      <itemData name="Alert" defStyleNum="dsAlert" backgroundColor="#EF9A9A" />-    </itemDatas>-  </highlighting>--  <general>-    <folding indentationsensitive="1" />-    <emptyLines>-      <emptyLine regexpr="(?:\s+|\s*#.*)"/>-    </emptyLines>-    <comments>-      <comment name="singleLine" start="#" position="afterwhitespace" />+  <!--+  https://yaml.org/spec/1.2.2/#1032-tag-resolution with extensions+  -->++  <!ENTITY tab            "&#9;">++  <!-- For correct highlight range between selected brackets... -->+  <!ENTITY listOpen "[">+  <!ENTITY listClose "]">+  <!ENTITY hashOpen "{">+  <!ENTITY hashClose "}">++  <!--+  @{ Literal+  -->+  <!ENTITY null "(?:null|Null|NULL|~)">+  <!ENTITY bool "(?:y|Y|yes|Yes|YES|n|N|no|No|NO|true|True|TRUE|false|False|FALSE|on|On|ON|off|Off|OFF)">++  <!ENTITY int         "[1-9](?:_*+[0-9]++)*+">+  <!-- Hex, Octal, Binary -->+  <!ENTITY intOther    "0(?:x(?:_*+[0-9a-fA-F]++)++|o(?:_*+[0-7]++)++|(?:_*+[0-7]++)*+|b(?:_*+[01]++)++)">+  <!ENTITY intBase60   "[1-9][0-9_]*(?::[0-5]?[0-9])+">+  <!ENTITY allInt      "[-+]?(?:&intBase60;|&intOther;|&int;)">++  <!ENTITY date           "[0-9]{4}-[0-9]{2}-[0-9]{2}">+  <!ENTITY time           "[0-9]{2}:[0-9]{2}:[0-9]{2}(?:\.[0-9]*)?">+  <!ENTITY time_canonical "T&time;Z?">+  <!ENTITY time_iso8601   "t&time;(?:[-+][0-9]+(?::[0-9]{2})?)?">+  <!ENTITY time_spaced    " +&time;(?: +[-+][0-9]+)?">+  <!ENTITY timestamp      "&date;(?:&time_canonical;|&time_iso8601;|&time_spaced;)?">++  <!ENTITY floatExp    "(?:[eE][-+]?[0-9]+)">+  <!ENTITY float1      "[0-9][0-9_]*+(?:&floatExp;|\.(?:_*+[0-9]++)*+(?:_*+&floatExp;)?)">+  <!ENTITY float2      "\._*+[0-9]++(?:_*+[0-9]++)*+(?:_*+&floatExp;)?">+  <!ENTITY floatBase60 "[0-9][0-9_]*(?::[0-5]?[0-9])+\.(?:_*+[0-9]++)*+">+  <!ENTITY inf         "\.(?:inf|Inf|INF)">+  <!ENTITY nan         "\.(?:nan|NaN|NAN)">+  <!ENTITY allFloat    "(?:[-+]?(?:&float1;|&float2;|&floatBase60;|&inf;)|&nan;)">++  <!ENTITY firstLitChar "nN~yYnNtTfFoO-+0123456789.">++  <!-- Key quoted -->+  <!ENTITY keyDQ          '"(?:\\.|[^"])*+"'>+  <!ENTITY keySQ          "'(?:[^']|'')*+'">++  <!ENTITY endValue       "(?:$|\s++(?:#|$))">+  <!ENTITY inlineSep      "[,\[\]{}]|:(?:\s|$)">+  <!ENTITY endValueInline "(?:$|&inlineSep;|\s++(?:#|$|&inlineSep;))">+  <!--+  @} Literal+  -->++  <!--+  @{ Key attribute+  - key: value+    ~~~+  -->+  <!ENTITY keyPlainData             "(?:[^: \t]++|:(?! |$)|[\t ]++(?!#))">+  <!ENTITY listKeyPlainData "(?:[^,{}\[\]?: \t]++|:(?! |$)|[\t ]++(?!#)|[?](?! |$))">+  <!ENTITY keyPlain "&keyPlainData;++">+  <!ENTITY isKeyPoint "(?=:(?: |$))">+  <!ENTITY isPlain "(?!['&quot;&#37;\&listClose;\&hashClose;])">+  <!ENTITY keyAttr "(?:&keyDQ;[\t ]*+|&keySQ;[\t ]*+|&isPlain;&keyPlain;)?+&isKeyPoint;">++  <!-- string attributes in a list or hash have an optional space after ':' (json compatibility) -->+  <!ENTITY keyAttrDQEnd  '"[\t ]*+&isKeyPoint;'>+  <!ENTITY jsonAttrDQEnd '"[\t ]*+(?=:)'>+  <!ENTITY keyAttrSQEnd  "'[\t ]*+&isKeyPoint;">+  <!ENTITY jsonAttrSQEnd "'[\t ]*+(?=:)">+  <!ENTITY keyDQWithEscape  '"[^"\\]*+(?:&keyAttrDQEnd;|(?=\\.(\\.|[^"])*+&keyAttrDQEnd;))'>+  <!ENTITY jsonDQWithEscape '"[^"\\]*+(?:&jsonAttrDQEnd;|(?=\\.(\\.|[^"])*+&jsonAttrDQEnd;))'>+  <!ENTITY keySQWithEscape  "'[^']*+(?:&keyAttrSQEnd;|(?=''(?:[^']|'')*+&keyAttrSQEnd;))">+  <!ENTITY jsonSQWithEscape "'[^']*+(?:&jsonAttrSQEnd;|(?=''(?:[^']|'')*+&jsonAttrSQEnd;))">++  <!ENTITY keyAttrWithEscape  "&keyDQWithEscape;|&keySQWithEscape;|&isPlain;&keyPlainData;++&isKeyPoint;">+  <!ENTITY jsonAttrWithEscape "&jsonDQWithEscape;|&jsonSQWithEscape;|&isPlain;&listKeyPlainData;++&isKeyPoint;">+  <!--+  @} Key attribute+  -->++  <!-- Detect indentation with at most 4 symbols:+       >  - - - - key: value+          ~ ~ ~ ~ symbols++  Indentation level:++  - -   key: value+          value+      # ^ final indent+  - -   value+       value+  # ^ final indent+  - -   |+              line 1+               line 2+           # ^ final indent+  # ^ minimal final indent++  Captures spaces at the start of a line as well as spaces between -, : and ?.+  The captures between symbols are in 2 parts:+  - a single space which replaces the symbol in the dynamic construction rules+  - and the spaces which follow++     -   -   - bla+  ~~~         capture 1+      ~   ~   capture 2 and 4+       ~~  ~~ capture 3 and 5+     ^   ^    replaced with capture 2 and 4 for dynamic indent++  The empty capture at the end is necessary to ensure+  that the number of captures is always at least 9.+  Otherwise, %N in dynamic rules are not replaced with empty string. -->+  <!ENTITY spaceAndOpPrefix "^( ++)(?![|>&#37;])&afterSpaceLookAheadPrefix;">+  <!ENTITY spaceAndOpNewPrefix "^( ++)&afterSpaceLookAheadPrefix;">+  <!ENTITY afterSpaceLookAheadPrefix "(?=[-:?](?: |$)|&keyAttrOrSeq;)&lookAheadPrefix;()">+  <!ENTITY opPrefix "^(?=[-:?](?: |$)|(?!---(?:$| )|\.\.\.(?:$| ))&keyAttr;)()&lookAheadPrefix;.()">+  <!ENTITY keyAttrOrSeq "(?:[\&listOpen;\&hashOpen;]|&keyAttr;)">+  <!ENTITY noLastAttrOp  "[-:?]( )( *+)(?=[-:?](?: |$))">+  <!ENTITY tooManySym    "[-:?] ++[-:?](?: |$)">+  <!ENTITY noLastAttrOps "(?:&noLastAttrOp;(?:&noLastAttrOp;(?:&noLastAttrOp;)?+)?+)?+">+  <!ENTITY lookAheadPrefix "(?=&noLastAttrOps;(?!&tooManySym;)(?:(?:[-:?]( ))?+( *+)&keyAttrOrSeq;)?+)">+  <!ENTITY indent  "&#37;1&#37;2&#37;2&#37;3&#37;4&#37;4&#37;5&#37;6&#37;6&#37;7&#37;8&#37;8&#37;9 ">++  <!ENTITY newValueContexts "BlockPrefix!ValueTextIndent!ExplicitValueIndent!ExplicitKeyTextIndent!KeyOrValueIndent!KeyOrValue">+]>++<!-- Author: Dr Orlovsky MA <maxim@orlovsky.info> //-->+<!-- Modifications (YAML 1.2), values & support for literal/folded style:+       Nibaldo González S. <nibgonz@gmail.com>+       These modifications are under the MIT license. //-->+<!-- https://yaml.org/spec/1.2.2/#chapter-4-syntax-conventions -->+<language name="YAML" alternativeNames="YML" version="18" kateversion="6.22" section="Markup"+          extensions="*.yaml;*.yml;.clang-format;.clang-tidy;metadata;*.ksy" mimetype="text/yaml;application/buildstream+yaml" priority="9"+          author="Dr Orlovsky MA (dr.orlovsky@gmail.com), Nibaldo González (nibgonz@gmail.com)" license="LGPL">+  <highlighting>+    <contexts>+      <context attribute="Normal Text" lineEndContext="#stay" name="normal" fallthroughContext="Lvl0Text">+        <IncludeRules context="FindSingleComment"/>++        <RegExpr attribute="Normal Text" context="&newValueContexts;" String="&spaceAndOpPrefix;" column="0"/>+        <AnyChar lookAhead="1" context="FindSpaces" String=" &tab;"/>+        <RegExpr lookAhead="1" context="&newValueContexts;" String="&opPrefix;" column="0"/>++        <AnyChar lookAhead="1" context="Lvl0Prefix" String="*!&amp;"/>+        <IncludeRules context="FindSeq"/>+        <IncludeRules context="FindStr"/>+        <AnyChar attribute="Literal/Folded Operator" context="Lvl0BlockPrefix!BlockHeader" String="|>" beginRegion="Block"/>+        <DetectChar attribute="Directive" context="Directive" char="%" column="0"/>+        <AnyChar lookAhead="1" context="Lvl0MaybeHeader" String="-" column="0"/>+        <AnyChar lookAhead="1" context="Lvl0SymIndent" String=":?"/>+        <AnyChar lookAhead="1" context="Lvl0MaybeEOD" String="." column="0"/>+        <AnyChar attribute="Error" context="Lvl0Text" String="%&listClose;&hashClose;"/>+        <AnyChar lookAhead="1" context="Lvl0Literal" String="&firstLitChar;"/>+      </context>++      <context name="FindSeq" attribute="Normal Text">+        <DetectChar attribute="Operator" context="List" char="&listOpen;" beginRegion="List"/>+        <DetectChar attribute="Operator" context="Hash" char="&hashOpen;" beginRegion="Hash"/>+      </context>++      <context name="FindStr" attribute="Normal Text">+        <DetectChar attribute="String" context="StringSq" char="'" beginRegion="String"/>+        <DetectChar attribute="String" context="StringDq" char='"' beginRegion="String"/>+      </context>+++      <!--+      @{ No indented text++      Normally, `lineEndContext` should be set to `#stay`,+      but this prevents the embedding of code blocks such as Markdown:++      ```+      text+      continuation (LvL0 context)+      ``` <- continuation also (LvL0 context, no top level context),++      This is not compliant and displays incorrectly in some cases:++      ```+      text+      [ a # should be text, not a list+      ```+      -->+      <context name="Lvl0Prefix" attribute="Normal Text" lineEndContext="#pop" fallthroughContext="Lvl0Text">+        <DetectSpaces/>+        <IncludeRules context="FindMarker"/>+        <IncludeRules context="FindSeq"/>+        <IncludeRules context="FindStr"/>+        <DetectChar attribute="Comment" context="#pop!comment" char="#"/>+        <AnyChar lookAhead="1" context="#pop!Lvl0Literal" String="&firstLitChar;"/>+        <AnyChar attribute="Literal/Folded Operator" context="#pop!Lvl0BlockPrefix!BlockHeader" String="|>" beginRegion="Block"/>+      </context>++      <context name="Lvl0Literal" attribute="Attribute" lineEndContext="#pop" fallthroughContext="Lvl0Text">+        <RegExpr attribute="Integer" context="#pop!Lvl0Text" String="&allInt;(?=&endValue;)"/>+        <RegExpr attribute="Boolean" context="#pop!Lvl0Text" String="&bool;(?=&endValue;)"/>+        <RegExpr attribute="Float" context="#pop!Lvl0Text" String="&allFloat;(?=&endValue;)"/>+        <RegExpr attribute="Null" context="#pop!Lvl0Text" String="&null;(?=&endValue;)"/>+        <RegExpr attribute="Timestamp" context="#pop!Lvl0Text" String="&timestamp;(?=&endValue;)"/>+      </context>++      <context name="Lvl0Text" attribute="Attribute" lineEndContext="#pop">+        <StringDetect attribute="Comment" context="#pop!comment" String="#" column="0"/>+        <StringDetect attribute="Comment" context="#pop!comment" String=" #"/>+        <StringDetect attribute="Comment" context="#pop!comment" String="&tab;#"/>+        <StringDetect attribute="Error" String=": "/>+        <StringDetect attribute="Error" String=":&tab;"/>+        <LineContinue attribute="Error" char=":"/>+      </context>++      <context name="Lvl0SymIndent" attribute="Normal Text" fallthroughContext="#pop" lineEndContext="#pop">+        <DetectSpaces/>+        <StringDetect attribute="Operator" String="- "/>+        <StringDetect attribute="Operator" String="-&tab;"/>+        <StringDetect attribute="Operator" String="? "/>+        <StringDetect attribute="Operator" String="?&tab;"/>+        <StringDetect attribute="Key Points Operator" String=": "/>+        <StringDetect attribute="Key Points Operator" String=":&tab;"/>+        <LineContinue lookAhead="1" context="Lvl0SymIndentEndLineOp" char="-"/>+        <LineContinue lookAhead="1" context="Lvl0SymIndentEndLineOp" char="?"/>+        <LineContinue lookAhead="1" context="Lvl0SymIndentEndLineKpOp" char=":"/>+        <RegExpr attribute="Key" String="&keyAttrWithEscape;" context="#pop"/>+      </context>+      <context name="Lvl0SymIndentEndLineOp" attribute="Attribute">+        <AnyChar attribute="Operator" context="#pop#pop" String="?-"/>+      </context>+      <context name="Lvl0SymIndentEndLineKpOp" attribute="Attribute">+        <StringDetect attribute="Operator" context="#pop#pop" String=":"/>+      </context>++      <context name="Lvl0MaybeHeader" attribute="Attribute" fallthroughContext="#pop!Lvl0Text">+        <RegExpr attribute="Document Header" context="#pop" String="^---( +|$)" column="0"/>+        <RegExpr attribute="Integer" context="#pop!Lvl0Text" String="&allInt;(?=&endValue;)"/>+        <RegExpr attribute="Float" context="#pop!Lvl0Text" String="&allFloat;(?=&endValue;)"/>+        <StringDetect attribute="Operator" context="#pop!Lvl0SymIndent" String="- "/>+        <StringDetect attribute="Operator" context="#pop!Lvl0SymIndent" String="-&tab;"/>+        <LineContinue lookAhead="1" context="Lvl0SymIndentEndLineOp" char="-"/>+      </context>++      <context name="Lvl0MaybeEOD" attribute="Attribute" fallthroughContext="#pop!Lvl0Text">+        <RegExpr attribute="End of Document" context="#pop!EOD" String="^\.\.\.($| +(?=#|$))" column="0"/>+        <RegExpr attribute="Float" context="#pop!Lvl0Text" String="&allFloat;(?=&endValue;)"/>+      </context>+      <!--+      @} No indented text+      -->+++      <!--+      @{ Find whitespace+      -->+      <context name="FindSpaces" attribute="Normal Text" lineEndContext="#pop" fallthroughContext="#pop">+        <StringDetect attribute="Normal Text" String=" "/>+        <StringDetect attribute="Alert" String="&tab;"/>+      </context>++      <context name="FindBlankLine" attribute="Attribute">+        <RegExpr String="^\s+(?=#|$)" column="0"/>+      </context>+      <!--+      @} Find whitespace+      -->+++      <!--+      @{ # ...+      -->+      <context attribute="Comment" lineEndContext="#pop" name="comment">+        <DetectSpaces/>+        <IncludeRules context="##Comments"/>+        <DetectIdentifier/>+      </context>++      <context name="FindSingleComment" attribute="Attribute">+        <DetectChar attribute="Comment" context="comment" char="#"/>+      </context>+      <!--+      @} # ...+      -->+++      <!--+      @{ '...'+      -->+      <context name="StringSq" attribute="String" noIndentationBasedFolding="true">+        <StringDetect attribute="Escaped Character" String="''"/>+        <DetectChar attribute="String" context="#pop" char="'" endRegion="String"/>+      </context>++      <context name="StringSqAsKey" attribute="Key" noIndentationBasedFolding="true">+        <StringDetect attribute="Escaped Character" String="''"/>+        <DetectChar attribute="Key" context="#pop" char="'" endRegion="String"/>+      </context>+      <!--+      @} '...'+      -->+++      <!--+      @{ "..."+      -->+      <context name="StringDq" attribute="String" noIndentationBasedFolding="true">+        <DetectChar lookAhead="true" context="EscapeDq" char="\"/>+        <DetectChar attribute="String" context="#pop" char="&quot;" endRegion="String"/>+      </context>++      <context name="StringDqAsKey" attribute="Key" noIndentationBasedFolding="true">+        <DetectChar lookAhead="true" context="EscapeDq" char="\"/>+        <DetectChar attribute="Key" context="#pop" char="&quot;" endRegion="String"/>+      </context>++      <context name="EscapeDq" attribute="Normal Text">+        <RegExpr attribute="Escaped Character" context="#pop" String="\\([0abtnvfre &tab;&quot;/\\N_LP]|x[a-fA-F0-9]{2}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{8}|$)"/>+        <RegExpr attribute="Error" context="#pop" String="\\(?:x[a-fA-F0-9]?|u[a-fA-F0-9]{0,3}|U[a-fA-F0-9]{0,7})?"/>+      </context>+      <!--+      @} "..."+      -->+++      <!--+      @{ KeyOrValue+        - ? xxx+        ~~~~+        key:+        ~~~~+      -->+      <context name="KeyOrValueIndent" attribute="Normal Text" fallthroughContext="#pop#pop#pop#pop#pop">+        <IncludeRules context="FindSingleComment"/>+        <RegExpr attribute="Normal Text" context="#pop#pop#pop#pop#pop!&newValueContexts;" String="&spaceAndOpNewPrefix;" column="0"/>+        <IncludeRules context="FindBlankLine"/>+        <StringDetect context="KeyOrValue" String="&indent;" dynamic="1" column="0"/>+      </context>++      <context name="KeyOrValue" attribute="Normal Text" lineEndContext="#pop"  fallthroughContext="#pop#pop#pop#pop!ValueText">+        <IncludeRules context="KeyOrValueCommonBase"/>+        <RegExpr attribute="Key" String="&keyAttrWithEscape;" context="#pop#pop#pop!KeyOrValueKey"/>+        <IncludeRules context="KeyOrValueCommonStr"/>+        <AnyChar lookAhead="1" String="-:?" context="KeyOrValueMaybeOp"/>+        <AnyChar lookAhead="1" context="#pop#pop#pop#pop!ValueLiteral" String="&firstLitChar;"/>+        <AnyChar attribute="Error" context="#pop#pop#pop#pop!ValueText" String="%&listClose;&hashClose;"/>+      </context>++      <context name="KeyOrValueAsKey" attribute="Normal Text" lineEndContext="#pop"  fallthroughContext="#pop#pop!ExplicitKeyText">+        <IncludeRules context="KeyOrValueCommonBase"/>+        <IncludeRules context="KeyOrValueCommonStr"/>+        <AnyChar String="-:?" lookAhead="1" context="KeyOrValueAsKeyMaybeOp"/>+        <AnyChar attribute="Error" context="#pop#pop!ExplicitKeyText" String="%&listClose;&hashClose;"/>+      </context>++      <context name="KeyOrValueKey" attribute="Key" fallthroughContext="StringDqAsKey!EscapeDq">+        <StringDetect String=":" attribute="Key Points Operator" context="#pop!ExplicitValuePrefix"/>+        <DetectSpaces attribute="Key"/>+        <StringDetect attribute="Escaped Character" context="StringSqAsKey" String="''"/>+      </context>++      <context name="KeyOrValueMaybeOp" attribute="Attribute">+        <IncludeRules context="KeyOrValueOp"/>+        <AnyChar lookAhead="1" context="#pop#pop#pop#pop!ValueLiteral" String="-"/>+        <AnyChar String="-:?" context="#pop#pop#pop#pop#pop!ValueText"/>+      </context>++      <context name="KeyOrValueAsKeyMaybeOp" attribute="Attribute">+        <IncludeRules context="KeyOrValueOp"/>+        <AnyChar String="-:?" context="#pop#pop#pop!ExplicitKeyText"/>+      </context>++      <context name="KeyOrValueOp" attribute="Attribute">+        <LineContinue attribute="Operator" context="#pop#pop" char="-"/>+        <LineContinue attribute="Operator" context="#pop#pop" char="?"/>+        <LineContinue attribute="Key Points Operator" context="#pop#pop" char=":"/>+      </context>++      <context name="KeyOrValueCommonBase" attribute="Attribute">+        <StringDetect attribute="Operator" String="- "/>+        <StringDetect attribute="Key Points Operator" context="#pop!KeyOrValue" String=": "/>+        <StringDetect attribute="Key Points Operator" context="#pop!KeyOrValue" String=":&tab;"/>+        <StringDetect attribute="Operator" context="#pop!KeyOrValueAsKey" String="? "/>+        <StringDetect attribute="Operator" context="#pop!KeyOrValueAsKey" String="?&tab;"/>++        <IncludeRules context="FindSpaces"/>++        <DetectChar attribute="Comment" context="#pop!comment" char="#"/>++        <IncludeRules context="FindMarker"/>++        <DetectChar attribute="Operator" context="ValueSepOrRoot!List" char="&listOpen;" beginRegion="List"/>+        <DetectChar attribute="Operator" context="ValueSepOrRoot!Hash" char="&hashOpen;" beginRegion="Hash"/>++        <AnyChar attribute="Literal/Folded Operator" context="#pop#pop#pop#pop#pop!BlockHeader" String="|>" beginRegion="Block"/>+      </context>++      <context name="KeyOrValueCommonStr" attribute="Attribute">+        <DetectChar attribute="String" context="ValueSepOrRoot!StringSq" char="'" beginRegion="String"/>+        <DetectChar attribute="String" context="ValueSepOrRoot!StringDq" char='"' beginRegion="String"/>+      </context>++      <context name="ValueSepOrRoot" attribute="Attribute" lineEndContext="#pop#pop#pop#pop#pop#pop#pop" fallthroughContext="#pop">+        <DetectSpaces/>+        <DetectChar attribute="Comment" context="#pop#pop#pop#pop#pop#pop#pop!comment" char="#"/>+        <StringDetect attribute="Key Points Operator" context="#pop#pop#pop#pop!ExplicitValuePrefix" String=": "/>+        <StringDetect attribute="Key Points Operator" context="#pop#pop#pop#pop!ExplicitValuePrefix" String=":&tab;"/>+        <LineContinue attribute="Key Points Operator" context="#pop#pop#pop#pop" char=":"/>+      </context>+      <!--+      @} KeyOrValue+      -->+++      <!--+      @{ marker (alias, reference, tag)+      https://yaml.org/spec/1.2.2/#6821-tag-handles+      https://yaml.org/spec/1.2.2/#692-node-anchors+      https://yaml.org/spec/1.2.2/#71-alias-nodes+      -->+      <context name="FindMarker" attribute="Attribute">+        <DetectChar char="*" attribute="Reference" context="Reference"/>+        <DetectChar char="&amp;" attribute="Alias" context="Alias"/>+        <DetectChar char="!" context="Tag" lookAhead="1"/>+      </context>++      <!-- &alias -->+      <context name="Alias" attribute="Alias" lineEndContext="#pop">+        <AnyChar String=" &tab;,[]{}:" lookAhead="1" context="#pop"/>+      </context>++      <!-- *ref -->+      <context name="Reference" attribute="Reference" lineEndContext="#pop">+        <IncludeRules context="Alias"/>+      </context>++      <context name="Tag" attribute="Attribute">+        <!-- ns_word_char = [-0-9a-zA-Z] -->+        <!-- named tag: !ns_word_char!ns_tag_char -->+        <!-- primary tag: !ns_tag_char -->+        <!-- secondary tag: !!ns_tag_char -->+        <!-- verbatim tag: !<ns_tag_char> -->+        <StringDetect String="!!" attribute="Data Types" context="SecondaryTag"/>+        <StringDetect String="!&lt;" attribute="Tag" context="VerbatimTag"/>+        <StringDetect String="!" attribute="Tag" context="PrimaryTag"/>+      </context>+      <context name="FindTagError" attribute="Tag">+        <StringDetect String="!!" attribute="Error" context="#pop!SecondaryTag"/>+        <StringDetect String="!&lt;" attribute="Error" context="#pop!VerbatimTag"/>+        <StringDetect String="!" attribute="Error" context="#pop!PrimaryTag"/>+      </context>+      <context name="PrimaryTag" attribute="Tag" lineEndContext="#pop#pop" fallthroughContext="#pop#pop">+        <IncludeRules context="ns_tag_char"/>+        <DetectChar char="!" attribute="Tag" context="#pop!NamedTag"/>+      </context>+      <context name="NamedTag" attribute="Tag" lineEndContext="#pop#pop" fallthroughContext="#pop#pop">+        <IncludeRules context="ns_tag_char"/>+        <IncludeRules context="FindTagError"/>+      </context>+      <context name="SecondaryTag" attribute="Data Types" lineEndContext="#pop#pop" fallthroughContext="#pop#pop">+        <IncludeRules context="ns_tag_char"/>+        <IncludeRules context="FindTagError"/>+      </context>+      <context name="VerbatimTag" attribute="Tag" lineEndContext="#pop#pop" fallthroughContext="#pop#pop">+        <IncludeRules context="ns_tag_char"/>+        <DetectChar char=">" attribute="Tag" context="#pop#pop"/>+        <IncludeRules context="FindTagError"/>+      </context>+      <context name="ns_tag_char" attribute="Tag">+        <!-- ns_tag_char + "^," -->+        <AnyChar String="-0123456789abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz%#;/?:@&amp;=+$_.~*'()^,"/>+      </context>+      <!--+      @} marker (alias, reference, tag)+      -->+++      <!--+      @{ | and >+      https://yaml.org/spec/1.2.2/#812-literal-style+      https://yaml.org/spec/1.2.2/#813-folded-style++      ```yaml+      - key:+              |+           text+      # ^ final indent (for current indent)+        # ^ final indent for block (last space)+      ```++      ```yaml+              |+           text+        # ^ final indent for block (last space)+      ```+      -->+      <!-- |1+ # dsds+            ~~~~~~~~~+      -->+      <context name="BlockHeader" attribute="Error" lineEndContext="#pop" fallthroughContext="BlockHeaderNoText">+        <AnyChar attribute="Literal/Folded Operator" String="-+123456789"/>+      </context>+      <context name="BlockHeaderNoText" attribute="Error" lineEndContext="#pop#pop">+        <DetectSpaces attribute="Literal/Folded Operator"/>+        <DetectChar attribute="Comment" context="#pop#pop!comment" char="#"/>+      </context>++      <context name="BlockPrefix" attribute="Literal/Folded Block" fallthroughContext="BlockEnd" noIndentationBasedFolding="true">+        <IncludeRules context="FindEmptyLine"/>+        <RegExpr context="BlockIndent!BlockText" String="^(&indent; *)" dynamic="1" column="0"/>+      </context>++      <context name="Lvl0BlockPrefix" attribute="Literal/Folded Block" fallthroughContext="BlockEnd" noIndentationBasedFolding="true">+        <IncludeRules context="FindEmptyLine"/>+        <RegExpr context="BlockIndent!BlockText" String="^( +)" column="0"/>+      </context>++      <context name="BlockIndent" attribute="Literal/Folded Block" fallthroughContext="#pop!BlockEnd" noIndentationBasedFolding="true">+        <StringDetect context="BlockText" String="%1" dynamic="1"/>+        <IncludeRules context="FindEmptyLine"/>+      </context>++      <context name="BlockText" attribute="Literal/Folded Block" lineEndContext="#pop">+      </context>++      <context name="BlockEnd" attribute="Literal/Folded Block">+        <RegExpr lookAhead="1" context="#pop#pop" String="." endRegion="Block"/>+      </context>++      <context name="FindEmptyLine" attribute="Attribute">+        <RegExpr String="^\s+$" column="0"/>+      </context>+      <!--+      @} | and >+      -->+++      <!--+      @{ Value++                   (fallthrough) -> root+                         ^+                        / \+         "ValueTextIndent!ExplicitValueIndent"+          ^         |            |          ^+      (endline)  (indent)     (indent)  (endline)+          |         v            v          |+          \____ ValueText <~.  ExplicitValuePrefix+                 |          |          |+           (fallthrough)    |    (fallthrough)+                 v          |          v+               root         +~~~~ ValueLiteral+                            |          |+                            \___ (fallthrough)+      -->+      <context name="ExplicitValueIndent" attribute="Normal Text" fallthroughContext="#pop#pop#pop">+        <IncludeRules context="FindSingleComment"/>+        <RegExpr attribute="Normal Text" context="#pop#pop#pop!&newValueContexts;" String="&spaceAndOpNewPrefix;" column="0"/>+        <IncludeRules context="FindBlankLine"/>+        <StringDetect context="ExplicitValuePrefix" String="&indent;" dynamic="1" column="0"/>+      </context>++      <context name="ExplicitValuePrefix" attribute="Normal Text" lineEndContext="#pop" fallthroughContext="#pop#pop!ValueText">+        <DetectSpaces/>+        <IncludeRules context="FindMarker"/>+        <DetectChar attribute="Comment" context="#pop!comment" char="#"/>++        <IncludeRules context="FindStr"/>+        <IncludeRules context="FindSeq"/>+        <AnyChar attribute="Literal/Folded Operator" context="#pop#pop#pop!BlockHeader" String="|>" beginRegion="Block"/>++        <StringDetect attribute="Operator" String="- "/>+        <StringDetect attribute="Operator" String="? "/>+        <StringDetect attribute="Operator" String="?&tab;"/>+        <LineContinue context="#pop" attribute="Operator" char="?"/>+        <LineContinue context="#pop" attribute="Operator" char="-"/>+        <AnyChar lookAhead="1" context="#pop#pop!ValueLiteral" String="&firstLitChar;"/>+        <AnyChar attribute="Error" context="#pop#pop!ValueText" String="%&listClose;&hashClose;"/>+      </context>+++      <context name="ValueLiteral" attribute="Attribute" fallthroughContext="#pop!ValueText">+        <RegExpr attribute="Integer" context="#pop!ValueText" String="&allInt;(?=&endValue;)"/>+        <RegExpr attribute="Boolean" context="#pop!ValueText" String="&bool;(?=&endValue;)"/>+        <RegExpr attribute="Float" context="#pop!ValueText" String="&allFloat;(?=&endValue;)"/>+        <RegExpr attribute="Null" context="#pop!ValueText" String="&null;(?=&endValue;)"/>+        <RegExpr attribute="Timestamp" context="#pop!ValueText" String="&timestamp;(?=&endValue;)"/>+      </context>+++      <context name="ValueTextIndent" attribute="Attribute" fallthroughContext="#pop#pop">+        <DetectChar attribute="Comment" context="#pop#pop!comment" char="#"/>+        <IncludeRules context="FindBlankLine"/>+        <StringDetect context="ValueText" String="&indent;" dynamic="1" column="0"/>+      </context>++      <context name="ValueText" attribute="Attribute" lineEndContext="#pop">+        <StringDetect attribute="Comment" context="#pop#pop#pop!comment" String="#" column="0"/>+        <StringDetect attribute="Comment" context="#pop#pop#pop!comment" String=" #"/>+        <StringDetect attribute="Comment" context="#pop#pop#pop!comment" String="&tab;#"/>+        <StringDetect attribute="Error" context="#pop#pop#pop" String=": "/>+        <StringDetect attribute="Error" context="#pop#pop#pop" String=":&tab;"/>+        <LineContinue attribute="Error" context="#pop#pop#pop" char=":"/>+      </context>+      <!--+      @} Value+      -->+++      <!--+      @{ Key++      '? ' key+      -->+      <context name="ExplicitKeyTextIndent" attribute="Key" fallthroughContext="#pop#pop#pop#pop#pop">+        <DetectChar attribute="Comment" context="#pop#pop#pop#pop#pop!comment" char="#"/>+        <IncludeRules context="FindBlankLine"/>+        <StringDetect context="ExplicitKeyText" String="&indent;" dynamic="1" column="0"/>+      </context>++      <context name="ExplicitKeyText" attribute="Key" lineEndContext="#pop">+        <StringDetect context="#pop#pop#pop#pop#pop#pop!comment" String="#" column="0"/>+        <StringDetect context="#pop#pop#pop#pop#pop#pop!comment" String=" #"/>+        <StringDetect context="#pop#pop#pop#pop#pop#pop!comment" String="&tab;#"/>+        <StringDetect attribute="Key Points Operator" context="#pop#pop!ExplicitValuePrefix" String=": "/>+        <StringDetect attribute="Key Points Operator" context="#pop#pop!ExplicitValuePrefix" String=":&tab;"/>+        <LineContinue lookAhead="1" context="ValueOnKeyOp" char=":"/>+      </context>++      <context name="ValueOnKeyOp" attribute="Attribute">+        <StringDetect String=":" attribute="Key Points Operator" context="#pop#pop#pop!ExplicitValuePrefix"/>+      </context>+      <!--+      @} Key+      -->+++      <!--+      @{ List and Hash+      -->++      <!-- [ ... ] -->+      <context name="List" attribute="List" fallthroughContext="ListValue" noIndentationBasedFolding="true">+        <DetectChar attribute="Operator" context="#pop" char="&listClose;" endRegion="List"/>+        <IncludeRules context="ElementCommon"/>+        <AnyChar attribute="Error" String=">|%&hashClose;"/>+      </context>++      <!-- { ... } -->+      <context name="Hash" attribute="Hash" fallthroughContext="HashValue" noIndentationBasedFolding="true">+        <DetectChar attribute="Operator" context="#pop" char="&hashClose;" endRegion="Hash"/>+        <IncludeRules context="ElementCommon"/>+        <AnyChar attribute="Error" String=">|%&listClose;"/>+      </context>++      <context name="ElementCommon" attribute="List">+        <DetectSpaces/>+        <DetectChar attribute="Operator" char=","/>+        <IncludeRules context="FindSingleComment"/>+        <IncludeRules context="FindSeq"/>+        <IncludeRules context="FindMarker"/>+        <StringDetect attribute="Operator" context="ListAttr" String=": "/>+        <StringDetect attribute="Operator" context="ListAttr" String=":&tab;"/>+        <LineContinue attribute="Operator" context="ListAttr" char=":"/>++        <RegExpr attribute="Key" context="ListKey" String="&jsonAttrWithEscape;"/>++        <IncludeRules context="FindStr"/>++        <StringDetect attribute="Operator" context="ListExplicitKey" String="? "/>+        <StringDetect attribute="Operator" context="ListExplicitKey" String="?&tab;"/>+        <LineContinue attribute="Operator" context="ListExplicitKey" char="?"/>++        <IncludeRules context="FindDashError"/>+      </context>++      <!-- [ - value ] / [ key: - value ] / { - value } / { key: - value }+             ~                  ~             ~                  ~+      -->+      <context name="FindDashError" attribute="Error" noIndentationBasedFolding="true">+        <StringDetect attribute="Error" String="- "/>+        <StringDetect attribute="Error" String="-&tab;"/>+        <LineContinue attribute="Error" char="-"/>+      </context>++      <!-- [ ? key ] / { ? key }+               ~~~         ~~~+      -->+      <context name="ListExplicitKey" attribute="Key" fallthroughContext="ListExplicitKeyName" noIndentationBasedFolding="true">+        <DetectSpaces/>+        <IncludeRules context="FindMarker"/>+        <IncludeRules context="FindDashError"/>+        <AnyChar lookAhead="1" context="#pop" String=",[]{}'&quot;"/>+        <AnyChar attribute="Error" String=">|"/>+      </context>++      <context name="ListExplicitKeyName" attribute="Key" noIndentationBasedFolding="true">+        <StringDetect attribute="Comment" context="#pop#pop!comment" String="#" column="0"/>+        <StringDetect attribute="Comment" context="#pop#pop!comment" String=" #"/>+        <StringDetect attribute="Comment" context="#pop#pop!comment" String="&tab;#"/>+        <AnyChar lookAhead="1" context="#pop#pop" String=",[]{}"/>+        <StringDetect attribute="Operator" context="#pop#pop!ListAttr" String=": "/>+        <StringDetect attribute="Operator" context="#pop#pop!ListAttr" String=":&tab;"/>+        <LineContinue attribute="Operator" context="#pop#pop!ListAttr" char=":"/>+        <StringDetect attribute="Error" context="#pop" String="? "/>+        <StringDetect attribute="Error" context="#pop" String="?&tab;"/>+        <LineContinue attribute="Error" context="#pop" char="?"/>+      </context>++      <!-- [ key: value ] / { key: value }+                ~                ~+      -->+      <context name="ListKey" attribute="Key" fallthroughContext="StringDqAsKey!EscapeDq" noIndentationBasedFolding="true">+        <StringDetect String=":" attribute="Key Points Operator" context="#pop!ListAttr"/>+        <DetectSpaces attribute="Key"/>+        <StringDetect attribute="Escaped Character" context="StringSqAsKey" String="''"/>+      </context>++      <!-- [ value ]+             ~~~~~+      -->+      <context name="ListValue" attribute="List" fallthroughContext="ListValueText" noIndentationBasedFolding="true">+        <IncludeRules context="ListExplicitKey"/>+        <RegExpr attribute="Integer" context="#pop" String="&allInt;(?=&endValueInline;)"/>+        <RegExpr attribute="Boolean" context="#pop" String="&bool;(?=&endValueInline;)"/>+        <RegExpr attribute="Float" context="#pop" String="&allFloat;(?=&endValueInline;)"/>+        <RegExpr attribute="Null" context="#pop" String="&null;(?=&endValueInline;)"/>+        <RegExpr attribute="Timestamp" context="#pop" String="&timestamp;(?=&endValueInline;)"/>+      </context>++      <context name="ListValueText" attribute="List" noIndentationBasedFolding="true">+        <StringDetect attribute="Comment" context="#pop#pop!comment" String="#" column="0"/>+        <StringDetect attribute="Comment" context="#pop#pop!comment" String=" #"/>+        <StringDetect attribute="Comment" context="#pop#pop!comment" String="&tab;#"/>+        <AnyChar lookAhead="1" context="#pop#pop" String=",[]{}"/>+        <StringDetect attribute="Error" context="#pop#pop!ListAttr" String=": "/>+        <StringDetect attribute="Error" context="#pop#pop!ListAttr" String=":&tab;"/>+        <LineContinue attribute="Error" context="#pop#pop!ListAttr" char=":"/>+        <StringDetect attribute="Error" context="#pop#pop!ListExplicitKey" String="? "/>+        <StringDetect attribute="Error" context="#pop#pop!ListExplicitKey" String="?&tab;"/>+        <LineContinue attribute="Error" context="#pop#pop!ListExplicitKey" char="?"/>+      </context>++      <!-- { value }+             ~~~~~+      -->+      <context name="HashValue" attribute="Hash" fallthroughContext="HashValueText" noIndentationBasedFolding="true">+        <IncludeRules context="ListExplicitKey"/>+      </context>+      <context name="HashValueText" attribute="Hash" noIndentationBasedFolding="true">+        <IncludeRules context="ListValueText"/>+      </context>++      <!-- [ key: value ] / { key: value }+                  ~~~~~            ~~~~~+      -->+      <context name="ListAttr" attribute="Attribute" fallthroughContext="ListAttrText" noIndentationBasedFolding="true">+        <IncludeRules context="ListValue"/>+      </context>++      <context name="ListAttrText" attribute="Attribute" noIndentationBasedFolding="true">+        <IncludeRules context="ListValueText"/>+      </context>+      <!--+      @} List and Hash+      -->+++      <context attribute="Error" lineEndContext="#stay" name="EOD">+        <DetectChar attribute="Comment" context="#pop!comment" char="#"/>+        <DetectChar attribute="Error" context="#pop!List" char="&listOpen;" beginRegion="List"/>+        <DetectChar attribute="Error" context="#pop!Hash" char="&hashOpen;" beginRegion="Hash"/>+        <DetectChar attribute="Error" context="#pop!StringSq" char="'" beginRegion="String"/>+        <DetectChar attribute="Error" context="#pop!StringDq" char='"' beginRegion="String"/>+      </context>++      <context attribute="Directive" lineEndContext="#pop" name="Directive">+      </context>++    </contexts>++    <itemDatas>+      <itemData name="Normal Text" defStyleNum="dsAttribute"/>+      <itemData name="Attribute" defStyleNum="dsAttribute"/>+      <itemData name="List" defStyleNum="dsAttribute"/>+      <itemData name="Hash" defStyleNum="dsAttribute"/>+      <itemData name="Comment" defStyleNum="dsComment"/>+      <itemData name="End of Document" defStyleNum="dsComment"/>+      <itemData name="Document Header" defStyleNum="dsPreprocessor"/>+      <itemData name="Data Types" defStyleNum="dsOthers"/>+      <itemData name="Tag" defStyleNum="dsOthers"/>+      <itemData name="Alias" defStyleNum="dsOthers"/>+      <itemData name="Reference" defStyleNum="dsOthers"/>+      <itemData name="Key" defStyleNum="dsFunction" bold="1"/>+      <itemData name="Directive" defStyleNum="dsPreprocessor"/>+      <itemData name="Key Points Operator" defStyleNum="dsKeyword"/>+      <itemData name="Operator" defStyleNum="dsKeyword"/>+      <itemData name="String" defStyleNum="dsString"/>+      <itemData name="Escaped Character" defStyleNum="dsSpecialChar"/>+      <itemData name="Literal/Folded Operator" defStyleNum="dsChar" bold="1"/>+      <itemData name="Literal/Folded Block" defStyleNum="dsNormal"/>+      <itemData name="Null" defStyleNum="dsChar"/>+      <itemData name="Boolean" defStyleNum="dsChar"/>+      <itemData name="Integer" defStyleNum="dsDecVal"/>+      <itemData name="Float" defStyleNum="dsFloat"/>+      <itemData name="Timestamp" defStyleNum="dsBaseN"/>+      <itemData name="Error" defStyleNum="dsError"/>+      <itemData name="Alert" defStyleNum="dsAlert" backgroundColor="#EF9A9A"/>+    </itemDatas>+  </highlighting>++  <general>+    <folding indentationsensitive="1"/>+    <emptyLines>+      <emptyLine regexpr="(?:\s+|\s*#.*)"/>+    </emptyLines>+    <comments>+      <comment name="singleLine" start="#" position="afterwhitespace"/>     </comments>     <keywords casesensitive="1"/>   </general>
xml/zig.xml view
@@ -7,7 +7,7 @@     <!ENTITY exp_float "(?:[eE][+-]?&dec_int;)">     <!ENTITY exp_hexfloat "(?:[pP][-+]?&dec_int;)"> ]>-<language name="Zig" section="Sources" version="3" kateversion="5.62" indenter="cstyle" extensions="*.zig" mimetype="text/x-zig" priority="1" author="Waqar Ahmed (waqar.17a@gmail.com)" license="MIT">+<language name="Zig" section="Sources" version="4" kateversion="5.62" indenter="cstyle" extensions="*.zig" mimetype="text/x-zig" priority="1" author="Waqar Ahmed (waqar.17a@gmail.com)" license="MIT">     <highlighting>         <list name="keywords">             <item>addrspace</item>@@ -234,6 +234,8 @@                 <keyword attribute="Control Flow" context="#stay" String="controlflow"/>                 <keyword attribute="Modifiers" context="#stay" String="modifiers"/>                 <WordDetect attribute="Self Variable" String="self"/>+                <DetectChar attribute="Symbol" context="#stay" char="{" beginRegion="Brace1" />+                <DetectChar attribute="Symbol" context="#stay" char="}" endRegion="Brace1" />                 <!-- <AnyChar context="SpecialType" String="iu" lookAhead="1"/> -->                 <DetectIdentifier/>             </context>
xml/zsh.xml view
@@ -1,2172 +1,2987 @@ <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE language [-        <!ENTITY tab      "&#009;">-        <!ENTITY funcname "[^&_fragpathseps;=]*+">-        <!ENTITY varname  "[A-Za-z_][A-Za-z0-9_]*">-        <!ENTITY eos      "(?=$|[ &tab;])">                 <!-- eol or space following -->-        <!ENTITY eoexpr   "(?=$|[ &tab;&lt;>|&amp;;)])">--        <!ENTITY substseps  "${}'&quot;`\\">-        <!ENTITY symbolseps "&lt;>|&amp;;()">-        <!ENTITY wordseps   " &tab;&symbolseps;">-        <!ENTITY wordseps_or_extglog " &tab;>|&amp;;)`"> <!-- wordseps without < and ( -->--        <!ENTITY bq_string  "`[^`]*+`">-        <!ENTITY sq_string  "'[^']*+'">-        <!ENTITY dq_string  "&quot;(?:[^&quot;\\`]*+|&bq_string;|\\.)*+&quot;">-        <!ENTITY strings    "(?:&sq_string;|&dq_string;|&bq_string;)">--        <!ENTITY simpleglob "*?#^~">-        <!ENTITY globrange  "&lt;[0-9]*-[0-9]*>">-        <!ENTITY globany    "\[(?:[^&wordseps;&quot;'`\\\[\]]+|\\.|&strings;|\[:\w+:\]|\[)*\]">--        <!ENTITY _fragpathseps  "&simpleglob;[&wordseps;&substseps;">-        <!ENTITY _fragpathnosep "(?:&_brace_noexpansion;)?+">-        <!ENTITY path        "(?:[^&_fragpathseps;]*+&_fragpathnosep;)*+">-        <!ENTITY fragpath    "(?:[^&_fragpathseps;/]*+&_fragpathnosep;)*+">-        <!ENTITY fragpathesc "\\.(?:[^&_fragpathseps;/]*+(?:\\.|&_brace_noexpansion;)?+)*+">-        <!ENTITY opt         "(?:[^&_fragpathseps;=/]*+&_fragpathnosep;)*+">-        <!ENTITY assumepath  "/&path;|(?=[&simpleglob;([]|&globrange;)">-        <!ENTITY pathpart    "(?:~(?:/&path;|(?=[&wordseps;]|$))|&fragpath;(?:&assumepath;|(?=&fragpathesc;&assumepath;))|\.\.?(?=[&wordseps;]|$))">--        <!-- Path only with / -->-        <!ENTITY path_with_sep_text  "[^[&wordseps;'&quot;`\\/]">-        <!ENTITY path_with_sep_text2 "[^[()&lt;>'&quot;`\\/]">-        <!ENTITY path_with_sep_expr  "\\.|&strings;|&globany;|&globrange;">-        <!ENTITY path_with_sep_spe   "(~|\.\.?)($|[/ &tab;&lt;>|&amp;;)])">-        <!ENTITY path_with_sep_sub   "\((&path_with_sep_text2;++|&path_with_sep_expr;)*+(\)|(?=/))">-        <!ENTITY path_with_sep "/|&path_with_sep_spe;|(&path_with_sep_text;++|&path_with_sep_expr;|&path_with_sep_sub;)*+/">--        <!ENTITY _braceexpansion_spe     " &tab;&lt;>|&amp;;{}\\`'&quot;$">-        <!ENTITY _brace_noexpansion      "\{[^&_braceexpansion_spe;,]*+\}">-        <!ENTITY _braceexpansion_var     "\$(?:\{[^\[\]&_braceexpansion_spe;]*+(?:\[[*@a-zA-Z0-9]\])\})?">-        <!ENTITY _braceexpansion_elems   "\\.|&strings;|&_braceexpansion_var;|&_brace_noexpansion;">-        <!ENTITY _braceexpansion_consume "&_braceexpansion_elems;|{(?:[^&_braceexpansion_spe;,]++|&_braceexpansion_elems;)*?}|(?R)?+">-        <!ENTITY _braceexpansion "(?:[^&_braceexpansion_spe;,]++|&_braceexpansion_consume;)*?,(?:[^&_braceexpansion_spe;]++|&_braceexpansion_consume;)*?}">-        <!ENTITY braceexpansion "{&_braceexpansion;">--        <!ENTITY _bracerangevar "\$([#+^=~]*([_a-zA-Z0-9]+|[*@#])(\[((\$[#+^=~]*)?([-+_a-zA-Z0-9]+|[*@])|$#)\])?|#|'(\\.|[^'\\])')">-        <!ENTITY _bracerangeoperand "-?([0-9]+|[a-zA-Z!#$&#37;*+,-./:=?@^_~]|&_bracerangevar;|\\.|'[^'\\]'|&quot;(\\.|[^&quot;\\`])&quot;|`[^`]*`)">-        <!ENTITY bracerangeexpansion "{(?=&_bracerangeoperand;\.\.&_bracerangeoperand;(\.\.-?([0-9]+|&_bracerangevar;))?})">--        <!ENTITY nobraceexpansion "(?:{([^&_braceexpansion_spe;/{},]++|(?R))+?})+">-        <!ENTITY nogroupend "(?:}+(?:[^&_fragpathseps;]|(?=[}$'&quot;`\\])))">--        <!-- glob with |, ( or spaces is a pattern -->-        <!ENTITY _ispattern_ugN "[ug][0123456789]+">-        <!ENTITY _ispattern_ugeP "[ugeP](?:&_ispattern_ugeP_0;|&_ispattern_ugeP_1;|&_ispattern_ugeP_2;|&_ispattern_ugeP_3;|&_ispattern_ugeP_4;|(?=\|))">-        <!ENTITY _ispattern_ugeP_0    ":(?:[^:'`&quot;\\|()]*+(?:&_ispattern_q;)?)*(?::|(?=[|()]))">-        <!ENTITY _ispattern_ugeP_1   "\[(?:[^]'`&quot;\\|()]*+(?:&_ispattern_q;)?)*(?:\](?=[|()]))">-        <!ENTITY _ispattern_ugeP_2    "{(?:[^}'`&quot;\\|()]*+(?:&_ispattern_q;)?)*(?:}(?=[|()]))">-        <!ENTITY _ispattern_ugeP_3 "&lt;(?:[^>'`&quot;\\|()]*+(?:&_ispattern_q;)?)*(?:>|(?=[|()]))">-        <!ENTITY _ispattern_ugeP_4  "([^&wordseps;{}'&quot;`\\])(?:(?:(?!\1)[^'`&quot;\\\1|()])*+(?:&_ispattern_q;)?)*(?:\1|(?=[|()]))">-        <!ENTITY _ispattern_q "\\.|&strings;">-        <!ENTITY _ispattern_check "(?:\)(?:[^ &tab;}&lt;>|&amp;;)]|&nogroupend;)|[ &tab;|(]|$)">-        <!ENTITY ispattern "(?:[^ &tab;\\'&quot;|()`ugeP]*+(?:&_ispattern_ugN;|&_ispattern_ugeP;|&_ispattern_q;)?)*&_ispattern_check;">--        <!ENTITY heredocq "(?|&quot;([^&quot;]+)&quot;|'([^']+)'|\\(.[^&wordseps;&substseps;]*))">--        <!ENTITY arithmetic_as_subshell "\(((?:[^`'&quot;()$]++|\$\{[^`'&quot;(){}$]+\}|\$(?=[^{`'&quot;()])|&bq_string;|\((?1)(?:[)]|(?=['&quot;])))++)(?:[)](?=$|[^)])|[&quot;'])">--        <!ENTITY unary_operators  "-[abcdefghknoprstuvwxzLOGNS](?=\\?$|[ &tab;])">-        <!ENTITY binary_operators "(?:-(?:e[fq]|[nolg]t|[nlg]e)|==?|!=)(?=\\?$|[ &tab;])">--        <!ENTITY dblbracket_close "\]\](?=($|[ &tab;;|&amp;)]))">--        <!ENTITY int "(?:[0-9]++[_0-9]*+)">-        <!ENTITY exp "(?:[eE][-+]?&int;)">-]>--<!---https://zsh.sourceforge.io/releases.html-current: 5.9--->--<language name="Zsh" version="34" kateversion="5.79" section="Scripts" extensions="*.sh;*.zsh;.zshrc;.zprofile;.zlogin;.zlogout;.profile" mimetype="application/x-shellscript" casesensitive="1" author="Jonathan Poelen (jonathan.poelen@gmail.com)" license="MIT">--  <highlighting>-    <list name="keywords">-      <item>continue</item>-      <item>break</item>-      <item>case</item>-      <item>do</item>-      <item>done</item>-      <item>elif</item>-      <item>else</item>-      <item>end</item>-      <item>esac</item>-      <item>fi</item>-      <item>for</item>-      <item>foreach</item>-      <item>function</item>-      <item>if</item>-      <item>in</item>-      <item>repeat</item>-      <item>return</item>-      <item>select</item>-      <item>then</item>-      <item>until</item>-      <item>while</item>-    </list>--<list name="builtins"><!-- see man zshbuiltins -->-	<item>-</item>-	<item>.</item>-	<item>:</item>-	<item>alias</item>-	<item>autoload</item>-	<item>bg</item>-	<item>bindkey</item>-	<item>builtin</item>-	<item>bye</item>-	<item>cap</item>-	<item>cd</item>-	<item>chdir</item>-	<item>clone</item>-	<item>command</item>-	<item>comparguments</item>-	<item>compcall</item>-	<item>compctl</item>-	<item>compdescribe</item>-	<item>compfiles</item>-	<item>compgroups</item>-	<item>compquote</item>-	<item>comptags</item>-	<item>comptry</item>-	<item>compvalues</item>-	<item>coproc</item>-	<item>dirs</item>-	<item>disable</item>-	<item>disown</item>-	<item>echo</item>-	<item>echotc</item>-	<item>echoti</item>-	<item>emulate</item>-	<item>enable</item>-	<item>eval</item>-	<item>exec</item>-	<item>exit</item>-	<item>false</item>-	<item>fc</item>-	<item>fg</item>-	<item>functions</item>-	<item>getcap</item>-	<item>hash</item>-	<item>history</item>-	<item>jobs</item>-	<item>kill</item>-	<item>limit</item>-	<item>log</item>-	<item>logout</item>-	<item>nocorrect</item>-	<item>noglob</item>-	<item>popd</item>-	<item>print</item>-	<item>printf</item>-	<item>pushd</item>-	<item>pushln</item>-	<item>pwd</item>-	<item>r</item>-	<item>rehash</item>-	<item>sched</item>-	<item>set</item>-	<item>setcap</item>-	<item>setopt</item>-	<item>shift</item>-	<item>source</item>-	<item>stat</item>-	<item>suspend</item>-	<item>test</item>-	<item>times</item>-	<item>trap</item>-	<item>true</item>-	<item>ttyctl</item>-	<item>type</item>-	<item>ulimit</item>-	<item>umask</item>-	<item>unalias</item>-	<item>unfunction</item>-	<item>unhash</item>-	<item>unlimit</item>-	<item>unset</item>-	<item>unsetopt</item>-	<item>vared</item>-	<item>wait</item>-	<item>whence</item>-	<item>where</item>-	<item>which</item>-	<item>zcompile</item>-	<item>zformat</item>-	<item>zftp</item>-	<item>zle</item>-	<item>zmodload</item>-	<item>zparseopts</item>-	<item>zprof</item>-	<item>zpty</item>-	<item>zregexparse</item>-	<item>zsocket</item>-	<item>zstyle</item>-	<item>ztcp</item>-    </list>--    <list name="builtins_var">-	<item>declare</item>-	<item>export</item>-	<item>float</item>-	<item>getln</item>-	<item>getopts</item>-	<item>integer</item>-	<item>let</item>-	<item>local</item>-	<item>read</item>-	<item>readonly</item>-	<item>typeset</item>-	<item>unset</item>-    </list>--    <list name="unixcommands">-      <include>unixcommands##Bash</include>-    </list>--    <contexts>-      <context attribute="Normal Text" lineEndContext="#stay" name="Start" fallthroughContext="Command">-        <DetectSpaces attribute="Normal Text" context="#stay"/>-        <DetectChar attribute="Comment" context="Comment" char="#"/>-        <!-- start expression in double parentheses -->-        <Detect2Chars context="ExprDblParenOrSubShell" char="(" char1="(" lookAhead="1"/>-        <!-- start a subshell -->-        <DetectChar attribute="Keyword" context="SubShell" char="(" beginRegion="subshell"/>-        <!-- start expression in single/double brackets -->-        <DetectChar context="MaybeBracketExpression" char="[" lookAhead="1"/>-        <!-- start a group command or BraceExpansion with { -->-        <DetectChar attribute="Keyword" context="Group" char="{" beginRegion="group"/>--        <!-- handle ` -->-        <DetectChar attribute="Backquote" context="CommandBackq" char="`"/>--        <!-- &> redirections -->-        <Detect2Chars attribute="Redirection" context="Prefix&amp;>" char="&amp;" char1=">"/>-        <Detect2Chars attribute="Control" context="#stay" char="&amp;" char1="!"/>--        <!-- handle branche conditions -->-        <Detect2Chars attribute="Control" context="#stay" char="&amp;" char1="&amp;"/>-        <Detect2Chars attribute="Control" context="#stay" char="|" char1="|"/>--        <!-- handle &, |, ; -->-        <AnyChar attribute="Control" context="#stay" String="&amp;|;"/>--        <!-- handle variable assignments -->-        <RegExpr attribute="Variable" context="VarAssign" String="&varname;(?=\+?=|\[(?:$|[^]]))|[0-9]+(?=\+?=)"/>-        <!-- handle keywords -->-        <keyword context="DispatchKeyword" String="keywords" lookAhead="1"/>-        <!-- handle commands that have variable names as argument -->-        <keyword attribute="Builtin" context="VarName" String="builtins_var" lookAhead="1"/>-        <WordDetect attribute="Builtin" context="#stay" String="noglob"/>-        <WordDetect attribute="Builtin" context="#stay" String="coproc"/>-        <!-- mark function definitions without function keyword -->-        <RegExpr attribute="Function" context="#stay" String="&funcname;[ &tab;]*\(\)"/>-        <keyword attribute="Builtin" context="CommandArgs" String="builtins"/>-        <keyword attribute="Command" context="CommandArgs" String="unixcommands"/>--        <!-- handle redirection -->-        <AnyChar context="CommandMaybeRedirection" String="&lt;&gt;0123456789" lookAhead="1"/>--        <DetectChar attribute="Error" context="#stay" char=")"/>-        <DetectChar context="MaybeGroupEnd" char="}" lookAhead="1"/>--        <LineContinue attribute="Escape" context="#stay"/>--        <Detect2Chars attribute="Expression" context="#stay" char="!" char1=" "/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="MaybeGroupEnd">-        <RegExpr context="#pop!Command" String="&nogroupend;" lookAhead="1"/>-        <DetectChar attribute="Error" context="#pop" char="}"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="MaybeBracketExpression" fallthroughContext="#pop!Command">-        <!-- start expression in double brackets -->-        <RegExpr attribute="Keyword" context="#pop!ExprDblBracket" String="\[\[(?=$|[ &tab;(])" beginRegion="expression"/>-        <!-- start expression in single brackets -->-        <RegExpr attribute="Builtin" context="#pop!ExprBracket" String="\[&eos;" beginRegion="expression"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="CommandMaybeRedirection" fallthroughContext="#pop!Command">-        <IncludeRules context="FindRedirection"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="Return" fallthroughContext="#pop">-        <DetectSpaces attribute="Normal Text" context="#stay"/>-        <Int attribute="Number" context="#stay"/>-      </context>-      <!-- Comment consumes shell comments till EOL -->-      <context attribute="Comment" lineEndContext="#pop" name="Comment">-        <DetectSpaces attribute="Comment"/>-        <IncludeRules context="##Comments"/>-        <DetectIdentifier attribute="Comment" context="#stay"/>-      </context>--      <!-- Group is called after a { is encountered -->-      <context attribute="Normal Text" lineEndContext="#stay" name="Group" fallthroughContext="Command">-        <DetectChar attribute="Keyword" context="#pop!GroupEnd" char="}" endRegion="group"/>-        <IncludeRules context="Start"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="GroupEnd" fallthroughContext="#pop!CommandArgs">-        <DetectSpaces attribute="Normal Text" context="#stay"/>-        <WordDetect attribute="Control Flow" context="#pop" String="always"/>-      </context>--      <context attribute="OtherCommand" lineEndContext="#pop" name="Command">-        <DetectSpaces attribute="Normal Text" context="#pop!CommandArgs"/>-        <DetectIdentifier attribute="OtherCommand" context="#stay"/>-        <DetectChar context="CommandVariables" char="$" lookAhead="1"/>-        <IncludeRules context="FindStrings"/>-        <Detect2Chars attribute="Control" context="#pop" char="&amp;" char1="&amp;"/>-        <Detect2Chars attribute="Control" context="#pop" char="|" char1="|"/>-        <DetectChar attribute="Control" context="#pop" char="|"/>-        <AnyChar context="#pop" String=";)`" lookAhead="1"/>-        <AnyChar context="#pop!CommandArgs" String="&amp;&lt;>" lookAhead="1"/>-        <!-- start expression in double parentheses -->-        <Detect2Chars attribute="Error" context="#pop!ExprDblParen" char="(" char1="(" beginRegion="expression"/>-        <!-- start a subshell -->-        <DetectChar attribute="Error" context="#pop!SubShell" char="(" beginRegion="subshell"/>-        <DetectChar context="CommandAssumeEscape" char="\" lookAhead="1"/>-        <DetectChar context="CommandMaybeBraceExpansion" char="{" lookAhead="1"/>-        <DetectChar context="CommandMaybeGroupEnd" char="}" lookAhead="1"/>-      </context>-      <context attribute="Command" lineEndContext="#pop" name="CommandVariables">-        <IncludeRules context="DispatchVariables"/>-        <DetectChar attribute="OtherCommand" context="#pop" char="$"/>-      </context>-      <context attribute="OtherCommand" lineEndContext="#pop" name="CommandAssumeEscape">-        <LineContinue attribute="Escape" context="#pop"/>-        <RegExpr attribute="OtherCommand" context="#pop" String="\\."/>-      </context>-      <context attribute="OtherCommand" lineEndContext="#pop" name="CommandMaybeBraceExpansion">-        <IncludeRules context="DispatchBraceExpansion"/>-        <DetectChar attribute="OtherCommand" context="#pop" char="{"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="CommandMaybeGroupEnd">-        <RegExpr attribute="OtherCommand" context="#pop" String="&nogroupend;+"/>-        <DetectChar context="#pop#pop" char="}" lookAhead="1"/>-      </context>--      <context attribute="Variable" lineEndContext="#pop" name="DispatchVariables">-        <IncludeRules context="DispatchSubstVariables"/>-        <IncludeRules context="DispatchStringVariables"/>-        <IncludeRules context="DispatchVarNameVariables"/>-      </context>-      <context attribute="Variable" lineEndContext="#pop" name="DispatchSubstVariables">-        <Detect2Chars attribute="Parameter Expansion" context="#pop!VarBraceStart" char="$" char1="{"/>-        <StringDetect context="#pop!ExprDblParenSubstOrSubstCommand" String="$((" lookAhead="1"/>-        <Detect2Chars attribute="Parameter Expansion" context="#pop!SubstCommand" char="$" char1="(" beginRegion="subshell"/>-      </context>-      <context attribute="Variable" lineEndContext="#pop" name="DispatchStringVariables">-        <Detect2Chars attribute="String SingleQ" context="#pop!StringEsc" char="$" char1="'"/>-        <Detect2Chars attribute="String Transl." context="#pop!StringDQ" char="$" char1="&quot;"/>-      </context>-      <context attribute="Variable" lineEndContext="#pop" name="DispatchVarNameVariables">-        <RegExpr attribute="Dollar Prefix" context="#pop!VarNamePrefixedWithDollar" String="\$(?=&varname;|[0-9]+|[-*@?$!#~=^+])"/>-      </context>-      <context attribute="Variable" lineEndContext="#pop" name="VarNamePrefixedWithDollar">-        <DetectIdentifier attribute="Variable" context="#pop!AfterVarName"/>-        <Int attribute="Variable" context="#pop!AfterVarName" additionalDeliminator="$"/>-        <AnyChar attribute="Variable" context="#pop!AfterVarName" String="-*@?$!"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarNameSubstLen" char="#"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarNameParam+" char="+"/>-        <AnyChar attribute="Parameter Expansion Operator" context="#pop!VarNameParam" String="~=^"/>-      </context>-      <context attribute="Variable" lineEndContext="#pop" name="VarNameSubstLen" fallthroughContext="#pop!AfterVarName">-        <DetectIdentifier attribute="Variable" context="#pop!AfterVarName"/>-        <AnyChar attribute="Variable" context="#pop!AfterVarName" String="-*@?$!"/>-        <Int attribute="Variable" context="#pop!AfterVarName" additionalDeliminator="#~=^+{}[]:-/$"/>-      </context>-      <context attribute="Variable" lineEndContext="#pop" name="VarNameParam" fallthroughContext="#pop!AfterVarName">-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarNameSubstLen" char="#"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarNameParam+" char="+"/>-        <AnyChar attribute="Parameter Expansion Operator" context="#stay" String="^=~"/>-        <IncludeRules context="VarNameSubstLen"/>-      </context>-      <context attribute="Variable" lineEndContext="#pop" name="VarNameParam+" fallthroughContext="#pop">-        <IncludeRules context="VarNameSubstLen"/>-      </context>--      <!-- called as soon as $xxx is encoutered -->-      <context attribute="Normal Text" lineEndContext="#pop" name="AfterVarName" fallthroughContext="#pop">-        <DetectChar context="VarNameDispatchModifiers" char=":" lookAhead="1"/>-        <DetectChar attribute="Parameter Expansion Operator" context="Subscript" char="["/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop#pop" name="VarNameDispatchModifiers" fallthroughContext="#pop#pop">-        <Detect2Chars attribute="Parameter Expansion" context="#pop" char=":" char1="a"/>-        <Detect2Chars attribute="Parameter Expansion" context="#pop" char=":" char1="A"/>-        <Detect2Chars attribute="Parameter Expansion" context="#pop" char=":" char1="c"/>-        <Detect2Chars attribute="Parameter Expansion" context="#pop" char=":" char1="e"/>-        <Detect2Chars attribute="Parameter Expansion" context="#pop!VarNameModifier_h" char=":" char1="h"/>-        <Detect2Chars attribute="Parameter Expansion" context="#pop" char=":" char1="l"/>-        <Detect2Chars attribute="Parameter Expansion" context="#pop" char=":" char1="p"/>-        <Detect2Chars attribute="Parameter Expansion" context="#pop" char=":" char1="P"/>-        <Detect2Chars attribute="Parameter Expansion" context="#pop" char=":" char1="q"/>-        <Detect2Chars attribute="Parameter Expansion" context="#pop" char=":" char1="Q"/>-        <Detect2Chars attribute="Parameter Expansion" context="#pop" char=":" char1="r"/>-        <Detect2Chars attribute="Parameter Expansion" context="#pop!VarNameModifier_s" char=":" char1="s"/>-        <Detect2Chars attribute="Parameter Expansion" context="#pop!VarNameModifier_h" char=":" char1="t"/>-        <Detect2Chars attribute="Parameter Expansion" context="#pop" char=":" char1="u"/>-        <Detect2Chars attribute="Parameter Expansion" context="#pop" char=":" char1="x"/>-        <Detect2Chars attribute="Parameter Expansion" context="#pop" char=":" char1="&amp;"/>-        <StringDetect attribute="Parameter Expansion" context="#pop!VarNameModifier_s" String=":gs"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop#pop" name="VarNameModifier_h" fallthroughContext="#pop">-        <AnyChar attribute="Number" context="#stay" String="0123456789"/>-      </context>-      <context attribute="Parameter Expansion Operator" lineEndContext="#pop#pop" name="VarNameModifier_s" fallthroughContext="#pop#pop">-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarNameModifier_s_Str" char="/"/>-      </context>-      <context attribute="String SingleQ" lineEndContext="#pop#pop" name="VarNameModifier_s_Str">-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarNameModifier_s_Rep" char="/"/>-        <DetectChar context="AssumeEscape" char="\" lookAhead="1"/>-        <DetectChar attribute="String DoubleQ" context="#pop" char="&quot;"/>-        <DetectChar attribute="String SingleQ" context="#pop" char="'"/>-      </context>-      <context attribute="String SingleQ" lineEndContext="#pop#pop" name="VarNameModifier_s_Rep">-        <DetectChar context="AssumeEscape" char="\" lookAhead="1"/>-        <IncludeRules context="FindWord"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="/"/>-        <AnyChar context="#pop#pop" String=" &tab;&lt;>|&amp;;()" lookAhead="1"/>-        <DetectIdentifier attribute="String SingleQ"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#stay" name="CommandBackq" fallthroughContext="Command">-        <DetectChar attribute="Backquote" context="#pop!CommandArgs" char="`"/>-        <DetectChar attribute="Comment" context="CommentBackq" char="#"/>-        <IncludeRules context="Start"/>-      </context>-      <!-- CommentBackq consumes shell comments till EOL or a backquote -->-      <context attribute="Comment" lineEndContext="#pop" name="CommentBackq">-        <DetectChar context="#pop" char="`" lookAhead="1"/>-        <IncludeRules context="Comment"/>-      </context>--      <!-- CommandArgs matches the items after a command -->-      <context attribute="Normal Text" lineEndContext="#pop" name="CommandArgs" fallthroughContext="CommandArg">-        <DetectSpaces attribute="Normal Text" context="#stay"/>--        <!-- &> redirections -->-        <Detect2Chars attribute="Redirection" context="Prefix&amp;>" char="&amp;" char1=">"/>--        <!-- handle &, |, ;, ` -->-        <AnyChar context="#pop" String="&amp;|;`" lookAhead="1"/>--        <!-- handle process subst -->-        <Detect2Chars attribute="Redirection" context="ProcessSubst" char="=" char1="("/>-        <!-- handle redirection -->-        <AnyChar context="CommandArgMaybeRedirection" String="&gt;&lt;0123456789" lookAhead="1"/>--        <DetectChar context="#pop" char=")" lookAhead="1"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop#pop" name="CommandArg" fallthroughContext="#pop!NormalOption">-        <!-- In command arguments, do not allow comments after escaped characters.-             This avoids highlighting comments within paths or other text. Ex: pathtext\ #no\ comment -->-        <DetectChar context="#pop#pop" char="#" lookAhead="1"/>-        <Detect2Chars attribute="Option" context="#pop!LongOption" char="-" char1="-"/>-        <DetectChar attribute="Option" context="#pop!ShortOption" char="-"/>-        <DetectChar attribute="Keyword" context="#pop!NormalOption" char="="/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="CommandArgMaybeRedirection" fallthroughContext="#pop!NormalOption">-        <IncludeRules context="FindRedirection"/>-      </context>--      <context attribute="Option" lineEndContext="#pop" name="ShortOption" fallthroughContext="#pop">-        <DetectChar attribute="Path" context="PathThenPop" char="/"/>-        <IncludeRules context="LongOption"/>-      </context>-      <context attribute="Option" lineEndContext="#pop" name="LongOption" fallthroughContext="#pop">-        <AnyChar context="#pop" String="&wordseps_or_extglog;" lookAhead="1"/>-        <DetectChar attribute="Operator" context="#pop!NormalOption" char="="/>-        <IncludeRules context="FindWord"/>-        <IncludeRules context="FindSingleGlob"/>-        <IncludeRules context="FindGlobAny"/>-        <AnyChar context="#pop!NormalOption" String="({}&lt;" lookAhead="1"/>-        <RegExpr attribute="Option" context="#stay" String="&opt;"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="NormalOption" fallthroughContext="#pop">-        <AnyChar context="#pop" String="&wordseps_or_extglog;" lookAhead="1"/>-        <IncludeRules context="FindWord"/>-        <DetectChar attribute="Glob" context="PathThenPop" char="[" lookAhead="1"/>-        <DetectChar context="ExprGlobParenThenPath" char="(" lookAhead="1"/>-        <IncludeRules context="FindPathThenPop"/>-        <DetectChar context="NormalOptionMaybeBraceExpansion" char="{" lookAhead="1"/>-        <DetectChar context="NormalOptionMaybeGroupEnd" char="}" lookAhead="1"/>-        <IncludeRules context="FindNormalTextOption"/>-        <DetectChar context="MaybeGlobRangeOrPop" char="&lt;" lookAhead="1"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop#pop" name="NormalOptionRecBrace">-        <AnyChar context="#pop#pop" String="&wordseps_or_extglog;" lookAhead="1"/>-        <IncludeRules context="FindWord"/>-        <IncludeRules context="FindSingleGlob"/>-        <IncludeRules context="FindGlobAny"/>-        <DetectChar context="ExprGlobParen" char="(" lookAhead="1"/>-        <DetectChar context="NormalOptionMaybeBraceExpansion" char="{" lookAhead="1"/>-        <DetectChar attribute="Normal Text" context="#pop" char="}"/>-        <DetectChar context="MaybeGlobRangeOrPop" char="&lt;" lookAhead="1"/>-        <DetectIdentifier/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="NormalOptionMaybeGroupEnd">-        <IncludeRules context="FindNoGroupEndThenPop"/>-        <DetectChar context="#pop#pop#pop" char="}" lookAhead="1"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="FindNoGroupEndThenPop">-        <RegExpr context="#pop" String="&nogroupend;"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="FindNormalTextOption">-        <RegExpr attribute="Normal Text" context="#stay" String="([^[&wordseps;&substseps;]+|&nogroupend;)+"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="NormalOptionMaybeBraceExpansion">-        <IncludeRules context="DispatchBraceExpansion"/>-        <DetectChar attribute="Normal Text" context="#pop!NormalOptionRecBrace" char="{"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#pop" name="AssumeEscape">-        <LineContinue attribute="Escape" context="#pop"/>-        <RegExpr attribute="Escape" context="#pop" String="\\."/>-      </context>--<!-- ====== The following rulessets are meant to be included ======== -->--      <!-- FindRedirection consumes shell redirection -->-      <context attribute="Normal Text" lineEndContext="#pop" name="FindRedirection">-        <RegExpr attribute="File Descriptor" context="#pop!AssumeRedirection" String="[0-9]++(?=[&lt;>])"/>-        <IncludeRules context="AssumeRedirection"/>-      </context>--      <!-- DispatchBraceExpansion consumes brace expansions -->-      <context attribute="Normal Text" lineEndContext="#pop" name="DispatchBraceExpansion">-        <RegExpr context="#pop!BraceExpansion" String="&braceexpansion;" lookAhead="1"/>-        <IncludeRules context="IncBraceExpansion"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="DispatchPathBraceExpansion">-        <RegExpr context="#pop!PathBraceExpansion" String="&braceexpansion;" lookAhead="1"/>-        <IncludeRules context="IncBraceExpansion"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="IncBraceExpansion">-        <RegExpr attribute="Escape" context="#pop!SequenceExpression" String="&bracerangeexpansion;"/>-        <RegExpr context="#pop" String="&nobraceexpansion;"/>-      </context>--      <!-- FindPathThenPop consumes path -->-      <context attribute="Normal Text" lineEndContext="#pop" name="FindPathThenPop">-        <AnyChar attribute="Glob" context="PathThenPop" String="?*#^"/>-        <RegExpr attribute="Path" context="PathThenPop" String="&pathpart;"/>-        <DetectChar attribute="Glob" context="PathThenPop" char="~"/>-      </context>-      <context attribute="Path" lineEndContext="#pop#pop" name="IncPath">-        <IncludeRules context="FindWord"/>-        <IncludeRules context="FindSingleGlob"/>-        <IncludeRules context="FindGlobAny"/>-        <DetectChar context="ExprGlobParen" char="(" lookAhead="1"/>-        <RegExpr attribute="Path" context="#stay" String="&path;"/>-        <DetectChar context="MaybeGlobRangeOrPop" char="&lt;" lookAhead="1"/>-        <DetectChar context="PathMaybeBraceExpansion" char="{" lookAhead="1"/>-      </context>-      <context attribute="Path" lineEndContext="#pop#pop" name="PathThenPop">-        <AnyChar context="#pop#pop" String="&wordseps_or_extglog;" lookAhead="1"/>-        <IncludeRules context="IncPath"/>-        <DetectChar context="PathMaybeGroupEnd" char="}" lookAhead="1"/>-        <DetectIdentifier attribute="Path"/>-      </context>-      <context attribute="Path" lineEndContext="#pop" name="PathRecBrace">-        <AnyChar context="#pop" String="&wordseps_or_extglog;" lookAhead="1"/>-        <IncludeRules context="IncPath"/>-        <DetectChar attribute="Path" context="#pop" char="}"/>-        <DetectIdentifier attribute="Path"/>-      </context>-      <context attribute="Glob" lineEndContext="#stay" name="MaybeGlobRangeOrPop" fallthroughContext="#pop#pop">-        <IncludeRules context="FindGlobRangeThenPop"/>-      </context>-      <context attribute="Path" lineEndContext="#pop" name="PathMaybeBraceExpansion">-        <IncludeRules context="DispatchPathBraceExpansion"/>-        <DetectChar attribute="Path" context="#pop!PathRecBrace" char="{"/>-      </context>-      <context attribute="Path" lineEndContext="#pop" name="PathMaybeGroupEnd">-        <IncludeRules context="FindNoGroupEndThenPop"/>-        <DetectChar context="#pop#pop#pop" char="}" lookAhead="1"/>-      </context>-      <context attribute="Glob" lineEndContext="#stay" name="FindGlobRangeThenPop">-        <RegExpr attribute="Glob" context="#pop!InGlobRange" String="&lt;(?=[0-9]*-[0-9]*>)"/>-      </context>-      <context attribute="Number" lineEndContext="#stay" name="InGlobRange">-        <AnyChar attribute="Number" context="#stay" String="0123456789"/>-        <DetectChar attribute="Glob" context="#stay" char="-"/>-        <DetectChar attribute="Glob" context="#pop" char=">"/>-      </context>--      <!-- FindPathThenPopInAlternateValue consumes path in ${xx:here}-->-      <context attribute="Normal Text" lineEndContext="#pop" name="FindPathThenPopInAlternateValue">-        <AnyChar attribute="Glob" context="PathThenPopInAlternateValue" String="&simpleglob;|"/>-        <Detect2Chars context="PathThenPopInAlternateValue" char="(" char1="#" lookAhead="1"/>-        <AnyChar context="PathThenPopInAlternateValue" String="[(" lookAhead="1"/>-        <RegExpr attribute="Path" context="PathThenPopInAlternateValue" String="&pathpart;"/>-      </context>-      <context attribute="Path" lineEndContext="#pop" name="PathThenPopInAlternateValue">-        <AnyChar context="#pop" String="&wordseps_or_extglog;}" lookAhead="1"/>-        <IncludeRules context="IncPath"/>-        <DetectIdentifier/>-      </context>--      <context attribute="Glob" lineEndContext="#stay" name="FindGlobAny">-        <DetectChar attribute="Glob" context="GlobAnyFlag" char="["/>-      </context>-      <context attribute="String SingleQ" lineEndContext="#pop" name="GlobAnyFlag" fallthroughContext="#pop!GlobAny">-        <DetectChar attribute="Glob Flag" context="#pop!GlobAny" char="^"/>-      </context>-      <context attribute="String SingleQ" lineEndContext="#pop" name="GlobAny">-        <DetectIdentifier attribute="String SingleQ"/>-        <DetectChar context="AssumeEscape" char="\" lookAhead="1"/>-        <DetectChar attribute="Glob Flag" context="#stay" char="-"/>-        <IncludeRules context="FindStrings"/>-        <DetectChar attribute="Glob" context="#pop" char="]"/>-        <Detect2Chars attribute="Glob" context="GlobClass" char="[" char1=":"/>-      </context>-      <context attribute="Glob" lineEndContext="#pop#pop" name="GlobClass">-        <DetectIdentifier attribute="Pattern"/>-        <Detect2Chars attribute="Glob" context="#pop" char=":" char1="]"/>-        <DetectChar attribute="Error" context="#pop" char="]"/>-      </context>--      <context attribute="Pattern" lineEndContext="#stay" name="FindSingleGlob">-        <AnyChar attribute="Glob" context="#stay" String="&simpleglob;"/>-      </context>--      <context attribute="Pattern" lineEndContext="#stay" name="FindGlobPattern">-        <AnyChar attribute="Glob" context="#stay" String="&simpleglob;|"/>-        <IncludeRules context="FindGlobAny"/>-        <IncludeRules context="FindGroupPattern"/>-      </context>--      <context attribute="Pattern" lineEndContext="#stay" name="FindPattern">-        <IncludeRules context="FindGlobPattern"/>-        <DetectChar context="GlobRangeOrError" char="&lt;" lookAhead="1"/>-      </context>-      <context attribute="Glob" lineEndContext="#stay" name="GlobRangeOrError">-        <IncludeRules context="FindGlobRangeThenPop"/>-        <DetectChar attribute="Error" context="#pop" char="&lt;"/>-      </context>--      <context attribute="Pattern" lineEndContext="#stay" name="FindSubPattern">-        <IncludeRules context="FindGlobPattern"/>-        <DetectChar context="GlobRangeOrPattern" char="&lt;" lookAhead="1"/>-      </context>-      <context attribute="Pattern" lineEndContext="#stay" name="GlobRangeOrPattern">-        <IncludeRules context="FindGlobRangeThenPop"/>-        <DetectChar attribute="Pattern" context="#pop" char="&lt;"/>-      </context>--      <context attribute="Pattern" lineEndContext="#stay" name="FindStringDQPattern">-        <IncludeRules context="FindGlobPattern"/>-        <DetectChar context="GlobRangeOrStringDQ" char="&lt;" lookAhead="1"/>-      </context>-      <context attribute="String DoubleQ" lineEndContext="#stay" name="GlobRangeOrStringDQ">-        <IncludeRules context="FindGlobRangeThenPop"/>-        <DetectChar attribute="String DoubleQ" context="#pop" char="&lt;"/>-      </context>--      <context attribute="Glob Flag" lineEndContext="#stay" name="FindGroupPattern">-        <Detect2Chars attribute="Glob Flag" context="GlobPatFlag" char="(" char1="#"/>-        <DetectChar attribute="Glob" context="ExtGlobPattern" char="("/>-      </context>-      <context attribute="Pattern" lineEndContext="#stay" name="ExtGlobPattern">-        <DetectChar attribute="Glob" context="#pop" char=")"/>-        <IncludeRules context="FindWord"/>-        <IncludeRules context="FindSubPattern"/>-        <DetectIdentifier attribute="Pattern"/>-      </context>-      <context attribute="Pattern" lineEndContext="#stay" name="ExtGlobPatternThenPath">-        <DetectChar attribute="Glob" context="#pop!PathThenPop" char=")"/>-        <IncludeRules context="FindWord"/>-        <IncludeRules context="FindSubPattern"/>-        <DetectIdentifier attribute="Pattern"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#pop" name="VarAssign" fallthroughContext="#pop">-        <DetectChar attribute="Parameter Expansion Operator" context="Subscript" char="["/>-        <DetectChar attribute="Operator" context="#pop!Assign" char="="/>-        <Detect2Chars attribute="Operator" context="#pop!Assign" char="+" char1="="/>-      </context>--      <context attribute="Normal Text" lineEndContext="#pop" name="DispatchKeyword">-        <!-- match do and if blocks -->-        <Detect2Chars attribute="Control Flow" context="#pop!NotCond" char="i" char1="f" beginRegion="if"/>-        <Detect2Chars attribute="Control Flow" context="#pop" char="f" char1="i" endRegion="if"/>-        <StringDetect attribute="Control Flow" context="#pop" String="done" endRegion="do"/>-        <Detect2Chars attribute="Control Flow" context="#pop" char="d" char1="o" beginRegion="do"/>-        <!-- handle while/until as a special case -->-        <StringDetect attribute="Control Flow" context="#pop!NotCond" String="while"/>-        <StringDetect attribute="Control Flow" context="#pop!NotCond" String="until"/>-        <!-- handle for as a special case -->-        <StringDetect attribute="Control Flow" context="#pop!Foreach" String="foreach"/>-        <StringDetect attribute="Control Flow" context="#pop!For" String="for"/>-        <!-- handle select as a special case -->-        <StringDetect attribute="Control Flow" context="#pop!Select" String="select"/>-        <StringDetect attribute="Control Flow" context="#pop!Repeat" String="repeat"/>-        <!-- handle case as a special case -->-        <StringDetect attribute="Control Flow" context="#pop!Case" String="case" beginRegion="case"/>-        <!-- handle functions with function keyword before keywords -->-        <StringDetect attribute="Keyword" context="#pop!FunctionDef" String="function"/>-        <StringDetect attribute="Control Flow" context="#pop!Return" String="return"/>-        <!-- not a keyword in this context -->-        <Detect2Chars attribute="Error" context="#pop" char="i" char1="n"/>-        <StringDetect attribute="Error" context="#pop" String="esac"/>-        <!-- handle keywords -->-        <DetectIdentifier attribute="Control Flow" context="#pop"/>-      </context>--      <!-- if ! ... and while ! ... -->-      <context attribute="Normal Text" lineEndContext="#pop" name="NotCond" fallthroughContext="#pop">-        <DetectSpaces attribute="Normal Text" context="#pop!NotCond2"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="NotCond2" fallthroughContext="#pop">-        <Detect2Chars attribute="Expression" context="#pop" char="!" char1="&tab;"/>-        <Detect2Chars attribute="Expression" context="#pop" char="!" char1=" "/>-        <LineContinue attribute="Expression" context="#pop" char="!"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#pop" name="Foreach" fallthroughContext="#pop">-        <LineContinue attribute="Escape" context="#stay"/>-        <DetectSpaces attribute="Normal Text" context="#stay"/>-        <DetectIdentifier attribute="Normal Text" context="#stay"/>-        <DetectChar attribute="Keyword" context="#pop!ForeachWord" char="("/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="ForeachWord" fallthroughContext="NormalOption">-        <DetectSpaces attribute="Normal Text" context="#stay"/>-        <DetectChar attribute="Control" context="#stay" char=";"/>-        <DetectChar attribute="Keyword" context="#pop" char=")"/>-        <DetectChar attribute="Backquote" context="CommandBackq" char="`"/>-        <AnyChar attribute="Control" context="#stay" String="&symbolseps;"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#pop" name="For" fallthroughContext="#pop">-        <LineContinue attribute="Escape" context="#stay"/>-        <DetectSpaces attribute="Normal Text" context="#stay"/>-        <WordDetect attribute="Keyword" context="#pop!CommandArgs" String="in"/>-        <DetectIdentifier attribute="Normal Text" context="#stay"/>-        <Detect2Chars attribute="Keyword" context="#pop!ForArithmeticExpr" char="(" char1="("/>-        <DetectChar attribute="Keyword" context="#pop!ForeachWord" char="("/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="ForArithmeticExpr">-        <DetectSpaces attribute="Normal Text" context="#stay"/>-        <DetectChar attribute="Control" context="#stay" char=";"/>-        <Detect2Chars attribute="Keyword" context="#pop" char=")" char1=")"/>-        <IncludeRules context="FindExprDblParen"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#pop" name="Select" fallthroughContext="#pop">-        <LineContinue attribute="Escape" context="#stay"/>-        <DetectSpaces attribute="Normal Text" context="#stay"/>-        <DetectIdentifier attribute="Normal Text" context="#pop!SelectIn"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="SelectIn" fallthroughContext="#pop">-        <LineContinue attribute="Escape" context="#stay"/>-        <DetectSpaces attribute="Normal Text" context="#stay"/>-        <WordDetect attribute="Keyword" context="#pop!CommandArgs" String="in"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#pop" name="Repeat" fallthroughContext="#pop!RepeatArithmeticExpr">-        <LineContinue attribute="Escape" context="#stay"/>-        <DetectSpaces attribute="Normal Text" context="#stay"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="RepeatArithmeticExpr">-        <DetectSpaces attribute="Normal Text" context="#pop"/>-        <DetectChar attribute="Control" context="#pop" char=";"/>-        <IncludeRules context="FindExprDblParen"/>-      </context>--      <!-- &> and &>> redirection -->-      <context attribute="Normal Text" lineEndContext="#pop" name="Prefix&amp;>" fallthroughContext="#pop!FdRedirection">-        <Detect2Chars attribute="Redirection" context="#pop!WordRedirection" char=">" char1="|"/>-        <Detect2Chars attribute="Redirection" context="#pop!WordRedirection" char=">" char1="!"/>-        <AnyChar attribute="Redirection" context="#pop!WordRedirection" String=">|!"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#pop" name="AssumeRedirection">-        <!-- handle output redirection -->-        <StringDetect attribute="Redirection" context="#pop!WordRedirection" String=">>|"/>-        <StringDetect attribute="Redirection" context="#pop!WordRedirection" String=">>!"/>-        <StringDetect attribute="Redirection" context="#pop!WordRedirection" String=">>&amp;|"/>-        <StringDetect attribute="Redirection" context="#pop!WordRedirection" String=">>&amp;!"/>-        <StringDetect attribute="Redirection" context="#pop!ProcessSubst" String=">>("/>-        <Detect2Chars attribute="Redirection" context="#pop!WordRedirection" char=">" char1=">"/>-        <Detect2Chars attribute="Redirection" context="#pop!WordRedirection" char=">" char1="|"/>-        <Detect2Chars attribute="Redirection" context="#pop!WordRedirection" char=">" char1="!"/>-        <StringDetect attribute="Redirection" context="#pop!WordRedirection" String=">&amp;|"/>-        <StringDetect attribute="Redirection" context="#pop!WordRedirection" String=">&amp;!"/>-        <Detect2Chars attribute="Redirection" context="#pop!FdRedirection" char=">" char1="&amp;"/>-        <Detect2Chars attribute="Redirection" context="#pop!ProcessSubst" char=">" char1="("/>-        <DetectChar attribute="Redirection" context="#pop!WordRedirection" char=">"/>-        <!-- handle input redirection -->-        <Detect2Chars attribute="Redirection" context="#pop!ProcessSubst" char="&lt;" char1="("/>-        <StringDetect attribute="Redirection" context="#pop!ProcessSubst" String="&lt;&lt;("/>-        <StringDetect attribute="Redirection" context="#pop!StringRedirection" String="&lt;&lt;&lt;"/>-        <!-- handle here document -->-        <Detect2Chars context="#pop!HereDoc" char="&lt;" char1="&lt;" lookAhead="1"/>-        <Detect2Chars attribute="Redirection" context="#pop!FdRedirection" char="&lt;" char1="&amp;"/>-        <Detect2Chars attribute="Redirection" context="#pop!WordRedirection" char="&lt;" char1=">"/>-        <IncludeRules context="FindGlobRangeThenPop"/>-        <DetectChar attribute="Redirection" context="#pop!WordRedirection" char="&lt;"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="FdRedirection" fallthroughContext="#pop!FdRedirection2">-        <DetectSpaces attribute="Normal Text" context="#pop!FdRedirection2"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="FdRedirection2" fallthroughContext="#pop!WordRedirection2">-        <RegExpr attribute="File Descriptor" context="#pop!CloseFile" String="[0-9]+(?=-?&eoexpr;)"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="WordRedirection" fallthroughContext="#pop!WordRedirection2">-        <DetectSpaces attribute="Normal Text" context="#pop!WordRedirection2"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="WordRedirection2" fallthroughContext="#pop">-        <AnyChar context="#pop" String="&wordseps;`" lookAhead="1"/>-        <IncludeRules context="FindWord"/>-        <RegExpr attribute="Path" context="PathThenPop" String="&path;"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="StringRedirection" fallthroughContext="#pop!StringRedirection2">-        <DetectSpaces attribute="Normal Text" context="#pop!StringRedirection2"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="StringRedirection2">-        <AnyChar context="#pop" String="&wordseps;`" lookAhead="1"/>-        <IncludeRules context="FindWord"/>-        <DetectIdentifier attribute="Normal Text"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="CloseFile" fallthroughContext="#pop">-        <DetectChar attribute="Keyword" context="#pop" char="-"/>-      </context>--      <!-- HereDoc consumes Here-documents. It is called at the beginning of the "<<" construct. -->-      <context attribute="Normal Text" lineEndContext="#stay" name="HereDoc">-        <RegExpr attribute="Redirection" context="HereDocIQ"  String="&lt;&lt;-[ &tab;]*&heredocq;(?=[ &tab;]*$)"/>-        <RegExpr attribute="Redirection" context="HereDocINQ" String="&lt;&lt;-[ &tab;]*([^&wordseps;]+)(?=[ &tab;]*$)"/>-        <RegExpr attribute="Redirection" context="HereDocQ"   String="&lt;&lt;[ &tab;]*&heredocq;(?=[ &tab;]*$)"/>-        <RegExpr attribute="Redirection" context="HereDocNQ"  String="&lt;&lt;[ &tab;]*([^&wordseps;]+)(?=[ &tab;]*$)"/>--        <RegExpr context="HereDocIQCmd"  String="(&lt;&lt;-[ &tab;]*&heredocq;)" lookAhead="1"/>-        <RegExpr context="HereDocINQCmd" String="(&lt;&lt;-[ &tab;]*([^&wordseps;]+))" lookAhead="1"/>-        <RegExpr context="HereDocQCmd"   String="(&lt;&lt;[ &tab;]*&heredocq;)" lookAhead="1"/>-        <RegExpr context="HereDocNQCmd"  String="(&lt;&lt;[ &tab;]*([^&wordseps;]+))" lookAhead="1"/>--        <Detect2Chars attribute="Redirection" context="#pop"  char="&lt;" char1="&lt;"/><!-- always met -->-      </context>--      <context attribute="Normal Text" lineEndContext="#pop" name="HereDocRemainder" fallthroughContext="CommandArg">-        <AnyChar context="ZshOneLine" String="&amp;|;`" lookAhead="1"/>-        <IncludeRules context="CommandArgs"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="ZshOneLine" fallthroughContext="Command">-        <IncludeRules context="Start"/>-      </context>--      <context attribute="Here Doc" lineEndContext="#stay" name="HereDocQ" dynamic="1" fallthroughContext="HereDocText">-        <RegExpr attribute="Redirection" context="#pop#pop" String="^%1$" dynamic="1" column="0"/>-      </context>--      <context attribute="Here Doc" lineEndContext="#stay" name="HereDocNQ" dynamic="1" fallthroughContext="HereDocSubstitutions">-        <IncludeRules context="HereDocQ" />-      </context>--      <context attribute="Here Doc" lineEndContext="#stay" name="HereDocIQ" dynamic="1" fallthroughContext="HereDocText">-        <RegExpr attribute="Redirection" context="#pop#pop" String="^\t*%1$" dynamic="1" column="0"/>-      </context>--      <context attribute="Here Doc" lineEndContext="#stay" name="HereDocINQ" dynamic="1" fallthroughContext="HereDocSubstitutions">-        <IncludeRules context="HereDocIQ" />-      </context>--      <context attribute="Here Doc" lineEndContext="#stay" name="HereDocCmd">-        <!-- Only if the redirect is before the command, but as this is too complicated,-             check if the redirect is at the beginning of the line. -->-        <StringDetect attribute="Redirection" context="ZshOneLine" String="%1" dynamic="true" firstNonSpace="1"/>-        <StringDetect attribute="Redirection" context="HereDocRemainder" String="%1" dynamic="true"/>-      </context>--      <context attribute="Here Doc" lineEndContext="#stay" name="HereDocQCmd" dynamic="1" fallthroughContext="HereDocText">-        <IncludeRules context="HereDocCmd"/>-        <RegExpr attribute="Redirection" context="#pop#pop" String="^%2$" dynamic="1" column="0"/>-      </context>--      <context attribute="Here Doc" lineEndContext="#stay" name="HereDocNQCmd" dynamic="1" fallthroughContext="HereDocSubstitutions">-        <IncludeRules context="HereDocQCmd"/>-      </context>--      <context attribute="Here Doc" lineEndContext="#stay" name="HereDocIQCmd" dynamic="1" fallthroughContext="HereDocText">-        <IncludeRules context="HereDocCmd"/>-        <RegExpr attribute="Redirection" context="#pop#pop" String="^\t*%2$" dynamic="1" column="0"/>-      </context>--      <context attribute="Here Doc" lineEndContext="#stay" name="HereDocINQCmd" dynamic="1" fallthroughContext="HereDocSubstitutions">-        <IncludeRules context="HereDocIQCmd"/>-      </context>--      <context attribute="Here Doc" lineEndContext="#pop" name="HereDocText">-      </context>--      <context attribute="Here Doc" lineEndContext="#pop" name="HereDocSubstitutions">-        <DetectSpaces attribute="Here Doc"/>-        <DetectIdentifier attribute="Here Doc"/>-        <DetectChar context="HereDocVariables" char="$" lookAhead="1"/>-        <DetectChar attribute="Backquote" context="CommandBackq" char="`"/>-        <DetectChar context="AssumeEscape" char="\" lookAhead="1"/>-      </context>-      <context attribute="Here Doc" lineEndContext="#pop" name="HereDocVariables">-        <IncludeRules context="DispatchSubstVariables"/>-        <IncludeRules context="DispatchVarNameVariables"/>-        <DetectChar attribute="Here Doc" context="#pop" char="$"/>-      </context>--      <!-- VarName consumes spare variable names and assignments -->-      <context attribute="Normal Text" lineEndContext="#pop" name="VarName">-        <StringDetect attribute="Builtin" context="#pop!BuiltinGetopts" String="getopts"/>-        <StringDetect attribute="Builtin" context="#pop!BuiltinLet" String="let"/>-        <DetectIdentifier attribute="Builtin" context="#pop!VarNameArgs"/>-        <AnyChar attribute="Builtin" context="#pop!VarNameArgs" String=".:-"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="VarNameArgs" fallthroughContext="#pop!CommandArgs">-        <DetectSpaces attribute="Normal Text" context="VarNameArg"/>-        <LineContinue attribute="Escape" context="#stay"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop#pop" name="VarNameArg" fallthroughContext="#pop!VarNameArg2">-        <!-- In command arguments, do not allow comments after escaped characters.-             This avoids highlighting comments within paths or other text. Ex: pathtext\ #no\ comment -->-        <DetectChar context="#pop#pop" char="#" lookAhead="1"/>-        <AnyChar attribute="Option" context="#pop!ShortOption" String="-+"/>-        <DetectChar attribute="Keyword" context="#pop!VarNameArg2" char="="/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="VarNameArg2" fallthroughContext="#pop!NormalOption">-        <DetectChar attribute="Variable" context="Subscript" char="["/>-        <DetectChar attribute="Operator" context="Assign" char="="/>-        <DetectChar attribute="Variable" context="AssignArray" char="("/>-        <DetectIdentifier attribute="Variable" context="#stay"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="BuiltinGetopts" fallthroughContext="#pop!CommandArgs">-        <DetectSpaces attribute="Normal Text" context="#pop!BuiltinGetoptsOpt"/>-        <LineContinue attribute="Escape" context="#stay"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop#pop" name="BuiltinGetoptsOpt" fallthroughContext="#pop!BuiltinGetoptsOpt2">-        <DetectChar context="#pop#pop" char="#" lookAhead="1"/>-        <DetectChar attribute="Keyword" context="#pop!NormalOption" char="="/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="BuiltinGetoptsOpt2" fallthroughContext="#pop!NormalOption">-        <DetectChar attribute="Operator" context="#stay" char=":"/>-        <DetectIdentifier attribute="Normal Text" context="#stay" />-        <DetectSpaces attribute="Normal Text" context="#pop!BuiltinGetoptsVar"/>-        <AnyChar context="#pop" String="&wordseps_or_extglog;" lookAhead="1"/>-        <IncludeRules context="FindWord"/>-        <DetectChar context="NormalOptionMaybeBraceExpansion" char="{" lookAhead="1"/>-        <DetectChar context="NormalOptionMaybeGroupEnd" char="}" lookAhead="1"/>-        <AnyChar attribute="Normal Text" context="#stay" String="/%.0123456789"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="BuiltinGetoptsVar" fallthroughContext="#pop!CommandArgs">-        <DetectIdentifier attribute="Variable" context="#pop!CommandArgs"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="BuiltinLet" fallthroughContext="#pop!CommandArgs">-        <DetectSpaces attribute="Normal Text" context="#pop!BuiltinLetArgs"/>-        <LineContinue attribute="Escape" context="#stay"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="BuiltinLetArgs" fallthroughContext="BuiltinLetArg">-        <AnyChar context="BuiltinLetArgsNumber" String="0123456789" lookAhead="1"/>-        <IncludeRules context="CommandArgs"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="BuiltinLetArgsNumber" fallthroughContext="#pop!BuiltinLetArg">-        <IncludeRules context="FindRedirection"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop#pop" name="BuiltinLetArg" fallthroughContext="#pop!BuiltinLetExpr">-        <DetectChar context="#pop#pop" char="#" lookAhead="1"/>-        <DetectChar attribute="Keyword" context="#pop!NormalOption" char="="/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="BuiltinLetExpr" fallthroughContext="#pop!NormalOption">-        <DetectIdentifier attribute="Variable" context="#stay" />-        <AnyChar context="#pop" String="&wordseps_or_extglog;" lookAhead="1"/>-        <AnyChar attribute="Operator" context="#stay" String="+-!%=^:"/>-        <AnyChar context="Number" String="0123456789." lookAhead="1"/>-        <DetectChar attribute="Parameter Expansion Operator" context="Subscript" char="["/>-        <IncludeRules context="FindWord"/>-        <Detect2Chars attribute="BaseN" context="NoPrefix" char="#" char1="#"/>-        <DetectChar attribute="Error" context="#stay" char="#"/>-        <DetectChar context="NormalOptionMaybeBraceExpansion" char="{" lookAhead="1"/>-        <DetectChar context="NormalOptionMaybeGroupEnd" char="}" lookAhead="1"/>-      </context>--      <!-- ProcessSubst handles <(command) and >(command) -->-      <context attribute="Normal Text" lineEndContext="#stay" name="ProcessSubst" fallthroughContext="Command">-        <DetectChar attribute="Redirection" context="#pop" char=")"/>-        <IncludeRules context="Start"/>-      </context>--      <!-- StringSQ consumes anything till ' -->-      <context attribute="String SingleQ" lineEndContext="#stay" name="StringSQ">-        <DetectSpaces attribute="String SingleQ"/>-        <DetectIdentifier attribute="String SingleQ"/>-        <DetectChar attribute="String SingleQ" context="#pop" char="'"/>-      </context>--      <!-- StringDQ consumes anything till ", substitutes vars and expressions -->-      <context attribute="String DoubleQ" lineEndContext="#stay" name="StringDQ">-        <DetectSpaces attribute="String DoubleQ"/>-        <DetectIdentifier attribute="String DoubleQ"/>-        <DetectChar attribute="String DoubleQ" context="#pop" char="&quot;"/>-        <DetectChar context="StringDQEscape" char="\" lookAhead="1"/>-        <DetectChar context="StringDQDispatchVariables" char="$" lookAhead="1"/>-        <DetectChar attribute="Backquote" context="RegularBackq" char="`"/>-      </context>-      <context attribute="String DoubleQ" lineEndContext="#stay" name="StringDQDispatchVariables">-        <IncludeRules context="DispatchSubstVariables"/>-        <IncludeRules context="DispatchVarNameVariables"/>-        <DetectChar attribute="String DoubleQ" context="#pop" char="$"/>-      </context>-      <context attribute="String DoubleQ" lineEndContext="#pop" name="StringDQEscape">-        <Detect2Chars attribute="String Escape" context="#pop" char="\" char1="&quot;"/>-        <Detect2Chars attribute="String Escape" context="#pop" char="\" char1="\"/>-        <Detect2Chars attribute="String Escape" context="#pop" char="\" char1="`"/>-        <Detect2Chars attribute="String Escape" context="#pop" char="\" char1="$"/>-        <LineContinue attribute="String Escape" context="#pop"/>-        <DetectChar attribute="String DoubleQ" context="#pop" char="\"/>-      </context>--      <!-- RegularBackq consumes anything till ` -->-      <context attribute="Normal Text" lineEndContext="#stay" name="RegularBackq" fallthroughContext="Command">-        <DetectChar attribute="Backquote" context="#pop" char="`"/>-        <DetectChar attribute="Comment" context="CommentBackq" char="#"/>-        <IncludeRules context="Start"/>-      </context>--      <!-- StringEsc eats till ', but escaping many characters -->-      <context attribute="String SingleQ" lineEndContext="#stay" name="StringEsc">-        <DetectSpaces attribute="String SingleQ"/>-        <DetectIdentifier attribute="String SingleQ"/>-        <DetectChar attribute="String SingleQ" context="#pop" char="'"/>-        <RegExpr attribute="String Escape" context="#stay" String="\\(?:[abeEfnrtv\\']|[0-7]{1,3}|x[A-Fa-f0-9]{1,2}|u[A-Fa-f0-9]{1,4}|U[A-Fa-f0-9]{1,8}|c.)?"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#stay" name="FindWord">-        <IncludeRules context="FindStrings"/>-        <DetectChar context="RegularVariable" char="$" lookAhead="1"/>-        <DetectChar attribute="Backquote" context="RegularBackq" char="`"/>-        <DetectChar context="AssumeEscape" char="\" lookAhead="1"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="RegularVariable">-        <IncludeRules context="DispatchVariables"/>-        <DetectChar attribute="Normal Text" context="#pop" char="$"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#pop" name="FindStrings">-        <DetectChar attribute="String SingleQ" context="StringSQ" char="'"/>-        <DetectChar attribute="String DoubleQ" context="StringDQ" char="&quot;"/>-      </context>--      <!-- SubstCommand is called after a $( is encountered -->-      <context attribute="Normal Text" lineEndContext="#stay" name="SubstCommand" fallthroughContext="Command">-        <DetectChar attribute="Parameter Expansion" context="#pop" char=")" endRegion="subshell"/>-        <IncludeRules context="Start"/>-      </context>--      <!-- VarBraceStart is called as soon as ${ is encoutered -->-      <context attribute="Variable" lineEndContext="#pop" name="VarBraceStart" fallthroughContext="#pop!CheckVarAlt">-        <DetectChar attribute="Parameter Expansion" context="#pop!VarFlags" char="("/>-        <IncludeRules context="VarFlagsVar"/>-      </context>-      <context attribute="Variable" lineEndContext="#stay" name="VarBraceStartRecursive" fallthroughContext="#pop#pop!CheckVarAlt">-        <Detect2Chars attribute="Parameter Expansion" context="VarBraceStart" char="$" char1="{"/>-        <StringDetect context="#pop!ExprDblParenSubstOrSubstCommand" String="$((" lookAhead="1"/>-        <Detect2Chars attribute="Parameter Expansion" context="#pop!SubstCommand" char="$" char1="(" beginRegion="subshell"/>-        <DetectChar attribute="Error" context="#pop" char="$"/>-      </context>-      <context attribute="Error" lineEndContext="#stay" name="VarError">-        <DetectChar attribute="Parameter Expansion" context="#pop" char="}"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="CheckVarAlt" fallthroughContext="#pop!VarError">-        <DetectChar attribute="Parameter Expansion" context="#pop" char="}"/>-        <StringDetect attribute="Parameter Expansion Operator" context="#stay" String="[@]"/>-        <StringDetect attribute="Parameter Expansion Operator" context="#stay" String="[*]"/>-        <DetectChar attribute="Parameter Expansion Operator" context="Subscript" char="["/>-        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!AlternatePatternValue" char="%" char1="%"/>-        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!AlternatePatternValue" char="#" char1="#"/>-        <AnyChar attribute="Parameter Expansion Operator" context="#pop!AlternatePatternValue" String="#%"/>-        <AnyChar attribute="Parameter Expansion Operator" context="#pop!AlternateValue" String="-+=?"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!AlternateValuePrefix" char=":"/>-        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!VarBraceSubst" char="/" char1="/"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarBraceSubst" char="/"/>-      </context>-      <context attribute="Parameter Expansion" lineEndContext="#stay" name="AlternateValuePrefix" fallthroughContext="#pop!VarSub">-        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!AlternateValue" char="^" char1="^"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!AlternatePatternValue" char="#"/>-        <AnyChar attribute="Parameter Expansion Operator" context="#pop!AlternateValue" String="-+=?|*^"/>-        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!AlternateValue" char=":" char1="="/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarBraceSubst" char="/"/>--        <!-- Modifiers -->-        <AnyChar attribute="Parameter Expansion" context="#pop!VarBraceModifiers" String="aAcehlpPqQrsg&amp;tux" lookAhead="1"/>-      </context>--      <!-- called as soon as ${xxx:y (with y a modifier) is encoutered -->-      <context attribute="Parameter Expansion" lineEndContext="#stay" name="VarBraceModifiers">-        <DetectChar attribute="Parameter Expansion" context="#pop" char="}"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#stay" char=":"/>-        <AnyChar attribute="Parameter Expansion" context="VarBraceModifier_h" String="ht"/>-        <DetectChar attribute="Parameter Expansion" context="VarBraceModifier_s" char="s"/>-        <Detect2Chars attribute="Parameter Expansion" context="VarBraceModifier_s" char="g" char1="s"/>-      </context>-      <context attribute="Parameter Expansion" lineEndContext="#stay" name="VarBraceModifier_h" fallthroughContext="#pop">-        <AnyChar attribute="Number" context="#stay" String="0123456789"/>-      </context>--      <!-- called as soon as ${xxx:s and ${xxx:gs is encoutered -->-      <context attribute="Parameter Expansion" lineEndContext="#stay" name="VarBraceModifier_s">-        <DetectChar attribute="Error" context="#pop#pop" char="}"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarBraceModifier_s_Str" char="/"/>-        <DetectChar context="AssumeEscape" char="\" lookAhead="1"/>-      </context>-      <context attribute="String SingleQ" lineEndContext="#stay" name="VarBraceModifier_s_Str">-        <DetectChar attribute="Parameter Expansion" context="#pop#pop" char="}"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarBraceModifier_s_Rep" char="/"/>-        <DetectChar context="AssumeEscape" char="\" lookAhead="1"/>-        <DetectChar attribute="String SingleQ" context="RecursiveVarBraceModifier_s" char="{"/>-      </context>-      <context attribute="String SingleQ" lineEndContext="#stay" name="RecursiveVarBraceModifier_s">-        <DetectChar context="AssumeEscape" char="\" lookAhead="1"/>-        <DetectChar attribute="String SingleQ" context="#pop" char="}"/>-      </context>-      <context attribute="String SingleQ" lineEndContext="#stay" name="VarBraceModifier_s_Rep">-        <DetectChar attribute="Parameter Expansion" context="#pop#pop" char="}"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="/"/>-        <DetectChar attribute="String SingleQ" context="RecursiveVarBraceModifier_s" char="{"/>-      </context>--      <!-- called as soon as ${xxx: is encoutered -->-      <context attribute="Normal Text" lineEndContext="#stay" name="VarSub">-        <DetectChar attribute="Parameter Expansion" context="#pop" char="}"/>-        <AnyChar context="VarOffset" String="0123456789" lookAhead="1"/>-        <AnyChar attribute="Operator" context="#stay" String="+-!~*/%&lt;>=&amp;^|"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#stay" char=":"/>-        <DetectChar context="VarVariables" char="$" lookAhead="1"/>-        <IncludeRules context="FindStrings"/>-        <DetectChar attribute="Backquote" context="RegularBackq" char="`"/>-        <DetectChar context="AssumeEscape" char="\" lookAhead="1"/>-      </context>-      <context attribute="Command" lineEndContext="#pop" name="VarVariables">-        <IncludeRules context="DispatchVariables"/>-        <DetectChar attribute="Error" context="#pop" char="$"/>-      </context>-      <context attribute="Number" lineEndContext="#pop" name="VarOffset" fallthroughContext="#pop">-        <Detect2Chars attribute="Hex" context="#pop!Hex" char="0" char1="x"/>-        <Detect2Chars attribute="Hex" context="#pop!Hex" char="0" char1="X"/>-        <AnyChar attribute="Number" context="#stay" String="0123456789_"/>-        <DetectChar attribute="Base" context="#stay" char="#"/>-      </context>--      <!-- called as soon as ${xxx:-, etc are encoutered -->-      <context attribute="String DoubleQ" lineEndContext="#stay" name="AlternateValue">-        <DetectChar attribute="String DoubleQ" context="RecursiveAlternateValue" char="{"/>-        <DetectChar attribute="Parameter Expansion" context="#pop" char="}"/>-        <IncludeRules context="FindWord"/>-        <IncludeRules context="FindPathThenPopInAlternateValue"/>-        <DetectIdentifier attribute="String DoubleQ"/>-      </context>-      <context attribute="String DoubleQ" lineEndContext="#stay" name="RecursiveAlternateValue">-        <DetectChar attribute="String DoubleQ" context="RecursiveAlternateValue" char="{"/>-        <DetectChar attribute="String DoubleQ" context="#pop" char="}"/>-        <IncludeRules context="FindWord"/>-        <IncludeRules context="FindPathThenPopInAlternateValue"/>-        <DetectIdentifier attribute="String DoubleQ"/>-      </context>--      <!-- called as soon as ${xxx%, etc are encoutered -->-      <context attribute="String DoubleQ" lineEndContext="#stay" name="AlternatePatternValue">-        <DetectChar attribute="String DoubleQ" context="RecursiveAlternatePatternValue" char="{"/>-        <DetectChar attribute="Parameter Expansion" context="#pop" char="}"/>-        <IncludeRules context="FindWord"/>-        <IncludeRules context="FindStringDQPattern"/>-        <DetectIdentifier attribute="String DoubleQ"/>-      </context>-      <context attribute="String DoubleQ" lineEndContext="#stay" name="RecursiveAlternatePatternValue">-        <DetectChar attribute="String DoubleQ" context="RecursiveAlternateValue" char="{"/>-        <DetectChar attribute="String DoubleQ" context="#pop" char="}"/>-        <IncludeRules context="FindWord"/>-        <IncludeRules context="FindStringDQPattern"/>-        <DetectIdentifier attribute="String DoubleQ"/>-      </context>--      <!-- called as soon as ${xxx/ ${xxx// ${xxx:/ are encoutered -->-      <context attribute="Normal Text" lineEndContext="#stay" name="VarBraceSubst" fallthroughContext="#pop!VarBraceSubstPat">-        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!VarBraceSubstPat" char="#" char1="%"/>-        <AnyChar attribute="Parameter Expansion Operator" context="#pop!VarBraceSubstPat" String="#%"/>-      </context>-      <context attribute="Pattern" lineEndContext="#stay" name="VarBraceSubstPat">-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!AlternateValue" char="/"/>-        <DetectChar attribute="String DoubleQ" context="RecursiveAlternateValue" char="{"/>-        <DetectChar attribute="Parameter Expansion" context="#pop" char="}"/>-        <IncludeRules context="FindWord"/>-        <IncludeRules context="FindSubPattern"/>-        <DetectIdentifier attribute="Pattern"/>-      </context>--      <!-- called as soon as ${( is encoutered -->-      <context attribute="Parameter Expansion" lineEndContext="#stay" name="VarFlags">-        <AnyChar attribute="Parameter Expansion Operator" context="#stay" String="#%*q@AabcCDefFikLnoOPqQ+-tuUvVwWXz0~mSBEMNR"/>-        <AnyChar attribute="Parameter Expansion Operator" context="VarFlag_s" String="sjgZ_"/>-        <AnyChar attribute="Parameter Expansion Operator" context="VarFlag_l" String="lrI"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlagsSubs" char="p"/>--        <DetectChar attribute="Parameter Expansion" context="#pop!VarFlagsVar" char=")"/>-        <DetectChar attribute="Error" context="#pop" char="}"/>-      </context>-      <context attribute="Parameter Expansion" lineEndContext="#stay" name="VarFlagsSubs">-        <AnyChar attribute="Parameter Expansion Operator" context="#stay" String="#q@AabcCDefFikLnoOPqQ+-tuUvVwWXz0~mSBEMNRp"/>-        <AnyChar attribute="Parameter Expansion Operator" context="VarFlag_s" String="gZ"/>-        <AnyChar attribute="Parameter Expansion Operator" context="VarFlag_ps" String="sj_"/>-        <AnyChar attribute="Parameter Expansion Operator" context="VarFlag_pl" String="lrI"/>--        <DetectChar attribute="Parameter Expansion" context="#pop!VarFlagsVar" char=")"/>-        <DetectChar attribute="Error" context="#pop" char="}"/>-      </context>-      <context attribute="Variable" lineEndContext="#stay" name="VarFlagsVar" fallthroughContext="#pop!CheckVarAlt">-        <DetectChar context="VarBraceStartRecursive" char="$" lookAhead="1"/>-        <DetectChar attribute="Parameter Expansion" context="#pop" char="}"/>-        <DetectChar attribute="String DoubleQ" context="StringDQ" char="&quot;"/>-        <AnyChar attribute="Parameter Expansion Operator" context="#stay" String="#+^=~"/>-        <DetectIdentifier attribute="Variable" context="#pop!CheckVarAlt"/>-        <AnyChar attribute="Variable" context="#pop!CheckVarAlt" String="*@?$-"/>-        <Int attribute="Variable" context="#pop!CheckVarAlt" additionalDeliminator="#~=^+{}[]:-/$"/>-        <Detect2Chars context="#pop!VarSubShell" char="!" char1="}" lookAhead="1"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!AlternateValue" char="!"/>-      </context>--      <context attribute="Parameter Expansion" lineEndContext="#stay" name="VarSubShell">-        <DetectChar attribute="Variable" context="#pop!CheckVarAlt" char="!"/>-      </context>--      <context attribute="Parameter Expansion" lineEndContext="#stay" name="VarFlag_s">-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_s[" char="["/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_s&lt;" char="&lt;"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_s{" char="{"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_s(" char="("/>-        <RegExpr attribute="Parameter Expansion Operator" context="#pop!VarFlag_sx" String="(.)"/>-      </context>-      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_s[">-        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="]"/>-      </context>-      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_s&lt;">-        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char=">"/>-      </context>-      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_s{">-        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="}"/>-      </context>-      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_s(">-        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char=")"/>-      </context>-      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_sx">-        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="1" dynamic="1"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#stay" name="VarFlag_l">-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_l[" char="["/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_l&lt;" char="&lt;"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_l{" char="{"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_l(" char="("/>-        <RegExpr attribute="Parameter Expansion Operator" context="#pop!VarFlag_lx" String="(.)"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="VarFlag_l[">-        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!VarFlag_l[s" char="]" char1="["/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="]"/>-        <IncludeRules context="FindExprDblParen"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="VarFlag_l&lt;">-        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!VarFlag_l&lt;s" char=">" char1="&lt;"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char=">"/>-        <IncludeRules context="FindExprDblParen"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="VarFlag_l{">-        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!VarFlag_l{s" char="}" char1="{"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="}"/>-        <IncludeRules context="FindExprDblParen"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="VarFlag_l(">-        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!VarFlag_l(s" char=")" char1="("/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char=")"/>-        <IncludeRules context="FindExprDblParen"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="VarFlag_lx">-        <RegExpr attribute="Parameter Expansion Operator" context="#pop!VarFlag_lxs" String="(%1)%1" dynamic="1"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="1" dynamic="1"/>-        <IncludeRules context="FindExprDblParen"/>-      </context>-      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_l[s">-        <Detect2Chars attribute="Parameter Expansion Operator" context="#stay" char="]" char1="["/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="]"/>-      </context>-      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_l&lt;s">-        <Detect2Chars attribute="Parameter Expansion Operator" context="#stay" char=">" char1="&lt;"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char=">"/>-      </context>-      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_l{s">-        <Detect2Chars attribute="Parameter Expansion Operator" context="#stay" char="}" char1="{"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="}"/>-      </context>-      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_l(s">-        <Detect2Chars attribute="Parameter Expansion Operator" context="#stay" char=")" char1="("/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char=")"/>-      </context>-      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_lxs">-        <StringDetect attribute="Parameter Expansion Operator" context="#stay" String="%1%1" dynamic="1"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="1" dynamic="1"/>-      </context>--      <context attribute="Parameter Expansion" lineEndContext="#stay" name="VarFlag_ps">-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_ps[" char="["/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_ps&lt;" char="&lt;"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_ps{" char="{"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_ps(" char="("/>-        <RegExpr attribute="Parameter Expansion Operator" context="#pop!VarFlag_psx" String="(.)"/>-      </context>-      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_ps[">-        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="]"/>-        <RegExpr attribute="Variable" context="#stay" String="\$(&varname;|[0-9]+)(?=\])"/>-      </context>-      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_ps&lt;">-        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char=">"/>-        <RegExpr attribute="Variable" context="#stay" String="\$(&varname;|[0-9]+)(?=>)"/>-      </context>-      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_ps{">-        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="}"/>-        <RegExpr attribute="Variable" context="#stay" String="\$(&varname;|[0-9]+)(?=})"/>-      </context>-      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_ps(">-        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char=")"/>-        <RegExpr attribute="Variable" context="#stay" String="\$(&varname;|[0-9]+)(?=\))"/>-      </context>-      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_psx">-        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="1" dynamic="1"/>-        <RegExpr attribute="Variable" context="#stay" String="\$(?!%1)(?:[A-Za-z_](?:(?!%1)[A-Za-z0-9_])*+|(?:(?!%1)[0-9])++)(?=%1)" dynamic="1"/>-        <RegExpr attribute="String SingleQ" context="#stay" String="[^%1]+" dynamic="1"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#stay" name="VarFlag_pl">-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_pl[" char="["/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_pl&lt;" char="&lt;"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_pl{" char="{"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_pl(" char="("/>-        <RegExpr attribute="Parameter Expansion Operator" context="#pop!VarFlag_plx" String="(.)"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="VarFlag_pl[">-        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!VarFlag_pl[s" char="]" char1="["/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="]"/>-        <IncludeRules context="FindExprDblParen"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="VarFlag_pl&lt;">-        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!VarFlag_pl&lt;s" char=">" char1="&lt;"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char=">"/>-        <IncludeRules context="FindExprDblParen"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="VarFlag_pl{">-        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!VarFlag_pl{s" char="}" char1="{"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="}"/>-        <IncludeRules context="FindExprDblParen"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="VarFlag_pl(">-        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!VarFlag_pl(s" char=")" char1="("/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char=")"/>-        <IncludeRules context="FindExprDblParen"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="VarFlag_plx">-        <RegExpr attribute="Parameter Expansion Operator" context="#pop!VarFlag_plxs" String="(%1)%1" dynamic="1"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="1" dynamic="1"/>-        <IncludeRules context="FindExprDblParen"/>-      </context>-      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_pl[s">-        <Detect2Chars attribute="Parameter Expansion Operator" context="#stay" char="]" char1="["/>-        <IncludeRules context="VarFlag_ps["/>-      </context>-      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_pl&lt;s">-        <Detect2Chars attribute="Parameter Expansion Operator" context="#stay" char=">" char1="&lt;"/>-        <IncludeRules context="VarFlag_ps&lt;"/>-      </context>-      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_pl{s">-        <Detect2Chars attribute="Parameter Expansion Operator" context="#stay" char="}" char1="{"/>-        <IncludeRules context="VarFlag_ps{"/>-      </context>-      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_pl(s">-        <Detect2Chars attribute="Parameter Expansion Operator" context="#stay" char=")" char1="("/>-        <IncludeRules context="VarFlag_ps("/>-      </context>-      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_plxs">-        <StringDetect attribute="Parameter Expansion Operator" context="#stay" String="%1%1" dynamic="1"/>-        <IncludeRules context="VarFlag_psx"/>-      </context>--      <context attribute="Escape" lineEndContext="#pop" name="BraceExpansion">-        <DetectChar attribute="Escape" context="#pop!BraceExpansion2" char="{"/>-      </context>-      <context attribute="Escape" lineEndContext="#pop" name="BraceExpansion2">-        <DetectChar attribute="Operator" context="#stay" char=","/>-        <DetectChar attribute="Escape" context="#pop" char="}"/>-        <DetectChar context="EscapeMaybeBraceExpansion" char="{" lookAhead="1"/>-        <DetectChar context="AssumeEscape" char="\" lookAhead="1"/>-        <DetectChar attribute="Backquote" context="CommandBackq" char="`"/>-        <DetectChar context="BraceExpansionVariables" char="$" lookAhead="1"/>-        <IncludeRules context="FindStrings"/>-        <IncludeRules context="FindPattern"/>-        <DetectIdentifier attribute="Escape"/>-      </context>-      <context attribute="Escape" lineEndContext="#pop" name="EscapeMaybeBraceExpansion">-        <IncludeRules context="DispatchBraceExpansion"/>-        <DetectChar attribute="Escape" context="#pop!BraceExpansion2" char="{"/>-      </context>-      <context attribute="Escape" lineEndContext="#pop" name="BraceExpansionVariables">-        <IncludeRules context="DispatchVariables"/>-        <DetectChar attribute="Escape" context="#pop" char="$"/>-      </context>--      <context attribute="Escape" lineEndContext="#pop" name="PathBraceExpansion">-        <DetectChar attribute="Escape" context="#pop!PathBraceExpansion2" char="{"/>-      </context>-      <context attribute="Path" lineEndContext="#pop" name="PathBraceExpansion2">-        <DetectChar attribute="Operator" context="#stay" char=","/>-        <DetectChar attribute="Escape" context="#pop" char="}"/>-        <DetectChar context="PathMaybeBraceExpansion" char="{" lookAhead="1"/>-        <IncludeRules context="FindWord"/>-        <IncludeRules context="FindPattern"/>-        <DetectIdentifier attribute="Path"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#pop" name="SequenceExpression">-        <AnyChar attribute="Number" context="#stay" String="0123456789-"/>-        <IncludeRules context="FindWord"/>-        <Detect2Chars attribute="Escape" context="#stay" char="." char1="."/>-        <DetectChar attribute="Escape" context="#pop" char="}"/>-      </context>--<!-- ====== These are the contexts that can be branched to ======= -->--      <context attribute="Normal Text" lineEndContext="#stay" name="ExprDblParenOrSubShell">-        <RegExpr attribute="Keyword" context="#pop!SubShell" String="\((?=&arithmetic_as_subshell;)|" beginRegion="subshell"/>-        <Detect2Chars attribute="Keyword" context="#pop!ExprDblParen" char="(" char1="(" beginRegion="expression"/>-      </context>-      <!-- ExprDblParen consumes an expression started in command mode till )) -->-      <context attribute="Normal Text" lineEndContext="#stay" name="ExprDblParen">-        <DetectSpaces attribute="Normal Text" context="#stay"/>-        <Detect2Chars attribute="Keyword" context="#pop" char=")" char1=")" endRegion="expression"/>-        <IncludeRules context="FindExprDblParen"/>-        <!-- ((cmd-              ) # jump to SubShell context -->-        <DetectChar attribute="Keyword" context="#pop!SubShell" char=")" endRegion="expression" beginRegion="subshell"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="FindExprDblParen">-        <Detect2Chars attribute="Control" context="#stay" char="&amp;" char1="&amp;"/>-        <Detect2Chars attribute="Control" context="#stay" char="|" char1="|"/>-        <AnyChar attribute="Operator" context="#stay" String="+-!~*/%&lt;>=&amp;^|?:"/>-        <DetectChar attribute="Control" context="#stay" char=","/>-        <DetectChar attribute="Normal Text" context="ExprSubDblParen" char="("/>-        <AnyChar context="Number" String="0123456789." lookAhead="1"/>-        <DetectChar attribute="Parameter Expansion Operator" context="Subscript" char="["/>-        <IncludeRules context="FindWord"/>-        <DetectChar context="MaybeArithmeticBrace" char="{" lookAhead="1"/>-        <Detect2Chars attribute="BaseN" context="NoPrefix" char="#" char1="#"/>-        <DetectChar attribute="Error" context="#stay" char="#"/>-        <DetectIdentifier attribute="Variable" context="#stay"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="ExprSubDblParen">-        <DetectSpaces attribute="Normal Text" context="#stay"/>-        <DetectChar attribute="Normal Text" context="#pop" char=")"/>-        <IncludeRules context="FindExprDblParen"/>-      </context>-      <context attribute="Error" lineEndContext="#pop" name="MaybeArithmeticBrace">-        <IncludeRules context="DispatchBraceExpansion"/>-        <DetectChar attribute="Error" context="#pop" char="{"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="NoPrefix" fallthroughContext="#pop">-        <DetectChar context="AssumeEscape" char="\"/>-        <RegExpr attribute="Number" context="#pop" String="[^][()]"/>-      </context>--      <context attribute="Number" lineEndContext="#pop" name="Number">-        <Detect2Chars attribute="Hex" context="#pop!Hex" char="0" char1="x"/>-        <Detect2Chars attribute="Hex" context="#pop!Hex" char="0" char1="X"/>-        <RegExpr attribute="Base" context="#pop!BaseN" String="[1-9][0-9_]*+#"/>-        <RegExpr attribute="Number" context="#pop" String="&int;(\.(&int;&exp;?+|&exp;)?|&exp;)?|\.&int;&exp;?"/>-        <DetectChar attribute="Operator" context="#pop" char="."/>-      </context>-      <context attribute="Hex" lineEndContext="#pop" name="Hex" fallthroughContext="#pop">-        <RegExpr attribute="Hex" context="#pop" String="[0-9a-fA-F_]+"/>-      </context>-      <context attribute="BaseN" lineEndContext="#pop" name="BaseN" fallthroughContext="#pop">-        <RegExpr attribute="BaseN" context="#pop" String="[0-9a-zA-Z@_]+"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#stay" name="ExprDblParenSubstOrSubstCommand">-        <RegExpr attribute="Parameter Expansion" context="#pop!SubstCommand" String="\$\((?=&arithmetic_as_subshell;)|" beginRegion="subshell"/>-        <StringDetect attribute="Parameter Expansion" context="#pop!ExprDblParenSubst" String="$((" beginRegion="expression"/>-      </context>-      <!-- ExprDblParenSubst like ExprDblParen but matches )) as Variable -->-      <context attribute="Normal Text" lineEndContext="#stay" name="ExprDblParenSubst">-        <DetectSpaces attribute="Normal Text" context="#stay"/>-        <Detect2Chars attribute="Parameter Expansion" context="#pop" char=")" char1=")" endRegion="expression"/>-        <IncludeRules context="FindExprDblParen"/>-        <!-- $((cmd-              ) # jump to SubstCommand context -->-        <DetectChar attribute="Parameter Expansion" context="#pop!SubstCommand" char=")" endRegion="expression" beginRegion="subshell"/>-      </context>--      <!-- ExprBracket consumes an expression till ] -->-      <context attribute="Normal Text" lineEndContext="#stay" name="ExprBracket" fallthroughContext="#pop!ExprBracketNot">-        <DetectSpaces attribute="Normal Text" context="#stay"/>-        <IncludeRules context="FindExprBracketEnd"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#stay" name="ExprBracketNot" fallthroughContext="#pop!ExprBracketParam1">-        <DetectSpaces attribute="Normal Text" context="#pop!ExprBracketParam1"/>-        <Detect2Chars attribute="Expression" context="ExprBracketTestMaybeNot" char="!" char1=" " lookAhead="1"/>-        <Detect2Chars attribute="Expression" context="ExprBracketTestMaybeNot" char="!" char1="&tab;" lookAhead="1"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="ExprBracketTestMaybeNot">-        <DetectChar attribute="Expression" context="#pop" char="!"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#stay" name="ExprBracketParam1" fallthroughContext="ExprBracketValue">-        <DetectSpaces attribute="Normal Text" context="#pop!ExprBracketParam2"/>-        <DetectChar context="TestMaybeUnary" char="-" lookAhead="1"/>-        <IncludeRules context="FindExprBracketEnd"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#pop" name="ExprBracketValue">-        <AnyChar context="#pop" String=" &tab;" lookAhead="1"/>-        <AnyChar attribute="Error" context="#stay" String="&symbolseps;"/>-        <IncludeRules context="FindWord"/>-        <IncludeRules context="FindGlobAny"/>-        <IncludeRules context="FindPathThenPop"/>-        <DetectChar context="ExprBracketValueMaybeBraceExpansion" char="{" lookAhead="1"/>-        <DetectChar context="NormalOptionMaybeGroupEnd" char="}" lookAhead="1"/>-        <DetectIdentifier attribute="Normal Text"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="ExprBracketValueRecBrace">-        <AnyChar context="#pop#pop" String=" &tab;" lookAhead="1"/>-        <AnyChar attribute="Error" context="#stay" String="&symbolseps;"/>-        <IncludeRules context="FindWord"/>-        <IncludeRules context="FindGlobAny"/>-        <DetectChar context="ExprBracketValueMaybeBraceExpansion" char="{" lookAhead="1"/>-        <DetectChar attribute="Normal Text" context="#pop" char="}"/>-        <DetectIdentifier attribute="Normal Text"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="ExprBracketValueMaybeBraceExpansion">-        <IncludeRules context="DispatchBraceExpansion"/>-        <DetectChar attribute="Normal Text" context="#pop!ExprBracketValueRecBrace" char="{"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#stay" name="ExprBracketParam2" fallthroughContext="#pop!ExprBracketParam2_Value">-        <LineContinue attribute="Escape" context="SkipSpaces"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="ExprBracketParam2_Value" fallthroughContext="ExprBracketValue">-        <DetectSpaces attribute="Normal Text" context="#pop!ExprBracketParam3"/>-        <AnyChar context="TestMaybeBinary" String="-=!" lookAhead="1"/>-        <IncludeRules context="FindExprBracketEnd"/>-      </context>--      <context attribute="Normal Text" lineEndContext="ExprBracketFinal" name="ExprBracketParam3" fallthroughContext="#pop!ExprBracketParam3_Value">-        <LineContinue attribute="Escape" context="SkipSpaces"/>-      </context>-      <context attribute="Normal Text" lineEndContext="ExprBracketFinal" name="ExprBracketParam3_Value" fallthroughContext="ExprBracketValue">-        <DetectSpaces attribute="Normal Text" context="#pop!ExprBracketFinal"/>-        <IncludeRules context="FindExprBracketEnd"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#stay" name="ExprBracketFinal" fallthroughContext="ExprBracketValue">-        <DetectSpaces attribute="Normal Text" context="#stay"/>-        <IncludeRules context="FindExprBracketEnd"/>-        <RegExpr attribute="Expression" context="#pop!ExprBracket" String="-[ao]&eos;"/>-        <RegExpr attribute="Error" context="#pop" String="(?:[^] &tab;]++|\][^ &tab;])++" endRegion="expression"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#stay" name="FindExprBracketEnd">-        <DetectChar context="AssumeEscape" char="\" lookAhead="1"/>-        <RegExpr attribute="Builtin" context="#pop" String="\](?=($|[ &tab;;|&amp;&lt;>)]))" endRegion="expression"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#pop" name="TestMaybeUnary" fallthroughContext="#pop!ExprBracketValue">-        <RegExpr attribute="Expression" context="#pop#pop!ExprBracketParam2" String="&unary_operators;"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="TestMaybeBinary" fallthroughContext="#pop!ExprBracketValue">-        <RegExpr attribute="Expression" context="#pop" String="&binary_operators;"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#pop" name="SkipSpaces" fallthroughContext="#pop">-        <DetectSpaces context="#pop"/>-      </context>---      <!-- ExprDblBracket consumes an expression till ]] -->-      <context attribute="Normal Text" lineEndContext="#stay" name="ExprDblBracket" fallthroughContext="#pop!ExprDblBracketNot">-        <DetectSpaces attribute="Normal Text" context="#stay"/>-        <IncludeRules context="FindExprDblBracketEnd"/>-        <DetectChar attribute="Comment" context="Comment" char="#"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#stay" name="ExprDblBracketNot" fallthroughContext="#pop!ExprDblBracketParam1">-        <DetectChar context="ExprDblBracketTestMaybeNot" char="!" lookAhead="1"/>-        <DetectSpaces attribute="Normal Text" context="#stay"/>-        <DetectChar attribute="Comment" context="Comment" char="#"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="ExprDblBracketTestMaybeNot" fallthroughContext="#pop#pop!ExprDblBracketParam1">-        <RegExpr attribute="Expression" context="#pop" String="!(?=$|[ &tab;(])"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#stay" name="ExprDblBracketParam1" fallthroughContext="#pop!ExprDblBracketParam1_2">-        <DetectSpaces attribute="Normal Text" context="#stay"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="ExprDblBracketParam1_2" fallthroughContext="ExprDblBracketValueText">-        <DetectSpaces attribute="Normal Text" context="#pop!ExprDblBracketParam2"/>-        <DetectChar context="TestMaybeUnary2" char="-" lookAhead="1"/>-        <DetectChar context="ExprDblBracketSubValue" char="(" lookAhead="1"/>-        <IncludeRules context="FindExprDblBracketEnd"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="TestMaybeUnary2" fallthroughContext="#pop!ExprDblBracketValueText">-        <RegExpr attribute="Expression" context="#pop!ExprDblBracketUnary" String="&unary_operators;(?!\s+(?:=~|&binary_operators;))"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="ExprDblBracketUnary" fallthroughContext="#pop!ExprDblBracketValueText">-        <DetectSpaces attribute="Normal Text"/>-        <DetectChar attribute="Comment" context="Comment" char="#"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="ExprDblBracketSubValue" fallthroughContext="#pop">-        <DetectChar attribute="Operator" context="ExprDblBracketNot" char="("/>-        <DetectChar attribute="Operator" context="#pop" char=")"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#pop" name="ExprDblBracketValueText" fallthroughContext="#pop!ExprDblBracketValueText2">-        <Detect2Chars context="#pop!ExprDblBracketValueTextMaybeEnd" char="]" char1="]" lookAhead="1"/>-        <IncludeRules context="FindExprDblBracketValueTextPath"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="FindExprDblBracketValueTextPath">-        <RegExpr context="#pop!ExprDblBracketValueTextPath" String="&path_with_sep;|" lookAhead="1"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="ExprDblBracketValueTextMaybeEnd">-        <RegExpr attribute="Keyword" context="#pop#pop" String="&dblbracket_close;" endRegion="expression"/>-        <IncludeRules context="FindExprDblBracketValueTextPath"/>-        <Detect2Chars context="#pop!ExprDblBracketValueText2" char="]" char1="]" lookAhead="1"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="ExprDblBracketValueText2">-        <DetectIdentifier/>-        <AnyChar String="*?+@~^:%+-/,"/>-        <Detect2Chars attribute="Control" context="#pop#pop!ExprDblBracket" char="&amp;" char1="&amp;"/>-        <Detect2Chars attribute="Control" context="#pop#pop!ExprDblBracket" char="|" char1="|"/>-        <AnyChar context="#pop" String=" &tab;)" lookAhead="1"/>-        <IncludeRules context="FindWord"/>-        <IncludeRules context="FindGroupPattern"/>-        <AnyChar attribute="Error" context="#stay" String="&amp;;|"/>-        <DetectChar context="ExprDblBracketValueTextMaybeRange" char="&lt;" lookAhead="1"/>-        <DetectChar attribute="Expression" context="#pop!ExprDblBracketValuePattern" char=">"/>-      </context>-      <context attribute="Path" lineEndContext="#pop" name="ExprDblBracketValueTextPath">-        <IncludeRules context="ExprDblBracketValueText2"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="ExprDblBracketValueTextMaybeRange">-        <RegExpr context="#pop" String="&globrange;"/>-        <DetectChar attribute="Expression" context="#pop#pop!ExprDblBracketValuePattern" char="&lt;"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#pop" name="ExprDblBracketValuePattern" fallthroughContext="#pop!ExprDblBracketValuePattern2">-        <RegExpr context="ExprDblBracketValuePatternPath" String="&path_with_sep;|" lookAhead="1"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="ExprDblBracketValuePatternPath" fallthroughContext="#pop!PathThenPop">-        <DetectChar attribute="Path" context="#pop!PathThenPop" char="~"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="ExprDblBracketValuePattern2">-        <DetectIdentifier attribute="Normal Text"/>-        <Detect2Chars attribute="Control" context="#pop#pop!ExprDblBracket" char="&amp;" char1="&amp;"/>-        <Detect2Chars attribute="Control" context="#pop#pop!ExprDblBracket" char="|" char1="|"/>-        <AnyChar context="#pop" String=" &tab;)" lookAhead="1"/>-        <IncludeRules context="FindWord"/>-        <IncludeRules context="FindSingleGlob"/>-        <IncludeRules context="FindGlobAny"/>-        <IncludeRules context="FindGroupPattern"/>-        <DetectChar context="ExprDblBracketValueMaybeGlobRange" char="&lt;" lookAhead="1"/>-        <AnyChar attribute="Error" context="#stay" String=">&amp;|;"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="ExprDblBracketValueMaybeGlobRange">-        <IncludeRules context="FindGlobRangeThenPop"/>-        <DetectChar attribute="Error" context="#pop" char="&lt;"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#stay" name="ExprDblBracketParam2" fallthroughContext="#pop!ExprDblBracketParam2_2">-        <DetectSpaces attribute="Normal Text" context="#stay"/>-        <DetectChar attribute="Comment" context="Comment" char="#"/>-        <LineContinue attribute="Escape"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="ExprDblBracketParam2_2" fallthroughContext="ExprDblBracketValuePattern">-        <DetectSpaces attribute="Normal Text" context="#pop!ExprDblBracketParam3"/>-        <AnyChar context="TestMaybeBinary2" String="-=!" lookAhead="1"/>-        <AnyChar attribute="Expression" context="#pop!ExprDblBracketParam3Spe" String="&lt;>"/>-        <IncludeRules context="FindExprDblBracketEnd"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="TestMaybeBinary2" fallthroughContext="#pop!ExprDblBracketValuePattern">-        <IncludeRules context="TestMaybeBinary"/>-        <RegExpr attribute="Expression" context="#pop#pop!ExprDblBracketRegex" String="=~&eos;"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#stay" name="ExprDblBracketParam3Spe" fallthroughContext="#pop!ExprDblBracketParam3">-        <DetectSpaces attribute="Normal Text" context="#pop!ExprDblBracketParam3"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#stay" name="ExprDblBracketParam3" fallthroughContext="#pop!ExprDblBracketParam3_2">-        <IncludeRules context="ExprDblBracketParam2"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop!ExprDblBracketFinal" name="ExprDblBracketParam3_2" fallthroughContext="ExprDblBracketValuePattern">-        <DetectSpaces attribute="Normal Text" context="#pop!ExprDblBracketFinal"/>-        <IncludeRules context="FindExprDblBracketEnd"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#stay" name="ExprDblBracketFinal" fallthroughContext="ExprDblBracketValuePattern">-        <DetectSpaces attribute="Normal Text" context="#stay"/>-        <IncludeRules context="FindExprDblBracketEnd"/>-        <DetectChar attribute="Comment" context="Comment" char="#"/>-        <RegExpr attribute="Error" context="#pop" String="(?:[^] &tab;]++|\](?:[^]]|\][^ &tab;]))++" endRegion="expression"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#stay" name="FindExprDblBracketEnd">-        <DetectChar context="AssumeEscape" char="\" lookAhead="1"/>-        <DetectChar context="#pop" char=")" lookAhead="1"/>-        <Detect2Chars attribute="Control" context="#pop!ExprDblBracket" char="&amp;" char1="&amp;"/>-        <Detect2Chars attribute="Control" context="#pop!ExprDblBracket" char="|" char1="|"/>-        <RegExpr attribute="Keyword" context="#pop" String="&dblbracket_close;" endRegion="expression"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#stay" name="ExprDblBracketRegex" fallthroughContext="#pop!Regex">-        <DetectSpaces attribute="Normal Text" context="#stay"/>-        <DetectChar attribute="Comment" context="Comment" char="#"/>-      </context>-      <context attribute="Pattern" lineEndContext="#stay" name="Regex">-        <DetectIdentifier attribute="Pattern"/>-        <DetectSpaces attribute="Normal Text" context="#pop!ExprDblBracketFinal"/>-        <DetectChar attribute="Operator" context="#pop" char=")"/>-        <Detect2Chars attribute="Operator" context="RegexChar" char="[" char1="^"/>-        <DetectChar attribute="Operator" context="RegexChar" char="["/>-        <IncludeRules context="FindRegex"/>-      </context>-      <context attribute="Pattern" lineEndContext="#stay" name="ExprDblBracketSubRegex">-        <DetectIdentifier attribute="Pattern"/>-        <DetectSpaces attribute="Pattern" context="#stay"/>-        <DetectChar attribute="Operator" context="#pop" char=")"/>-        <Detect2Chars attribute="Operator" context="RegexSubChar" char="[" char1="^"/>-        <DetectChar attribute="Operator" context="RegexSubChar" char="["/>-        <IncludeRules context="FindRegex"/>-      </context>--      <context attribute="Pattern" lineEndContext="#stay" name="FindRegex">-        <DetectChar attribute="Operator" context="ExprDblBracketSubRegex" char="("/>-        <DetectChar attribute="Escape" context="RegexEscape" char="\"/>-        <DetectChar attribute="Parameter Expansion" context="RegexDup" char="{"/>-        <AnyChar attribute="Glob" context="#stay" String="^?+*.|"/>-        <IncludeRules context="FindStrings"/>-        <DetectChar context="RegexDispatchVariables" char="$" lookAhead="1"/>-        <DetectChar attribute="Backquote" context="RegularBackq" char="`"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="RegexDispatchVariables">-        <IncludeRules context="DispatchVariables"/>-        <DetectChar attribute="Operator" context="#pop" char="$"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#pop" name="RegexEscape">-        <RegExpr attribute="Escape" context="#pop" String="x[0-9a-fA-F]{1,2}|[0-7]{1,3}|."/>-      </context>--      <context attribute="Normal Text" lineEndContext="#pop" name="RegexDup">-        <Int attribute="Number"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#stay" char=","/>-        <DetectChar attribute="Parameter Expansion" context="#pop" char="}"/>-      </context>--      <context attribute="Pattern" lineEndContext="#pop" name="RegexSubChar" fallthroughContext="#pop!RegexSubInChar">-        <AnyChar attribute="Pattern" context="#pop!RegexSubInChar" String="-]"/>-      </context>-      <context attribute="Pattern" lineEndContext="#pop" name="RegexSubInChar">-        <DetectSpaces attribute="Pattern" context="#stay"/>-        <IncludeRules context="RegexInChar"/>-      </context>--      <context attribute="Pattern" lineEndContext="#pop" name="RegexChar" fallthroughContext="#pop!RegexInChar">-        <AnyChar attribute="Pattern" context="#pop!RegexInChar" String="-]"/>-      </context>-      <context attribute="Pattern" lineEndContext="#pop" name="RegexInChar">-        <Detect2Chars context="RegexInCharEnd" char="-" char1="]" lookAhead="1"/>-        <DetectChar attribute="Operator" context="#stay" char="-"/>-        <DetectChar attribute="Escape" context="RegexEscape" char="\"/>-        <DetectChar context="RegexCharClassSelect" char="[" lookAhead="1"/>-        <DetectChar attribute="Operator" context="#pop" char="]"/>-        <AnyChar context="#pop" String="() &tab;" lookAhead="1"/>-        <IncludeRules context="FindStrings"/>-      </context>-      <context attribute="Operator" lineEndContext="#stay" name="RegexInCharEnd">-        <DetectChar attribute="Pattern" context="#stay" char="-"/>-        <DetectChar attribute="Operator" context="#pop#pop" char="]"/>-      </context>-      <context attribute="Parameter Expansion" lineEndContext="#pop#pop#pop" name="RegexCharClassSelect">-        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!RegexCharClass" char="[" char1=":"/>-        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!RegexCollatingSymbols" char="[" char1="."/>-        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!RegexEquivalenceClass" char="[" char1="="/>-        <DetectChar attribute="Pattern" context="#pop" char="["/>-      </context>--      <context attribute="Parameter Expansion" lineEndContext="#pop#pop#pop" name="RegexCharClass">-        <DetectIdentifier attribute="Parameter Expansion"/>-        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop" char=":" char1="]"/>-        <DetectChar attribute="Error" context="#pop" char="]"/>-      </context>-      <context attribute="Parameter Expansion" lineEndContext="#pop#pop#pop" name="RegexCollatingSymbols">-        <DetectIdentifier attribute="Parameter Expansion"/>-        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop" char="." char1="]"/>-        <DetectChar attribute="Error" context="#pop" char="]"/>-      </context>-      <context attribute="Parameter Expansion" lineEndContext="#pop#pop#pop" name="RegexEquivalenceClass">-        <DetectIdentifier attribute="Parameter Expansion"/>-        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop" char="=" char1="]"/>-        <DetectChar attribute="Error" context="#pop" char="]"/>-      </context>--      <!-- SubShell consumes shell input till ) -->-      <context attribute="Normal Text" lineEndContext="#stay" name="SubShell" fallthroughContext="Command">-        <DetectChar attribute="Keyword" context="#pop" char=")" endRegion="subshell"/>-        <IncludeRules context="Start"/>-      </context>--      <!-- Assign consumes an expression till EOL or whitespace -->-      <context attribute="Normal Text" lineEndContext="#pop" name="Assign" fallthroughContext="#pop!RegularAssign">-        <DetectChar attribute="Variable" context="#pop!AssignArray" char="("/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="RegularAssign" fallthroughContext="#pop">-        <DetectChar attribute="Backquote" context="RegularBackq" char="`"/>-        <IncludeRules context="NormalOption"/>-      </context>--      <!-- AssignArray consumes everything till ), marking assignments -->-      <context attribute="Normal Text" lineEndContext="#stay" name="AssignArray" fallthroughContext="NormalOption">-        <DetectSpaces attribute="Normal Text" context="#stay"/>-        <DetectChar attribute="Comment" context="Comment" char="#"/>-        <DetectChar attribute="Variable" context="#pop" char=")"/>-        <DetectChar context="AssignArrayKey" char="[" lookAhead="1"/>-        <DetectChar attribute="Backquote" context="AssignArrayBackq" char="`"/>-        <AnyChar attribute="Error" context="#stay" String="&symbolseps;"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="AssignArrayKey" fallthroughContext="#pop">-        <DetectChar attribute="Parameter Expansion Operator" context="Subscript" char="["/>-        <DetectChar attribute="Variable" context="#pop" char="="/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="AssignArrayBackq" fallthroughContext="Command">-        <DetectChar attribute="Backquote" context="#pop!NormalOption" char="`"/>-        <DetectChar attribute="Comment" context="CommentBackq" char="#"/>-        <IncludeRules context="Start"/>-      </context>--      <!-- Subscript consumes anything till ], marks as Variable -->-      <context attribute="Normal Text" lineEndContext="#stay" name="Subscript" fallthroughContext="Subscript2">-        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="]"/>-        <AnyChar attribute="Number" context="#stay" String="0123456789-"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="Subscript2">-        <DetectIdentifier attribute="Normal Text"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop" char="]"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char=","/>-        <IncludeRules context="FindGroupPattern"/>-        <IncludeRules context="FindStrings"/>-        <DetectChar context="VariableOrSubscriptPos" char="$" lookAhead="1"/>-        <DetectChar attribute="Backquote" context="RegularBackq" char="`"/>-        <DetectChar context="AssumeEscape" char="\" lookAhead="1"/>-        <AnyChar attribute="Operator" context="#pop" String="@+-!~*/%&lt;>=&amp;^|?:"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#pop" name="VariableOrSubscriptPos">-        <IncludeRules context="DispatchVariables"/>-        <DetectChar attribute="Number" context="#pop" char="$"/>-      </context>--      <!-- FunctionDef consumes a name, possibly with (), marks as Function -->-      <context attribute="Function" lineEndContext="#pop" name="FunctionDef" fallthroughContext="#pop">-        <Detect2Chars attribute="Operator" context="#pop" char="(" char1=")"/>-        <DetectSpaces attribute="Normal Text" context="FunctionNameStart"/>-      </context>-      <context attribute="Function" lineEndContext="#pop" name="FunctionNameStart" fallthroughContext="#pop!FunctionName">-        <AnyChar context="#pop#pop" String="&symbolseps;#" lookAhead="1"/>-        <DetectChar context="FunctionNameStartMaybeBraceExpansion" char="{" lookAhead="1"/>-      </context>-      <context attribute="Function" lineEndContext="#pop" name="FunctionName">-        <AnyChar context="#pop" String=" &tab;(" lookAhead="1"/>-        <IncludeRules context="FindWord"/>-        <DetectChar context="FunctionNameMaybeBraceExpansion" char="{" lookAhead="1"/>-        <DetectChar context="NormalOptionMaybeGroupEnd" char="}" lookAhead="1"/>-        <DetectIdentifier attribute="Function"/>-      </context>-      <context attribute="Function" lineEndContext="#pop" name="FunctionNameRecBrace" fallthroughContext="#pop">-        <IncludeRules context="FindWord"/>-        <DetectChar context="FunctionNameMaybeBraceExpansion" char="{" lookAhead="1"/>-        <DetectChar attribute="Function" context="#pop" char="}"/>-        <DetectIdentifier attribute="Function"/>-      </context>-      <context attribute="Function" lineEndContext="#pop" name="FunctionNameStartMaybeBraceExpansion">-        <IncludeRules context="DispatchBraceExpansion"/>-        <DetectChar attribute="Keyword" context="#pop#pop#pop!Group" char="{" beginRegion="group"/>-      </context>-      <context attribute="Function" lineEndContext="#pop" name="FunctionNameMaybeBraceExpansion">-        <IncludeRules context="DispatchBraceExpansion"/>-        <DetectChar attribute="Function" context="#pop!FunctionNameRecBrace" char="{" beginRegion="group"/>-      </context>--      <!-- Case is called after the case keyword is encoutered. We handle this because of-           the lonely closing parentheses that would otherwise disturb the expr matching -->-      <context attribute="Normal Text" lineEndContext="#stay" name="Case">-        <DetectSpaces attribute="Normal Text" context="#stay"/>-        <DetectChar attribute="Keyword" context="#pop!CaseAlt" char="{"/>-        <WordDetect attribute="Keyword" context="#pop!CaseIn" String="in"/>-        <IncludeRules context="FindWord"/>-        <DetectIdentifier attribute="Normal Text" context="#stay"/>-      </context>--      <!-- CaseIn is called when the construct 'case ... in' has been found. -->-      <context attribute="Normal Text" lineEndContext="#stay" name="CaseIn" fallthroughContext="CasePattern">-        <DetectSpaces attribute="Normal Text" context="#stay"/>-        <DetectChar attribute="Keyword" context="CaseClosedPattern" char="("/>-        <DetectChar attribute="Comment" context="Comment" char="#"/>-      </context>-      <context attribute="Pattern" lineEndContext="#stay" name="CasePattern">-        <WordDetect attribute="Control Flow" context="#pop#pop" String="esac" endRegion="case"/>-        <IncludeRules context="CaseClosedPattern"/>-      </context>-      <context attribute="Pattern" lineEndContext="#stay" name="CaseClosedPattern">-        <DetectSpaces attribute="Normal Text" context="#stay"/>-        <DetectChar attribute="Keyword" context="#pop!CaseExpr" char=")" beginRegion="caseexpr"/>-        <DetectChar context="AssumeEscape" char="\" lookAhead="1"/>-        <DetectChar attribute="Keyword" context="#stay" char="|"/>-        <IncludeRules context="FindWord"/>-        <IncludeRules context="FindPattern"/>-        <DetectIdentifier attribute="Pattern" context="#stay"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#stay" name="CaseAlt" fallthroughContext="CasePattern">-        <DetectSpaces attribute="Normal Text" context="#stay"/>-        <DetectChar attribute="Keyword" context="CasePattern" char="("/>-        <DetectChar attribute="Keyword" context="#pop!CaseAltEnd" char="}" endRegion="caseexpr" lookAhead="1"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="CaseAltEnd">-        <DetectChar attribute="Keyword" context="#pop" char="}" endRegion="case"/>-      </context>--      <!-- CaseExpr eats shell input till ;; / ;& / ;| -->-      <context attribute="Normal Text" lineEndContext="#stay" name="CaseExpr" fallthroughContext="Command">-        <Detect2Chars attribute="Control Flow" context="#pop" char=";" char1="|" endRegion="caseexpr"/>-        <Detect2Chars attribute="Control Flow" context="#pop" char=";" char1=";" endRegion="caseexpr"/>-        <Detect2Chars attribute="Control Flow" context="#pop" char=";" char1="&amp;" endRegion="caseexpr"/>-        <WordDetect context="#pop" String="esac" endRegion="caseexpr" lookAhead="1"/>-        <DetectChar context="#pop" char="}" lookAhead="1"/>-        <IncludeRules context="Start"/>-      </context>--      <!-- ExprGlobParen is called after a ( is encountered in a argument -->-      <context attribute="Glob Flag" lineEndContext="#pop" name="ExprGlobParen" fallthroughContext="#pop">-        <Detect2Chars attribute="Glob Flag" context="#pop!GlobPatFlag" char="(" char1="#"/>-        <RegExpr attribute="Glob" context="#pop!ExtGlobPattern" String="\((?=&ispattern;)"/>-        <DetectChar attribute="Glob Flag" context="#pop!GlobQualifier" char="("/>-      </context>-      <context attribute="Glob Flag" lineEndContext="#pop" name="ExprGlobParenThenPath" fallthroughContext="#pop">-        <Detect2Chars attribute="Glob Flag" context="#pop!GlobPatFlagThenPath" char="(" char1="#"/>-        <RegExpr attribute="Glob" context="#pop!ExtGlobPatternThenPath" String="\((?=&ispattern;)"/>-        <DetectChar attribute="Glob Flag" context="#pop!GlobQualifier" char="("/>-      </context>-      <context attribute="Glob Flag" lineEndContext="#pop" name="GlobQualifier">-        <AnyChar attribute="Glob Flag" context="#stay" String="/F.@=p*%bcrwxAIERWXsStUG^-MTNDn"/>-        <AnyChar attribute="Glob Flag" context="GlobQualifier_e" String="eP"/>-        <AnyChar attribute="Glob Flag" context="GlobQualifier_u" String="ug"/>-        <AnyChar attribute="Glob Flag" context="GlobQualifier_a" String="amc"/>-        <AnyChar attribute="Glob Flag" context="GlobQualifier_o" String="oO"/>-        <DetectChar attribute="Glob Flag" context="GlobQualifier_f" char="f"/>-        <DetectChar attribute="Glob Flag" context="GlobQualifier_+" char="+"/>-        <DetectChar attribute="Glob Flag" context="GlobQualifier_d" char="d"/>-        <DetectChar attribute="Glob Flag" context="GlobQualifier_L" char="L"/>-        <DetectChar attribute="Glob Flag" context="GlobQualifier_Y" char="Y"/>-        <DetectChar attribute="Parameter Expansion Operator" context="Subscript" char="["/>--        <DetectChar attribute="Operator" context="#stay" char=","/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!GlobModifier" char=":"/>-        <DetectChar attribute="Glob Flag" context="#pop" char=")"/>-        <IncludeRules context="FindWord"/>-      </context>--      <context attribute="Normal Text" lineEndContext="#pop" name="GlobQualifier_o" fallthroughContext="#pop">-        <AnyChar attribute="Normal Text" context="#stay" String="nLlamcdN"/>-      </context>--      <context attribute="Number" lineEndContext="#pop" name="GlobQualifier_Y" fallthroughContext="#pop">-        <AnyChar attribute="Number" context="#stay" String="0123456789"/>-      </context>--      <context attribute="Glob Flag" lineEndContext="#pop" name="GlobQualifier_L" fallthroughContext="#pop">-        <AnyChar attribute="Normal Text" context="#stay" String="kKmMpPgGtT"/>-        <AnyChar attribute="Number" context="#pop!GlobQualifier_Y" String="-+0123456789"/>-      </context>--      <context attribute="Glob Flag" lineEndContext="#pop" name="GlobQualifier_a" fallthroughContext="#pop">-        <AnyChar attribute="Normal Text" context="#stay" String="Mwhmsd"/>-        <AnyChar attribute="Number" context="#pop!GlobQualifier_Y" String="-+0123456789"/>-      </context>--      <context attribute="Glob Flag" lineEndContext="#pop" name="GlobQualifier_+" fallthroughContext="#pop">-        <RegExpr attribute="Function" context="#pop" String="[^&_fragpathseps;=,\[]+"/>-      </context>--      <context attribute="Path" lineEndContext="#pop" name="GlobQualifier_d">-        <AnyChar context="#pop" String=")," lookAhead="1"/>-      </context>--      <context attribute="Glob Flag" lineEndContext="#pop" name="GlobQualifier_u">-        <AnyChar attribute="Number" context="#pop!GlobQualifier_Y" String="0123456789"/>-        <IncludeRules context="GlobQualifier_e"/>-      </context>--      <context attribute="Glob Flag" lineEndContext="#pop" name="GlobQualifier_f" fallthroughContext="#pop">-        <AnyChar attribute="Number" context="#pop!GlobQualifier_fo" String="0123456789=+-"/>-        <DetectChar attribute="Glob" context="#pop!GlobQualifier_fo" char="?"/>-        <DetectChar attribute="Glob Flag" context="#pop!GlobQualifier_f[" char="["/>-        <DetectChar attribute="Glob Flag" context="#pop!GlobQualifier_f&lt;" char="&lt;"/>-        <DetectChar attribute="Glob Flag" context="#pop!GlobQualifier_f{" char="{"/>-        <RegExpr attribute="Glob Flag" context="#pop!GlobQualifier_fx" String="(.)"/>-      </context>-      <context attribute="Number" lineEndContext="#pop" name="GlobQualifier_fo" fallthroughContext="#pop">-        <AnyChar attribute="Number" context="#stay" String="0123456789"/>-        <DetectChar attribute="Glob" context="#stay" char="?"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="GlobQualifier_f[">-        <DetectChar attribute="Operator" context="#stay" char=","/>-        <DetectChar attribute="Glob Flag" context="#pop" char="]"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="GlobQualifier_f&lt;">-        <DetectChar attribute="Operator" context="#stay" char=","/>-        <DetectChar attribute="Glob Flag" context="#pop" char=">"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="GlobQualifier_f{">-        <DetectChar attribute="Operator" context="#stay" char=","/>-        <DetectChar attribute="Glob Flag" context="#pop" char="}"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="GlobQualifier_fx">-        <DetectChar attribute="Operator" context="#stay" char=","/>-        <DetectChar attribute="Glob Flag" context="#pop" char="1" dynamic="1"/>-      </context>--      <context attribute="Glob Flag" lineEndContext="#pop" name="GlobQualifier_e" fallthroughContext="#pop">-        <DetectChar attribute="Glob Flag" context="#pop!GlobQualifier_e[" char="["/>-        <DetectChar attribute="Glob Flag" context="#pop!GlobQualifier_e&lt;" char="&lt;"/>-        <DetectChar attribute="Glob Flag" context="#pop!GlobQualifier_e{" char="{"/>-        <RegExpr attribute="Glob Flag" context="#pop!GlobQualifier_ex" String="(.)"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="IncGlobQualifier_e">-        <IncludeRules context="FindStrings"/>-        <DetectChar context="RegularVariable" char="$" lookAhead="1"/>-        <DetectChar attribute="Backquote" context="RegularBackq" char="`"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="GlobQualifier_e[">-        <DetectChar attribute="Glob Flag" context="#pop" char="]"/>-        <IncludeRules context="IncGlobQualifier_e"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="GlobQualifier_e&lt;">-        <DetectChar attribute="Glob Flag" context="#pop" char=">"/>-        <IncludeRules context="IncGlobQualifier_e"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="GlobQualifier_e{">-        <DetectChar attribute="Glob Flag" context="#pop" char="}"/>-        <IncludeRules context="IncGlobQualifier_e"/>-      </context>-      <context attribute="Normal Text" lineEndContext="#stay" name="GlobQualifier_ex">-        <DetectChar attribute="Glob Flag" context="#pop" char="1" dynamic="1"/>-        <IncludeRules context="IncGlobQualifier_e"/>-      </context>--      <!-- GlobPatFlag is called after a (# is encountered -->-      <context attribute="Glob Flag" lineEndContext="#pop" name="GlobPatFlag" fallthroughContext="#pop">-        <IncludeRules context="IncGlobPatFlag"/>-        <DetectChar attribute="Glob Flag" context="#pop" char=")"/>-      </context>-      <context attribute="Glob Flag" lineEndContext="#pop" name="GlobPatFlagThenPath" fallthroughContext="#pop">-        <IncludeRules context="IncGlobPatFlag"/>-        <DetectChar attribute="Glob Flag" context="#pop!PathThenPop" char=")"/>-      </context>-      <context attribute="Glob Flag" lineEndContext="#pop" name="IncGlobPatFlag" fallthroughContext="#pop">-        <AnyChar attribute="Glob Flag" context="#stay" String="ilIbBcmMaseuU,"/>-        <AnyChar attribute="Number" context="#stay" String="0123456789"/>-        <DetectChar attribute="Glob Flag" context="#pop!GlobQualifier" char="q"/>-      </context>--      <!-- GlobModifier is called after a : is encountered in a GlobQualifier -->-      <context attribute="Parameter Expansion" lineEndContext="#pop" name="GlobModifier">-        <DetectChar attribute="Parameter Expansion Operator" context="#stay" char=":"/>-        <AnyChar attribute="Parameter Expansion" context="VarBraceModifier_h" String="ht"/>-        <DetectChar attribute="Parameter Expansion" context="GlobModifier_s" char="s"/>-        <Detect2Chars attribute="Parameter Expansion" context="GlobModifier_s" char="g" char1="s"/>-        <DetectChar attribute="Glob Flag" context="#pop" char=")"/>-      </context>-      <context attribute="Parameter Expansion" lineEndContext="#stay" name="GlobModifier_s" fallthroughContext="#pop">-        <DetectChar attribute="Error" context="#pop#pop" char=")"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!GlobModifier_s_PatPrefix" char="/"/>-      </context>-      <context attribute="Pattern" lineEndContext="#stay" name="GlobModifier_s_PatPrefix" fallthroughContext="#pop!GlobModifier_s_Pat">-        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!GlobModifier_s_Pat" char="#" char1="%"/>-        <AnyChar attribute="Parameter Expansion Operator" context="#pop!GlobModifier_s_Pat" String="#%"/>-      </context>-      <context attribute="Pattern" lineEndContext="#stay" name="GlobModifier_s_Pat">-        <DetectChar attribute="Parameter Expansion Operator" context="#pop!GlobModifier_s_Rep" char="/"/>-        <IncludeRules context="FindWord"/>-        <IncludeRules context="FindSubPattern"/>-        <DetectChar attribute="Error" context="#pop#pop" char=")"/>-        <DetectIdentifier attribute="Pattern"/>-      </context>-      <context attribute="String DoubleQ" lineEndContext="#stay" name="GlobModifier_s_Rep">-        <DetectChar attribute="Glob Flag" context="#pop#pop" char=")"/>-        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="/"/>-        <DetectChar attribute="String DoubleQ" context="GlobModifier_s_RecursiveRep" char="("/>-        <IncludeRules context="FindWord"/>-        <DetectIdentifier attribute="String DoubleQ"/>-      </context>-      <context attribute="String DoubleQ" lineEndContext="#stay" name="GlobModifier_s_RecursiveRep">-        <DetectChar attribute="String DoubleQ" context="#pop" char=")"/>-        <DetectChar attribute="String DoubleQ" context="GlobModifier_s_RecursiveRep" char="("/>-        <IncludeRules context="FindWord"/>-        <DetectIdentifier attribute="String DoubleQ"/>-      </context>--    </contexts>--    <itemDatas>-      <itemData name="Normal Text"    defStyleNum="dsNormal"/>-      <itemData name="Comment"        defStyleNum="dsComment"/>-      <itemData name="Keyword"        defStyleNum="dsKeyword"       spellChecking="false"/>-      <itemData name="Control"        defStyleNum="dsKeyword"       spellChecking="false"/>-      <itemData name="Control Flow"   defStyleNum="dsControlFlow"   spellChecking="false"/>-      <itemData name="Builtin"        defStyleNum="dsBuiltIn"       spellChecking="false"/>-      <itemData name="Command"        defStyleNum="dsFunction"      spellChecking="false"/>-      <itemData name="OtherCommand"   defStyleNum="dsExtension"     spellChecking="false"/>-      <itemData name="Redirection"    defStyleNum="dsOperator"      spellChecking="false"/>-      <itemData name="Escape"         defStyleNum="dsDataType"      spellChecking="false"/>-      <itemData name="String SingleQ" defStyleNum="dsString"/>-      <itemData name="String DoubleQ" defStyleNum="dsString"/>-      <itemData name="Here Doc"       defStyleNum="dsString"/>-      <itemData name="Backquote"      defStyleNum="dsKeyword"       spellChecking="false"/>-      <itemData name="String Transl." defStyleNum="dsString"/>-      <itemData name="String Escape"  defStyleNum="dsDataType"/>-      <itemData name="Variable"       defStyleNum="dsVariable"      spellChecking="false"/>-      <itemData name="Dollar Prefix"  defStyleNum="dsVariable"      spellChecking="false"/>-      <itemData name="Expression"     defStyleNum="dsOthers"        spellChecking="false"/>-      <itemData name="Function"       defStyleNum="dsFunction"      spellChecking="false"/>-      <itemData name="Pattern"        defStyleNum="dsSpecialString" spellChecking="false"/>-      <itemData name="Path"           defStyleNum="dsNormal"        spellChecking="false"/>-      <itemData name="Glob"           defStyleNum="dsPreprocessor"  spellChecking="false"/>-      <itemData name="Glob Flag"      defStyleNum="dsOperator"      spellChecking="false"/>-      <itemData name="Option"         defStyleNum="dsAttribute"     spellChecking="false"/>-      <itemData name="Hex"            defStyleNum="dsBaseN"         spellChecking="false"/>-      <itemData name="Number"         defStyleNum="dsDecVal"        spellChecking="false"/>-      <itemData name="Base"           defStyleNum="dsDataType"      spellChecking="false"/>-      <itemData name="BaseN"          defStyleNum="dsBaseN"         spellChecking="false"/>-      <itemData name="File Descriptor" defStyleNum="dsDecVal"       spellChecking="false"/>-      <itemData name="Parameter Expansion" defStyleNum="dsVariable" spellChecking="false"/>-      <itemData name="Parameter Expansion Operator" defStyleNum="dsOperator" spellChecking="false"/>-      <itemData name="Operator"       defStyleNum="dsOperator"      spellChecking="false"/>-      <itemData name="Error"          defStyleNum="dsError"         spellChecking="false"/>-    </itemDatas>-  </highlighting>-  <general>-    <comments>-      <comment name="singleLine" start="#"/>+        <!ENTITY ws      " &tab;">+        <!ENTITY tab      "&#009;">+        <!ENTITY funcname "[^&_fragpathseps;=]*+">+        <!ENTITY varname  "[A-Za-z_][A-Za-z0-9_]*">+        <!ENTITY eos      "(?=$|[&ws;])">                 <!-- eol or space following -->+        <!ENTITY eoexpr   "(?=$|[&ws;&lt;>|&amp;;)])">++        <!ENTITY substseps  "${}'&quot;`\\">+        <!ENTITY symbolseps "&lt;>|&amp;;()">+        <!ENTITY wordseps   "&ws;&symbolseps;">+        <!ENTITY wordseps_or_extglog "&ws;>|&amp;;)`"> <!-- wordseps without < and ( -->+        <!ENTITY symbolseps_without_parens "&lt;>|&amp;;">+        <!ENTITY wordseps_without_parens   "&ws;&symbolseps_without_parens;">++        <!ENTITY bq_string  "`[^`]*+`">+        <!ENTITY sq_string  "'[^']*+'">+        <!ENTITY dq_string  "&quot;(?:[^&quot;\\`]*+|&bq_string;|\\.)*+&quot;">+        <!ENTITY strings    "(?:&sq_string;|&dq_string;|&bq_string;)">++        <!ENTITY simpleglob "*?#^~">+        <!ENTITY globrange  "&lt;[0-9]*-[0-9]*>">+        <!ENTITY globany    "\[(?:[^&wordseps;&quot;'`\\\[\]]+|\\.|&strings;|\[:\w+:\]|\[)*\]">++        <!ENTITY _fragpathseps  "&simpleglob;[&wordseps;&substseps;">+        <!ENTITY _fragpathnosep "(?:&_brace_noexpansion;)?+">+        <!ENTITY path        "(?:[^&_fragpathseps;]*+&_fragpathnosep;)*+">+        <!ENTITY fragpath    "(?:[^&_fragpathseps;/]*+&_fragpathnosep;)*+">+        <!ENTITY fragpathesc "\\.(?:[^&_fragpathseps;/]*+(?:\\.|&_brace_noexpansion;)?+)*+">+        <!ENTITY opt         "(?:[^&_fragpathseps;=/]*+&_fragpathnosep;)*+">+        <!ENTITY assumepath  "/&path;|(?=[&simpleglob;([]|&globrange;)">+        <!ENTITY pathpart    "(?:~(?:/&path;|(?=[&wordseps;]|$))|&fragpath;(?:&assumepath;|(?=&fragpathesc;&assumepath;))|\.\.?(?=[&wordseps;]|$))">++        <!-- Path only with / -->+        <!ENTITY path_with_sep_text  "[^[&wordseps;'&quot;`\\/]">+        <!ENTITY path_with_sep_text2 "[^[()&lt;>'&quot;`\\/]">+        <!ENTITY path_with_sep_expr  "\\.|&strings;|&globany;|&globrange;">+        <!ENTITY path_with_sep_spe   "(~|\.\.?)($|[/&ws;&lt;>|&amp;;)])">+        <!ENTITY path_with_sep_sub   "\((&path_with_sep_text2;++|&path_with_sep_expr;)*+(\)|(?=/))">+        <!ENTITY path_with_sep "/|&path_with_sep_spe;|(&path_with_sep_text;++|&path_with_sep_expr;|&path_with_sep_sub;)*+/">++        <!ENTITY _braceexpansion_spe     "&ws;&lt;>|&amp;;{}\\`'&quot;$">+        <!ENTITY _brace_noexpansion      "\{[^&_braceexpansion_spe;,]*+\}">+        <!ENTITY _braceexpansion_var     "\$(?:\{[^\[\]&_braceexpansion_spe;]*+(?:\[[*@a-zA-Z0-9]\])\})?">+        <!ENTITY _braceexpansion_elems   "\\.|&strings;|&_braceexpansion_var;|&_brace_noexpansion;">+        <!ENTITY _braceexpansion_consume "&_braceexpansion_elems;|{(?:[^&_braceexpansion_spe;,]++|&_braceexpansion_elems;)*?}|(?R)?+">+        <!ENTITY _braceexpansion "(?:[^&_braceexpansion_spe;,]++|&_braceexpansion_consume;)*?,(?:[^&_braceexpansion_spe;]++|&_braceexpansion_consume;)*?}">+        <!ENTITY braceexpansion "{&_braceexpansion;">++        <!ENTITY _bracerangevar "\$([#+^=~]*([_a-zA-Z0-9]+|[*@#])(\[((\$[#+^=~]*)?([-+_a-zA-Z0-9]+|[*@])|$#)\])?|#|'(\\.|[^'\\])')">+        <!ENTITY _bracerangeoperand "-?([0-9]+|[a-zA-Z!#$&#37;*+,-./:=?@^_~]|&_bracerangevar;|\\.|'[^'\\]'|&quot;(\\.|[^&quot;\\`])&quot;|`[^`]*`)">+        <!ENTITY bracerangeexpansion "{(?=&_bracerangeoperand;\.\.&_bracerangeoperand;(\.\.-?([0-9]+|&_bracerangevar;))?})">++        <!ENTITY nobraceexpansion "(?:{([^&_braceexpansion_spe;/{},]++|(?R))+?})+">+        <!ENTITY nogroupend "(?:}+(?:[^&_fragpathseps;]|(?=[}$'&quot;`\\])))">++        <!-- glob with |, ( or spaces is a pattern -->+        <!ENTITY _ispattern_ugN "[ug][0123456789]+">+        <!ENTITY _ispattern_ugeP "[ugeP](?:&_ispattern_ugeP_0;|&_ispattern_ugeP_1;|&_ispattern_ugeP_2;|&_ispattern_ugeP_3;|&_ispattern_ugeP_4;|(?=\|))">+        <!ENTITY _ispattern_ugeP_0    ":(?:[^:'`&quot;\\|()]*+(?:&_ispattern_q;)?)*(?::|(?=[|()]))">+        <!ENTITY _ispattern_ugeP_1   "\[(?:[^]'`&quot;\\|()]*+(?:&_ispattern_q;)?)*(?:\](?=[|()]))">+        <!ENTITY _ispattern_ugeP_2    "{(?:[^}'`&quot;\\|()]*+(?:&_ispattern_q;)?)*(?:}(?=[|()]))">+        <!ENTITY _ispattern_ugeP_3 "&lt;(?:[^>'`&quot;\\|()]*+(?:&_ispattern_q;)?)*(?:>|(?=[|()]))">+        <!ENTITY _ispattern_ugeP_4  "([^&wordseps;{}'&quot;`\\])(?:(?:(?!\1)[^'`&quot;\\\1|()])*+(?:&_ispattern_q;)?)*(?:\1|(?=[|()]))">+        <!ENTITY _ispattern_q "\\.|&strings;">+        <!ENTITY _ispattern_check "(?:\)(?:[^&ws;}&lt;>|&amp;;)]|&nogroupend;)|[&ws;|(]|$)">+        <!ENTITY ispattern "(?:[^&ws;\\'&quot;|()`ugeP]*+(?:&_ispattern_ugN;|&_ispattern_ugeP;|&_ispattern_q;)?)*&_ispattern_check;">++        <!ENTITY heredocq "(?|&quot;([^&quot;]+)&quot;|'([^']+)'|\\(.[^&wordseps;&substseps;]*))">++        <!ENTITY arithmetic_as_subshell "\(((?:[^`'&quot;()$]++|\$\{[^`'&quot;(){}$]+\}|\$(?=[^{`'&quot;()])|&bq_string;|\((?1)(?:[)]|(?=['&quot;])))++)(?:[)](?=$|[^)])|[&quot;'])">++        <!ENTITY unary_operators  "-[abcdefghknoprstuvwxzLOGNS](?=\\?$|[&ws;])">+        <!ENTITY binary_operators "(?:-(?:e[fq]|[nolg]t|[nlg]e)|==?|!=)(?=\\?$|[&ws;])">++        <!ENTITY dblbracket_close "\]\](?=($|[&ws;;|&amp;)]))">++        <!ENTITY int "(?:[0-9]++[_0-9]*+)">+        <!ENTITY exp "(?:[eE][-+]?_*+&int;)">++        <!ENTITY escaped_ch "(?:[abeEfnrtv\\']|[0-7]{1,3}|x[A-Fa-f0-9]{1,2}|u[A-Fa-f0-9]{1,4}|U[A-Fa-f0-9]{1,8}|c.)">++        <!-- just to make highlight range between selected bracket work well -->+        <!ENTITY paren_open "(">+        <!ENTITY paren_close ")">+        <!ENTITY brace_open "{">+        <!ENTITY brace_close "}">+        <!ENTITY bracket_open "[">+        <!ENTITY bracket_close "]">++        <!ENTITY arithmetic_op "+-!~*/&#37;&lt;>=&amp;^|?:">+]>++<!--+https://zsh.sourceforge.io/releases.html+current: 5.9+-->++<language name="Zsh" version="38" kateversion="6.22" section="Scripts" extensions="*.sh;*.zsh;.zshrc;.zprofile;.zlogin;.zlogout;.profile" mimetype="application/x-shellscript;text/x-shellscript" casesensitive="1" author="Jonathan Poelen (jonathan.poelen@gmail.com)" license="MIT">++  <highlighting>+    <list name="keywords">+      <item>continue</item>+      <item>break</item>+      <item>case</item>+      <item>do</item>+      <item>done</item>+      <item>elif</item>+      <item>else</item>+      <item>end</item>+      <item>esac</item>+      <item>fi</item>+      <item>for</item>+      <item>foreach</item>+      <item>function</item>+      <item>if</item>+      <item>in</item>+      <item>repeat</item>+      <item>return</item>+      <item>select</item>+      <item>then</item>+      <item>until</item>+      <item>while</item>+    </list>++<list name="builtins"><!-- see man zshbuiltins -->+	<item>-</item>+	<item>.</item>+	<item>:</item>+	<item>alias</item>+	<item>autoload</item>+	<item>bg</item>+	<item>bindkey</item>+	<item>builtin</item>+	<item>bye</item>+	<item>cap</item>+	<item>cd</item>+	<item>chdir</item>+	<item>clone</item>+	<item>command</item>+	<item>comparguments</item>+	<item>compcall</item>+	<item>compctl</item>+	<item>compdescribe</item>+	<item>compfiles</item>+	<item>compgroups</item>+	<item>compquote</item>+	<item>comptags</item>+	<item>comptry</item>+	<item>compvalues</item>+	<item>coproc</item>+	<item>dirs</item>+	<item>disable</item>+	<item>disown</item>+	<item>echo</item>+	<item>echotc</item>+	<item>echoti</item>+	<item>emulate</item>+	<item>enable</item>+	<item>eval</item>+	<item>exec</item>+	<item>exit</item>+	<item>false</item>+	<item>fc</item>+	<item>fg</item>+	<item>functions</item>+	<item>getcap</item>+	<item>hash</item>+	<item>history</item>+	<item>jobs</item>+	<item>kill</item>+	<item>limit</item>+	<item>log</item>+	<item>logout</item>+	<item>nocorrect</item>+	<item>noglob</item>+	<item>popd</item>+	<item>print</item>+	<item>printf</item>+	<item>pushd</item>+	<item>pushln</item>+	<item>pwd</item>+	<item>r</item>+	<item>rehash</item>+	<item>sched</item>+	<item>set</item>+	<item>setcap</item>+	<item>setopt</item>+	<item>shift</item>+	<item>source</item>+	<item>stat</item>+	<item>suspend</item>+	<item>test</item>+	<item>times</item>+	<item>trap</item>+	<item>true</item>+	<item>ttyctl</item>+	<item>type</item>+	<item>ulimit</item>+	<item>umask</item>+	<item>unalias</item>+	<item>unfunction</item>+	<item>unhash</item>+	<item>unlimit</item>+	<item>unset</item>+	<item>unsetopt</item>+	<item>vared</item>+	<item>wait</item>+	<item>whence</item>+	<item>where</item>+	<item>which</item>+	<item>zcompile</item>+	<item>zformat</item>+	<item>zftp</item>+	<item>zle</item>+	<item>zmodload</item>+	<item>zparseopts</item>+	<item>zprof</item>+	<item>zpty</item>+	<item>zregexparse</item>+	<item>zsocket</item>+	<item>zstyle</item>+	<item>ztcp</item>+    </list>++    <list name="builtins_var">+	<item>declare</item>+	<item>export</item>+	<item>float</item>+	<item>getln</item>+	<item>getopts</item>+	<item>integer</item>+	<item>let</item>+	<item>local</item>+	<item>read</item>+	<item>readonly</item>+	<item>typeset</item>+	<item>unset</item>+    </list>++    <list name="unixcommands">+      <include>unixcommands##Bash</include>+    </list>++    <contexts>+      <context attribute="Normal Text" lineEndContext="#stay" name="Start" fallthroughContext="Command">+        <IncludeRules context="FindSpaceAndComment"/>+        <!-- start expression in double parentheses -->+        <Detect2Chars context="ExprDblParenOrSubShell" char="(" char1="(" lookAhead="1"/>+        <!-- start a subshell -->+        <DetectChar attribute="Keyword" context="SubShell" char="(" beginRegion="subshell"/>+        <!-- start expression in single/double brackets -->+        <DetectChar context="MaybeBracketExpression" char="[" lookAhead="1"/>+        <!-- start a group command or BraceExpansion with { -->+        <DetectChar attribute="Keyword" context="Group" char="{" beginRegion="group"/>++        <!-- handle ` -->+        <DetectChar attribute="Backquote" context="CommandBackq" char="`"/>++        <!-- &> redirections -->+        <Detect2Chars attribute="Redirection" context="Prefix&amp;>" char="&amp;" char1=">"/>+        <Detect2Chars attribute="Control" context="#stay" char="&amp;" char1="!"/>++        <!-- handle branch conditions || && -->+        <IncludeRules context="FindBranchCondition"/>++        <!-- handle &, |, ; -->+        <AnyChar attribute="Control" context="#stay" String="&amp;|;"/>++        <!-- handle variable assignments -->+        <RegExpr attribute="Variable" context="VarAssign" String="&varname;(?=\+?=|\[(?:$|[^]]))|[0-9]+(?=\+?=)"/>+        <!-- handle keywords -->+        <keyword context="DispatchKeyword" String="keywords" lookAhead="1"/>+        <!-- handle commands that have variable names as argument -->+        <keyword attribute="Builtin" context="VarName" String="builtins_var" lookAhead="1"/>+        <WordDetect attribute="Builtin" context="#stay" String="noglob"/>+        <WordDetect attribute="Builtin" context="#stay" String="coproc"/>+        <!-- mark function definitions without function keyword -->+        <RegExpr attribute="Function" context="#stay" String="&funcname;[&ws;]*\(\)"/>+        <keyword attribute="Builtin" context="CommandArgs" String="builtins"/>+        <keyword attribute="Command" context="CommandArgs" String="unixcommands"/>++        <!-- handle redirection -->+        <AnyChar context="CommandMaybeRedirection" String="&lt;&gt;0123456789" lookAhead="1"/>++        <DetectChar attribute="Error" context="#stay" char=")"/>+        <DetectChar context="MaybeGroupEnd" char="}" lookAhead="1"/>++        <LineContinue attribute="Escape" context="#stay"/>++        <Detect2Chars attribute="Expression" context="#stay" char="!" char1=" "/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="MaybeGroupEnd">+        <RegExpr context="#pop!Command" String="&nogroupend;" lookAhead="1"/>+        <DetectChar attribute="Error" context="#pop" char="}"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="MaybeBracketExpression" fallthroughContext="#pop!Command">+        <!-- start expression in double brackets -->+        <RegExpr attribute="Keyword" context="#pop!ExprDblBracket" String="\[\[(?=$|[&ws;(])" beginRegion="expression"/>+        <!-- start expression in single brackets -->+        <RegExpr attribute="Builtin" context="#pop!ExprBracket" String="\[&eos;" beginRegion="expression"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="CommandMaybeRedirection" fallthroughContext="#pop!Command">+        <IncludeRules context="FindRedirection"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="Return" fallthroughContext="#pop">+        <DetectSpaces attribute="Normal Text" context="#stay"/>+        <Int attribute="Number" context="#stay"/>+      </context>+      <!-- Comment consumes shell comments till EOL -->+      <context attribute="Comment" lineEndContext="#pop" name="Comment">+        <DetectSpaces attribute="Comment"/>+        <IncludeRules context="##Comments"/>+        <DetectIdentifier attribute="Comment" context="#stay"/>+      </context>++      <!-- Group is called after a { is encountered -->+      <context attribute="Normal Text" lineEndContext="#stay" name="Group" fallthroughContext="Command">+        <DetectChar attribute="Keyword" context="#pop!GroupEnd" char="}" endRegion="group"/>+        <IncludeRules context="Start"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="GroupEnd" fallthroughContext="#pop!CommandArgs">+        <DetectSpaces attribute="Normal Text" context="#stay"/>+        <WordDetect attribute="Control Flow" context="#pop" String="always"/>+      </context>++      <context attribute="OtherCommand" lineEndContext="#pop" name="Command">+        <DetectSpaces attribute="Normal Text" context="#pop!CommandArgs"/>+        <DetectIdentifier attribute="OtherCommand" context="#stay"/>+        <IncludeRules context="FindVariableOrCurrentStyle"/>+        <IncludeRules context="FindStrings"/>+        <Detect2Chars attribute="Control" context="#pop" char="&amp;" char1="&amp;"/>+        <Detect2Chars attribute="Control" context="#pop" char="|" char1="|"/>+        <DetectChar attribute="Control" context="#pop" char="|"/>+        <AnyChar context="#pop" String=";)`" lookAhead="1"/>+        <AnyChar context="#pop!CommandArgs" String="&amp;&lt;>" lookAhead="1"/>+        <!-- start expression in double parentheses -->+        <Detect2Chars attribute="Error" context="#pop!ExprDblParen" char="(" char1="(" beginRegion="expression"/>+        <!-- start a subshell -->+        <DetectChar attribute="Error" context="#pop!SubShell" char="(" beginRegion="subshell"/>+        <DetectChar context="CommandAssumeEscape" char="\" lookAhead="1"/>+        <DetectChar context="CommandMaybeBraceExpansion" char="{" lookAhead="1"/>+        <DetectChar context="CommandMaybeGroupEnd" char="}" lookAhead="1"/>+      </context>+      <context attribute="OtherCommand" lineEndContext="#pop" name="CommandAssumeEscape">+        <LineContinue attribute="Escape" context="#pop"/>+        <RegExpr attribute="OtherCommand" context="#pop" String="\\."/>+      </context>+      <context attribute="OtherCommand" lineEndContext="#pop" name="CommandMaybeBraceExpansion">+        <IncludeRules context="DispatchBraceExpansion"/>+        <DetectChar attribute="OtherCommand" context="#pop" char="{"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="CommandMaybeGroupEnd">+        <RegExpr attribute="OtherCommand" context="#pop" String="&nogroupend;+"/>+        <DetectChar context="#pop#pop" char="}" lookAhead="1"/>+      </context>++      <!-- $... -->+      <context attribute="Variable" lineEndContext="#pop" name="DispatchVariables">+        <IncludeRules context="DispatchSubstVariables"/>+        <IncludeRules context="DispatchStringVariables"/>+        <IncludeRules context="DispatchVarNameVariables"/>+      </context>++      <!-- ${var}+           ~~+      -->+      <context attribute="Variable" lineEndContext="#pop" name="DispatchSubstVariables">+        <Detect2Chars attribute="Parameter Expansion" context="#pop!VarBraceStart" char="$" char1="{"/>+        <StringDetect context="#pop!ExprDblParenSubstOrSubstCommand" String="$((" lookAhead="1"/>+        <Detect2Chars attribute="Parameter Expansion" context="#pop!SubstCommand" char="$" char1="(" beginRegion="subshell"/>+        <StringDetect attribute="Parameter Expansion" context="#pop!ExprBracketSubst" String="$[" beginRegion="expression"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="ExprBracketSubst">+        <DetectChar attribute="Parameter Expansion" context="#pop" char="]" endRegion="expression"/>+        <IncludeRules context="FindArithmetic"/>+      </context>++      <!-- $'...'+           ~~+      -->+      <context attribute="Variable" lineEndContext="#pop" name="DispatchStringVariables">+        <Detect2Chars attribute="String SingleQ" context="#pop!StringEsc" char="$" char1="'"/>+      </context>++      <!-- $var $1 $* etc+           ~    ~  ~+      -->+      <context attribute="Variable" lineEndContext="#pop" name="DispatchVarNameVariables">+        <RegExpr attribute="Dollar Prefix" context="#pop!VarNamePrefixedWithDollar" String="\$(?=&varname;|[-*@?$!#~=^+0-9])"/>+      </context>+      <context attribute="Variable" lineEndContext="#pop" name="VarNamePrefixedWithDollar">+        <DetectIdentifier attribute="Variable" context="#pop!AfterVarName"/>+        <Int attribute="Variable" context="#pop!AfterVarName" additionalDeliminator="$"/>+        <AnyChar attribute="Variable" context="#pop!AfterVarName" String="-*@?$!"/>+        <AnyChar attribute="Parameter Expansion Operator" context="#pop!VarNameSubstLen" String="#+"/>+        <AnyChar attribute="Parameter Expansion Operator" context="#pop!VarNameParam" String="~=^"/>+      </context>+      <context attribute="Variable" lineEndContext="#pop" name="VarNameSubstLen" fallthroughContext="#pop!AfterVarName">+        <DetectIdentifier attribute="Variable" context="#pop!AfterVarName"/>+        <AnyChar attribute="Variable" context="#pop!AfterVarName" String="-*@?$!"/>+        <Int attribute="Variable" context="#pop!AfterVarName" additionalDeliminator="#~=^+{}[]:-/$"/>+      </context>+      <context attribute="Variable" lineEndContext="#pop" name="VarNameParam" fallthroughContext="#pop!AfterVarName">+        <AnyChar attribute="Parameter Expansion Operator" context="#pop!VarNameSubstLen" String="#+"/>+        <AnyChar attribute="Parameter Expansion Operator" context="#stay" String="^=~"/>+        <IncludeRules context="VarNameSubstLen"/>+      </context>++      <!-- called as soon as $xxx is encoutered+        $var:... $var[xxx]:...+            ~        ~    ~+      -->+      <context attribute="Normal Text" lineEndContext="#pop" name="AfterVarName" fallthroughContext="#pop">+        <DetectChar context="VarNameDispatchModifiers" char=":" lookAhead="1"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!AfterVarNameSubscript!Subscript" char="["/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="AfterVarNameSubscript" fallthroughContext="#pop">+        <DetectChar context="VarNameDispatchModifiers" char=":" lookAhead="1"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop#pop" name="VarNameDispatchModifiers" fallthroughContext="#pop#pop">+        <StringDetect attribute="Parameter Expansion" String=":a"/>+        <StringDetect attribute="Parameter Expansion" String=":A"/>+        <StringDetect attribute="Parameter Expansion" String=":c"/>+        <StringDetect attribute="Parameter Expansion" String=":e"/>+        <StringDetect attribute="Parameter Expansion" String=":h"/>+        <StringDetect attribute="Parameter Expansion" String=":l"/>+        <StringDetect attribute="Parameter Expansion" String=":p"/>+        <StringDetect attribute="Parameter Expansion" String=":P"/>+        <StringDetect attribute="Parameter Expansion" String=":q"/>+        <StringDetect attribute="Parameter Expansion" String=":Q"/>+        <StringDetect attribute="Parameter Expansion" String=":r"/>+        <StringDetect attribute="Parameter Expansion" context="VarNameModifier_s" String=":s"/>+        <StringDetect attribute="Parameter Expansion" String=":t"/>+        <StringDetect attribute="Parameter Expansion" String=":u"/>+        <StringDetect attribute="Parameter Expansion" context="VarNameModifier_s" String=":gs"/>+        <StringDetect String=":f" context="VarNameModifier_fFwW_Check" lookAhead="1"/>+        <StringDetect String=":F" context="VarNameModifier_fFwW_Check" lookAhead="1"/>+        <StringDetect String=":w" context="VarNameModifier_fFwW_Check" lookAhead="1"/>+        <StringDetect String=":W" context="VarNameModifier_fFwW_Check" lookAhead="1"/>+      </context>+++      <!-- $var:s/../....+                 ~~~~~...+      -->+      <context attribute="Parameter Expansion Operator" lineEndContext="#pop#pop#pop" name="VarNameModifier_s" fallthroughContext="#pop#pop#pop">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop!VarNameModifier_s_Str" char="/"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop!VarNameModifier_s_StrSQ_Sep" char="'"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop!VarNameModifier_s_StrDQ_Sep" char='"'/>+        <RegExpr attribute="Parameter Expansion Operator" context="#pop#pop!VarNameModifier_s_C_Rep!VarNameModifier_s_C_Str" String="([^&wordseps;\[\]{}\\])"/>+      </context>+      <!-- By default the left-hand side of substitutions are character strings,+      but pattern with HIST_SUBST_PATTERN option. Assume no option. -->+      <!-- $var:s/../....+                  ~~~+      -->+      <context attribute="Verbatim String" lineEndContext="#pop#pop" name="VarNameModifier_s_Str">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarNameModifier_s_Rep" char="/"/>+        <IncludeRules context="FindEscape"/>+        <DetectChar attribute="String SingleQ" context="VarNameModifier_s_StrSQ" char="'"/>+        <DetectChar attribute="String DoubleQ" context="VarNameModifier_s_StrDQ" char='"'/>+        <AnyChar context="#pop#pop" String="&wordseps;" lookAhead="1"/>+      </context>+      <!-- #pop -> is VarNameModifier_s_C_Rep -->+      <context attribute="Verbatim String" lineEndContext="#pop#pop#pop" name="VarNameModifier_s_C_Str">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="1" dynamic="1"/>+        <IncludeRules context="FindEscape"/>+        <!-- The string should stop if capture $1 is found,+        but there is no way to propagate the capture. -->+        <IncludeRules context="FindStrings"/>+        <AnyChar context="#pop#pop#pop" String="&wordseps;" lookAhead="1"/>+      </context>+      <!-- $var:s/..'../..'..  $var:s/..'..'../..+                    ~~~~                ~~~~+      -->+      <context attribute="String SingleQ" name="VarNameModifier_s_StrSQ">+        <DetectChar attribute="String SingleQ" context="#pop" char="'"/>+        <LineContinue attribute="Escape"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop!VarNameModifier_s_Rep!VarNameModifier_s_RepSQ" char="/"/>+      </context>+      <!-- $var:s'..'..+                 ~~~~+      -->+      <context attribute="String SingleQ" name="VarNameModifier_s_StrSQ_Sep">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarNameModifier_s_Rep" char="'"/>+        <LineContinue attribute="Escape"/>+      </context>+      <!-- $var:s/.."../.."..  $var:s/..".."../..+                    ~~~~                ~~~~+      -->+      <context attribute="String DoubleQ" name="VarNameModifier_s_StrDQ">+        <DetectChar attribute="String DoubleQ" context="#pop" char='"'/>+        <IncludeRules context="FindEscape"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop!VarNameModifier_s_Rep!VarNameModifier_s_RepDQ" char="/"/>+      </context>+      <!-- $var:s".."..+                 ~~~~+      -->+      <context attribute="String DoubleQ" name="VarNameModifier_s_StrDQ_Sep">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarNameModifier_s_Rep" char='"'/>+        <IncludeRules context="FindEscape"/>+      </context>+      <!-- $var:s/../....+                     ~~..+      -->+      <context attribute="Replacement String" lineEndContext="#pop#pop" name="VarNameModifier_s_Rep">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="/"/>+        <!-- FindWord with a search for '/' in single and double quoted string -->+        <DetectChar attribute="String SingleQ" context="VarNameModifier_s_RepSQ" char="'"/>+        <DetectChar attribute="String DoubleQ" context="VarNameModifier_s_RepDQ" char="&quot;"/>+        <IncludeRules context="VarNameModifier_s_Rep_Common"/>+      </context>+      <context attribute="Replacement String" lineEndContext="#pop#pop" name="VarNameModifier_s_C_Rep">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="1" dynamic="1"/>+        <!-- The string should stop if capture $1 is found,+        but there is no way to propagate the capture. -->+        <IncludeRules context="FindVarNameModifier_s_C_RepQ"/>+        <IncludeRules context="VarNameModifier_s_Rep_Common"/>+      </context>+      <context attribute="Replacement String" name="FindVarNameModifier_s_C_RepQ">+        <DetectChar attribute="String SingleQ" context="VarNameModifier_s_C_RepSQ" char="'"/>+        <DetectChar attribute="String DoubleQ" context="VarNameModifier_s_C_RepDQ" char="&quot;"/>+      </context>+      <context attribute="Replacement String" lineEndContext="#pop#pop" name="VarNameModifier_s_Rep_Common">+        <IncludeRules context="FindVariable"/>+        <DetectChar attribute="Backquote" context="RegularBackq" char="`"/>+        <IncludeRules context="FindEscape"/>+        <AnyChar context="#pop#pop" String="&wordseps;" lookAhead="1"/>+      </context>+      <!-- $var:s/../..'../'..  $var:s/../..'..'..+                       ~~~~                 ~~~~+      -->+      <context attribute="String SingleQ" name="VarNameModifier_s_RepSQ">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop#pop#pop!StringSQ" char="/"/>+        <IncludeRules context="VarNameModifier_s_C_RepSQ"/>+      </context>+      <context attribute="String SingleQ" name="VarNameModifier_s_C_RepSQ">+        <IncludeRules context="StringSQ"/>+        <!-- When no HIST_SUBST_PATTERN -->+        <DetectChar attribute="Builtin" char="&amp;"/>+        <StringDetect attribute="String Escape" String="\&amp;"/>+      </context>+      <!-- $var:s/../.."../"..  $var:s/../..".."..+                       ~~~~                 ~~~~+      -->+      <context attribute="String DoubleQ" name="VarNameModifier_s_RepDQ">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop#pop#pop!StringDQ" char="/"/>+        <IncludeRules context="VarNameModifier_s_C_RepDQ"/>+      </context>+      <context attribute="String DoubleQ" name="VarNameModifier_s_C_RepDQ">+        <!-- When no HIST_SUBST_PATTERN -->+        <StringDetect attribute="String Escape" String="\&amp;"/>+        <IncludeRules context="StringDQ"/>+        <!-- When no HIST_SUBST_PATTERN -->+        <DetectChar attribute="Builtin" char="&amp;"/>+      </context>+++      <!-- $var:fwh+               ~..+      -->+      <context attribute="Normal Text" name="VarNameModifier_fFwW_Check" fallthroughContext="#pop#pop#pop">+        <RegExpr attribute="Parameter Expansion" context="VarNameModifier_fFwW" String=":(?=(?:[fw]|[FW](?:&strings;|\([^&paren_close;&symbolseps;]*+\)|\{[^&brace_close;&wordseps;]*+\}|\[[^&bracket_close;&wordseps;]*+\]|([^&wordseps;{}])(?:[^&quot;'`\s&wordseps;]|&strings;)*?\1))+(?:[aAcehlpPqQrstu]|gs))|"/>+      </context>+      <!-- $var:fW(2)h+                ~~   ~+      -->+      <context attribute="Normal Text" name="VarNameModifier_fFwW" lineEndContext="#pop#pop#pop#pop">+        <AnyChar attribute="Parameter Expansion" String="fw"/>+        <DetectChar attribute="Parameter Expansion" context="VarNameModifier_F" char="F"/>+        <DetectChar attribute="Parameter Expansion" context="VarNameModifier_W" char="W"/>+        <AnyChar attribute="Parameter Expansion" context="#pop#pop" String="aAcehlpPqQrtu"/>+        <StringDetect attribute="Parameter Expansion" context="#pop#pop!VarNameModifier_s" String=":s"/>+        <StringDetect attribute="Parameter Expansion" context="#pop#pop!VarNameModifier_s" String=":gs"/>+      </context>+      <!-- $var:F(expr)h+                 ~~~~~~+      -->+      <context attribute="Normal Text" name="VarNameModifier_F" lineEndContext="#pop#pop#pop#pop#pop">+        <IncludeRules context="FindStringsThenPop"/>+        <DetectChar attribute="Parameter Expansion Operator" context="ArithmeticParamColon" char=":"/>+        <DetectChar attribute="Parameter Expansion Operator" context="ArithmeticParamParen" char="("/>+        <DetectChar attribute="Parameter Expansion Operator" context="ArithmeticParamBracket" char="["/>+        <DetectChar attribute="Parameter Expansion Operator" context="ArithmeticParamBrace" char="{"/>+        <RegExpr attribute="Parameter Expansion Operator" context="ArithmeticParamDyn" String="(.)"/>+      </context>+      <context attribute="Normal Text" name="ArithmeticParamParen" lineEndContext="#pop#pop">+        <IncludeRules context="VerbatimParamParen"/>+        <IncludeRules context="FindArithmetic"/>+      </context>+      <context attribute="Normal Text" name="ArithmeticParamBracket" lineEndContext="#pop#pop">+        <IncludeRules context="VerbatimParamBracket"/>+        <IncludeRules context="FindArithmetic"/>+      </context>+      <context attribute="Normal Text" name="ArithmeticParamBrace" lineEndContext="#pop#pop">+        <IncludeRules context="VerbatimParamBrace"/>+        <IncludeRules context="FindArithmetic"/>+      </context>+      <context attribute="Normal Text" name="ArithmeticParamColon" lineEndContext="#pop#pop">+        <IncludeRules context="VerbatimParamColon"/>+        <IncludeRules context="FindArithmetic"/>+      </context>+      <context attribute="Normal Text" name="ArithmeticParamDyn" lineEndContext="#pop#pop">+        <IncludeRules context="VerbatimParamDyn"/>+        <IncludeRules context="FindArithmetic"/>+      </context>+      <!-- $var:W(xxx)h+                 ~~~~~+      -->+      <context attribute="Normal Text" name="VarNameModifier_W" lineEndContext="#pop#pop#pop#pop#pop">+        <IncludeRules context="FindStringsThenPop"/>+        <DetectChar attribute="Parameter Expansion Operator" context="VerbatimParamColon" char=":"/>+        <DetectChar attribute="Parameter Expansion Operator" context="VerbatimParamParen" char="("/>+        <DetectChar attribute="Parameter Expansion Operator" context="VerbatimParamBracket" char="["/>+        <DetectChar attribute="Parameter Expansion Operator" context="VerbatimParamBrace" char="{"/>+        <RegExpr attribute="Parameter Expansion Operator" context="VerbatimParamDyn" String="(.)"/>+      </context>+      <context attribute="Verbatim String" name="VerbatimParamParen" lineEndContext="#pop#pop">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop" char=")"/>+      </context>+      <context attribute="Verbatim String" name="VerbatimParamBracket" lineEndContext="#pop#pop">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop" char="]"/>+      </context>+      <context attribute="Verbatim String" name="VerbatimParamBrace" lineEndContext="#pop#pop">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop" char="}"/>+      </context>+      <context attribute="Verbatim String" name="VerbatimParamColon" lineEndContext="#pop#pop">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop" char=":"/>+      </context>+      <context attribute="Verbatim String" name="VerbatimParamDyn" lineEndContext="#pop#pop">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop" char="1" dynamic="1"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#stay" name="CommandBackq" fallthroughContext="Command">+        <DetectChar attribute="Backquote" context="#pop!CommandArgs" char="`"/>+        <DetectChar attribute="Comment" context="CommentBackq" char="#"/>+        <IncludeRules context="Start"/>+      </context>+      <!-- CommentBackq consumes shell comments till EOL or a backquote -->+      <context attribute="Comment" lineEndContext="#pop" name="CommentBackq">+        <DetectChar context="#pop" char="`" lookAhead="1"/>+        <IncludeRules context="Comment"/>+      </context>++      <!-- CommandArgs matches the items after a command -->+      <context attribute="Normal Text" lineEndContext="#pop" name="CommandArgs" fallthroughContext="CommandArg">+        <DetectSpaces attribute="Normal Text" context="#stay"/>++        <!-- &> redirections -->+        <Detect2Chars attribute="Redirection" context="Prefix&amp;>" char="&amp;" char1=">"/>++        <!-- handle &, |, ;, ` -->+        <AnyChar context="#pop" String="&amp;|;`" lookAhead="1"/>++        <!-- handle process subst -->+        <Detect2Chars attribute="Redirection" context="ProcessSubst" char="=" char1="("/>+        <!-- handle redirection -->+        <AnyChar context="CommandArgMaybeRedirection" String="&gt;&lt;0123456789" lookAhead="1"/>++        <DetectChar context="#pop" char=")" lookAhead="1"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop#pop" name="CommandArg" fallthroughContext="#pop!NormalOption">+        <!-- In command arguments, do not allow comments after escaped characters.+             This avoids highlighting comments within paths or other text. Ex: pathtext\ #no\ comment -->+        <DetectChar context="#pop#pop" char="#" lookAhead="1"/>+        <Detect2Chars attribute="Option" context="#pop!LongOption" char="-" char1="-"/>+        <DetectChar attribute="Option" context="#pop!ShortOption" char="-"/>+        <DetectChar attribute="Keyword" context="#pop!NormalOption" char="="/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="CommandArgMaybeRedirection" fallthroughContext="#pop!NormalOption">+        <IncludeRules context="FindRedirection"/>+      </context>++      <context attribute="Option" lineEndContext="#pop" name="ShortOption" fallthroughContext="#pop">+        <DetectChar attribute="Path" context="PathThenPop" char="/"/>+        <IncludeRules context="LongOption"/>+      </context>+      <context attribute="Option" lineEndContext="#pop" name="LongOption" fallthroughContext="#pop">+        <AnyChar context="#pop" String="&wordseps_or_extglog;" lookAhead="1"/>+        <DetectChar attribute="Operator" context="#pop!NormalOption" char="="/>+        <IncludeRules context="FindWord"/>+        <IncludeRules context="FindSingleGlob"/>+        <IncludeRules context="FindGlobAny"/>+        <AnyChar context="#pop!NormalOption" String="({}&lt;" lookAhead="1"/>+        <RegExpr attribute="Option" context="#stay" String="&opt;"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="NormalOption" fallthroughContext="#pop">+        <AnyChar context="#pop" String="&wordseps_or_extglog;" lookAhead="1"/>+        <IncludeRules context="FindWord"/>+        <DetectChar attribute="Glob" context="PathThenPop" char="[" lookAhead="1"/>+        <DetectChar context="ExprGlobParenThenPath" char="(" lookAhead="1"/>+        <IncludeRules context="FindPathThenPop"/>+        <DetectChar context="NormalOptionMaybeBraceExpansion" char="{" lookAhead="1"/>+        <DetectChar context="NormalOptionMaybeGroupEnd" char="}" lookAhead="1"/>+        <IncludeRules context="FindNormalTextOption"/>+        <DetectChar context="MaybeGlobRangeOrPop" char="&lt;" lookAhead="1"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop#pop" name="NormalOptionRecBrace">+        <AnyChar context="#pop#pop" String="&wordseps_or_extglog;" lookAhead="1"/>+        <IncludeRules context="FindWord"/>+        <IncludeRules context="FindSingleGlob"/>+        <IncludeRules context="FindGlobAny"/>+        <DetectChar context="ExprGlobParen" char="(" lookAhead="1"/>+        <DetectChar context="NormalOptionMaybeBraceExpansion" char="{" lookAhead="1"/>+        <DetectChar attribute="Normal Text" context="#pop" char="}"/>+        <DetectChar context="MaybeGlobRangeOrPop" char="&lt;" lookAhead="1"/>+        <DetectIdentifier/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="NormalOptionMaybeGroupEnd">+        <IncludeRules context="FindNoGroupEndThenPop"/>+        <DetectChar context="#pop#pop#pop" char="}" lookAhead="1"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="FindNoGroupEndThenPop">+        <RegExpr context="#pop" String="&nogroupend;"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="FindNormalTextOption">+        <RegExpr attribute="Normal Text" context="#stay" String="([^[&wordseps;&substseps;]+|&nogroupend;)+"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="NormalOptionMaybeBraceExpansion">+        <IncludeRules context="DispatchBraceExpansion"/>+        <DetectChar attribute="Normal Text" context="#pop!NormalOptionRecBrace" char="{"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#pop" name="FindEscape">+        <DetectChar context="AssumeEscape" char="\" lookAhead="1"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="AssumeEscape">+        <LineContinue attribute="Escape" context="#pop"/>+        <RegExpr attribute="Escape" context="#pop" String="\\."/>+      </context>++<!-- ====== The following rulessets are meant to be included ======== -->++      <!-- FindRedirection consumes shell redirection -->+      <context attribute="Normal Text" lineEndContext="#pop" name="FindRedirection">+        <RegExpr attribute="File Descriptor" context="#pop!AssumeRedirection" String="[0-9]++(?=[&lt;>])"/>+        <IncludeRules context="AssumeRedirection"/>+      </context>++      <!-- DispatchBraceExpansion consumes brace expansions -->+      <context attribute="Normal Text" lineEndContext="#pop" name="DispatchBraceExpansion">+        <RegExpr context="#pop!BraceExpansion" String="&braceexpansion;" lookAhead="1"/>+        <IncludeRules context="IncBraceExpansion"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="DispatchPathBraceExpansion">+        <RegExpr context="#pop!PathBraceExpansion" String="&braceexpansion;" lookAhead="1"/>+        <IncludeRules context="IncBraceExpansion"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="IncBraceExpansion">+        <RegExpr attribute="Escape" context="#pop!SequenceExpression" String="&bracerangeexpansion;"/>+        <RegExpr context="#pop" String="&nobraceexpansion;"/>+      </context>++      <!-- FindPathThenPop consumes path -->+      <context attribute="Normal Text" lineEndContext="#pop" name="FindPathThenPop">+        <AnyChar attribute="Glob" context="PathThenPop" String="?*#^"/>+        <RegExpr attribute="Path" context="PathThenPop" String="&pathpart;"/>+        <DetectChar attribute="Glob" context="PathThenPop" char="~"/>+      </context>+      <context attribute="Path" lineEndContext="#pop#pop" name="IncPath">+        <IncludeRules context="FindWord"/>+        <IncludeRules context="FindSingleGlob"/>+        <IncludeRules context="FindGlobAny"/>+        <DetectChar context="ExprGlobParen" char="(" lookAhead="1"/>+        <RegExpr attribute="Path" context="#stay" String="&path;"/>+        <DetectChar context="MaybeGlobRangeOrPop" char="&lt;" lookAhead="1"/>+        <DetectChar context="PathMaybeBraceExpansion" char="{" lookAhead="1"/>+      </context>+      <context attribute="Path" lineEndContext="#pop#pop" name="PathThenPop">+        <AnyChar context="#pop#pop" String="&wordseps_or_extglog;" lookAhead="1"/>+        <IncludeRules context="IncPath"/>+        <DetectChar context="PathMaybeGroupEnd" char="}" lookAhead="1"/>+        <DetectIdentifier attribute="Path"/>+      </context>+      <context attribute="Path" lineEndContext="#pop" name="PathRecBrace">+        <AnyChar context="#pop" String="&wordseps_or_extglog;" lookAhead="1"/>+        <IncludeRules context="IncPath"/>+        <DetectChar attribute="Path" context="#pop" char="}"/>+        <DetectIdentifier attribute="Path"/>+      </context>+      <context attribute="Glob" lineEndContext="#stay" name="MaybeGlobRangeOrPop" fallthroughContext="#pop#pop">+        <IncludeRules context="FindGlobRangeThenPop"/>+      </context>+      <context attribute="Path" lineEndContext="#pop" name="PathMaybeBraceExpansion">+        <IncludeRules context="DispatchPathBraceExpansion"/>+        <DetectChar attribute="Path" context="#pop!PathRecBrace" char="{"/>+      </context>+      <context attribute="Path" lineEndContext="#pop" name="PathMaybeGroupEnd">+        <IncludeRules context="FindNoGroupEndThenPop"/>+        <DetectChar context="#pop#pop#pop" char="}" lookAhead="1"/>+      </context>+      <context attribute="Glob" lineEndContext="#stay" name="FindGlobRangeThenPop">+        <RegExpr attribute="Glob" context="#pop!InGlobRange" String="&lt;(?=[0-9]*-[0-9]*>)"/>+      </context>+      <context attribute="Number" lineEndContext="#stay" name="InGlobRange">+        <IncludeRules context="FindDigit"/>+        <DetectChar attribute="Glob" context="#stay" char="-"/>+        <DetectChar attribute="Glob" context="#pop" char=">"/>+      </context>++      <!-- FindPathThenPopInAlternateValue consumes path in ${xx:here}-->+      <context attribute="Normal Text" lineEndContext="#pop" name="FindPathThenPopInAlternateValue">+        <AnyChar attribute="Glob" context="PathThenPopInAlternateValue" String="&simpleglob;|"/>+        <Detect2Chars context="PathThenPopInAlternateValue" char="(" char1="#" lookAhead="1"/>+        <AnyChar context="PathThenPopInAlternateValue" String="[(" lookAhead="1"/>+        <RegExpr attribute="Path" context="PathThenPopInAlternateValue" String="&pathpart;"/>+      </context>+      <context attribute="Path" lineEndContext="#pop" name="PathThenPopInAlternateValue">+        <AnyChar context="#pop" String="&wordseps_or_extglog;}" lookAhead="1"/>+        <IncludeRules context="IncPath"/>+        <DetectIdentifier/>+      </context>++      <!-- [a-Z]+           ~+      -->+      <context attribute="Glob" lineEndContext="#stay" name="FindGlobAny">+        <DetectChar attribute="Glob" context="GlobAnyFlag" char="["/>+      </context>+      <!-- [^a-Z]+            ~+      -->+      <context attribute="String SingleQ" lineEndContext="#pop" name="GlobAnyFlag" fallthroughContext="#pop!GlobAnyNoClose">+        <AnyChar attribute="Glob Flag" context="#pop!GlobAnyNoClose" String="!^"/>+      </context>+      <!-- []a-Z] [^]a-Z] [-a-Z] [^-a-Z]+            ~       ~      ~       ~+      -->+      <context attribute="Glob" lineEndContext="#pop#pop" name="GlobAnyNoClose" fallthroughContext="#pop!GlobAny">+        <AnyChar attribute="String SingleQ" context="#pop!GlobAny" String="]-"/>+      </context>+      <context attribute="String SingleQ" lineEndContext="#pop" name="GlobAny">+        <DetectIdentifier attribute="String SingleQ"/>+        <IncludeRules context="FindEscape"/>+        <DetectChar attribute="Glob Flag" context="#stay" char="-"/>+        <IncludeRules context="FindStrings"/>+        <DetectChar attribute="Glob" context="#pop" char="]"/>+        <Detect2Chars attribute="Glob" context="GlobClass" char="[" char1=":"/>+        <IncludeRules context="FindVariableOrCurrentStyle"/>+        <DetectChar context="GlobAnyMaybeNumRange" char="&lt;" lookAhead="1"/>+        <!-- some characters are prohibited, but it depends on the context of use+        ${s/[...]/}, [[ $foo = [...] ]], [[ $foo = ( [...] ) ]], etc+        -->+      </context>+      <!-- [abc<0-9>def<ghi]+               ~~~~~   ~+      -->+      <context attribute="String SingleQ" name="GlobAnyMaybeNumRange">+        <!-- [<0-9>] is quivalent to [-09\<\>], not [0-9\<\>]+                ~ not a Glob Flag+        -->+        <RegExpr attribute="String SingleQ" context="#pop" String="&lt;[0-9]*-[0-9]*>"/>+        <DetectChar context="#pop" char="&lt;"/>+      </context>+      <context attribute="Glob" lineEndContext="#pop#pop" name="GlobClass">+        <DetectIdentifier attribute="Pattern"/>+        <Detect2Chars attribute="Glob" context="#pop" char=":" char1="]"/>+        <DetectChar attribute="Error" context="#pop" char="]"/>+      </context>++      <context attribute="Pattern" lineEndContext="#stay" name="FindSingleGlob">+        <AnyChar attribute="Glob" context="#stay" String="&simpleglob;"/>+      </context>++      <context attribute="Pattern" lineEndContext="#stay" name="FindGlobPattern">+        <AnyChar attribute="Glob" context="#stay" String="&simpleglob;|"/>+        <IncludeRules context="FindGlobAny"/>+        <IncludeRules context="FindGroupPattern"/>+      </context>++      <context attribute="Pattern" lineEndContext="#stay" name="FindPattern">+        <IncludeRules context="FindGlobPattern"/>+        <IncludeRules context="FindGlobRangeOrError"/>+      </context>+      <context attribute="Glob" lineEndContext="#stay" name="FindGlobRangeOrError">+        <DetectChar context="GlobRangeOrError" char="&lt;" lookAhead="1"/>+      </context>+      <context attribute="Glob" lineEndContext="#stay" name="GlobRangeOrError">+        <IncludeRules context="FindGlobRangeThenPop"/>+        <DetectChar attribute="Error" context="#pop" char="&lt;"/>+      </context>++      <context attribute="Pattern" lineEndContext="#stay" name="FindSubPattern">+        <IncludeRules context="FindGlobPattern"/>+        <DetectChar context="GlobRangeOrPattern" char="&lt;" lookAhead="1"/>+      </context>+      <context attribute="Pattern" lineEndContext="#stay" name="GlobRangeOrPattern">+        <IncludeRules context="FindGlobRangeThenPop"/>+        <DetectChar attribute="Pattern" context="#pop" char="&lt;"/>+      </context>++      <context attribute="Pattern" lineEndContext="#stay" name="FindStringDQPattern">+        <IncludeRules context="FindGlobPattern"/>+        <DetectChar context="GlobRangeOrStringDQ" char="&lt;" lookAhead="1"/>+      </context>+      <context attribute="String DoubleQ" lineEndContext="#stay" name="GlobRangeOrStringDQ">+        <IncludeRules context="FindGlobRangeThenPop"/>+        <DetectChar attribute="String DoubleQ" context="#pop" char="&lt;"/>+      </context>++      <context attribute="Glob Flag" lineEndContext="#stay" name="FindGroupPattern">+        <Detect2Chars attribute="Glob Flag" context="GlobPatFlag" char="(" char1="#"/>+        <DetectChar attribute="Glob" context="ExtGlobPattern" char="("/>+      </context>+      <context attribute="Pattern" lineEndContext="#stay" name="ExtGlobPattern">+        <DetectChar attribute="Glob" context="#pop" char=")"/>+        <IncludeRules context="FindWord"/>+        <IncludeRules context="FindSubPattern"/>+        <DetectIdentifier attribute="Pattern"/>+      </context>+      <context attribute="Pattern" lineEndContext="#stay" name="ExtGlobPatternThenPath">+        <DetectChar attribute="Glob" context="#pop!PathThenPop" char=")"/>+        <IncludeRules context="FindWord"/>+        <IncludeRules context="FindSubPattern"/>+        <DetectIdentifier attribute="Pattern"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#pop" name="VarAssign" fallthroughContext="#pop">+        <IncludeRules context="FindSubscript"/>+        <DetectChar attribute="Operator" context="#pop!Assign" char="="/>+        <Detect2Chars attribute="Operator" context="#pop!Assign" char="+" char1="="/>+      </context>++      <context attribute="Normal Text" lineEndContext="#pop" name="DispatchKeyword">+        <!-- match do and if blocks -->+        <Detect2Chars attribute="Control Flow" context="#pop!NotCond" char="i" char1="f" beginRegion="if"/>+        <Detect2Chars attribute="Control Flow" context="#pop" char="f" char1="i" endRegion="if"/>+        <StringDetect attribute="Control Flow" context="#pop" String="done" endRegion="do"/>+        <Detect2Chars attribute="Control Flow" context="#pop" char="d" char1="o" beginRegion="do"/>+        <!-- handle while/until as a special case -->+        <StringDetect attribute="Control Flow" context="#pop!NotCond" String="while"/>+        <StringDetect attribute="Control Flow" context="#pop!NotCond" String="until"/>+        <!-- handle for as a special case -->+        <StringDetect attribute="Control Flow" context="#pop!Foreach" String="foreach"/>+        <StringDetect attribute="Control Flow" context="#pop!For" String="for"/>+        <!-- handle select as a special case -->+        <StringDetect attribute="Control Flow" context="#pop!Select" String="select"/>+        <StringDetect attribute="Control Flow" context="#pop!Repeat" String="repeat"/>+        <!-- handle case as a special case -->+        <StringDetect attribute="Control Flow" context="#pop!Case" String="case" beginRegion="case"/>+        <!-- handle functions with function keyword before keywords -->+        <StringDetect attribute="Keyword" context="#pop!FunctionDef" String="function"/>+        <StringDetect attribute="Control Flow" context="#pop!Return" String="return"/>+        <!-- not a keyword in this context -->+        <Detect2Chars attribute="Error" context="#pop" char="i" char1="n"/>+        <StringDetect attribute="Error" context="#pop" String="esac"/>+        <!-- handle keywords -->+        <DetectIdentifier attribute="Control Flow" context="#pop"/>+      </context>++      <!-- if ! ... and while ! ... -->+      <context attribute="Normal Text" lineEndContext="#pop" name="NotCond" fallthroughContext="#pop">+        <DetectSpaces attribute="Normal Text" context="#pop!NotCond2"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="NotCond2" fallthroughContext="#pop">+        <Detect2Chars attribute="Expression" context="#pop" char="!" char1="&tab;"/>+        <Detect2Chars attribute="Expression" context="#pop" char="!" char1=" "/>+        <LineContinue attribute="Expression" context="#pop" char="!"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#pop" name="Foreach" fallthroughContext="#pop">+        <LineContinue attribute="Escape" context="#stay"/>+        <DetectSpaces attribute="Normal Text" context="#stay"/>+        <DetectIdentifier attribute="Normal Text" context="#stay"/>+        <DetectChar attribute="Keyword" context="#pop!ForeachWord" char="("/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="ForeachWord" fallthroughContext="NormalOption">+        <DetectSpaces attribute="Normal Text" context="#stay"/>+        <DetectChar attribute="Control" context="#stay" char=";"/>+        <DetectChar attribute="Keyword" context="#pop" char=")"/>+        <DetectChar attribute="Backquote" context="CommandBackq" char="`"/>+        <AnyChar attribute="Control" context="#stay" String="&symbolseps;"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#pop" name="For" fallthroughContext="#pop">+        <LineContinue attribute="Escape" context="#stay"/>+        <DetectSpaces attribute="Normal Text" context="#stay"/>+        <WordDetect attribute="Keyword" context="#pop!CommandArgs" String="in"/>+        <DetectIdentifier attribute="Normal Text" context="#stay"/>+        <Detect2Chars attribute="Keyword" context="#pop!ForArithmeticExpr" char="(" char1="("/>+        <DetectChar attribute="Keyword" context="#pop!ForeachWord" char="("/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="ForArithmeticExpr">+        <DetectSpaces attribute="Normal Text" context="#stay"/>+        <DetectChar attribute="Control" context="#stay" char=";"/>+        <Detect2Chars attribute="Keyword" context="#pop" char=")" char1=")"/>+        <IncludeRules context="FindExprDblParen"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#pop" name="Select" fallthroughContext="#pop">+        <LineContinue attribute="Escape" context="#stay"/>+        <DetectSpaces attribute="Normal Text" context="#stay"/>+        <DetectIdentifier attribute="Normal Text" context="#pop!SelectIn"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="SelectIn" fallthroughContext="#pop">+        <LineContinue attribute="Escape" context="#stay"/>+        <DetectSpaces attribute="Normal Text" context="#stay"/>+        <WordDetect attribute="Keyword" context="#pop!CommandArgs" String="in"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#pop" name="Repeat" fallthroughContext="#pop!RepeatArithmeticExpr">+        <LineContinue attribute="Escape" context="#stay"/>+        <DetectSpaces attribute="Normal Text" context="#stay"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="RepeatArithmeticExpr">+        <DetectSpaces attribute="Normal Text" context="#pop"/>+        <DetectChar attribute="Control" context="#pop" char=";"/>+        <IncludeRules context="FindExprDblParen"/>+      </context>++      <!-- &> and &>> redirection -->+      <context attribute="Normal Text" lineEndContext="#pop" name="Prefix&amp;>" fallthroughContext="#pop!FdRedirection">+        <Detect2Chars attribute="Redirection" context="#pop!WordRedirection" char=">" char1="|"/>+        <Detect2Chars attribute="Redirection" context="#pop!WordRedirection" char=">" char1="!"/>+        <AnyChar attribute="Redirection" context="#pop!WordRedirection" String=">|!"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#pop" name="AssumeRedirection">+        <!-- handle output redirection -->+        <StringDetect attribute="Redirection" context="#pop!WordRedirection" String=">>|"/>+        <StringDetect attribute="Redirection" context="#pop!WordRedirection" String=">>!"/>+        <StringDetect attribute="Redirection" context="#pop!WordRedirection" String=">>&amp;|"/>+        <StringDetect attribute="Redirection" context="#pop!WordRedirection" String=">>&amp;!"/>+        <StringDetect attribute="Redirection" context="#pop!ProcessSubst" String=">>("/>+        <Detect2Chars attribute="Redirection" context="#pop!WordRedirection" char=">" char1=">"/>+        <Detect2Chars attribute="Redirection" context="#pop!WordRedirection" char=">" char1="|"/>+        <Detect2Chars attribute="Redirection" context="#pop!WordRedirection" char=">" char1="!"/>+        <StringDetect attribute="Redirection" context="#pop!WordRedirection" String=">&amp;|"/>+        <StringDetect attribute="Redirection" context="#pop!WordRedirection" String=">&amp;!"/>+        <Detect2Chars attribute="Redirection" context="#pop!FdRedirection" char=">" char1="&amp;"/>+        <Detect2Chars attribute="Redirection" context="#pop!ProcessSubst" char=">" char1="("/>+        <DetectChar attribute="Redirection" context="#pop!WordRedirection" char=">"/>+        <!-- handle input redirection -->+        <Detect2Chars attribute="Redirection" context="#pop!ProcessSubst" char="&lt;" char1="("/>+        <StringDetect attribute="Redirection" context="#pop!ProcessSubst" String="&lt;&lt;("/>+        <StringDetect attribute="Redirection" context="#pop!StringRedirection" String="&lt;&lt;&lt;"/>+        <!-- handle here document -->+        <Detect2Chars context="#pop!HereDoc" char="&lt;" char1="&lt;" lookAhead="1"/>+        <Detect2Chars attribute="Redirection" context="#pop!FdRedirection" char="&lt;" char1="&amp;"/>+        <Detect2Chars attribute="Redirection" context="#pop!WordRedirection" char="&lt;" char1=">"/>+        <IncludeRules context="FindGlobRangeThenPop"/>+        <DetectChar attribute="Redirection" context="#pop!WordRedirection" char="&lt;"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="FdRedirection" fallthroughContext="#pop!FdRedirection2">+        <DetectSpaces attribute="Normal Text" context="#pop!FdRedirection2"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="FdRedirection2" fallthroughContext="#pop!WordRedirection2">+        <RegExpr attribute="File Descriptor" context="#pop!CloseFile" String="[0-9]+(?=-?&eoexpr;)"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="WordRedirection" fallthroughContext="#pop!WordRedirection2">+        <DetectSpaces attribute="Normal Text" context="#pop!WordRedirection2"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="WordRedirection2" fallthroughContext="#pop">+        <AnyChar context="#pop" String="&wordseps;`" lookAhead="1"/>+        <IncludeRules context="FindWord"/>+        <RegExpr attribute="Path" context="PathThenPop" String="&path;"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="StringRedirection" fallthroughContext="#pop!StringRedirection2">+        <DetectSpaces attribute="Normal Text" context="#pop!StringRedirection2"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="StringRedirection2">+        <AnyChar context="#pop" String="&wordseps;`" lookAhead="1"/>+        <IncludeRules context="FindWord"/>+        <DetectIdentifier attribute="Normal Text"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="CloseFile" fallthroughContext="#pop">+        <DetectChar attribute="Keyword" context="#pop" char="-"/>+      </context>++      <!-- HereDoc consumes Here-documents. It is called at the beginning of the "<<" construct. -->+      <context attribute="Normal Text" lineEndContext="#stay" name="HereDoc">+        <RegExpr attribute="Redirection" context="HereDocIQ"  String="&lt;&lt;-[&ws;]*&heredocq;(?=[&ws;]*$)"/>+        <RegExpr attribute="Redirection" context="HereDocINQ" String="&lt;&lt;-[&ws;]*([^&wordseps;]+)(?=[&ws;]*$)"/>+        <RegExpr attribute="Redirection" context="HereDocQ"   String="&lt;&lt;[&ws;]*&heredocq;(?=[&ws;]*$)"/>+        <RegExpr attribute="Redirection" context="HereDocNQ"  String="&lt;&lt;[&ws;]*([^&wordseps;]+)(?=[&ws;]*$)"/>++        <RegExpr context="HereDocIQCmd"  String="(&lt;&lt;-[&ws;]*&heredocq;)" lookAhead="1"/>+        <RegExpr context="HereDocINQCmd" String="(&lt;&lt;-[&ws;]*([^&wordseps;]+))" lookAhead="1"/>+        <RegExpr context="HereDocQCmd"   String="(&lt;&lt;[&ws;]*&heredocq;)" lookAhead="1"/>+        <RegExpr context="HereDocNQCmd"  String="(&lt;&lt;[&ws;]*([^&wordseps;]+))" lookAhead="1"/>++        <Detect2Chars attribute="Redirection" context="#pop"  char="&lt;" char1="&lt;"/><!-- always met -->+      </context>++      <context attribute="Normal Text" lineEndContext="#pop" name="HereDocRemainder" fallthroughContext="CommandArg">+        <AnyChar context="ZshOneLine" String="&amp;|;`" lookAhead="1"/>+        <IncludeRules context="CommandArgs"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="ZshOneLine" fallthroughContext="Command">+        <IncludeRules context="Start"/>+      </context>++      <context attribute="Here Doc" lineEndContext="#stay" name="HereDocQ" dynamic="1" fallthroughContext="HereDocText">+        <RegExpr attribute="Redirection" context="#pop#pop" String="^%1$" dynamic="1" column="0"/>+      </context>++      <context attribute="Here Doc" lineEndContext="#stay" name="HereDocNQ" dynamic="1" fallthroughContext="HereDocSubstitutions">+        <IncludeRules context="HereDocQ" />+      </context>++      <context attribute="Here Doc" lineEndContext="#stay" name="HereDocIQ" dynamic="1" fallthroughContext="HereDocText">+        <RegExpr attribute="Redirection" context="#pop#pop" String="^\t*%1$" dynamic="1" column="0"/>+      </context>++      <context attribute="Here Doc" lineEndContext="#stay" name="HereDocINQ" dynamic="1" fallthroughContext="HereDocSubstitutions">+        <IncludeRules context="HereDocIQ" />+      </context>++      <context attribute="Here Doc" lineEndContext="#stay" name="HereDocCmd">+        <!-- Only if the redirect is before the command, but as this is too complicated,+             check if the redirect is at the beginning of the line. -->+        <StringDetect attribute="Redirection" context="ZshOneLine" String="%1" dynamic="true" firstNonSpace="1"/>+        <StringDetect attribute="Redirection" context="HereDocRemainder" String="%1" dynamic="true"/>+      </context>++      <context attribute="Here Doc" lineEndContext="#stay" name="HereDocQCmd" dynamic="1" fallthroughContext="HereDocText">+        <IncludeRules context="HereDocCmd"/>+        <RegExpr attribute="Redirection" context="#pop#pop" String="^%2$" dynamic="1" column="0"/>+      </context>++      <context attribute="Here Doc" lineEndContext="#stay" name="HereDocNQCmd" dynamic="1" fallthroughContext="HereDocSubstitutions">+        <IncludeRules context="HereDocQCmd"/>+      </context>++      <context attribute="Here Doc" lineEndContext="#stay" name="HereDocIQCmd" dynamic="1" fallthroughContext="HereDocText">+        <IncludeRules context="HereDocCmd"/>+        <RegExpr attribute="Redirection" context="#pop#pop" String="^\t*%2$" dynamic="1" column="0"/>+      </context>++      <context attribute="Here Doc" lineEndContext="#stay" name="HereDocINQCmd" dynamic="1" fallthroughContext="HereDocSubstitutions">+        <IncludeRules context="HereDocIQCmd"/>+      </context>++      <context attribute="Here Doc" lineEndContext="#pop" name="HereDocText">+      </context>++      <context attribute="Here Doc" lineEndContext="#pop" name="HereDocSubstitutions">+        <DetectSpaces attribute="Here Doc"/>+        <DetectIdentifier attribute="Here Doc"/>+        <DetectChar context="HereDocVariables" char="$" lookAhead="1"/>+        <DetectChar attribute="Backquote" context="CommandBackq" char="`"/>+        <IncludeRules context="FindEscape"/>+      </context>+      <context attribute="Here Doc" lineEndContext="#pop" name="HereDocVariables">+        <IncludeRules context="DispatchSubstVariables"/>+        <IncludeRules context="DispatchVarNameVariables"/>+        <DetectChar attribute="Here Doc" context="#pop" char="$"/>+      </context>++      <!-- VarName consumes spare variable names and assignments -->+      <context attribute="Normal Text" lineEndContext="#pop" name="VarName">+        <StringDetect attribute="Builtin" context="#pop!BuiltinGetopts" String="getopts"/>+        <StringDetect attribute="Builtin" context="#pop!BuiltinLet" String="let"/>+        <DetectIdentifier attribute="Builtin" context="#pop!VarNameArgs"/>+        <AnyChar attribute="Builtin" context="#pop!VarNameArgs" String=".:-"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="VarNameArgs" fallthroughContext="#pop!CommandArgs">+        <DetectSpaces attribute="Normal Text" context="VarNameArg"/>+        <LineContinue attribute="Escape" context="#stay"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop#pop" name="VarNameArg" fallthroughContext="#pop!VarNameArg2">+        <!-- In command arguments, do not allow comments after escaped characters.+             This avoids highlighting comments within paths or other text. Ex: pathtext\ #no\ comment -->+        <DetectChar context="#pop#pop" char="#" lookAhead="1"/>+        <AnyChar attribute="Option" context="#pop!ShortOption" String="-+"/>+        <DetectChar attribute="Keyword" context="#pop!VarNameArg2" char="="/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="VarNameArg2" fallthroughContext="#pop!NormalOption">+        <DetectChar attribute="Variable" context="Subscript" char="["/>+        <DetectChar attribute="Operator" context="Assign" char="="/>+        <DetectChar attribute="Variable" context="AssignArray" char="("/>+        <DetectIdentifier attribute="Variable" context="#stay"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="BuiltinGetopts" fallthroughContext="#pop!CommandArgs">+        <DetectSpaces attribute="Normal Text" context="#pop!BuiltinGetoptsOpt"/>+        <LineContinue attribute="Escape" context="#stay"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop#pop" name="BuiltinGetoptsOpt" fallthroughContext="#pop!BuiltinGetoptsOpt2">+        <DetectChar context="#pop#pop" char="#" lookAhead="1"/>+        <DetectChar attribute="Keyword" context="#pop!NormalOption" char="="/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="BuiltinGetoptsOpt2" fallthroughContext="#pop!NormalOption">+        <DetectChar attribute="Operator" context="#stay" char=":"/>+        <DetectIdentifier attribute="Normal Text" context="#stay" />+        <DetectSpaces attribute="Normal Text" context="#pop!BuiltinGetoptsVar"/>+        <AnyChar context="#pop" String="&wordseps_or_extglog;" lookAhead="1"/>+        <IncludeRules context="FindWord"/>+        <DetectChar context="NormalOptionMaybeBraceExpansion" char="{" lookAhead="1"/>+        <DetectChar context="NormalOptionMaybeGroupEnd" char="}" lookAhead="1"/>+        <AnyChar attribute="Normal Text" context="#stay" String="/%.0123456789"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="BuiltinGetoptsVar" fallthroughContext="#pop!CommandArgs">+        <DetectIdentifier attribute="Variable" context="#pop!CommandArgs"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="BuiltinLet" fallthroughContext="#pop!CommandArgs">+        <DetectSpaces attribute="Normal Text" context="#pop!BuiltinLetArgs"/>+        <LineContinue attribute="Escape" context="#stay"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="BuiltinLetArgs" fallthroughContext="BuiltinLetArg">+        <AnyChar context="BuiltinLetArgsNumber" String="0123456789" lookAhead="1"/>+        <IncludeRules context="CommandArgs"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="BuiltinLetArgsNumber" fallthroughContext="#pop!BuiltinLetArg">+        <IncludeRules context="FindRedirection"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop#pop" name="BuiltinLetArg" fallthroughContext="#pop!BuiltinLetExpr">+        <DetectChar context="#pop#pop" char="#" lookAhead="1"/>+        <DetectChar attribute="Keyword" context="#pop!NormalOption" char="="/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="BuiltinLetExpr" fallthroughContext="#pop!NormalOption">+        <DetectIdentifier attribute="Variable"/>+        <AnyChar context="#pop" String="&wordseps_or_extglog;" lookAhead="1"/>+        <AnyChar attribute="Operator" context="#stay" String="+-!%=^:"/>+        <IncludeRules context="FindNumber"/>+        <IncludeRules context="FindSubscript"/>+        <IncludeRules context="FindWord"/>+        <IncludeRules context="FindToNum"/>+        <DetectChar attribute="Control" char=","/>+        <DetectChar context="NormalOptionMaybeBraceExpansion" char="{" lookAhead="1"/>+        <DetectChar context="NormalOptionMaybeGroupEnd" char="}" lookAhead="1"/>+      </context>++      <!-- ProcessSubst handles <(command) and >(command) -->+      <context attribute="Normal Text" lineEndContext="#stay" name="ProcessSubst" fallthroughContext="Command">+        <DetectChar attribute="Redirection" context="#pop" char=")"/>+        <IncludeRules context="Start"/>+      </context>++      <!-- StringSQ consumes anything till ' -->+      <context attribute="String SingleQ" lineEndContext="#stay" name="StringSQ">+        <DetectSpaces attribute="String SingleQ"/>+        <DetectIdentifier attribute="String SingleQ"/>+        <DetectChar attribute="String SingleQ" context="#pop" char="'"/>+      </context>++      <!-- StringDQ consumes anything till ", substitutes vars and expressions -->+      <context attribute="String DoubleQ" lineEndContext="#stay" name="StringDQ">+        <DetectSpaces attribute="String DoubleQ"/>+        <DetectIdentifier attribute="String DoubleQ"/>+        <DetectChar attribute="String DoubleQ" context="#pop" char="&quot;"/>+        <DetectChar context="StringDQEscape" char="\" lookAhead="1"/>+        <DetectChar context="StringDQDispatchVariables" char="$" lookAhead="1"/>+        <DetectChar attribute="Backquote" context="RegularBackq" char="`"/>+      </context>+      <context attribute="String DoubleQ" lineEndContext="#stay" name="StringDQDispatchVariables">+        <IncludeRules context="DispatchSubstVariables"/>+        <IncludeRules context="DispatchVarNameVariables"/>+        <DetectChar attribute="String DoubleQ" context="#pop" char="$"/>+      </context>+      <context attribute="String DoubleQ" lineEndContext="#pop" name="StringDQEscape">+        <Detect2Chars attribute="String Escape" context="#pop" char="\" char1="&quot;"/>+        <Detect2Chars attribute="String Escape" context="#pop" char="\" char1="\"/>+        <Detect2Chars attribute="String Escape" context="#pop" char="\" char1="`"/>+        <Detect2Chars attribute="String Escape" context="#pop" char="\" char1="$"/>+        <LineContinue attribute="String Escape" context="#pop"/>+        <DetectChar attribute="String DoubleQ" context="#pop" char="\"/>+      </context>++      <!-- RegularBackq consumes anything till ` -->+      <context attribute="Normal Text" lineEndContext="#stay" name="RegularBackq" fallthroughContext="Command">+        <DetectChar attribute="Backquote" context="#pop" char="`"/>+        <DetectChar attribute="Comment" context="CommentBackq" char="#"/>+        <IncludeRules context="Start"/>+      </context>++      <!-- StringEsc eats till ', but escaping many characters -->+      <context attribute="String SingleQ" lineEndContext="#stay" name="StringEsc">+        <DetectSpaces attribute="String SingleQ"/>+        <DetectIdentifier attribute="String SingleQ"/>+        <DetectChar attribute="String SingleQ" context="#pop" char="'"/>+        <RegExpr attribute="String Escape" context="#stay" String="\\&escaped_ch;?"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#stay" name="FindSpaceAndComment">+        <DetectSpaces attribute="Normal Text" context="#stay"/>+        <DetectChar attribute="Comment" context="Comment" char="#"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#stay" name="FindWord">+        <IncludeRules context="FindStrings"/>+        <IncludeRules context="FindVariable"/>+        <DetectChar attribute="Backquote" context="RegularBackq" char="`"/>+        <IncludeRules context="FindEscape"/>+      </context>++      <!-- $foo ${foo} $((...)) $(...) -->+      <context attribute="Command" lineEndContext="#pop" name="FindVariableOrCurrentStyle">+        <DetectChar context="VariableOrCurrentStyle" char="$" lookAhead="1"/>+      </context>+      <context attribute="Command" lineEndContext="#pop" name="VariableOrCurrentStyle">+        <IncludeRules context="DispatchVariables"/>+        <DetectChar context="#pop" char="$"/>+      </context>+      <!-- $foo ${foo} $((...)) $(...) -->+      <context attribute="Normal Text" lineEndContext="#pop" name="FindVariable">+        <DetectChar context="RegularVariable" char="$" lookAhead="1"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="RegularVariable">+        <IncludeRules context="DispatchVariables"/>+        <DetectChar attribute="Normal Text" context="#pop" char="$"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#pop" name="FindStrings">+        <DetectChar attribute="String SingleQ" context="StringSQ" char="'"/>+        <DetectChar attribute="String DoubleQ" context="StringDQ" char="&quot;"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="FindStringsThenPop">+        <DetectChar attribute="String SingleQ" context="#pop!StringSQ" char="'"/>+        <DetectChar attribute="String DoubleQ" context="#pop!StringDQ" char="&quot;"/>+      </context>++      <!-- SubstCommand is called after a $( is encountered -->+      <context attribute="Normal Text" lineEndContext="#stay" name="SubstCommand" fallthroughContext="Command">+        <DetectChar attribute="Parameter Expansion" context="#pop" char=")" endRegion="subshell"/>+        <IncludeRules context="Start"/>+      </context>++      <!-- VarBraceStart is called as soon as ${ is encoutered -->+      <context attribute="Variable" lineEndContext="#pop!VarCmd" name="VarBraceStart" fallthroughContext="#pop!CheckVarAlt">+        <DetectChar attribute="Parameter Expansion" context="#pop!VarFlags" char="("/>+        <AnyChar attribute="Parameter Expansion" context="#pop!VarCmd" String="&ws;|"/>+        <DetectChar attribute="Normal Text" context="#pop!VarCmdVar" char="{"/>+        <IncludeRules context="VarFlagsVar"/>+      </context>+      <context attribute="Variable" lineEndContext="#stay" name="VarBraceStartRecursive" fallthroughContext="#pop#pop!CheckVarAlt">+        <Detect2Chars attribute="Parameter Expansion" context="VarBraceStart" char="$" char1="{"/>+        <StringDetect context="#pop!ExprDblParenSubstOrSubstCommand" String="$((" lookAhead="1"/>+        <Detect2Chars attribute="Parameter Expansion" context="#pop!SubstCommand" char="$" char1="(" beginRegion="subshell"/>+        <DetectChar attribute="Error" context="#pop" char="$"/>+      </context>+      <context attribute="Error" lineEndContext="#stay" name="VarError">+        <DetectChar attribute="Parameter Expansion" context="#pop" char="}"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="CheckVarAlt" fallthroughContext="#pop!VarError">+        <DetectChar attribute="Parameter Expansion" context="#pop" char="}"/>+        <StringDetect attribute="Parameter Expansion Operator" context="#stay" String="[@]"/>+        <StringDetect attribute="Parameter Expansion Operator" context="#stay" String="[*]"/>+        <IncludeRules context="FindSubscript"/>+        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!AlternatePatternValue" char="%" char1="%"/>+        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!AlternatePatternValue" char="#" char1="#"/>+        <AnyChar attribute="Parameter Expansion Operator" context="#pop!AlternatePatternValue" String="#%"/>+        <AnyChar attribute="Parameter Expansion Operator" context="#pop!AlternateValue" String="-+=?"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!AlternateValuePrefix" char=":"/>+        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!VarBraceSubst" char="/" char1="/"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarBraceSubst" char="/"/>+      </context>+      <context attribute="Parameter Expansion" lineEndContext="#pop!VarSub" name="AlternateValuePrefix" fallthroughContext="#pop!VarSub">+        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!AlternateValue" char="^" char1="^"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!AlternatePatternValue" char="#"/>+        <AnyChar attribute="Parameter Expansion Operator" context="#pop!AlternateValue" String="-+=?|*^"/>+        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!AlternateValue" char=":" char1="="/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarBraceSubst" char="/"/>+        <IncludeRules context="VarBraceModifierOrArithmetic"/>+      </context>+      <context attribute="Parameter Expansion" lineEndContext="#pop!VarSub" name="VarBraceModifierOrArithmetic" fallthroughContext="#pop!VarSub">+        <AnyChar context="#pop!VarBraceModifiers" String="aAcehlpPqQrsg&amp;tufFwW" lookAhead="1"/>+        <DetectIdentifier attribute="Error" context="#pop!VarBraceModifiers"/>+      </context>++      <!-- ${var:h:s/...}+                 ~~~+      -->+      <context attribute="Error" lineEndContext="#stay" name="VarBraceModifiers" fallthroughContext="VarBraceModifierNext">+        <AnyChar attribute="Parameter Expansion" context="VarBraceModifierNext" String="aAcelpPqQr&amp;u"/>+        <AnyChar attribute="Parameter Expansion" context="VarBraceModifier_h" String="ht"/>+        <AnyChar attribute="Parameter Expansion" String="fw"/>+        <StringDetect attribute="Parameter Expansion" context="VarBraceModifier_s" String="s"/>+        <StringDetect attribute="Parameter Expansion" context="VarBraceModifier_s" String="gs"/>+        <StringDetect attribute="Parameter Expansion" context="VarBraceModifierNext" String="g&amp;"/>+        <StringDetect attribute="Parameter Expansion" context="VarBraceModifier_W" String="W"/>+        <StringDetect attribute="Parameter Expansion" context="VarBraceModifier_F" String="F"/>+        <!-- TODO ${a:2:2:a} VarSub amène à VarSub or VarBraceModifierNext quand : (pas plus de 2)-->+      </context>+      <context attribute="Error" lineEndContext="#stay" name="VarBraceModifierNext">+        <DetectChar attribute="Parameter Expansion" context="#pop#pop" char="&brace_close;"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char=":"/>+        <AnyChar context="#pop#pop" String="&wordseps;" lookAhead="1"/>+      </context>++      <!-- ${var:h3}  ${var:t11}+                  ~          ~~+      -->+      <context attribute="Parameter Expansion" lineEndContext="#pop!VarBraceModifierNext" name="VarBraceModifier_h" fallthroughContext="#pop!VarBraceModifierNext">+        <IncludeRules context="FindDigit"/>+      </context>+++      <!-- ${var:s/../....}+                  ~~~~~...+      -->+      <context attribute="Parameter Expansion" lineEndContext="#stay" name="VarBraceModifier_s" fallthroughContext="#pop!VarBraceModifierNext">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarBraceModifier_s_Str" char="/"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarBraceModifier_s_StrSQ_Sep" char="'"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarBraceModifier_s_StrDQ_Sep" char='"'/>+        <RegExpr attribute="Parameter Expansion Operator" context="#pop!VarBraceModifier_s_C_Rep!VarBraceModifier_s_C_Str" String="([^&symbolseps;\[\]{}\\])"/>+      </context>+      <context attribute="Verbatim String" name="VarBraceModifier_End">+        <AnyChar context="#pop!VarBraceModifierNext" String="&symbolseps;&brace_close;" lookAhead="1"/>+      </context>+      <context attribute="Verbatim String" name="VarBraceModifier_End2">+        <AnyChar context="#pop#pop!VarBraceModifierNext" String="&symbolseps;&brace_close;" lookAhead="1"/>+      </context>+      <!-- By default the left-hand side of substitutions are character strings,+      but pattern with HIST_SUBST_PATTERN option. Assume no option. -->+      <!-- ${var:s/../....}+                   ~~~+      -->+      <context attribute="Verbatim String" name="VarBraceModifier_s_Str">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarBraceModifier_s_Rep" char="/"/>+        <IncludeRules context="FindEscape"/>+        <DetectChar attribute="String SingleQ" context="VarBraceModifier_s_StrSQ" char="'"/>+        <DetectChar attribute="String DoubleQ" context="VarBraceModifier_s_StrDQ" char='"'/>+        <DetectChar attribute="Verbatim String" context="VarBraceModifier_s_StrSQ!VarBraceModifier_s_StrDQ_to_Rep!VarBraceModifier_s_Str_Recursive" char="{"/>+        <DetectChar attribute="Parameter Expansion" context="#pop#pop" char="}"/>+      </context>+      <context attribute="Verbatim String" name="VarBraceModifier_s_Str_Recursive">+        <DetectChar context="#pop#pop#pop" char="/" lookAhead="1"/>+        <IncludeRules context="FindEscape"/>+        <DetectChar attribute="String SingleQ" context="VarBraceModifier_s_StrSQ_Recursive" char="'"/>+        <DetectChar attribute="String DoubleQ" context="VarBraceModifier_s_StrDQ_Recursive" char='"'/>+        <DetectChar attribute="Verbatim String" context="Modifier_s_Str_to_Parent!Modifier_s_Str_to_Parent!VarBraceModifier_s_Str_Recursive" char="{"/>+        <DetectChar context="#pop#pop#pop" char="}"/>+      </context>+      <!-- #pop -> is VarBraceModifier_s_C_Rep -->+      <context attribute="Verbatim String" name="VarBraceModifier_s_C_Str">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="1" dynamic="1"/>+        <IncludeRules context="FindEscape"/>+        <!-- The string should stop if capture $1 is found,+        but there is no way to propagate the capture. -->+        <IncludeRules context="FindStrings"/>+        <DetectChar attribute="Verbatim String" context="VarBraceModifier_s_C_Str_Recursive" char="{"/>+        <DetectChar attribute="Parameter Expansion" context="#pop#pop#pop" char="}"/>+      </context>+      <context attribute="Verbatim String" name="VarBraceModifier_s_C_Str_Recursive">+        <IncludeRules context="FindEscape"/>+        <IncludeRules context="FindStrings"/>+        <DetectChar attribute="Verbatim String" context="VarBraceModifier_s_C_Str_Recursive" char="{"/>+        <DetectChar context="#pop" char="}"/>+      </context>+      <!-- ${var:s/..'../..'..}  ${var:s/..'..'../..}+                     ~~~~                  ~~~~+      -->+      <context attribute="String SingleQ" name="VarBraceModifier_s_StrSQ">+        <DetectChar attribute="String SingleQ" context="#pop" char="'"/>+        <LineContinue attribute="Escape"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop!VarBraceModifier_s_Rep!VarBraceModifier_s_RepSQ" char="/"/>+      </context>+      <context attribute="Error" name="Modifier_s_Str_to_Parent">+        <DetectChar context="#pop#pop#pop" char="/" lookAhead="1"/>+      </context>+      <context attribute="String SingleQ" name="VarBraceModifier_s_StrSQ_Recursive">+        <DetectChar attribute="String SingleQ" context="#pop" char="'"/>+        <LineContinue attribute="Escape"/>+        <DetectChar context="#pop#pop#pop" char="/" lookAhead="1"/>+      </context>+      <!-- ${var:s'..'..}+                  ~~~~+      -->+      <context attribute="Verbatim String" name="VarBraceModifier_s_StrSQ_Sep">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarBraceModifier_s_Rep" char="'"/>+        <LineContinue attribute="Escape"/>+      </context>+      <!-- ${var:s/.."../.."..}  ${var:s/..".."../..}+                     ~~~~                  ~~~~+      -->+      <context attribute="String DoubleQ" name="VarBraceModifier_s_StrDQ">+        <DetectChar attribute="String DoubleQ" context="#pop" char='"'/>+        <IncludeRules context="FindEscape"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop!VarBraceModifier_s_Rep!VarBraceModifier_s_RepDQ" char="/"/>+      </context>+      <context attribute="Error" name="VarBraceModifier_s_StrDQ_to_Rep">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop#pop!VarBraceModifier_s_Rep!VarBraceModifier_s_RepDQ" char="/"/>+      </context>+      <context attribute="String DoubleQ" name="VarBraceModifier_s_StrDQ_Recursive">+        <DetectChar attribute="String DoubleQ" context="#pop" char='"'/>+        <IncludeRules context="FindEscape"/>+        <DetectChar context="#pop#pop" char="/" lookAhead="1"/>+      </context>+      <!-- ${var:s".."..}+                  ~~~~+      -->+      <context attribute="String DoubleQ" name="VarBraceModifier_s_StrDQ_Sep">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarBraceModifier_s_Rep" char='"'/>+        <IncludeRules context="FindEscape"/>+      </context>+      <!-- ${var:s/../....}+                      ~~..+      -->+      <context attribute="Replacement String" name="VarBraceModifier_s_Rep">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarBraceModifierNext" char="/"/>+        <!-- FindWord with a search for '/' in single and double quoted string -->+        <DetectChar attribute="String SingleQ" context="VarBraceModifier_s_RepSQ" char="'"/>+        <DetectChar attribute="String DoubleQ" context="VarBraceModifier_s_RepDQ" char="&quot;"/>+        <DetectChar attribute="Replacement String" context="VarBraceModifier_s_RepSQ!VarBraceModifier_s_RepDQ_to_End!VarBraceModifier_s_Rep_Recursive" char="&brace_open;"/>+        <IncludeRules context="VarBraceModifier_s_Rep_Common"/>+        <IncludeRules context="VarBraceModifier_End"/>+      </context>+      <context attribute="Replacement String" name="VarBraceModifier_s_Rep_Recursive">+        <DetectChar context="#pop#pop#pop" char="/" lookAhead="1"/>+        <DetectChar attribute="String SingleQ" context="VarBraceModifier_s_RepSQ_Recursive" char="'"/>+        <DetectChar attribute="String DoubleQ" context="VarBraceModifier_s_RepDQ_Recursive" char='"'/>+        <DetectChar attribute="Replacement String" context="Modifier_s_Str_to_Parent!Modifier_s_Str_to_Parent!VarBraceModifier_s_Rep_Recursive" char="{"/>+        <DetectChar context="#pop#pop#pop" char="}"/>+        <IncludeRules context="VarBraceModifier_s_Rep_Common"/>+        <AnyChar context="#pop" String="&symbolseps;" lookAhead="1"/>+      </context>+      <context attribute="Replacement String" name="VarBraceModifier_s_C_Rep">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarBraceModifierNext" char="1" dynamic="1"/>+        <!-- The string should stop if capture $1 is found,+        but there is no way to propagate the capture. -->+        <IncludeRules context="FindVarNameModifier_s_C_RepQ"/>+        <DetectChar attribute="Replacement String" context="VarBraceModifier_s_C_Rep_Recursive" char="&brace_open;"/>+        <IncludeRules context="VarBraceModifier_s_Rep_Common"/>+        <IncludeRules context="VarBraceModifier_End"/>+      </context>+      <context attribute="Replacement String" name="VarBraceModifier_s_C_Rep_Recursive">+        <IncludeRules context="FindVarNameModifier_s_C_RepQ"/>+        <IncludeRules context="VarBraceModifier_s_Rep_Common"/>+        <DetectChar attribute="Replacement String" context="VarBraceModifier_s_C_Rep_Recursive" char="{"/>+        <DetectChar context="#pop" char="}"/>+        <AnyChar context="#pop" String="&symbolseps;" lookAhead="1"/>+      </context>+      <context attribute="Replacement String" name="VarBraceModifier_s_Rep_Common">+        <IncludeRules context="FindVariable"/>+        <DetectChar attribute="Backquote" context="RegularBackq" char="`"/>+        <IncludeRules context="FindEscape"/>+        <IncludeRules context="FindSingleGlob"/>+        <IncludeRules context="FindGlobRangeOrError"/>+      </context>+      <!-- ${var:s/../..'../'..}  ${var:s/../..'..'..}+                        ~~~~                   ~~~~+      -->+      <context attribute="String SingleQ" name="VarBraceModifier_s_RepSQ">+        <IncludeRules context="VarNameModifier_s_C_RepSQ"/>+        <DetectChar attribute="Error" context="#pop#pop!VarBraceModifierNext!StringSQ" char="/"/>+      </context>+      <context attribute="String SingleQ" name="VarBraceModifier_s_RepSQ_Recursive">+        <IncludeRules context="VarNameModifier_s_C_RepSQ"/>+        <DetectChar context="#pop#pop#pop" char="/" lookAhead="1"/>+      </context>+      <!-- ${var:s/../.."../"..}  ${var:s/../..".."..}+                        ~~~~                   ~~~~+      -->+      <context attribute="String DoubleQ" name="VarBraceModifier_s_RepDQ">+        <IncludeRules context="VarNameModifier_s_C_RepDQ"/>+        <DetectChar attribute="Error" context="#pop#pop!VarBraceModifierNext!StringDQ" char="/"/>+      </context>+      <context attribute="String DoubleQ" name="VarBraceModifier_s_RepDQ_Recursive">+        <IncludeRules context="VarNameModifier_s_C_RepDQ"/>+        <DetectChar context="#pop#pop" char="/" lookAhead="1"/>+      </context>+      <context attribute="String DoubleQ" name="VarBraceModifier_s_RepDQ_to_End">+        <DetectChar attribute="Error" context="#pop#pop#pop!VarBraceModifierNext!StringDQ" char="/"/>+      </context>+++      <!-- ${var:F(expr)h}+                  ~~~~~~+      -->+      <context attribute="Normal Text" name="VarBraceModifier_F" lineEndContext="BraceArithmeticParamNL" fallthroughContext="#pop!VarBraceModifierNext">+        <IncludeRules context="FindStringsThenPop"/>+        <DetectChar attribute="Parameter Expansion Operator" context="BraceArithmeticParamColon" char=":"/>+        <DetectChar attribute="Parameter Expansion Operator" context="BraceArithmeticParamParen" char="("/>+        <DetectChar attribute="Parameter Expansion Operator" context="BraceArithmeticParamBracket" char="["/>+        <DetectChar attribute="Parameter Expansion Operator" context="BraceArithmeticParamBrace" char="{"/>+        <RegExpr attribute="Parameter Expansion Operator" context="BraceArithmeticParamDyn" String="([^&symbolseps;])"/>+      </context>+      <context attribute="Normal Text" name="BraceArithmeticParamParen">+        <IncludeRules context="BraceVerbatimParamParen"/>+        <IncludeRules context="FindArithmetic"/>+      </context>+      <context attribute="Normal Text" name="BraceArithmeticParamBracket">+        <IncludeRules context="BraceVerbatimParamBracket"/>+        <IncludeRules context="FindArithmetic"/>+      </context>+      <context attribute="Normal Text" name="BraceArithmeticParamBrace">+        <IncludeRules context="BraceVerbatimParamBrace"/>+        <IncludeRules context="FindArithmetic"/>+      </context>+      <context attribute="Normal Text" name="BraceArithmeticParamColon">+        <IncludeRules context="BraceVerbatimParamColon"/>+        <IncludeRules context="FindArithmetic"/>+      </context>+      <context attribute="Normal Text" name="BraceArithmeticParamDyn">+        <IncludeRules context="BraceVerbatimParamDyn"/>+        <IncludeRules context="FindArithmetic"/>+      </context>+      <!-- ${var:F+                  ^ new line -> BraceArithmeticParamNL+      arithmetic or empty line+                              ^ new line -> BraceArithmeticParamNL2+      }+      -->+      <context attribute="Normal Text" name="BraceArithmeticParamNL" lineEmptyContext="#pop!BraceArithmeticParamNL2" fallthroughContext="#pop!BraceArithmeticParamNL2">+      </context>+      <context attribute="Normal Text" name="BraceArithmeticParamNL2" lineEndContext="#pop#pop">+        <IncludeRules context="BraceVerbatimParamNL2"/>+        <IncludeRules context="FindArithmetic"/>+      </context>+      <!-- ${var:W(xxx)h}+                  ~~~~~+      -->+      <context attribute="Normal Text" name="VarBraceModifier_W" lineEndContext="BraceVerbatimParamNL" fallthroughContext="#pop!VarBraceModifierNext">+        <IncludeRules context="FindStringsThenPop"/>+        <DetectChar attribute="Parameter Expansion Operator" context="BraceVerbatimParamColon" char=":"/>+        <DetectChar attribute="Parameter Expansion Operator" context="BraceVerbatimParamParen" char="("/>+        <DetectChar attribute="Parameter Expansion Operator" context="BraceVerbatimParamBracket" char="["/>+        <DetectChar attribute="Parameter Expansion Operator" context="BraceVerbatimParamBrace" char="{"/>+        <RegExpr attribute="Parameter Expansion Operator" context="BraceVerbatimParamDyn" String="([^&symbolseps;])"/>+      </context>+      <context attribute="Verbatim String" name="BraceVerbatimParamParen">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop" char=")"/>+        <IncludeRules context="VarBraceModifier_End2"/>+      </context>+      <context attribute="Verbatim String" name="BraceVerbatimParamBracket">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop" char="]"/>+        <IncludeRules context="VarBraceModifier_End2"/>+      </context>+      <context attribute="Verbatim String" name="BraceVerbatimParamBrace">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop" char="}"/>+        <IncludeRules context="VarBraceModifier_End2"/>+      </context>+      <context attribute="Verbatim String" name="BraceVerbatimParamColon">+        <IncludeRules context="VarBraceModifier_End2"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop" char=":"/>+      </context>+      <context attribute="Verbatim String" name="BraceVerbatimParamDyn">+        <IncludeRules context="VarBraceModifier_End2"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop" char="1" dynamic="1"/>+      </context>+      <!-- ${var:W+                  ^ new line -> BraceVerbatimParamNL+      sep or empty line+                       ^ new line -> BraceVerbatimParamNL2+      }+      -->+      <context attribute="Verbatim String" name="BraceVerbatimParamNL" lineEmptyContext="#pop!BraceVerbatimParamNL2" fallthroughContext="#pop!BraceVerbatimParamNL2">+      </context>+      <context attribute="Verbatim String" name="BraceVerbatimParamNL2" lineEndContext="#pop#pop">+        <IncludeRules context="VarBraceModifier_End2"/>+      </context>+++      <!-- called as soon as ${xxx: is encoutered and followed by a arithmetic context (not modifier, etc) -->+      <context attribute="Normal Text" lineEndContext="#stay" name="VarSub">+        <DetectChar attribute="Parameter Expansion" context="#pop" char="}"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarBraceModifierOrArithmetic" char=":"/>+        <IncludeRules context="FindArithmetic"/>+      </context>++      <!-- called as soon as ${xxx:-, etc are encoutered -->+      <context attribute="String DoubleQ" lineEndContext="#stay" name="AlternateValue">+        <DetectChar attribute="String DoubleQ" context="RecursiveAlternateValue" char="{"/>+        <DetectChar attribute="Parameter Expansion" context="#pop" char="}"/>+        <IncludeRules context="FindWord"/>+        <IncludeRules context="FindPathThenPopInAlternateValue"/>+        <DetectIdentifier attribute="String DoubleQ"/>+      </context>+      <context attribute="String DoubleQ" lineEndContext="#stay" name="RecursiveAlternateValue">+        <DetectChar attribute="String DoubleQ" context="RecursiveAlternateValue" char="{"/>+        <DetectChar attribute="String DoubleQ" context="#pop" char="}"/>+        <IncludeRules context="FindWord"/>+        <IncludeRules context="FindPathThenPopInAlternateValue"/>+        <DetectIdentifier attribute="String DoubleQ"/>+      </context>++      <!-- called as soon as ${xxx%, etc are encoutered -->+      <context attribute="String DoubleQ" lineEndContext="#stay" name="AlternatePatternValue">+        <DetectChar attribute="String DoubleQ" context="RecursiveAlternatePatternValue" char="{"/>+        <DetectChar attribute="Parameter Expansion" context="#pop" char="}"/>+        <IncludeRules context="FindWord"/>+        <IncludeRules context="FindStringDQPattern"/>+        <DetectIdentifier attribute="String DoubleQ"/>+      </context>+      <context attribute="String DoubleQ" lineEndContext="#stay" name="RecursiveAlternatePatternValue">+        <DetectChar attribute="String DoubleQ" context="RecursiveAlternateValue" char="{"/>+        <DetectChar attribute="String DoubleQ" context="#pop" char="}"/>+        <IncludeRules context="FindWord"/>+        <IncludeRules context="FindStringDQPattern"/>+        <DetectIdentifier attribute="String DoubleQ"/>+      </context>++      <!-- called as soon as ${xxx/ ${xxx// ${xxx:/ are encoutered -->+      <context attribute="Normal Text" lineEndContext="#stay" name="VarBraceSubst" fallthroughContext="#pop!VarBraceSubstPat">+        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!VarBraceSubstPat" char="#" char1="%"/>+        <AnyChar attribute="Parameter Expansion Operator" context="#pop!VarBraceSubstPat" String="#%"/>+      </context>+      <context attribute="Pattern" lineEndContext="#stay" name="VarBraceSubstPat">+        <DetectChar attribute="Parameter Expansion Operator" context="VarBraceSubstRep" char="/"/>+        <DetectChar attribute="String DoubleQ" context="RecursiveAlternateValue" char="{"/>+        <DetectChar attribute="Parameter Expansion" context="#pop" char="}"/>+        <IncludeRules context="FindWord"/>+        <IncludeRules context="FindSubPattern"/>+        <DetectIdentifier attribute="Pattern"/>+      </context>+      <!-- ${foo/.../...}+                     ~~~~+      -->+      <context attribute="Replacement String" lineEndContext="#stay" name="VarBraceSubstRep">+        <DetectChar attribute="Replacement String" context="VarBraceSubstRepRec" char="{"/>+        <DetectChar attribute="Parameter Expansion" context="#pop#pop" char="}"/>+        <IncludeRules context="FindWord"/>+      </context>+      <context attribute="Replacement String" lineEndContext="#stay" name="VarBraceSubstRepRec">+        <DetectChar attribute="Replacement String" context="VarBraceSubstRepRec" char="{"/>+        <DetectChar attribute="Replacement String" context="#pop" char="}"/>+        <IncludeRules context="FindWord"/>+      </context>++      <!-- called as soon as ${( is encoutered -->+      <context attribute="Parameter Expansion" lineEndContext="#stay" name="VarFlags">+        <AnyChar attribute="Parameter Expansion Operator" context="#stay" String="#%*q@AabcCDefFikLnoOPqQ+-tuUvVwWXz0~mSBEMNR"/>+        <AnyChar attribute="Parameter Expansion Operator" context="VarFlag_s" String="sjgZ_"/>+        <AnyChar attribute="Parameter Expansion Operator" context="VarFlag_l" String="lrI"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlagsSubs" char="p"/>++        <DetectChar attribute="Parameter Expansion" context="#pop!VarFlagsVar" char=")"/>+        <DetectChar attribute="Error" context="#pop" char="}"/>+      </context>+      <context attribute="Parameter Expansion" lineEndContext="#stay" name="VarFlagsSubs">+        <AnyChar attribute="Parameter Expansion Operator" context="#stay" String="#q@AabcCDefFikLnoOPqQ+-tuUvVwWXz0~mSBEMNRp"/>+        <AnyChar attribute="Parameter Expansion Operator" context="VarFlag_s" String="gZ"/>+        <AnyChar attribute="Parameter Expansion Operator" context="VarFlag_ps" String="sj_"/>+        <AnyChar attribute="Parameter Expansion Operator" context="VarFlag_pl" String="lrI"/>++        <DetectChar attribute="Parameter Expansion" context="#pop!VarFlagsVar" char=")"/>+        <DetectChar attribute="Error" context="#pop" char="}"/>+      </context>+      <context attribute="Variable" lineEndContext="#stay" name="VarFlagsVar" fallthroughContext="#pop!CheckVarAlt">+        <DetectChar context="VarBraceStartRecursive" char="$" lookAhead="1"/>+        <DetectChar attribute="Parameter Expansion" context="#pop" char="}"/>+        <DetectChar attribute="String DoubleQ" context="StringDQ" char="&quot;"/>+        <AnyChar attribute="Parameter Expansion Operator" context="#stay" String="#+^=~"/>+        <DetectIdentifier attribute="Variable" context="#pop!CheckVarAlt"/>+        <AnyChar attribute="Variable" context="#pop!CheckVarAlt" String="*@?$-"/>+        <Int attribute="Variable" context="#pop!CheckVarAlt" additionalDeliminator="#~=^+{}[]:-/$"/>+        <Detect2Chars context="#pop!VarSubShell" char="!" char1="}" lookAhead="1"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!AlternateValue" char="!"/>+      </context>++      <context attribute="Parameter Expansion" lineEndContext="#stay" name="VarSubShell">+        <DetectChar attribute="Variable" context="#pop!CheckVarAlt" char="!"/>+      </context>++      <context attribute="Parameter Expansion" lineEndContext="#stay" name="VarFlag_s">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_s[" char="["/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_s&lt;" char="&lt;"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_s{" char="{"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_s(" char="("/>+        <RegExpr attribute="Parameter Expansion Operator" context="#pop!VarFlag_sx" String="(.)"/>+      </context>+      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_s[">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="]"/>+      </context>+      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_s&lt;">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char=">"/>+      </context>+      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_s{">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="}"/>+      </context>+      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_s(">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char=")"/>+      </context>+      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_sx">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="1" dynamic="1"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#stay" name="VarFlag_l">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_l[" char="["/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_l&lt;" char="&lt;"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_l{" char="{"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_l(" char="("/>+        <RegExpr attribute="Parameter Expansion Operator" context="#pop!VarFlag_lx" String="(.)"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="VarFlag_l[">+        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!VarFlag_l[s" char="]" char1="["/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="]"/>+        <IncludeRules context="FindExprDblParen"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="VarFlag_l&lt;">+        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!VarFlag_l&lt;s" char=">" char1="&lt;"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char=">"/>+        <IncludeRules context="FindExprDblParen"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="VarFlag_l{">+        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!VarFlag_l{s" char="}" char1="{"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="}"/>+        <IncludeRules context="FindExprDblParen"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="VarFlag_l(">+        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!VarFlag_l(s" char=")" char1="("/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char=")"/>+        <IncludeRules context="FindExprDblParen"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="VarFlag_lx">+        <RegExpr attribute="Parameter Expansion Operator" context="#pop!VarFlag_lxs" String="(%1)%1" dynamic="1"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="1" dynamic="1"/>+        <IncludeRules context="FindExprDblParen"/>+      </context>+      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_l[s">+        <Detect2Chars attribute="Parameter Expansion Operator" context="#stay" char="]" char1="["/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="]"/>+      </context>+      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_l&lt;s">+        <Detect2Chars attribute="Parameter Expansion Operator" context="#stay" char=">" char1="&lt;"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char=">"/>+      </context>+      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_l{s">+        <Detect2Chars attribute="Parameter Expansion Operator" context="#stay" char="}" char1="{"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="}"/>+      </context>+      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_l(s">+        <Detect2Chars attribute="Parameter Expansion Operator" context="#stay" char=")" char1="("/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char=")"/>+      </context>+      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_lxs">+        <StringDetect attribute="Parameter Expansion Operator" context="#stay" String="%1%1" dynamic="1"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="1" dynamic="1"/>+      </context>++      <context attribute="Parameter Expansion" lineEndContext="#stay" name="VarFlag_ps">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_ps[" char="["/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_ps&lt;" char="&lt;"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_ps{" char="{"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_ps(" char="("/>+        <RegExpr attribute="Parameter Expansion Operator" context="#pop!VarFlag_psx" String="(.)"/>+      </context>+      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_ps[">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="]"/>+        <RegExpr attribute="Variable" context="#stay" String="\$(&varname;|[0-9]+)(?=\])"/>+      </context>+      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_ps&lt;">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char=">"/>+        <RegExpr attribute="Variable" context="#stay" String="\$(&varname;|[0-9]+)(?=>)"/>+      </context>+      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_ps{">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="}"/>+        <RegExpr attribute="Variable" context="#stay" String="\$(&varname;|[0-9]+)(?=})"/>+      </context>+      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_ps(">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char=")"/>+        <RegExpr attribute="Variable" context="#stay" String="\$(&varname;|[0-9]+)(?=\))"/>+      </context>+      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_psx">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="1" dynamic="1"/>+        <RegExpr attribute="Variable" context="#stay" String="\$(?!%1)(?:[A-Za-z_](?:(?!%1)[A-Za-z0-9_])*+|(?:(?!%1)[0-9])++)(?=%1)" dynamic="1"/>+        <RegExpr attribute="String SingleQ" context="#stay" String="[^%1]+" dynamic="1"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#stay" name="VarFlag_pl">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_pl[" char="["/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_pl&lt;" char="&lt;"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_pl{" char="{"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!VarFlag_pl(" char="("/>+        <RegExpr attribute="Parameter Expansion Operator" context="#pop!VarFlag_plx" String="(.)"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="VarFlag_pl[">+        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!VarFlag_pl[s" char="]" char1="["/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="]"/>+        <IncludeRules context="FindExprDblParen"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="VarFlag_pl&lt;">+        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!VarFlag_pl&lt;s" char=">" char1="&lt;"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char=">"/>+        <IncludeRules context="FindExprDblParen"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="VarFlag_pl{">+        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!VarFlag_pl{s" char="}" char1="{"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="}"/>+        <IncludeRules context="FindExprDblParen"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="VarFlag_pl(">+        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!VarFlag_pl(s" char=")" char1="("/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char=")"/>+        <IncludeRules context="FindExprDblParen"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="VarFlag_plx">+        <RegExpr attribute="Parameter Expansion Operator" context="#pop!VarFlag_plxs" String="(%1)%1" dynamic="1"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="1" dynamic="1"/>+        <IncludeRules context="FindExprDblParen"/>+      </context>+      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_pl[s">+        <Detect2Chars attribute="Parameter Expansion Operator" context="#stay" char="]" char1="["/>+        <IncludeRules context="VarFlag_ps["/>+      </context>+      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_pl&lt;s">+        <Detect2Chars attribute="Parameter Expansion Operator" context="#stay" char=">" char1="&lt;"/>+        <IncludeRules context="VarFlag_ps&lt;"/>+      </context>+      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_pl{s">+        <Detect2Chars attribute="Parameter Expansion Operator" context="#stay" char="}" char1="{"/>+        <IncludeRules context="VarFlag_ps{"/>+      </context>+      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_pl(s">+        <Detect2Chars attribute="Parameter Expansion Operator" context="#stay" char=")" char1="("/>+        <IncludeRules context="VarFlag_ps("/>+      </context>+      <context attribute="String SingleQ" lineEndContext="#stay" name="VarFlag_plxs">+        <StringDetect attribute="Parameter Expansion Operator" context="#stay" String="%1%1" dynamic="1"/>+        <IncludeRules context="VarFlag_psx"/>+      </context>++      <!-- brace command substitution:+        ${|cmd} ${ cmd }+           ~~~~    ~~~~~+      -->+      <context attribute="Normal Text" lineEndContext="#stay" name="VarCmd" fallthroughContext="Command">+        <DetectChar attribute="Parameter Expansion" context="#pop" char="}"/>+        <IncludeRules context="Start"/>+      </context>+      <!-- ${{param} cmd}+             ~~~~~~~+      -->+      <context attribute="Variable" lineEndContext="#stay" name="VarCmdVar">+        <DetectChar attribute="Normal Text" context="VarCmdCheckSpace" char="}"/>+        <AnyChar attribute="Error" context="#pop!VarCmd" String="&ws;"/>+        <IncludeRules context="FindSubscript"/>+      </context>+      <context attribute="Variable" lineEndContext="#pop#pop!VarCmd" name="VarCmdCheckSpace">+        <DetectChar attribute="Normal Text" context="#pop#pop!VarCmd" char=" "/>+        <DetectChar attribute="Parameter Expansion" context="#pop#pop" char="}"/>+        <RegExpr attribute="Error" context="#pop#pop!VarCmd" String="."/>+      </context>++      <context attribute="Escape" lineEndContext="#pop" name="BraceExpansion">+        <DetectChar attribute="Escape" context="#pop!BraceExpansion2" char="{"/>+      </context>+      <context attribute="Escape" lineEndContext="#pop" name="BraceExpansion2">+        <DetectChar attribute="Operator" context="#stay" char=","/>+        <DetectChar attribute="Escape" context="#pop" char="}"/>+        <DetectChar context="EscapeMaybeBraceExpansion" char="{" lookAhead="1"/>+        <IncludeRules context="FindEscape"/>+        <DetectChar attribute="Backquote" context="CommandBackq" char="`"/>+        <IncludeRules context="FindVariableOrCurrentStyle"/>+        <IncludeRules context="FindStrings"/>+        <IncludeRules context="FindPattern"/>+        <DetectIdentifier attribute="Escape"/>+      </context>+      <context attribute="Escape" lineEndContext="#pop" name="EscapeMaybeBraceExpansion">+        <IncludeRules context="DispatchBraceExpansion"/>+        <DetectChar attribute="Escape" context="#pop!BraceExpansion2" char="{"/>+      </context>++      <context attribute="Escape" lineEndContext="#pop" name="PathBraceExpansion">+        <DetectChar attribute="Escape" context="#pop!PathBraceExpansion2" char="{"/>+      </context>+      <context attribute="Path" lineEndContext="#pop" name="PathBraceExpansion2">+        <DetectChar attribute="Operator" context="#stay" char=","/>+        <DetectChar attribute="Escape" context="#pop" char="}"/>+        <DetectChar context="PathMaybeBraceExpansion" char="{" lookAhead="1"/>+        <IncludeRules context="FindWord"/>+        <IncludeRules context="FindPattern"/>+        <DetectIdentifier attribute="Path"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#pop" name="SequenceExpression">+        <AnyChar attribute="Number" context="#stay" String="0123456789-"/>+        <IncludeRules context="FindWord"/>+        <Detect2Chars attribute="Escape" context="#stay" char="." char1="."/>+        <DetectChar attribute="Escape" context="#pop" char="}"/>+      </context>++<!-- ====== These are the contexts that can be branched to ======= -->++      <context attribute="Normal Text" lineEndContext="#stay" name="ExprDblParenOrSubShell">+        <RegExpr attribute="Keyword" context="#pop!SubShell" String="\((?=&arithmetic_as_subshell;)|" beginRegion="subshell"/>+        <Detect2Chars attribute="Keyword" context="#pop!ExprDblParen" char="(" char1="(" beginRegion="expression"/>+      </context>+      <!-- ExprDblParen consumes an expression started in command mode till )) -->+      <context attribute="Normal Text" lineEndContext="#stay" name="ExprDblParen">+        <DetectSpaces attribute="Normal Text" context="#stay"/>+        <Detect2Chars attribute="Keyword" context="#pop" char=")" char1=")" endRegion="expression"/>+        <IncludeRules context="FindExprDblParen"/>+        <!-- ((cmd+              ) # jump to SubShell context -->+        <DetectChar attribute="Keyword" context="#pop!SubShell" char=")" endRegion="expression" beginRegion="subshell"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="FindExprDblParen">+        <DetectChar attribute="Normal Text" context="ExprSubDblParen" char="("/>+        <IncludeRules context="FindArithmetic"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="ExprSubDblParen">+        <DetectSpaces attribute="Normal Text" context="#stay"/>+        <DetectChar attribute="Normal Text" context="#pop" char=")"/>+        <IncludeRules context="FindExprDblParen"/>+      </context>+      <context attribute="Error" lineEndContext="#pop" name="MaybeArithmeticBrace">+        <IncludeRules context="DispatchBraceExpansion"/>+        <DetectChar attribute="Error" context="#pop" char="{"/>+      </context>++      <context attribute="Number" name="FindBranchCondition">+        <Detect2Chars attribute="Control" context="#stay" char="&amp;" char1="&amp;"/>+        <Detect2Chars attribute="Control" context="#stay" char="|" char1="|"/>+      </context>++      <context attribute="Number" name="FindArithmetic">+        <IncludeRules context="FindBranchCondition"/>+        <AnyChar attribute="Operator" String="&arithmetic_op;"/>+        <IncludeRules context="FindNumber"/>+        <IncludeRules context="FindSubscript"/>+        <IncludeRules context="FindWord"/>+        <IncludeRules context="FindToNum"/>+        <DetectChar attribute="Control" char=","/>+        <DetectChar context="MaybeArithmeticBrace" char="{" lookAhead="1"/>+        <DetectIdentifier attribute="Variable"/>+      </context>++      <context attribute="Number" name="FindToNum">+        <Detect2Chars attribute="Base" context="ChToNum" char="#" char1="#"/>+        <DetectChar attribute="Base" context="MaybeOutputBase" char="#"/>+      </context>+      <!-- ##c in ((##c)) -->+      <context attribute="Normal Text" lineEndContext="#pop" name="ChToNum" fallthroughContext="#pop">+        <LineContinue attribute="Escape"/>+        <!-- '##\)' is ok, but not '##\(' -->+        <RegExpr attribute="BaseN" context="#pop" String="[^\[\]()\\$^]|\$(?=$|\)|[^+=:#^~+$@*'?{(\w])|\^?\\(&escaped_ch;|[^\[\]\(])|\^[^\[\]()\\]|\^(?=[)])"/>+      </context>+      <!-- #n in ((#n)) -->+      <context attribute="Normal Text" lineEndContext="#pop" name="MaybeOutputBase" fallthroughContext="#pop">+        <AnyChar attribute="BaseN" String="0123456789_"/>+      </context>++      <context attribute="Number" name="FindDigit">+        <AnyChar attribute="Number" context="#stay" String="0123456789"/>+      </context>++      <context attribute="Number" name="FindNumber">+        <AnyChar context="Number" String="0123456789." lookAhead="1"/>+      </context>+      <context attribute="Number" lineEndContext="#pop" name="Number">+        <Detect2Chars attribute="Hex" context="#pop!Hex" char="0" char1="x"/>+        <Detect2Chars attribute="Hex" context="#pop!Hex" char="0" char1="X"/>+        <RegExpr attribute="Base" context="#pop!BaseN" String="[1-9][0-9_]*+#"/>+        <RegExpr attribute="Number" context="#pop" String="&int;(\._*+(&int;&exp;?+|&exp;)?|&exp;)?|\._*+&int;&exp;?"/>+        <DetectChar attribute="Operator" context="#pop" char="."/>+      </context>+      <context attribute="Hex" lineEndContext="#pop" name="Hex" fallthroughContext="#pop">+        <RegExpr attribute="Hex" context="#pop" String="[0-9a-fA-F_]+"/>+      </context>+      <context attribute="BaseN" lineEndContext="#pop" name="BaseN" fallthroughContext="#pop">+        <RegExpr attribute="BaseN" context="#pop" String="[0-9a-zA-Z@_]+"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#stay" name="ExprDblParenSubstOrSubstCommand">+        <RegExpr attribute="Parameter Expansion" context="#pop!SubstCommand" String="\$\((?=&arithmetic_as_subshell;)|" beginRegion="subshell"/>+        <StringDetect attribute="Parameter Expansion" context="#pop!ExprDblParenSubst" String="$((" beginRegion="expression"/>+      </context>+      <!-- ExprDblParenSubst like ExprDblParen but matches )) as Variable -->+      <context attribute="Normal Text" lineEndContext="#stay" name="ExprDblParenSubst">+        <DetectSpaces attribute="Normal Text" context="#stay"/>+        <Detect2Chars attribute="Parameter Expansion" context="#pop" char=")" char1=")" endRegion="expression"/>+        <IncludeRules context="FindExprDblParen"/>+        <!-- $((cmd+              ) # jump to SubstCommand context -->+        <DetectChar attribute="Parameter Expansion" context="#pop!SubstCommand" char=")" endRegion="expression" beginRegion="subshell"/>+      </context>++      <!-- ExprBracket consumes an expression till ] -->+      <context attribute="Normal Text" lineEndContext="#stay" name="ExprBracket" fallthroughContext="#pop!ExprBracketNot">+        <DetectSpaces attribute="Normal Text" context="#stay"/>+        <IncludeRules context="FindExprBracketEnd"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#stay" name="ExprBracketNot" fallthroughContext="#pop!ExprBracketParam1">+        <DetectSpaces attribute="Normal Text" context="#pop!ExprBracketParam1"/>+        <Detect2Chars attribute="Expression" context="ExprBracketTestMaybeNot" char="!" char1=" " lookAhead="1"/>+        <Detect2Chars attribute="Expression" context="ExprBracketTestMaybeNot" char="!" char1="&tab;" lookAhead="1"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="ExprBracketTestMaybeNot">+        <DetectChar attribute="Expression" context="#pop" char="!"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#stay" name="ExprBracketParam1" fallthroughContext="ExprBracketValue">+        <DetectSpaces attribute="Normal Text" context="#pop!ExprBracketParam2"/>+        <DetectChar context="TestMaybeUnary" char="-" lookAhead="1"/>+        <IncludeRules context="FindExprBracketEnd"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#pop" name="ExprBracketValue">+        <AnyChar context="#pop" String="&ws;" lookAhead="1"/>+        <AnyChar attribute="Error" context="#stay" String="&symbolseps;"/>+        <IncludeRules context="FindWord"/>+        <IncludeRules context="FindGlobAny"/>+        <IncludeRules context="FindPathThenPop"/>+        <DetectChar context="ExprBracketValueMaybeBraceExpansion" char="{" lookAhead="1"/>+        <DetectChar context="NormalOptionMaybeGroupEnd" char="}" lookAhead="1"/>+        <DetectIdentifier attribute="Normal Text"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="ExprBracketValueRecBrace">+        <AnyChar context="#pop#pop" String="&ws;" lookAhead="1"/>+        <AnyChar attribute="Error" context="#stay" String="&symbolseps;"/>+        <IncludeRules context="FindWord"/>+        <IncludeRules context="FindGlobAny"/>+        <DetectChar context="ExprBracketValueMaybeBraceExpansion" char="{" lookAhead="1"/>+        <DetectChar attribute="Normal Text" context="#pop" char="}"/>+        <DetectIdentifier attribute="Normal Text"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="ExprBracketValueMaybeBraceExpansion">+        <IncludeRules context="DispatchBraceExpansion"/>+        <DetectChar attribute="Normal Text" context="#pop!ExprBracketValueRecBrace" char="{"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#stay" name="ExprBracketParam2" fallthroughContext="#pop!ExprBracketParam2_Value">+        <LineContinue attribute="Escape" context="SkipSpaces"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="ExprBracketParam2_Value" fallthroughContext="ExprBracketValue">+        <DetectSpaces attribute="Normal Text" context="#pop!ExprBracketParam3"/>+        <AnyChar context="TestMaybeBinary" String="-=!" lookAhead="1"/>+        <IncludeRules context="FindExprBracketEnd"/>+      </context>++      <context attribute="Normal Text" lineEndContext="ExprBracketFinal" name="ExprBracketParam3" fallthroughContext="#pop!ExprBracketParam3_Value">+        <LineContinue attribute="Escape" context="SkipSpaces"/>+      </context>+      <context attribute="Normal Text" lineEndContext="ExprBracketFinal" name="ExprBracketParam3_Value" fallthroughContext="ExprBracketValue">+        <DetectSpaces attribute="Normal Text" context="#pop!ExprBracketFinal"/>+        <IncludeRules context="FindExprBracketEnd"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#stay" name="ExprBracketFinal" fallthroughContext="ExprBracketValue">+        <DetectSpaces attribute="Normal Text" context="#stay"/>+        <IncludeRules context="FindExprBracketEnd"/>+        <RegExpr attribute="Expression" context="#pop!ExprBracket" String="-[ao]&eos;"/>+        <RegExpr attribute="Error" context="#pop" String="(?:[^]&ws;]++|\][^&ws;])++" endRegion="expression"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#stay" name="FindExprBracketEnd">+        <IncludeRules context="FindEscape"/>+        <RegExpr attribute="Builtin" context="#pop" String="\](?=($|[&ws;;|&amp;&lt;>)]))" endRegion="expression"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#pop" name="TestMaybeUnary" fallthroughContext="#pop!ExprBracketValue">+        <RegExpr attribute="Expression" context="#pop#pop!ExprBracketParam2" String="&unary_operators;"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="TestMaybeBinary" fallthroughContext="#pop!ExprBracketValue">+        <RegExpr attribute="Expression" context="#pop" String="&binary_operators;"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#pop" name="SkipSpaces" fallthroughContext="#pop">+        <DetectSpaces context="#pop"/>+      </context>+++      <!-- ExprDblBracket consumes an expression till ]] -->+      <context attribute="Normal Text" lineEndContext="#stay" name="ExprDblBracket" fallthroughContext="#pop!ExprDblBracketNot">+        <DetectSpaces attribute="Normal Text" context="#stay"/>+        <IncludeRules context="FindExprDblBracketEnd"/>+        <DetectChar attribute="Comment" context="Comment" char="#"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#stay" name="ExprDblBracketNot" fallthroughContext="#pop!ExprDblBracketParam1">+        <DetectChar context="ExprDblBracketTestMaybeNot" char="!" lookAhead="1"/>        <IncludeRules context="FindSpaceAndComment"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="ExprDblBracketTestMaybeNot" fallthroughContext="#pop#pop!ExprDblBracketParam1">+        <RegExpr attribute="Expression" context="#pop" String="!(?=$|[&ws;(])"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#stay" name="ExprDblBracketParam1" fallthroughContext="#pop!ExprDblBracketParam1_2">+        <DetectSpaces attribute="Normal Text" context="#stay"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="ExprDblBracketParam1_2" fallthroughContext="ExprDblBracketValueText">+        <DetectSpaces attribute="Normal Text" context="#pop!ExprDblBracketParam2"/>+        <DetectChar context="TestMaybeUnary2" char="-" lookAhead="1"/>+        <DetectChar context="ExprDblBracketSubValue" char="(" lookAhead="1"/>+        <IncludeRules context="FindExprDblBracketEnd"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="TestMaybeUnary2" fallthroughContext="#pop!ExprDblBracketValueText">+        <RegExpr attribute="Expression" context="#pop!ExprDblBracketUnary" String="&unary_operators;(?!\s+(?:=~|&binary_operators;))"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="ExprDblBracketUnary" fallthroughContext="#pop!ExprDblBracketValueText">+        <IncludeRules context="FindSpaceAndComment"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="ExprDblBracketSubValue" fallthroughContext="#pop">+        <DetectChar attribute="Operator" context="ExprDblBracketNot" char="("/>+        <DetectChar attribute="Operator" context="#pop" char=")"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#pop" name="ExprDblBracketValueText" fallthroughContext="#pop!ExprDblBracketValueText2">+        <Detect2Chars context="#pop!ExprDblBracketValueTextMaybeEnd" char="]" char1="]" lookAhead="1"/>+        <IncludeRules context="FindExprDblBracketValueTextPath"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="FindExprDblBracketValueTextPath">+        <RegExpr context="#pop!ExprDblBracketValueTextPath" String="&path_with_sep;|" lookAhead="1"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="ExprDblBracketValueTextMaybeEnd">+        <RegExpr attribute="Keyword" context="#pop#pop" String="&dblbracket_close;" endRegion="expression"/>+        <IncludeRules context="FindExprDblBracketValueTextPath"/>+        <Detect2Chars context="#pop!ExprDblBracketValueText2" char="]" char1="]" lookAhead="1"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="ExprDblBracketValueText2">+        <DetectIdentifier/>+        <AnyChar String="*?+@~^:%+-/,"/>+        <Detect2Chars attribute="Control" context="#pop#pop!ExprDblBracket" char="&amp;" char1="&amp;"/>+        <Detect2Chars attribute="Control" context="#pop#pop!ExprDblBracket" char="|" char1="|"/>+        <AnyChar context="#pop" String="&ws;)" lookAhead="1"/>+        <IncludeRules context="FindWord"/>+        <IncludeRules context="FindGroupPattern"/>+        <AnyChar attribute="Error" context="#stay" String="&amp;;|"/>+        <DetectChar context="ExprDblBracketValueTextMaybeRange" char="&lt;" lookAhead="1"/>+        <DetectChar attribute="Expression" context="#pop!ExprDblBracketValuePattern" char=">"/>+      </context>+      <context attribute="Path" lineEndContext="#pop" name="ExprDblBracketValueTextPath">+        <IncludeRules context="ExprDblBracketValueText2"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="ExprDblBracketValueTextMaybeRange">+        <RegExpr context="#pop" String="&globrange;"/>+        <DetectChar attribute="Expression" context="#pop#pop!ExprDblBracketValuePattern" char="&lt;"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#pop" name="ExprDblBracketValuePattern" fallthroughContext="#pop!ExprDblBracketValuePattern2">+        <RegExpr context="ExprDblBracketValuePatternPath" String="&path_with_sep;|" lookAhead="1"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="ExprDblBracketValuePatternPath" fallthroughContext="#pop!PathThenPop">+        <DetectChar attribute="Path" context="#pop!PathThenPop" char="~"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="ExprDblBracketValuePattern2">+        <DetectIdentifier attribute="Normal Text"/>+        <Detect2Chars attribute="Control" context="#pop#pop!ExprDblBracket" char="&amp;" char1="&amp;"/>+        <Detect2Chars attribute="Control" context="#pop#pop!ExprDblBracket" char="|" char1="|"/>+        <AnyChar context="#pop" String="&ws;)" lookAhead="1"/>+        <IncludeRules context="FindWord"/>+        <IncludeRules context="FindSingleGlob"/>+        <IncludeRules context="FindGlobAny"/>+        <IncludeRules context="FindGroupPattern"/>+        <IncludeRules context="FindGlobRangeOrError"/>+        <AnyChar attribute="Error" context="#stay" String=">&amp;|;"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#stay" name="ExprDblBracketParam2" fallthroughContext="#pop!ExprDblBracketParam2_2">+        <IncludeRules context="FindSpaceAndComment"/>+        <LineContinue attribute="Escape"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="ExprDblBracketParam2_2" fallthroughContext="ExprDblBracketValuePattern">+        <DetectSpaces attribute="Normal Text" context="#pop!ExprDblBracketParam3"/>+        <AnyChar context="TestMaybeBinary2" String="-=!" lookAhead="1"/>+        <AnyChar attribute="Expression" context="#pop!ExprDblBracketParam3Spe" String="&lt;>"/>+        <IncludeRules context="FindExprDblBracketEnd"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="TestMaybeBinary2" fallthroughContext="#pop!ExprDblBracketValuePattern">+        <IncludeRules context="TestMaybeBinary"/>+        <RegExpr attribute="Expression" context="#pop#pop!ExprDblBracketRegex" String="=~&eos;"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#stay" name="ExprDblBracketParam3Spe" fallthroughContext="#pop!ExprDblBracketParam3">+        <DetectSpaces attribute="Normal Text" context="#pop!ExprDblBracketParam3"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#stay" name="ExprDblBracketParam3" fallthroughContext="#pop!ExprDblBracketParam3_2">+        <IncludeRules context="ExprDblBracketParam2"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop!ExprDblBracketFinal" name="ExprDblBracketParam3_2" fallthroughContext="ExprDblBracketValuePattern">+        <DetectSpaces attribute="Normal Text" context="#pop!ExprDblBracketFinal"/>+        <IncludeRules context="FindExprDblBracketEnd"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#stay" name="ExprDblBracketFinal" fallthroughContext="ExprDblBracketValuePattern">+        <DetectSpaces attribute="Normal Text" context="#stay"/>+        <IncludeRules context="FindExprDblBracketEnd"/>+        <DetectChar attribute="Comment" context="Comment" char="#"/>+        <RegExpr attribute="Error" context="#pop" String="(?:[^]&ws;]++|\](?:[^]]|\][^&ws;]))++" endRegion="expression"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#stay" name="FindExprDblBracketEnd">+        <IncludeRules context="FindEscape"/>+        <DetectChar context="#pop" char=")" lookAhead="1"/>+        <Detect2Chars attribute="Control" context="#pop!ExprDblBracket" char="&amp;" char1="&amp;"/>+        <Detect2Chars attribute="Control" context="#pop!ExprDblBracket" char="|" char1="|"/>+        <RegExpr attribute="Keyword" context="#pop" String="&dblbracket_close;" endRegion="expression"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#stay" name="ExprDblBracketRegex" fallthroughContext="#pop!Regex">+        <IncludeRules context="FindSpaceAndComment"/>+      </context>+      <context attribute="Pattern" lineEndContext="#stay" name="Regex">+        <DetectIdentifier attribute="Pattern"/>+        <DetectSpaces attribute="Normal Text" context="#pop!ExprDblBracketFinal"/>+        <DetectChar attribute="Operator" context="#pop" char=")"/>+        <Detect2Chars attribute="Operator" context="RegexChar" char="[" char1="^"/>+        <DetectChar attribute="Operator" context="RegexChar" char="["/>+        <IncludeRules context="FindRegex"/>+      </context>+      <context attribute="Pattern" lineEndContext="#stay" name="ExprDblBracketSubRegex">+        <DetectIdentifier attribute="Pattern"/>+        <DetectSpaces attribute="Pattern" context="#stay"/>+        <DetectChar attribute="Operator" context="#pop" char=")"/>+        <Detect2Chars attribute="Operator" context="RegexSubChar" char="[" char1="^"/>+        <DetectChar attribute="Operator" context="RegexSubChar" char="["/>+        <IncludeRules context="FindRegex"/>+      </context>++      <context attribute="Pattern" lineEndContext="#stay" name="FindRegex">+        <DetectChar attribute="Operator" context="ExprDblBracketSubRegex" char="("/>+        <DetectChar attribute="Escape" context="RegexEscape" char="\"/>+        <DetectChar attribute="Parameter Expansion" context="RegexDup" char="{"/>+        <AnyChar attribute="Glob" context="#stay" String="^?+*.|"/>+        <IncludeRules context="FindStrings"/>+        <DetectChar context="RegexDispatchVariables" char="$" lookAhead="1"/>+        <DetectChar attribute="Backquote" context="RegularBackq" char="`"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="RegexDispatchVariables">+        <IncludeRules context="DispatchVariables"/>+        <DetectChar attribute="Operator" context="#pop" char="$"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#pop" name="RegexEscape">+        <RegExpr attribute="Escape" context="#pop" String="x[0-9a-fA-F]{1,2}|[0-7]{1,3}|."/>+      </context>++      <context attribute="Normal Text" lineEndContext="#pop" name="RegexDup">+        <Int attribute="Number"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#stay" char=","/>+        <DetectChar attribute="Parameter Expansion" context="#pop" char="}"/>+      </context>++      <context attribute="Pattern" lineEndContext="#pop" name="RegexSubChar" fallthroughContext="#pop!RegexSubInChar">+        <AnyChar attribute="Pattern" context="#pop!RegexSubInChar" String="-]"/>+      </context>+      <context attribute="Pattern" lineEndContext="#pop" name="RegexSubInChar">+        <DetectSpaces attribute="Pattern" context="#stay"/>+        <IncludeRules context="RegexInChar"/>+      </context>++      <context attribute="Pattern" lineEndContext="#pop" name="RegexChar" fallthroughContext="#pop!RegexInChar">+        <AnyChar attribute="Pattern" context="#pop!RegexInChar" String="-]"/>+      </context>+      <context attribute="Pattern" lineEndContext="#pop" name="RegexInChar">+        <Detect2Chars context="RegexInCharEnd" char="-" char1="]" lookAhead="1"/>+        <DetectChar attribute="Operator" context="#stay" char="-"/>+        <DetectChar attribute="Escape" context="RegexEscape" char="\"/>+        <DetectChar context="RegexCharClassSelect" char="[" lookAhead="1"/>+        <DetectChar attribute="Operator" context="#pop" char="]"/>+        <AnyChar context="#pop" String="()&ws;" lookAhead="1"/>+        <IncludeRules context="FindStrings"/>+      </context>+      <context attribute="Operator" lineEndContext="#stay" name="RegexInCharEnd">+        <DetectChar attribute="Pattern" context="#stay" char="-"/>+        <DetectChar attribute="Operator" context="#pop#pop" char="]"/>+      </context>+      <context attribute="Parameter Expansion" lineEndContext="#pop#pop#pop" name="RegexCharClassSelect">+        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!RegexCharClass" char="[" char1=":"/>+        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!RegexCollatingSymbols" char="[" char1="."/>+        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop!RegexEquivalenceClass" char="[" char1="="/>+        <DetectChar attribute="Pattern" context="#pop" char="["/>+      </context>++      <context attribute="Parameter Expansion" lineEndContext="#pop#pop#pop" name="RegexCharClass">+        <DetectIdentifier attribute="Parameter Expansion"/>+        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop" char=":" char1="]"/>+        <DetectChar attribute="Error" context="#pop" char="]"/>+      </context>+      <context attribute="Parameter Expansion" lineEndContext="#pop#pop#pop" name="RegexCollatingSymbols">+        <DetectIdentifier attribute="Parameter Expansion"/>+        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop" char="." char1="]"/>+        <DetectChar attribute="Error" context="#pop" char="]"/>+      </context>+      <context attribute="Parameter Expansion" lineEndContext="#pop#pop#pop" name="RegexEquivalenceClass">+        <DetectIdentifier attribute="Parameter Expansion"/>+        <Detect2Chars attribute="Parameter Expansion Operator" context="#pop" char="=" char1="]"/>+        <DetectChar attribute="Error" context="#pop" char="]"/>+      </context>++      <!-- SubShell consumes shell input till ) -->+      <context attribute="Normal Text" lineEndContext="#stay" name="SubShell" fallthroughContext="Command">+        <DetectChar attribute="Keyword" context="#pop" char=")" endRegion="subshell"/>+        <IncludeRules context="Start"/>+      </context>++      <!-- Assign consumes an expression till EOL or whitespace -->+      <context attribute="Normal Text" lineEndContext="#pop" name="Assign" fallthroughContext="#pop!RegularAssign">+        <DetectChar attribute="Variable" context="#pop!AssignArray" char="("/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="RegularAssign" fallthroughContext="#pop">+        <DetectChar attribute="Backquote" context="RegularBackq" char="`"/>+        <IncludeRules context="NormalOption"/>+      </context>++      <!-- AssignArray consumes everything till ), marking assignments -->+      <context attribute="Normal Text" lineEndContext="#stay" name="AssignArray" fallthroughContext="NormalOption">+        <IncludeRules context="FindSpaceAndComment"/>+        <DetectChar attribute="Variable" context="#pop" char=")"/>+        <DetectChar context="AssignArrayKey" char="[" lookAhead="1"/>+        <DetectChar attribute="Backquote" context="AssignArrayBackq" char="`"/>+        <DetectChar attribute="Control" context="#stay" char=";"/>+        <AnyChar attribute="Error" context="#stay" String="&symbolseps;"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="AssignArrayKey" fallthroughContext="#pop">+        <DetectChar attribute="Parameter Expansion Operator" context="AssignArrayKeySubscript" char="["/>+        <DetectChar attribute="Variable" context="#pop" char="="/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="AssignArrayBackq" fallthroughContext="Command">+        <DetectChar attribute="Backquote" context="#pop!NormalOption" char="`"/>+        <DetectChar attribute="Comment" context="CommentBackq" char="#"/>+        <IncludeRules context="Start"/>+      </context>++      <!-- arr=([...]=...)+                 ~~~+      -->+      <context attribute="Normal Text" lineEndContext="#pop" name="AssignArrayKeySubscript">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="]"/>+        <DetectChar attribute="Control" context="#pop#pop" char=";"/>+        <IncludeRules context="FindWord"/>+        <AnyChar attribute="Error" context="#pop" String="&symbolseps;"/>+      </context>++      <!-- Subscript consumes anything till ], marks as Variable -->+      <context attribute="Normal Text" name="FindSubscript">+        <DetectChar attribute="Parameter Expansion Operator" context="Subscript" char="["/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="Subscript" fallthroughContext="SubscriptArithmetic">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="]"/>+        <IncludeRules context="InSubscript"/>+      </context>+      <context attribute="Normal Text" name="InSubscript">+        <DetectChar context="SubscriptMaybeFlag" char="(" lookAhead="1"/>+        <!-- so that '-1' in '$var[-1]' is a number rather than an operator -->+        <DetectChar attribute="Number" context="SubscriptArithmetic" char="-"/>+        <LineContinue attribute="Escape"/>+      </context>+      <!-- $var[(flag)...]+                ~+      -->+      <context attribute="Normal Text" lineEndContext="#stay" name="SubscriptMaybeFlag" fallthroughContext="#pop!SubscriptArithmetic">+        <RegExpr attribute="Parameter Expansion" context="SubscriptFlag" String="\((?=(?:[wpfrRiIkKe]+|[snb](?::[^:]*:|\[[^&bracket_close;]*\]|\{[^&brace_close;]*\}|\([^&paren_close;]*\)|([^&paren_close;&brace_close;]).*?\1))+\))"/>+      </context>+      <context attribute="Parameter Expansion" lineEndContext="#stay" name="SubscriptFlag">+        <DetectChar attribute="Parameter Expansion" context="SubscriptPattern" char=")"/>+        <AnyChar attribute="Parameter Expansion" context="SubscriptFlagParam" String="snb"/>+      </context>+      <!-- $var[(s:flag:)...]+                  ~+      -->+      <context attribute="Normal Text" lineEndContext="#stay" name="SubscriptFlagParam">+        <DetectChar attribute="Parameter Expansion Operator" context="SubscriptFlagParamReg" char=":"/>+        <DetectChar attribute="Parameter Expansion Operator" context="SubscriptFlagParamParen" char="&paren_open;"/>+        <DetectChar attribute="Parameter Expansion Operator" context="SubscriptFlagParamBrace" char="&brace_open;"/>+        <DetectChar attribute="Parameter Expansion Operator" context="SubscriptFlagParamBracket" char="&bracket_open;"/>+        <RegExpr attribute="Parameter Expansion Operator" context="SubscriptFlagParamAny" String="(.)"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="SubscriptFlagParamReg">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char=":"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="SubscriptFlagParamParen">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="&paren_close;"/>+        <IncludeRules context="FindArithmetic"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="SubscriptFlagParamBrace">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="&brace_close;"/>+        <IncludeRules context="FindArithmetic"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="SubscriptFlagParamBracket">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="&bracket_close;"/>+        <IncludeRules context="FindArithmetic"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="SubscriptFlagParamAny">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="1" dynamic="1"/>+        <IncludeRules context="FindArithmetic"/>+      </context>+      <!-- $var[(flag)...]+                      ~~~+      -->+      <context attribute="Pattern" lineEndContext="#stay" name="SubscriptPattern">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop#pop#pop" char="]"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop#pop" char=","/>+        <IncludeRules context="FindWord"/>+        <IncludeRules context="FindSingleGlob"/>+        <IncludeRules context="FindGlobAny"/>+        <IncludeRules context="FindGroupPattern"/>+      </context>+      <!-- $var[...]+                ~~~ math+      Same as FindArithmetic, but with a difference for Operator, '$' and text+      which are not variables in this context.+      A text is a variable only with a non-associative array.+      -->+      <context attribute="Normal Text" lineEndContext="#stay" name="SubscriptArithmetic">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop" char="]"/>+        <IncludeRules context="FindBranchCondition"/>+        <AnyChar attribute="Operator" context="#pop" String="@&arithmetic_op;"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char=","/>+        <IncludeRules context="FindNumber"/>+        <IncludeRules context="FindSubscript"/>+        <IncludeRules context="FindStrings"/>+        <DetectChar context="VariableOrSubscriptPos" char="$" lookAhead="1"/>+        <DetectChar attribute="Backquote" context="RegularBackq" char="`"/>+        <IncludeRules context="FindEscape"/>+        <IncludeRules context="FindToNum"/>+        <DetectChar context="MaybeArithmeticBrace" char="{" lookAhead="1"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#pop" name="VariableOrSubscriptPos">+        <IncludeRules context="DispatchVariables"/>+        <DetectChar attribute="Number" context="#pop" char="$"/>+      </context>++      <!-- FunctionDef consumes a name, possibly with (), marks as Function -->+      <context attribute="Function" lineEndContext="#pop" name="FunctionDef" fallthroughContext="#pop">+        <Detect2Chars attribute="Operator" context="#pop" char="(" char1=")"/>+        <DetectSpaces attribute="Normal Text" context="FunctionNameStart"/>+      </context>+      <context attribute="Function" lineEndContext="#pop" name="FunctionNameStart" fallthroughContext="#pop!FunctionName">+        <AnyChar context="#pop#pop" String="&symbolseps;#" lookAhead="1"/>+        <DetectChar context="FunctionNameStartMaybeBraceExpansion" char="{" lookAhead="1"/>+      </context>+      <context attribute="Function" lineEndContext="#pop" name="FunctionName">+        <AnyChar context="#pop" String="&ws;(" lookAhead="1"/>+        <IncludeRules context="FindWord"/>+        <DetectChar context="FunctionNameMaybeBraceExpansion" char="{" lookAhead="1"/>+        <DetectChar context="NormalOptionMaybeGroupEnd" char="}" lookAhead="1"/>+        <DetectIdentifier attribute="Function"/>+      </context>+      <context attribute="Function" lineEndContext="#pop" name="FunctionNameRecBrace" fallthroughContext="#pop">+        <IncludeRules context="FindWord"/>+        <DetectChar context="FunctionNameMaybeBraceExpansion" char="{" lookAhead="1"/>+        <DetectChar attribute="Function" context="#pop" char="}"/>+        <DetectIdentifier attribute="Function"/>+      </context>+      <context attribute="Function" lineEndContext="#pop" name="FunctionNameStartMaybeBraceExpansion">+        <IncludeRules context="DispatchBraceExpansion"/>+        <DetectChar attribute="Keyword" context="#pop#pop#pop!Group" char="{" beginRegion="group"/>+      </context>+      <context attribute="Function" lineEndContext="#pop" name="FunctionNameMaybeBraceExpansion">+        <IncludeRules context="DispatchBraceExpansion"/>+        <DetectChar attribute="Function" context="#pop!FunctionNameRecBrace" char="{" beginRegion="group"/>+      </context>++      <!-- Case is called after the case keyword is encoutered. We handle this because of+           the lonely closing parentheses that would otherwise disturb the expr matching -->+      <context attribute="Normal Text" lineEndContext="#stay" name="Case">+        <DetectSpaces attribute="Normal Text" context="#stay"/>+        <DetectChar attribute="Keyword" context="#pop!CaseAlt" char="{"/>+        <WordDetect attribute="Keyword" context="#pop!CaseIn" String="in"/>+        <IncludeRules context="FindWord"/>+        <DetectIdentifier attribute="Normal Text" context="#stay"/>+      </context>++      <!-- CaseIn is called when the construct 'case ... in' has been found. -->+      <context attribute="Normal Text" lineEndContext="#stay" name="CaseIn" fallthroughContext="CasePattern">+        <DetectSpaces attribute="Normal Text" context="#stay"/>+        <DetectChar attribute="Keyword" context="CaseClosedPattern" char="("/>+        <DetectChar attribute="Comment" context="Comment" char="#"/>+      </context>+      <context attribute="Pattern" lineEndContext="#stay" name="CasePattern">+        <WordDetect attribute="Control Flow" context="#pop#pop" String="esac" endRegion="case"/>+        <IncludeRules context="CaseClosedPattern"/>+      </context>+      <context attribute="Pattern" lineEndContext="#stay" name="CaseClosedPattern">+        <DetectSpaces attribute="Normal Text" context="#stay"/>+        <DetectChar attribute="Keyword" context="#pop!CaseExpr" char=")" beginRegion="caseexpr"/>+        <IncludeRules context="FindEscape"/>+        <DetectChar attribute="Keyword" context="#stay" char="|"/>+        <IncludeRules context="FindWord"/>+        <IncludeRules context="FindPattern"/>+        <DetectIdentifier attribute="Pattern" context="#stay"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#stay" name="CaseAlt" fallthroughContext="CasePattern">+        <DetectSpaces attribute="Normal Text" context="#stay"/>+        <DetectChar attribute="Keyword" context="CasePattern" char="("/>+        <DetectChar attribute="Keyword" context="#pop!CaseAltEnd" char="}" endRegion="caseexpr" lookAhead="1"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="CaseAltEnd">+        <DetectChar attribute="Keyword" context="#pop" char="}" endRegion="case"/>+      </context>++      <!-- CaseExpr eats shell input till ;; / ;& / ;| -->+      <context attribute="Normal Text" lineEndContext="#stay" name="CaseExpr" fallthroughContext="Command">+        <Detect2Chars attribute="Control Flow" context="#pop" char=";" char1="|" endRegion="caseexpr"/>+        <Detect2Chars attribute="Control Flow" context="#pop" char=";" char1=";" endRegion="caseexpr"/>+        <Detect2Chars attribute="Control Flow" context="#pop" char=";" char1="&amp;" endRegion="caseexpr"/>+        <WordDetect context="#pop" String="esac" endRegion="caseexpr" lookAhead="1"/>+        <DetectChar context="#pop" char="}" lookAhead="1"/>+        <IncludeRules context="Start"/>+      </context>++      <!-- ExprGlobParen is called after a ( is encountered in a argument -->+      <context attribute="Glob Flag" lineEndContext="#pop" name="ExprGlobParen" fallthroughContext="#pop">+        <Detect2Chars attribute="Glob Flag" context="#pop!GlobPatFlag" char="(" char1="#"/>+        <RegExpr attribute="Glob" context="#pop!ExtGlobPattern" String="\((?=&ispattern;)"/>+        <DetectChar attribute="Glob Flag" context="#pop!GlobQualifier" char="("/>+      </context>+      <context attribute="Glob Flag" lineEndContext="#pop" name="ExprGlobParenThenPath" fallthroughContext="#pop">+        <Detect2Chars attribute="Glob Flag" context="#pop!GlobPatFlagThenPath" char="(" char1="#"/>+        <RegExpr attribute="Glob" context="#pop!ExtGlobPatternThenPath" String="\((?=&ispattern;)"/>+        <DetectChar attribute="Glob Flag" context="#pop!GlobQualifier" char="("/>+      </context>+      <context attribute="Glob Flag" lineEndContext="#pop" name="GlobQualifier">+        <AnyChar attribute="Glob Flag" context="#stay" String="/F.@=p*%bcrwxAIERWXsStUG^-MTNDn"/>+        <AnyChar attribute="Glob Flag" context="GlobQualifier_e" String="eP"/>+        <AnyChar attribute="Glob Flag" context="GlobQualifier_u" String="ug"/>+        <AnyChar attribute="Glob Flag" context="GlobQualifier_a" String="amc"/>+        <AnyChar attribute="Glob Flag" context="GlobQualifier_o" String="oO"/>+        <DetectChar attribute="Glob Flag" context="GlobQualifier_f" char="f"/>+        <DetectChar attribute="Glob Flag" context="GlobQualifier_+" char="+"/>+        <DetectChar attribute="Glob Flag" context="GlobQualifier_d" char="d"/>+        <DetectChar attribute="Glob Flag" context="GlobQualifier_L" char="L"/>+        <DetectChar attribute="Glob Flag" context="GlobQualifier_Y" char="Y"/>+        <IncludeRules context="FindSubscript"/>++        <DetectChar attribute="Operator" context="#stay" char=","/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!GlobModifiers" char=":"/>+        <DetectChar attribute="Glob Flag" context="#pop" char=")"/>+        <IncludeRules context="FindWord"/>+      </context>++      <context attribute="Normal Text" lineEndContext="#pop" name="GlobQualifier_o" fallthroughContext="#pop">+        <AnyChar attribute="Normal Text" context="#stay" String="nLlamcdN"/>+      </context>++      <context attribute="Number" lineEndContext="#pop" name="GlobQualifier_Y" fallthroughContext="#pop">+        <IncludeRules context="FindDigit"/>+      </context>++      <context attribute="Glob Flag" lineEndContext="#pop" name="GlobQualifier_L" fallthroughContext="#pop">+        <AnyChar attribute="Normal Text" context="#stay" String="kKmMpPgGtT"/>+        <AnyChar attribute="Number" context="#pop!GlobQualifier_Y" String="-+0123456789"/>+      </context>++      <context attribute="Glob Flag" lineEndContext="#pop" name="GlobQualifier_a" fallthroughContext="#pop">+        <AnyChar attribute="Normal Text" context="#stay" String="Mwhmsd"/>+        <AnyChar attribute="Number" context="#pop!GlobQualifier_Y" String="-+0123456789"/>+      </context>++      <context attribute="Glob Flag" lineEndContext="#pop" name="GlobQualifier_+" fallthroughContext="#pop">+        <RegExpr attribute="Function" context="#pop" String="[^&_fragpathseps;=,\[]+"/>+      </context>++      <context attribute="Path" lineEndContext="#pop" name="GlobQualifier_d">+        <AnyChar context="#pop" String=")," lookAhead="1"/>+      </context>++      <context attribute="Glob Flag" lineEndContext="#pop" name="GlobQualifier_u">+        <AnyChar attribute="Number" context="#pop!GlobQualifier_Y" String="0123456789"/>+        <IncludeRules context="GlobQualifier_e"/>+      </context>++      <context attribute="Glob Flag" lineEndContext="#pop" name="GlobQualifier_f" fallthroughContext="#pop">+        <AnyChar attribute="Number" context="#pop!GlobQualifier_fo" String="0123456789=+-"/>+        <DetectChar attribute="Glob" context="#pop!GlobQualifier_fo" char="?"/>+        <DetectChar attribute="Glob Flag" context="#pop!GlobQualifier_f[" char="["/>+        <DetectChar attribute="Glob Flag" context="#pop!GlobQualifier_f&lt;" char="&lt;"/>+        <DetectChar attribute="Glob Flag" context="#pop!GlobQualifier_f{" char="{"/>+        <RegExpr attribute="Glob Flag" context="#pop!GlobQualifier_fx" String="(.)"/>+      </context>+      <context attribute="Number" lineEndContext="#pop" name="GlobQualifier_fo" fallthroughContext="#pop">+        <IncludeRules context="FindDigit"/>+        <DetectChar attribute="Glob" context="#stay" char="?"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="GlobQualifier_f[">+        <DetectChar attribute="Operator" context="#stay" char=","/>+        <DetectChar attribute="Glob Flag" context="#pop" char="]"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="GlobQualifier_f&lt;">+        <DetectChar attribute="Operator" context="#stay" char=","/>+        <DetectChar attribute="Glob Flag" context="#pop" char=">"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="GlobQualifier_f{">+        <DetectChar attribute="Operator" context="#stay" char=","/>+        <DetectChar attribute="Glob Flag" context="#pop" char="}"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="GlobQualifier_fx">+        <DetectChar attribute="Operator" context="#stay" char=","/>+        <DetectChar attribute="Glob Flag" context="#pop" char="1" dynamic="1"/>+      </context>++      <context attribute="Glob Flag" lineEndContext="#pop" name="GlobQualifier_e" fallthroughContext="#pop">+        <DetectChar attribute="Glob Flag" context="#pop!GlobQualifier_e[" char="["/>+        <DetectChar attribute="Glob Flag" context="#pop!GlobQualifier_e&lt;" char="&lt;"/>+        <DetectChar attribute="Glob Flag" context="#pop!GlobQualifier_e{" char="{"/>+        <RegExpr attribute="Glob Flag" context="#pop!GlobQualifier_ex" String="(.)"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="IncGlobQualifier_e">+        <IncludeRules context="FindStrings"/>+        <IncludeRules context="FindVariable"/>+        <DetectChar attribute="Backquote" context="RegularBackq" char="`"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="GlobQualifier_e[">+        <DetectChar attribute="Glob Flag" context="#pop" char="]"/>+        <IncludeRules context="IncGlobQualifier_e"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="GlobQualifier_e&lt;">+        <DetectChar attribute="Glob Flag" context="#pop" char=">"/>+        <IncludeRules context="IncGlobQualifier_e"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="GlobQualifier_e{">+        <DetectChar attribute="Glob Flag" context="#pop" char="}"/>+        <IncludeRules context="IncGlobQualifier_e"/>+      </context>+      <context attribute="Normal Text" lineEndContext="#stay" name="GlobQualifier_ex">+        <DetectChar attribute="Glob Flag" context="#pop" char="1" dynamic="1"/>+        <IncludeRules context="IncGlobQualifier_e"/>+      </context>++      <!-- GlobPatFlag is called after a (# is encountered -->+      <context attribute="Glob Flag" lineEndContext="#pop" name="GlobPatFlag" fallthroughContext="#pop">+        <IncludeRules context="IncGlobPatFlag"/>+        <DetectChar attribute="Glob Flag" context="#pop" char=")"/>+      </context>+      <context attribute="Glob Flag" lineEndContext="#pop" name="GlobPatFlagThenPath" fallthroughContext="#pop">+        <IncludeRules context="IncGlobPatFlag"/>+        <DetectChar attribute="Glob Flag" context="#pop!PathThenPop" char=")"/>+      </context>+      <context attribute="Glob Flag" lineEndContext="#pop" name="IncGlobPatFlag" fallthroughContext="#pop">+        <AnyChar attribute="Glob Flag" context="#stay" String="ilIbBcmMaseuU,"/>+        <IncludeRules context="FindDigit"/>+        <DetectChar attribute="Glob Flag" context="#pop!GlobQualifier" char="q"/>+      </context>++      <!-- GlobModifier is called after a : is encountered in a GlobQualifier -->+      <context attribute="Error" lineEndContext="#pop" name="GlobModifiers" fallthroughContext="GlobModifierNext">+        <AnyChar attribute="Parameter Expansion" context="GlobModifierNext" String="aAcelpPqQrux"/>+        <AnyChar attribute="Parameter Expansion" context="GlobModifier_h" String="ht"/>+        <AnyChar attribute="Parameter Expansion" String="fw"/>+        <StringDetect attribute="Parameter Expansion" context="GlobModifier_s" String="s"/>+        <StringDetect attribute="Parameter Expansion" context="GlobModifier_s" String="gs"/>+        <StringDetect attribute="Parameter Expansion" context="GlobModifierNext" String="\&amp;"/>+        <StringDetect attribute="Parameter Expansion" context="GlobModifierNext" String="g\&amp;"/>+        <StringDetect attribute="Parameter Expansion" context="GlobModifier_W" String="W"/>+        <StringDetect attribute="Parameter Expansion" context="GlobModifier_F" String="F"/>+      </context>+      <context attribute="Error" lineEndContext="#pop#pop" name="GlobModifierNext">+        <DetectChar attribute="Glob Flag" context="#pop#pop" char="&paren_close;"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char=":"/>+        <AnyChar context="#pop#pop" String="&wordseps;" lookAhead="1"/>+      </context>++      <!-- *(:h3)  *(:t11)+               ~       ~~+      -->+      <context attribute="Parameter Expansion" lineEndContext="#pop#pop" name="GlobModifier_h" fallthroughContext="#pop!GlobModifierNext">+        <IncludeRules context="FindDigit"/>+      </context>+++      <!-- *(#q:s/../....}+                 ~~~~~...+      -->+      <context attribute="Parameter Expansion" lineEndContext="#stay" name="GlobModifier_s" fallthroughContext="#pop!GlobModifierNext">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!GlobModifier_s_Str" char="/"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!GlobModifier_s_StrSQ_Sep" char="'"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!GlobModifier_s_StrDQ_Sep" char='"'/>+        <RegExpr attribute="Parameter Expansion Operator" context="#pop!GlobModifier_s_C_Rep!GlobModifier_s_C_Str" String="([^&symbolseps;\[\]{}\\])"/>+      </context>+      <context attribute="Verbatim String" name="GlobModifier_End">+        <AnyChar context="#pop!GlobModifierNext" String="&wordseps;&paren_close;" lookAhead="1"/>+      </context>+      <context attribute="Verbatim String" name="GlobModifier_End2">+        <AnyChar context="#pop#pop!GlobModifierNext" String="&wordseps;&paren_close;" lookAhead="1"/>+      </context>+      <!-- By default the left-hand side of substitutions are character strings,+      but pattern with HIST_SUBST_PATTERN option. Assume no option. -->+      <!-- *(#q:s/../....)+                  ~~~+      -->+      <context attribute="Verbatim String" name="GlobModifier_s_Str">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!GlobModifier_s_Rep" char="/"/>+        <IncludeRules context="FindEscape"/>+        <DetectChar attribute="String SingleQ" context="GlobModifier_s_StrSQ" char="'"/>+        <DetectChar attribute="String DoubleQ" context="GlobModifier_s_StrDQ" char='"'/>+        <DetectChar attribute="Verbatim String" context="GlobModifier_s_StrSQ!GlobModifier_s_StrDQ_to_Rep!GlobModifier_s_Str_Recursive" char="("/>+        <DetectChar attribute="Glob Flag" context="#pop#pop" char=")"/>+      </context>+      <context attribute="Verbatim String" name="GlobModifier_s_Str_Recursive">+        <DetectChar context="#pop#pop#pop" char="/" lookAhead="1"/>+        <IncludeRules context="FindEscape"/>+        <DetectChar attribute="String SingleQ" context="VarBraceModifier_s_StrSQ_Recursive" char="'"/>+        <DetectChar attribute="String DoubleQ" context="VarBraceModifier_s_StrDQ_Recursive" char='"'/>+        <DetectChar attribute="Verbatim String" context="Modifier_s_Str_to_Parent!Modifier_s_Str_to_Parent!GlobModifier_s_Str_Recursive" char="("/>+        <DetectChar context="#pop#pop#pop" char=")"/>+      </context>+      <!-- #pop -> is GlobModifier_s_C_Rep -->+      <context attribute="Verbatim String" name="GlobModifier_s_C_Str">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop" char="1" dynamic="1"/>+        <IncludeRules context="FindEscape"/>+        <!-- The string should stop if capture $1 is found,+        but there is no way to propagate the capture. -->+        <IncludeRules context="FindStrings"/>+        <DetectChar attribute="Verbatim String" context="GlobModifier_s_C_Str_Recursive" char="("/>+        <DetectChar attribute="Glob Flag" context="#pop#pop#pop" char=")"/>+      </context>+      <context attribute="Verbatim String" name="GlobModifier_s_C_Str_Recursive">+        <IncludeRules context="FindEscape"/>+        <IncludeRules context="FindStrings"/>+        <DetectChar attribute="Verbatim String" context="GlobModifier_s_C_Str_Recursive" char="("/>+        <DetectChar context="#pop" char=")"/>+      </context>+      <!-- *(#q:s/..'../..'..}  *(#q:s/..'..'../..}+                    ~~~~                 ~~~~+      -->+      <context attribute="String SingleQ" name="GlobModifier_s_StrSQ">+        <DetectChar attribute="String SingleQ" context="#pop" char="'"/>+        <LineContinue attribute="Escape"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop!GlobModifier_s_Rep!GlobModifier_s_RepSQ" char="/"/>+      </context>+      <!-- *(#q:s'..'..}+                 ~~~~+      -->+      <context attribute="Verbatim String" name="GlobModifier_s_StrSQ_Sep">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!GlobModifier_s_Rep" char="'"/>+        <LineContinue attribute="Escape"/>+      </context>+      <!-- *(#q:s/.."../.."..}  *(#q:s/..".."../..}+                    ~~~~                 ~~~~+      -->+      <context attribute="String DoubleQ" name="GlobModifier_s_StrDQ">+        <DetectChar attribute="String DoubleQ" context="#pop" char='"'/>+        <IncludeRules context="FindEscape"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop!GlobModifier_s_Rep!GlobModifier_s_RepDQ" char="/"/>+      </context>+      <context attribute="Error" name="GlobModifier_s_StrDQ_to_Rep">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop#pop!GlobModifier_s_Rep!GlobModifier_s_RepDQ" char="/"/>+      </context>+      <!-- *(#q:s".."..}+                 ~~~~+      -->+      <context attribute="String DoubleQ" name="GlobModifier_s_StrDQ_Sep">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!GlobModifier_s_Rep" char='"'/>+        <IncludeRules context="FindEscape"/>+      </context>+      <!-- *(#q:s/../....}+                     ~~..+      -->+      <context attribute="Replacement String" name="GlobModifier_s_Rep">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!GlobModifierNext" char="/"/>+        <!-- FindWord with a search for '/' in single and double quoted string -->+        <DetectChar attribute="String SingleQ" context="GlobModifier_s_RepSQ" char="'"/>+        <DetectChar attribute="String DoubleQ" context="GlobModifier_s_RepDQ" char="&quot;"/>+        <DetectChar attribute="Replacement String" context="GlobModifier_s_RepSQ!GlobModifier_s_RepDQ_to_End!GlobModifier_s_Rep_Recursive" char="&paren_open;"/>+        <IncludeRules context="VarBraceModifier_s_Rep_Common"/>+        <IncludeRules context="GlobModifier_End"/>+      </context>+      <context attribute="Replacement String" name="GlobModifier_s_Rep_Recursive">+        <DetectChar context="#pop#pop#pop" char="/" lookAhead="1"/>+        <DetectChar attribute="String SingleQ" context="VarBraceModifier_s_RepSQ_Recursive" char="'"/>+        <DetectChar attribute="String DoubleQ" context="VarBraceModifier_s_RepDQ_Recursive" char='"'/>+        <DetectChar attribute="Replacement String" context="Modifier_s_Str_to_Parent!Modifier_s_Str_to_Parent!GlobModifier_s_Rep_Recursive" char="("/>+        <DetectChar context="#pop#pop#pop" char=")"/>+        <IncludeRules context="VarBraceModifier_s_Rep_Common"/>+        <AnyChar context="#pop" String="&symbolseps;" lookAhead="1"/>+      </context>+      <context attribute="Replacement String" name="GlobModifier_s_C_Rep">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop!GlobModifierNext" char="1" dynamic="1"/>+        <!-- The string should stop if capture $1 is found,+        but there is no way to propagate the capture. -->+        <IncludeRules context="FindVarNameModifier_s_C_RepQ"/>+        <DetectChar attribute="Replacement String" context="GlobModifier_s_C_Rep_Recursive" char="&paren_open;"/>+        <IncludeRules context="VarBraceModifier_s_Rep_Common"/>+        <IncludeRules context="GlobModifier_End"/>+      </context>+      <context attribute="Replacement String" name="GlobModifier_s_C_Rep_Recursive">+        <IncludeRules context="FindVarNameModifier_s_C_RepQ"/>+        <IncludeRules context="VarBraceModifier_s_Rep_Common"/>+        <DetectChar attribute="Replacement String" context="GlobModifier_s_C_Rep_Recursive" char="("/>+        <DetectChar context="#pop" char=")"/>+        <AnyChar context="#pop" String="&symbolseps;" lookAhead="1"/>+      </context>+      <!-- *(#q:s/../..'../'..}  *(#q:s/../..'..'..}+                       ~~~~                  ~~~~+      -->+      <context attribute="String SingleQ" name="GlobModifier_s_RepSQ">+        <IncludeRules context="VarNameModifier_s_C_RepSQ"/>+        <DetectChar attribute="Error" context="#pop#pop!GlobModifierNext!StringSQ" char="/"/>+      </context>+      <!-- *(#q:s/../.."../"..}  *(#q:s/../..".."..}+                       ~~~~                  ~~~~+      -->+      <context attribute="String DoubleQ" name="GlobModifier_s_RepDQ">+        <IncludeRules context="VarNameModifier_s_C_RepDQ"/>+        <DetectChar attribute="Error" context="#pop#pop!GlobModifierNext!StringDQ" char="/"/>+      </context>+      <context attribute="String DoubleQ" name="GlobModifier_s_RepDQ_to_End">+        <DetectChar attribute="Error" context="#pop#pop#pop!GlobModifierNext!StringDQ" char="/"/>+      </context>+++      <!-- *(:F(expr)h)+               ~~~~~~+      -->+      <context attribute="Normal Text" name="GlobModifier_F" lineEndContext="#pop!GlobModifierNext" fallthroughContext="#pop!GlobModifierNext">+        <IncludeRules context="FindStringsThenPop"/>+        <DetectChar attribute="Parameter Expansion Operator" context="GlobArithmeticParamColon" char=":"/>+        <DetectChar attribute="Parameter Expansion Operator" context="GlobArithmeticParamParen" char="("/>+        <DetectChar attribute="Parameter Expansion Operator" context="GlobArithmeticParamBracket" char="["/>+        <DetectChar attribute="Parameter Expansion Operator" context="GlobArithmeticParamBrace" char="{"/>+        <RegExpr attribute="Parameter Expansion Operator" context="GlobArithmeticParamDyn" String="([^&symbolseps;])"/>+      </context>+      <context attribute="Normal Text" name="GlobArithmeticParamParen">+        <IncludeRules context="GlobVerbatimParamParen"/>+        <IncludeRules context="FindArithmetic"/>+      </context>+      <context attribute="Normal Text" name="GlobArithmeticParamBracket">+        <IncludeRules context="GlobVerbatimParamBracket"/>+        <IncludeRules context="FindArithmetic"/>+      </context>+      <context attribute="Normal Text" name="GlobArithmeticParamBrace">+        <IncludeRules context="GlobVerbatimParamBrace"/>+        <IncludeRules context="FindArithmetic"/>+      </context>+      <context attribute="Normal Text" name="GlobArithmeticParamColon">+        <IncludeRules context="GlobVerbatimParamColon"/>+        <IncludeRules context="FindArithmetic"/>+      </context>+      <context attribute="Normal Text" name="GlobArithmeticParamDyn">+        <IncludeRules context="GlobVerbatimParamDyn"/>+        <IncludeRules context="FindArithmetic"/>+      </context>+      <!-- *(:W(xxx)h)+               ~~~~~+      -->+      <context attribute="Normal Text" name="GlobModifier_W" lineEndContext="#pop!GlobModifierNext" fallthroughContext="#pop!GlobModifierNext">+        <IncludeRules context="FindStringsThenPop"/>+        <DetectChar attribute="Parameter Expansion Operator" context="GlobVerbatimParamColon" char=":"/>+        <DetectChar attribute="Parameter Expansion Operator" context="GlobVerbatimParamParen" char="("/>+        <DetectChar attribute="Parameter Expansion Operator" context="GlobVerbatimParamBracket" char="["/>+        <DetectChar attribute="Parameter Expansion Operator" context="GlobVerbatimParamBrace" char="{"/>+        <RegExpr attribute="Parameter Expansion Operator" context="GlobVerbatimParamDyn" String="([^&symbolseps;])"/>+      </context>+      <context attribute="Verbatim String" name="GlobVerbatimParamParen">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop" char=")"/>+        <IncludeRules context="GlobModifier_End2"/>+      </context>+      <context attribute="Verbatim String" name="GlobVerbatimParamBracket">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop" char="]"/>+        <IncludeRules context="GlobModifier_End2"/>+      </context>+      <context attribute="Verbatim String" name="GlobVerbatimParamBrace">+        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop" char="}"/>+        <IncludeRules context="GlobModifier_End2"/>+      </context>+      <context attribute="Verbatim String" name="GlobVerbatimParamColon">+        <IncludeRules context="GlobModifier_End2"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop" char=":"/>+      </context>+      <context attribute="Verbatim String" name="GlobVerbatimParamDyn">+        <IncludeRules context="GlobModifier_End2"/>+        <DetectChar attribute="Parameter Expansion Operator" context="#pop#pop" char="1" dynamic="1"/>+      </context>++    </contexts>++    <itemDatas>+      <itemData name="Normal Text"    defStyleNum="dsNormal"/>+      <itemData name="Comment"        defStyleNum="dsComment"/>+      <itemData name="Keyword"        defStyleNum="dsKeyword"       spellChecking="false"/>+      <itemData name="Control"        defStyleNum="dsKeyword"       spellChecking="false"/>+      <itemData name="Control Flow"   defStyleNum="dsControlFlow"   spellChecking="false"/>+      <itemData name="Builtin"        defStyleNum="dsBuiltIn"       spellChecking="false"/>+      <itemData name="Command"        defStyleNum="dsFunction"      spellChecking="false"/>+      <itemData name="OtherCommand"   defStyleNum="dsExtension"     spellChecking="false"/>+      <itemData name="Redirection"    defStyleNum="dsOperator"      spellChecking="false"/>+      <itemData name="Escape"         defStyleNum="dsDataType"      spellChecking="false"/>+      <itemData name="String SingleQ" defStyleNum="dsString"/>+      <itemData name="String DoubleQ" defStyleNum="dsString"/>+      <itemData name="Verbatim String" defStyleNum="dsVerbatimString" spellChecking="false"/>+      <itemData name="Replacement String" defStyleNum="dsSpecialString" spellChecking="false"/>+      <itemData name="Here Doc"       defStyleNum="dsString"/>+      <itemData name="Backquote"      defStyleNum="dsKeyword"       spellChecking="false"/>+      <itemData name="String Escape"  defStyleNum="dsDataType"/>+      <itemData name="Variable"       defStyleNum="dsVariable"      spellChecking="false"/>+      <itemData name="Dollar Prefix"  defStyleNum="dsVariable"      spellChecking="false"/>+      <itemData name="Expression"     defStyleNum="dsOthers"        spellChecking="false"/>+      <itemData name="Function"       defStyleNum="dsFunction"      spellChecking="false"/>+      <itemData name="Pattern"        defStyleNum="dsSpecialString" spellChecking="false"/>+      <itemData name="Path"           defStyleNum="dsNormal"        spellChecking="false"/>+      <itemData name="Glob"           defStyleNum="dsPreprocessor"  spellChecking="false"/>+      <itemData name="Glob Flag"      defStyleNum="dsOperator"      spellChecking="false"/>+      <itemData name="Option"         defStyleNum="dsAttribute"     spellChecking="false"/>+      <itemData name="Hex"            defStyleNum="dsBaseN"         spellChecking="false"/>+      <itemData name="Number"         defStyleNum="dsDecVal"        spellChecking="false"/>+      <itemData name="Base"           defStyleNum="dsPreprocessor"  spellChecking="false"/>+      <itemData name="BaseN"          defStyleNum="dsBaseN"         spellChecking="false"/>+      <itemData name="File Descriptor" defStyleNum="dsDecVal"       spellChecking="false"/>+      <itemData name="Parameter Expansion" defStyleNum="dsVariable" spellChecking="false"/>+      <itemData name="Parameter Expansion Operator" defStyleNum="dsOperator" spellChecking="false"/>+      <itemData name="Operator"       defStyleNum="dsOperator"      spellChecking="false"/>+      <itemData name="Error"          defStyleNum="dsError"         spellChecking="false"/>+    </itemDatas>+  </highlighting>+  <general>+    <comments>+      <comment name="singleLine" start="#" position="afterwhitespace"/>     </comments>     <keywords casesensitive="1" weakDeliminator="^%#[]$._:-/" additionalDeliminator="`"/>   </general>