Add highlight as worker

.gitignore

@@ -13,3 +13,5 @@ tmp
 jirs-server/target
 jirs-cli/target
 jirs-bat/bat
+
+highlight/jirs-highlight/build

Cargo.toml

@@ -8,15 +8,6 @@
 #license = "MPL-2.0"
 #license-file = "./LICENSE"
 
-[profile.dev]
-opt-level = 0               # Use slightly better optimizations.
-overflow-checks = false     # Disable integer overflow checks.
-debug = 2
-
-[profile.release]
-lto = true
-opt-level = 's'
-
 [workspace]
 members = [
     "./jirs-cli",
@@ -25,5 +16,9 @@ members = [
     "./jirs-data",
     "./jirs-css",
     "./jirs-bat",
+    "./jirs-syntect",
+    "./highlight/jirs-highlight",
+    "./highlight/jirs-contexts",
+    "./highlight/jirs-syntaxes",
+    "./highlight/jirs-themes",
 ]
-

highlight/jirs-contexts/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "jirs_contexts"
+version = "0.1.0"
+authors = ["Adrian Wozniak <adrian.wozniak@ita-prog.pl>"]
+edition = "2018"
+description = "JIRS (Simplified JIRA in Rust) WASM client"
+repository = "https://gitlab.com/adrian.wozniak/jirs"
+license = "MPL-2.0"
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+name = "jirs_contexts"
+path = "src/lib.rs"
+
+[dependencies]
+jirs-data = { path = "../../jirs-data", features = ["frontend"] }
+
+[dependencies.jirs_syntect]
+path = "../../jirs-syntect"
+features = ["wasm"]
+
+[dependencies.lazycell]
+version = "1.0"

highlight/jirs-contexts/src/c0.rs

@@ -0,0 +1,21 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Include(ContextReference::Direct(ContextId { index: 2 })),
+]
+} }

highlight/jirs-contexts/src/c1.rs

@@ -0,0 +1,40 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![
+    Scope {
+        a: 281483566645248,
+        b: 0,
+    },
+],
+  meta_content_scope: vec![
+    Scope {
+        a: 281483566645248,
+        b: 0,
+    },
+],
+  meta_include_prototype: false,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new(""),
+      scope: vec![],
+      captures: None,
+      operation: MatchOperation::Push(vec![
+        ContextReference::Direct(ContextId { index: 0 }),
+    ]),
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10.rs

@@ -0,0 +1,59 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Include(ContextReference::Direct(ContextId { index: 34 })),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\\("),
+      scope: vec![
+        Scope {
+            a: 47288521948725430,
+            b: 1125899906842624,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Push(vec![
+        ContextReference::Direct(ContextId { index: 11 }),
+    ]),
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\\s*(,)\\s*"),
+      scope: vec![],
+      captures: Some(vec![(1, vec![
+        Scope {
+            a: 47288620733759492,
+            b: 0,
+        },
+    ])]),
+      operation: MatchOperation::Set(vec![
+        ContextReference::Direct(ContextId { index: 46 }),
+    ]),
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new(""),
+      scope: vec![],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c1000.rs

@@ -0,0 +1,43 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(--)((?:[[-\\w][\\p{L}\\p{M}\\p{S}\\p{N}&&[[:^ascii:]]]]|(?:\\\\\\h{1,6}[ \\t\\n\\f]?|\\\\[^\\n\\f\\h]))+)"),
+      scope: vec![
+        Scope {
+            a: 61925375377932302,
+            b: 0,
+        },
+    ],
+      captures: Some(vec![(1, vec![
+        Scope {
+            a: 47288629344337934,
+            b: 0,
+        },
+    ]),(2, vec![
+        Scope {
+            a: 61925375377932500,
+            b: 3940649673949184,
+        },
+    ])]),
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10000.rs

@@ -0,0 +1,50 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?<!=|!)(=)(?!=)(?=\\s*\\S)"),
+      scope: vec![],
+      captures: Some(vec![(1, vec![
+        Scope {
+            a: 52636628111130775,
+            b: 0,
+        },
+    ])]),
+      operation: MatchOperation::Push(vec![
+        ContextReference::Direct(ContextId { index: 9850 }),
+    ]),
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?<!=|!)(=)(?!=)"),
+      scope: vec![],
+      captures: Some(vec![(1, vec![
+        Scope {
+            a: 52636628111130775,
+            b: 0,
+        },
+    ])]),
+      operation: MatchOperation::Push(vec![
+        ContextReference::Direct(ContextId { index: 9851 }),
+    ]),
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10001.rs

@@ -0,0 +1,33 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\\*/"),
+      scope: vec![],
+      captures: Some(vec![(0, vec![
+        Scope {
+            a: 47288629323038872,
+            b: 0,
+        },
+    ])]),
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10002.rs

@@ -0,0 +1,46 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\""),
+      scope: vec![],
+      captures: Some(vec![(0, vec![
+        Scope {
+            a: 47288629323956395,
+            b: 42784196460019712,
+        },
+    ])]),
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\\\\."),
+      scope: vec![
+        Scope {
+            a: 59955200847315096,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10003.rs

@@ -0,0 +1,46 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\'"),
+      scope: vec![],
+      captures: Some(vec![(0, vec![
+        Scope {
+            a: 47288629323956395,
+            b: 42784196460019712,
+        },
+    ])]),
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\\\\."),
+      scope: vec![
+        Scope {
+            a: 59955200847315096,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10004.rs

@@ -0,0 +1,21 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10008 })),
+]
+} }

highlight/jirs-contexts/src/c10005.rs

@@ -0,0 +1,40 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![
+    Scope {
+        a: 845077765160960,
+        b: 0,
+    },
+],
+  meta_content_scope: vec![
+    Scope {
+        a: 845077765160960,
+        b: 0,
+    },
+],
+  meta_include_prototype: false,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new(""),
+      scope: vec![],
+      captures: None,
+      operation: MatchOperation::Push(vec![
+        ContextReference::Direct(ContextId { index: 10004 }),
+    ]),
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10006.rs

@@ -0,0 +1,22 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10010 })),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10009 })),
+]
+} }

highlight/jirs-contexts/src/c10007.rs

@@ -0,0 +1,53 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("/\\*"),
+      scope: vec![],
+      captures: Some(vec![(0, vec![
+        Scope {
+            a: 47288629323038872,
+            b: 0,
+        },
+    ])]),
+      operation: MatchOperation::Push(vec![
+        ContextReference::Direct(ContextId { index: 10001 }),
+    ]),
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(//).*(?m:$)\\n?"),
+      scope: vec![
+        Scope {
+            a: 51510711028613272,
+            b: 0,
+        },
+    ],
+      captures: Some(vec![(1, vec![
+        Scope {
+            a: 47288629323038872,
+            b: 0,
+        },
+    ])]),
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10008.rs

@@ -0,0 +1,530 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![
+    Scope {
+        a: 845077765160960,
+        b: 0,
+    },
+],
+  meta_content_scope: vec![
+    Scope {
+        a: 845077765160960,
+        b: 0,
+    },
+],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("^\\s*(module|function|primitive)\\s+\\b([a-zA-Z_][a-zA-Z0-9_]*)\\b"),
+      scope: vec![
+        Scope {
+            a: 46444277445361816,
+            b: 0,
+        },
+    ],
+      captures: Some(vec![(1, vec![
+        Scope {
+            a: 48414576472489984,
+            b: 0,
+        },
+    ]),(2, vec![
+        Scope {
+            a: 59392130632450251,
+            b: 42784196460019712,
+        },
+    ])]),
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("^\\s*(?!else)(?!begin)([a-zA-Z_][a-zA-Z0-9_]*)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*(\\()"),
+      scope: vec![
+        Scope {
+            a: 46444204390875136,
+            b: 0,
+        },
+    ],
+      captures: Some(vec![(1, vec![
+        Scope {
+            a: 59392130632450251,
+            b: 42784196460019712,
+        },
+    ]),(2, vec![
+        Scope {
+            a: 59392130632450433,
+            b: 42784196460019712,
+        },
+    ]),(3, vec![
+        Scope {
+            a: 52636628154451214,
+            b: 42784196460019712,
+        },
+    ])]),
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("^\\s*(?!else)(?!begin)([a-zA-Z_][a-zA-Z0-9_]*)\\s+([#])(\\()([ ._+`,a-zA-Z0-9]+)(\\))\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*(\\()"),
+      scope: vec![
+        Scope {
+            a: 46444204548882584,
+            b: 0,
+        },
+    ],
+      captures: Some(vec![(1, vec![
+        Scope {
+            a: 59392130632450251,
+            b: 42784196460019712,
+        },
+    ]),(2, vec![
+        Scope {
+            a: 52636787022495744,
+            b: 0,
+        },
+    ]),(3, vec![
+        Scope {
+            a: 52636628154451214,
+            b: 42784196460019712,
+        },
+    ]),(4, vec![
+        Scope {
+            a: 52636787022495744,
+            b: 0,
+        },
+    ]),(5, vec![
+        Scope {
+            a: 52636628154451214,
+            b: 42784196460019712,
+        },
+    ]),(6, vec![
+        Scope {
+            a: 59392130632450433,
+            b: 42784196460019712,
+        },
+    ]),(7, vec![
+        Scope {
+            a: 52636628154451214,
+            b: 42784196460019712,
+        },
+    ])]),
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("^\\s*\\b(?!else)(?!begin)([a-zA-Z_][a-zA-Z0-9_]*)\\b\\s+([#])"),
+      scope: vec![
+        Scope {
+            a: 46444204548882584,
+            b: 0,
+        },
+    ],
+      captures: Some(vec![(1, vec![
+        Scope {
+            a: 59392130632450251,
+            b: 42784196460019712,
+        },
+    ]),(2, vec![
+        Scope {
+            a: 52636787022495744,
+            b: 0,
+        },
+    ])]),
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("^\\s*(defparam)\\s+([a-zA-Z_][a-zA-Z0-9_]*)(.[a-zA-Z_][a-zA-Z0-9_]*)\\s*(=)"),
+      scope: vec![
+        Scope {
+            a: 46444204548948120,
+            b: 0,
+        },
+    ],
+      captures: Some(vec![(1, vec![
+        Scope {
+            a: 52636787022495744,
+            b: 0,
+        },
+    ]),(2, vec![
+        Scope {
+            a: 59392130632450433,
+            b: 42784196460019712,
+        },
+    ]),(3, vec![
+        Scope {
+            a: 46446648233820312,
+            b: 0,
+        },
+    ]),(4, vec![
+        Scope {
+            a: 52636787022495744,
+            b: 0,
+        },
+    ])]),
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\\b(automatic|cell|config|deassign|defparam|design|disable|edge|endconfig|endgenerate|endspecify|endtable|endtask|event|generate|genvar|ifnone|incdir|include|instance|liblist|library|localparam|macromodule|negedge|noshowcancelled|posedge|pulsestyle_onevent|pulsestyle_ondetect|real|realtime|scalared|showcancelled|specify|specparam|table|task|time|use|vectored)\\b"),
+      scope: vec![
+        Scope {
+            a: 52636787022495744,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(#[0-9]+)"),
+      scope: vec![
+        Scope {
+            a: 52646837245968384,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\\b(initial|always|wait|force|release|assign)\\b"),
+      scope: vec![
+        Scope {
+            a: 52636636698640384,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\\b(begin|end|fork|join)\\b"),
+      scope: vec![
+        Scope {
+            a: 52636787022495744,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\\b(forever|repeat|while|for|if|else|case|casex|casez|default|endcase)\\b"),
+      scope: vec![
+        Scope {
+            a: 52636636698640384,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("^\\s*(`include)\\s+([\"<].*[\">])"),
+      scope: vec![
+        Scope {
+            a: 46445321082372096,
+            b: 0,
+        },
+    ],
+      captures: Some(vec![(1, vec![
+        Scope {
+            a: 46444466383880192,
+            b: 0,
+        },
+    ]),(2, vec![
+        Scope {
+            a: 59392130632450502,
+            b: 42784196460019712,
+        },
+    ])]),
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("^\\s*(`ifdef|`ifndef|`undef|`define)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\b"),
+      scope: vec![
+        Scope {
+            a: 46444466542084248,
+            b: 0,
+        },
+    ],
+      captures: Some(vec![(1, vec![
+        Scope {
+            a: 46444466383880192,
+            b: 0,
+        },
+    ]),(2, vec![
+        Scope {
+            a: 59955136437420184,
+            b: 0,
+        },
+    ])]),
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("`(celldefine|default_nettype|define|else|elsif|endcelldefine|endif|ifdef|ifndef|include|line|nounconnected_drive|resetall|timescale|unconnected_drive|undef)\\b"),
+      scope: vec![
+        Scope {
+            a: 46444466383880192,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("[.][_a-zA-Z0-9]+"),
+      scope: vec![
+        Scope {
+            a: 46446648233820312,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("`\\b([a-zA-Z_][a-zA-Z0-9_]*)\\b"),
+      scope: vec![
+        Scope {
+            a: 59955136437420184,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10007 })),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\\b(endmodule|endfunction|endprimitive)\\b"),
+      scope: vec![
+        Scope {
+            a: 48414576472489984,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("^\\s*\\b([a-zA-Z_][a-zA-Z0-9_]*)\\b\\s*(:)\\s*"),
+      scope: vec![
+        Scope {
+            a: 46445063384334336,
+            b: 0,
+        },
+    ],
+      captures: Some(vec![(1, vec![
+        Scope {
+            a: 59392130787246232,
+            b: 0,
+        },
+    ]),(2, vec![
+        Scope {
+            a: 52636628135903384,
+            b: 0,
+        },
+    ])]),
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10006 })),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(==|===|!=|!==|<=|>=|<|>)"),
+      scope: vec![
+        Scope {
+            a: 52636628119257240,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(\\-|\\+|\\*|\\/|%)"),
+      scope: vec![
+        Scope {
+            a: 52636628119191704,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(!|&&|\\|\\|)"),
+      scope: vec![
+        Scope {
+            a: 52636628114800792,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(&|\\||\\^|~|<<|>>|\\?|:)"),
+      scope: vec![
+        Scope {
+            a: 52636628135903384,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("({|})"),
+      scope: vec![
+        Scope {
+            a: 52636628154450892,
+            b: 42784196460019712,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(\\(|\\))"),
+      scope: vec![
+        Scope {
+            a: 52636628154451214,
+            b: 42784196460019712,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(\\[|\\])"),
+      scope: vec![
+        Scope {
+            a: 52636628154451215,
+            b: 42784196460019712,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("([;,])"),
+      scope: vec![
+        Scope {
+            a: 52642473559195648,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(#|@|=)"),
+      scope: vec![
+        Scope {
+            a: 52636787022495744,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\\b(output|input|inout|and|nand|nor|or|xor|xnor|buf|not|bufif[01]|notif[01]|r?[npc]mos|tran|r?tranif[01]|pullup|pulldown)\\b"),
+      scope: vec![
+        Scope {
+            a: 61925375354601472,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("((\\b\\d+)?\'s?([bB]\\s*(([0-1_xXzZ?]+)|(`[A-Z]+[_0-9a-zA-Z]*))|[oO]\\s*(([0-7_xXzZ?]+)|(`[A-Z]+[_0-9a-zA-Z]*))|[dD]\\s*(([0-9_xXzZ?]+)|(`[A-Z]+[_0-9a-zA-Z]*))|[hH]\\s*(([0-9a-fA-F_xXzZ?]+)|(`[A-Z]+[_0-9a-zA-Z]*)))((e|E)(\\+|-)?[0-9]+)?\\b)|(\\b\\d+\\b)"),
+      scope: vec![
+        Scope {
+            a: 59955089172332544,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10011 })),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\\$\\b([a-zA-Z_][a-zA-Z0-9_]*)\\b"),
+      scope: vec![
+        Scope {
+            a: 61925255095517184,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10009.rs

@@ -0,0 +1,33 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\\b(signed|unsigned|small|medium|large|supply[01]|strong[01]|pull[01]|weak[01]|highz[01])\\b"),
+      scope: vec![
+        Scope {
+            a: 48414439033536512,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c1001.rs

@@ -0,0 +1,25 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Include(ContextReference::Direct(ContextId { index: 974 })),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 1005 })),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 1014 })),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 1031 })),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 1037 })),
+]
+} }

highlight/jirs-contexts/src/c10010.rs

@@ -0,0 +1,33 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\\b(wire|tri|tri[01]|supply[01]|wand|triand|wor|trior|trireg|reg|parameter|integer)\\b"),
+      scope: vec![
+        Scope {
+            a: 48414576472489984,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10011.rs

@@ -0,0 +1,50 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\""),
+      scope: vec![],
+      captures: Some(vec![(0, vec![
+        Scope {
+            a: 47288629323956406,
+            b: 42784196460019712,
+        },
+    ])]),
+      operation: MatchOperation::Push(vec![
+        ContextReference::Direct(ContextId { index: 10002 }),
+    ]),
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\'"),
+      scope: vec![],
+      captures: Some(vec![(0, vec![
+        Scope {
+            a: 47288629323956406,
+            b: 42784196460019712,
+        },
+    ])]),
+      operation: MatchOperation::Push(vec![
+        ContextReference::Direct(ContextId { index: 10003 }),
+    ]),
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10012.rs

@@ -0,0 +1,46 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(\\()"),
+      scope: vec![],
+      captures: Some(vec![(1, vec![
+        Scope {
+            a: 47288629327560886,
+            b: 43065671436730368,
+        },
+    ])]),
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(s:)?[0-9a-zA-Z_#]+"),
+      scope: vec![
+        Scope {
+            a: 59392130630615193,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10013.rs

@@ -0,0 +1,21 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10023 })),
+]
+} }

highlight/jirs-contexts/src/c10014.rs

@@ -0,0 +1,40 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![
+    Scope {
+        a: 845082060128256,
+        b: 0,
+    },
+],
+  meta_content_scope: vec![
+    Scope {
+        a: 845082060128256,
+        b: 0,
+    },
+],
+  meta_include_prototype: false,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new(""),
+      scope: vec![],
+      captures: None,
+      operation: MatchOperation::Push(vec![
+        ContextReference::Direct(ContextId { index: 10013 }),
+    ]),
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10015.rs

@@ -0,0 +1,33 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("^\\s*\".*(?m:$)"),
+      scope: vec![
+        Scope {
+            a: 51510711180329113,
+            b: 0,
+        },
+    ],
+      captures: Some(vec![]),
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10016.rs

@@ -0,0 +1,33 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(\\|\\||&&|==(\\?|#)?|(!|>|<)=(#|\\?)?|(=|!)~(#|\\?)?|(>|<)(#|\\?)is|isnot|\\.|\\*|\\\\|%)"),
+      scope: vec![
+        Scope {
+            a: 48414456213471232,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10017.rs

@@ -0,0 +1,33 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\\b(fu(n|nction)?|end(f|fu|fun|function)?)\\b"),
+      scope: vec![
+        Scope {
+            a: 48414456213471232,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10018.rs

@@ -0,0 +1,33 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(([sgbwtl]|)?:?[0-9a-zA-Z_#]+)(?=\\()"),
+      scope: vec![
+        Scope {
+            a: 61925255157907456,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10019.rs

@@ -0,0 +1,35 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("^\\s*(function)\\s*!?\\s+(?=(s:)?[0-9a-zA-Z_#]+\\s*\\()"),
+      scope: vec![],
+      captures: Some(vec![(1, vec![
+        Scope {
+            a: 48414456213471232,
+            b: 0,
+        },
+    ])]),
+      operation: MatchOperation::Push(vec![
+        ContextReference::Direct(ContextId { index: 10012 }),
+    ]),
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c1002.rs

@@ -0,0 +1,35 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\\b(domain)(?=\\()"),
+      scope: vec![
+        Scope {
+            a: 61925255120748558,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Push(vec![
+        ContextReference::Direct(ContextId { index: 921 }),
+    ]),
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10020.rs

@@ -0,0 +1,33 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("-\\w+="),
+      scope: vec![
+        Scope {
+            a: 61925375354667008,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10021.rs

@@ -0,0 +1,38 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?!\\$)(\")(?!\\{).*(?m:$)\\n?"),
+      scope: vec![
+        Scope {
+            a: 51510711180329113,
+            b: 0,
+        },
+    ],
+      captures: Some(vec![(1, vec![
+        Scope {
+            a: 47288629323041289,
+            b: 0,
+        },
+    ])]),
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10022.rs

@@ -0,0 +1,33 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\\b(if|while|for|try|return|throw|end(if|for|while|try)?|au(g|group)|else(if|)?|do|in|catch|finally|:)\\b"),
+      scope: vec![
+        Scope {
+            a: 52636636698705920,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10023.rs

@@ -0,0 +1,47 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![
+    Scope {
+        a: 845082060128256,
+        b: 0,
+    },
+],
+  meta_content_scope: vec![
+    Scope {
+        a: 845082060128256,
+        b: 0,
+    },
+],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10015 })),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10026 })),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10027 })),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10028 })),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10021 })),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10025 })),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10024 })),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10022 })),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10029 })),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10031 })),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10030 })),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10020 })),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10019 })),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10018 })),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10017 })),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10032 })),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10016 })),
+]
+} }

highlight/jirs-contexts/src/c10024.rs

@@ -0,0 +1,33 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("0x[0-9a-f]+"),
+      scope: vec![
+        Scope {
+            a: 59955089201168384,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10025.rs

@@ -0,0 +1,33 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("-?\\d+"),
+      scope: vec![
+        Scope {
+            a: 59955089176461312,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10026.rs

@@ -0,0 +1,33 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\"(\\\\\\\\|\\\\\"|\\n[^\\S\\n]*\\\\|[^\\n\"])*\""),
+      scope: vec![
+        Scope {
+            a: 55451420828565657,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10027.rs

@@ -0,0 +1,33 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\'(\'\'|\\n[^\\S\\n]*\\\\|[^\\n\'])*\'"),
+      scope: vec![
+        Scope {
+            a: 55451420831973529,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10028.rs

@@ -0,0 +1,33 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("/(\\\\\\\\|\\\\/|\\n[^\\S\\n]*\\\\|[^\\n/])*/"),
+      scope: vec![
+        Scope {
+            a: 55450759400587264,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10029.rs

@@ -0,0 +1,33 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\\b(set(local|global)?|let|command|filetype|colorscheme|\\w*map|\\w*a(b|brev)?|syn|exe(c|cute)?|ec(ho|)?|au(tocmd|)?)\\b"),
+      scope: vec![
+        Scope {
+            a: 61925255095582720,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c1003.rs

@@ -0,0 +1,80 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\\b(blur)(?=\\()"),
+      scope: vec![
+        Scope {
+            a: 61925255119699982,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Push(vec![
+        ContextReference::Direct(ContextId { index: 923 }),
+    ]),
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\\b(brightness|contrast|grayscale|invert|opacity|saturate|sepia)(?=\\()"),
+      scope: vec![
+        Scope {
+            a: 61925255119699982,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Push(vec![
+        ContextReference::Direct(ContextId { index: 925 }),
+    ]),
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\\b(drop-shadow)(?=\\()"),
+      scope: vec![
+        Scope {
+            a: 61925255119699982,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Push(vec![
+        ContextReference::Direct(ContextId { index: 927 }),
+    ]),
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\\b(hue-rotate)(?=\\()"),
+      scope: vec![
+        Scope {
+            a: 61925255119699982,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Push(vec![
+        ContextReference::Direct(ContextId { index: 929 }),
+    ]),
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10030.rs

@@ -0,0 +1,33 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("<.*?>"),
+      scope: vec![
+        Scope {
+            a: 61925375354667008,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10031.rs

@@ -0,0 +1,33 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\\b(am(enu|)?|(hl|inc)?search|[Bb]uf([Nn]ew[Ff]ile|[Rr]ead)?|[Ff]ile[Tt]ype)\\b"),
+      scope: vec![
+        Scope {
+            a: 61925246505648128,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10032.rs

@@ -0,0 +1,33 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("([sSgGbBwWlLaAvV]:|@|(?m:$)|&(?!&))\\w*"),
+      scope: vec![
+        Scope {
+            a: 49259087302033408,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10033.rs

@@ -0,0 +1,43 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![
+    Scope {
+        a: 844609626505370,
+        b: 0,
+    },
+],
+  meta_content_scope: vec![
+    Scope {
+        a: 844609626505370,
+        b: 0,
+    },
+],
+  meta_include_prototype: false,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\""),
+      scope: vec![],
+      captures: Some(vec![(0, vec![
+        Scope {
+            a: 47288629323956395,
+            b: 1407374883553280,
+        },
+    ])]),
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10034.rs

@@ -0,0 +1,28 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: false,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?=\")"),
+      scope: vec![],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10035.rs

@@ -0,0 +1,43 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![
+    Scope {
+        a: 844609626505370,
+        b: 0,
+    },
+],
+  meta_content_scope: vec![
+    Scope {
+        a: 844609626505370,
+        b: 0,
+    },
+],
+  meta_include_prototype: false,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\'"),
+      scope: vec![],
+      captures: Some(vec![(0, vec![
+        Scope {
+            a: 47288629323956395,
+            b: 1407374883553280,
+        },
+    ])]),
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10036.rs

@@ -0,0 +1,28 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: false,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?=\')"),
+      scope: vec![],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10037.rs

@@ -0,0 +1,36 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\\?>"),
+      scope: vec![
+        Scope {
+            a: 47288629324153003,
+            b: 1407374883553280,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10178 })),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10159 })),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10160 })),
+]
+} }

highlight/jirs-contexts/src/c10038.rs

@@ -0,0 +1,51 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(<!-)?(--\\s*>)"),
+      scope: vec![],
+      captures: Some(vec![(1, vec![
+        Scope {
+            a: 50103314702794757,
+            b: 0,
+        },
+    ]),(2, vec![
+        Scope {
+            a: 47288629323038891,
+            b: 1407374883553280,
+        },
+    ])]),
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("<!--(?!-?>)|--!>"),
+      scope: vec![
+        Scope {
+            a: 50103314702794757,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10039.rs

@@ -0,0 +1,34 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?: ?/)?>"),
+      scope: vec![
+        Scope {
+            a: 47288629324153003,
+            b: 1407374883553280,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10169 })),
+]
+} }

highlight/jirs-contexts/src/c1004.rs

@@ -0,0 +1,38 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?x:\n  [-+]? \\d* (\\.) \\d+ (?:[eE](?:[-+]?\\d+))?\n| [-+]? \\d+          (?:[eE](?:[-+]?\\d+))\n)"),
+      scope: vec![
+        Scope {
+            a: 59955089176592602,
+            b: 3940649673949184,
+        },
+    ],
+      captures: Some(vec![(1, vec![
+        Scope {
+            a: 47288620735397902,
+            b: 0,
+        },
+    ])]),
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10040.rs

@@ -0,0 +1,34 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?: ?/)?>"),
+      scope: vec![
+        Scope {
+            a: 47288629324153003,
+            b: 1407374883553280,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10169 })),
+]
+} }

highlight/jirs-contexts/src/c10041.rs

@@ -0,0 +1,34 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?: ?/)?>"),
+      scope: vec![
+        Scope {
+            a: 47288629324153003,
+            b: 1407374883553280,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10169 })),
+]
+} }

highlight/jirs-contexts/src/c10042.rs

@@ -0,0 +1,34 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?: ?/)?>"),
+      scope: vec![
+        Scope {
+            a: 47288629324153003,
+            b: 1407374883553280,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10169 })),
+]
+} }

highlight/jirs-contexts/src/c10043.rs

@@ -0,0 +1,34 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?: ?/)?>"),
+      scope: vec![
+        Scope {
+            a: 47288629324153003,
+            b: 1407374883553280,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10169 })),
+]
+} }

highlight/jirs-contexts/src/c10044.rs

@@ -0,0 +1,34 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?: ?/)?>"),
+      scope: vec![
+        Scope {
+            a: 47288629324153003,
+            b: 1407374883553280,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10169 })),
+]
+} }

highlight/jirs-contexts/src/c10045.rs

@@ -0,0 +1,71 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new(">"),
+      scope: vec![
+        Scope {
+            a: 47288629324152837,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?i:DOCTYPE)"),
+      scope: vec![
+        Scope {
+            a: 59392130632123128,
+            b: 1407374883553280,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Push(vec![
+        ContextReference::Direct(ContextId { index: 10046 }),
+    ]),
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\\[CDATA\\["),
+      scope: vec![],
+      captures: None,
+      operation: MatchOperation::Push(vec![
+        ContextReference::Direct(ContextId { index: 10047 }),
+    ]),
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(\\s*)(?!--|>)\\S(\\s*)"),
+      scope: vec![
+        Scope {
+            a: 50103314702794757,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10046.rs

@@ -0,0 +1,41 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?=>)"),
+      scope: vec![],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\"[^\">]*\""),
+      scope: vec![
+        Scope {
+            a: 55451420828566264,
+            b: 659495891907903488,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10047.rs

@@ -0,0 +1,28 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("]](?=>)"),
+      scope: vec![],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10048.rs

@@ -0,0 +1,34 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?: ?/)?>"),
+      scope: vec![
+        Scope {
+            a: 47288629324153003,
+            b: 1407374883553280,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10169 })),
+]
+} }

highlight/jirs-contexts/src/c10049.rs

@@ -0,0 +1,34 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new(">"),
+      scope: vec![
+        Scope {
+            a: 47288629324153003,
+            b: 1407374883553280,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10169 })),
+]
+} }

highlight/jirs-contexts/src/c1005.rs

@@ -0,0 +1,61 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?x:\n  [-+]? \\d* (\\.) \\d+ (?:[eE](?:[-+]?\\d+))?\n| [-+]? \\d+          (?:[eE](?:[-+]?\\d+))\n)((?i:Hz|kHz))\\b"),
+      scope: vec![
+        Scope {
+            a: 59955089176592602,
+            b: 3940649673949184,
+        },
+    ],
+      captures: Some(vec![(1, vec![
+        Scope {
+            a: 47288620735397902,
+            b: 0,
+        },
+    ]),(2, vec![
+        Scope {
+            a: 52636787033309198,
+            b: 0,
+        },
+    ])]),
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?:[-+]?\\d+)((?i:Hz|kHz))\\b"),
+      scope: vec![
+        Scope {
+            a: 59955089176461530,
+            b: 3940649673949184,
+        },
+    ],
+      captures: Some(vec![(1, vec![
+        Scope {
+            a: 52636787033309198,
+            b: 0,
+        },
+    ])]),
+      operation: MatchOperation::None,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10050.rs

@@ -0,0 +1,34 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new(">"),
+      scope: vec![
+        Scope {
+            a: 47288629324153003,
+            b: 1407374883553280,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10169 })),
+]
+} }

highlight/jirs-contexts/src/c10051.rs

@@ -0,0 +1,34 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?: ?/)?>"),
+      scope: vec![
+        Scope {
+            a: 47288629324153003,
+            b: 1407374883553280,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10169 })),
+]
+} }

highlight/jirs-contexts/src/c10052.rs

@@ -0,0 +1,34 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new(">"),
+      scope: vec![
+        Scope {
+            a: 47288629324153003,
+            b: 1407374883553280,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10169 })),
+]
+} }

highlight/jirs-contexts/src/c10053.rs

@@ -0,0 +1,46 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("{{"),
+      scope: vec![
+        Scope {
+            a: 47288629340012726,
+            b: 1407374883553280,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Push(vec![
+        ContextReference::Direct(ContextId { index: 10054 }),
+        ContextReference::Direct(ContextId { index: 7848 }),
+    ]),
+      with_prototype: Some(
+        ContextReference::Direct(ContextId { index: 10055 }),
+    )
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new(""),
+      scope: vec![],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10054.rs

@@ -0,0 +1,47 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![
+    Scope {
+        a: 844609626505370,
+        b: 0,
+    },
+],
+  meta_content_scope: vec![
+    Scope {
+        a: 844609626505370,
+        b: 0,
+    },
+],
+  meta_include_prototype: false,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("}}"),
+      scope: vec![],
+      captures: Some(vec![(0, vec![
+        Scope {
+            a: 46445269542895616,
+            b: 0,
+        },
+        Scope {
+            a: 47288629340012715,
+            b: 1407374883553280,
+        },
+    ])]),
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10055.rs

@@ -0,0 +1,28 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: false,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?=}})"),
+      scope: vec![],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10056.rs

@@ -0,0 +1,32 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![
+    Scope {
+        a: 281496464326661,
+        b: 0,
+    },
+],
+  meta_content_scope: vec![
+    Scope {
+        a: 281496464326661,
+        b: 0,
+    },
+],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10150 })),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10148 })),
+]
+} }

highlight/jirs-contexts/src/c10057.rs

@@ -0,0 +1,34 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10150 })),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?=\\S)"),
+      scope: vec![],
+      captures: None,
+      operation: MatchOperation::Push(vec![
+        ContextReference::Direct(ContextId { index: 10058 }),
+        ContextReference::Direct(ContextId { index: 7848 }),
+    ]),
+      with_prototype: Some(
+        ContextReference::Direct(ContextId { index: 10059 }),
+    )
+    }),
+]
+} }

highlight/jirs-contexts/src/c10058.rs

@@ -0,0 +1,38 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![
+    Scope {
+        a: 844609626505221,
+        b: 0,
+    },
+],
+  meta_content_scope: vec![
+    Scope {
+        a: 844609626505221,
+        b: 0,
+    },
+],
+  meta_include_prototype: false,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?i)(?=(?:-->\\s*)?</script)"),
+      scope: vec![],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10059.rs

@@ -0,0 +1,28 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: false,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?=(?i)(?=(?:-->\\s*)?</script))"),
+      scope: vec![],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c1006.rs

@@ -0,0 +1,37 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\\)"),
+      scope: vec![
+        Scope {
+            a: 46443865079414784,
+            b: 0,
+        },
+        Scope {
+            a: 47288629318582443,
+            b: 3940649673949184,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10060.rs

@@ -0,0 +1,63 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![
+    Scope {
+        a: 46444230169723062,
+        b: 1407374883553280,
+    },
+    Scope {
+        a: 46446618152861696,
+        b: 0,
+    },
+],
+  meta_content_scope: vec![
+    Scope {
+        a: 46444230169723062,
+        b: 1407374883553280,
+    },
+    Scope {
+        a: 46446618152861696,
+        b: 0,
+    },
+],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("="),
+      scope: vec![
+        Scope {
+            a: 47288620737429509,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Set(vec![
+        ContextReference::Direct(ContextId { index: 10061 }),
+    ]),
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?=\\S)"),
+      scope: vec![],
+      captures: None,
+      operation: MatchOperation::Set(vec![
+        ContextReference::Direct(ContextId { index: 10153 }),
+    ]),
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10061.rs

@@ -0,0 +1,39 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![
+    Scope {
+        a: 46444230169723062,
+        b: 1407374883553280,
+    },
+    Scope {
+        a: 46446618152861696,
+        b: 0,
+    },
+],
+  meta_content_scope: vec![
+    Scope {
+        a: 46444230169723062,
+        b: 1407374883553280,
+    },
+    Scope {
+        a: 46446618152861696,
+        b: 0,
+    },
+],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10155 })),
+]
+} }

highlight/jirs-contexts/src/c10062.rs

@@ -0,0 +1,46 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![
+    Scope {
+        a: 46444230169723062,
+        b: 1407374883553280,
+    },
+],
+  meta_content_scope: vec![
+    Scope {
+        a: 46444230169723062,
+        b: 1407374883553280,
+    },
+],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10151 })),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new(">"),
+      scope: vec![
+        Scope {
+            a: 47288629324153003,
+            b: 1407374883553280,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Set(vec![
+        ContextReference::Direct(ContextId { index: 10063 }),
+    ]),
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10063.rs

@@ -0,0 +1,34 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10150 })),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new(""),
+      scope: vec![],
+      captures: None,
+      operation: MatchOperation::Push(vec![
+        ContextReference::Direct(ContextId { index: 10066 }),
+        ContextReference::Direct(ContextId { index: 6597 }),
+    ]),
+      with_prototype: Some(
+        ContextReference::Direct(ContextId { index: 10067 }),
+    )
+    }),
+]
+} }

highlight/jirs-contexts/src/c10064.rs

@@ -0,0 +1,38 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![
+    Scope {
+        a: 845069188005893,
+        b: 0,
+    },
+],
+  meta_content_scope: vec![
+    Scope {
+        a: 845069188005893,
+        b: 0,
+    },
+],
+  meta_include_prototype: false,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?i)(?=(?:-->\\s*)?</script)"),
+      scope: vec![],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10065.rs

@@ -0,0 +1,28 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: false,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?=(?i)(?=(?:-->\\s*)?</script))"),
+      scope: vec![],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10066.rs

@@ -0,0 +1,38 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![
+    Scope {
+        a: 844820079902725,
+        b: 0,
+    },
+],
+  meta_content_scope: vec![
+    Scope {
+        a: 844820079902725,
+        b: 0,
+    },
+],
+  meta_include_prototype: false,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?i)(?=(?:-->\\s*)?</script)"),
+      scope: vec![],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10067.rs

@@ -0,0 +1,28 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: false,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?=(?i)(?=(?:-->\\s*)?</script))"),
+      scope: vec![],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10068.rs

@@ -0,0 +1,46 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![
+    Scope {
+        a: 46444230169723062,
+        b: 1407374883553280,
+    },
+],
+  meta_content_scope: vec![
+    Scope {
+        a: 46444230169723062,
+        b: 1407374883553280,
+    },
+],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10151 })),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new(">"),
+      scope: vec![
+        Scope {
+            a: 47288629324153003,
+            b: 1407374883553280,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Set(vec![
+        ContextReference::Direct(ContextId { index: 10069 }),
+    ]),
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10069.rs

@@ -0,0 +1,37 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10150 })),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new(""),
+      scope: vec![],
+      captures: None,
+      operation: MatchOperation::Push(vec![
+        ContextReference::Direct(ContextId { index: 10070 }),
+        ContextReference::ByScope { scope: Scope {
+            a: 855462996082688,
+            b: 0,
+        }, sub_context: None  },
+    ]),
+      with_prototype: Some(
+        ContextReference::Direct(ContextId { index: 10071 }),
+    )
+    }),
+]
+} }

highlight/jirs-contexts/src/c1007.rs

@@ -0,0 +1,50 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\\b((?:repeating-)?linear-gradient)(?=\\()"),
+      scope: vec![
+        Scope {
+            a: 61925255120814094,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Push(vec![
+        ContextReference::Direct(ContextId { index: 931 }),
+    ]),
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\\b((?:repeating-)?radial-gradient)(?=\\()"),
+      scope: vec![
+        Scope {
+            a: 61925255120814094,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Push(vec![
+        ContextReference::Direct(ContextId { index: 933 }),
+    ]),
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10070.rs

@@ -0,0 +1,38 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![
+    Scope {
+        a: 855463008862213,
+        b: 0,
+    },
+],
+  meta_content_scope: vec![
+    Scope {
+        a: 855463008862213,
+        b: 0,
+    },
+],
+  meta_include_prototype: false,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?i)(?=(?:-->\\s*)?</script)"),
+      scope: vec![],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10071.rs

@@ -0,0 +1,28 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: false,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?=(?i)(?=(?:-->\\s*)?</script))"),
+      scope: vec![],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10072.rs

@@ -0,0 +1,46 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![
+    Scope {
+        a: 46444230169723062,
+        b: 1407374883553280,
+    },
+],
+  meta_content_scope: vec![
+    Scope {
+        a: 46444230169723062,
+        b: 1407374883553280,
+    },
+],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10151 })),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new(">"),
+      scope: vec![
+        Scope {
+            a: 47288629324153003,
+            b: 1407374883553280,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Set(vec![
+        ContextReference::Direct(ContextId { index: 10073 }),
+    ]),
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10073.rs

@@ -0,0 +1,34 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10150 })),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new(""),
+      scope: vec![],
+      captures: None,
+      operation: MatchOperation::Push(vec![
+        ContextReference::Direct(ContextId { index: 10064 }),
+        ContextReference::Direct(ContextId { index: 9624 }),
+    ]),
+      with_prototype: Some(
+        ContextReference::Direct(ContextId { index: 10065 }),
+    )
+    }),
+]
+} }

highlight/jirs-contexts/src/c10074.rs

@@ -0,0 +1,21 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10150 })),
+]
+} }

highlight/jirs-contexts/src/c10075.rs

@@ -0,0 +1,63 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![
+    Scope {
+        a: 46444230169723062,
+        b: 1407374883553280,
+    },
+    Scope {
+        a: 46446618152861696,
+        b: 0,
+    },
+],
+  meta_content_scope: vec![
+    Scope {
+        a: 46444230169723062,
+        b: 1407374883553280,
+    },
+    Scope {
+        a: 46446618152861696,
+        b: 0,
+    },
+],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("="),
+      scope: vec![
+        Scope {
+            a: 47288620737429509,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Set(vec![
+        ContextReference::Direct(ContextId { index: 10076 }),
+    ]),
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?=\\S)"),
+      scope: vec![],
+      captures: None,
+      operation: MatchOperation::Set(vec![
+        ContextReference::Direct(ContextId { index: 10153 }),
+    ]),
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10076.rs

@@ -0,0 +1,39 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![
+    Scope {
+        a: 46444230169723062,
+        b: 1407374883553280,
+    },
+    Scope {
+        a: 46446618152861696,
+        b: 0,
+    },
+],
+  meta_content_scope: vec![
+    Scope {
+        a: 46444230169723062,
+        b: 1407374883553280,
+    },
+    Scope {
+        a: 46446618152861696,
+        b: 0,
+    },
+],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10158 })),
+]
+} }

highlight/jirs-contexts/src/c10077.rs

@@ -0,0 +1,34 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\""),
+      scope: vec![
+        Scope {
+            a: 47288629323956395,
+            b: 1407374883553280,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10143 })),
+]
+} }

highlight/jirs-contexts/src/c10078.rs

@@ -0,0 +1,34 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\'"),
+      scope: vec![
+        Scope {
+            a: 47288629323956395,
+            b: 1407374883553280,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10143 })),
+]
+} }

highlight/jirs-contexts/src/c10079.rs

@@ -0,0 +1,34 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Include(ContextReference::Direct(ContextId { index: 10161 })),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new(""),
+      scope: vec![],
+      captures: None,
+      operation: MatchOperation::Push(vec![
+        ContextReference::Direct(ContextId { index: 10080 }),
+        ContextReference::Direct(ContextId { index: 1017 }),
+    ]),
+      with_prototype: Some(
+        ContextReference::Direct(ContextId { index: 10081 }),
+    )
+    }),
+]
+} }

highlight/jirs-contexts/src/c1008.rs

@@ -0,0 +1,35 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("\\b(image)(?=\\()"),
+      scope: vec![
+        Scope {
+            a: 61925255120683022,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Push(vec![
+        ContextReference::Direct(ContextId { index: 935 }),
+    ]),
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10080.rs

@@ -0,0 +1,38 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![
+    Scope {
+        a: 844485072453637,
+        b: 0,
+    },
+],
+  meta_content_scope: vec![
+    Scope {
+        a: 844485072453637,
+        b: 0,
+    },
+],
+  meta_include_prototype: false,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?i)(?=(?:-->\\s*)?</style)"),
+      scope: vec![],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10081.rs

@@ -0,0 +1,28 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![],
+  meta_content_scope: vec![],
+  meta_include_prototype: false,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?=(?i)(?=(?:-->\\s*)?</style))"),
+      scope: vec![],
+      captures: None,
+      operation: MatchOperation::Pop,
+      with_prototype: None
+    }),
+]
+} }

highlight/jirs-contexts/src/c10082.rs

@@ -0,0 +1,63 @@
+
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+use jirs_syntect::{*, parsing::*};
+use jirs_syntect::Pattern::*;
+use std::cell::*;
+
+#[inline(always)]
+pub fn load() -> Context {
+        Context {
+  meta_scope: vec![
+    Scope {
+        a: 46444230200328374,
+        b: 1407374883553280,
+    },
+    Scope {
+        a: 46446618152861696,
+        b: 0,
+    },
+],
+  meta_content_scope: vec![
+    Scope {
+        a: 46444230200328374,
+        b: 1407374883553280,
+    },
+    Scope {
+        a: 46446618152861696,
+        b: 0,
+    },
+],
+  meta_include_prototype: true,
+  clear_scopes: None,
+  prototype: None,
+  uses_backrefs: false,
+  patterns: vec![
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("="),
+      scope: vec![
+        Scope {
+            a: 47288620737429509,
+            b: 0,
+        },
+    ],
+      captures: None,
+      operation: MatchOperation::Set(vec![
+        ContextReference::Direct(ContextId { index: 10083 }),
+    ]),
+      with_prototype: None
+    }),
+    Pattern::Match(MatchPattern {
+      has_captures: false,
+      regex: Regex::new("(?=\\S)"),
+      scope: vec![],
+      captures: None,
+      operation: MatchOperation::Set(vec![
+        ContextReference::Direct(ContextId { index: 10163 }),
+    ]),
+      with_prototype: None
+    }),
+]
+} }