From 37f0b2f26dd05cb0461195a945bc21728226a1a7 Mon Sep 17 00:00:00 2001 From: Fela Date: Wed, 20 Dec 2023 17:19:42 +0400 Subject: [PATCH 01/22] Lazy load patterns --- libprisma/Highlight.cpp | 5 +++++ libprisma/Highlight.h | 34 +++++++++++++++++++++++++-------- libprisma/LanguageTree.cpp | 17 ++++++++++++++--- libprisma/LanguageTree.h | 1 + libprisma/SyntaxHighlighter.cpp | 12 ++++++------ 5 files changed, 52 insertions(+), 17 deletions(-) diff --git a/libprisma/Highlight.cpp b/libprisma/Highlight.cpp index 8d55452..6e45235 100644 --- a/libprisma/Highlight.cpp +++ b/libprisma/Highlight.cpp @@ -31,6 +31,11 @@ const Pattern* PatternPtr::get() const return m_tree->resolvePattern(m_path); } +std::shared_ptr PatternRaw::realize() +{ + return std::make_shared(m_regex, m_flags, m_lookbehind, m_greedy, m_alias, m_inside); +} + const Grammar* Pattern::inside() const { if (m_inside) diff --git a/libprisma/Highlight.h b/libprisma/Highlight.h index a1130e0..6248700 100644 --- a/libprisma/Highlight.h +++ b/libprisma/Highlight.h @@ -29,17 +29,35 @@ private: size_t m_path; }; +class PatternRaw +{ +public: + PatternRaw(std::string_view pattern, boost::regex_constants::syntax_option_type flags, bool lookbehind, bool greedy, std::string alias, std::shared_ptr inside) + : m_regex(std::string{pattern}) + , m_flags(flags) + , m_lookbehind(lookbehind) + , m_greedy(greedy) + , m_alias(alias) + , m_inside(inside) + { + } + + std::shared_ptr realize(); + +private: + std::string m_regex; + boost::regex_constants::syntax_option_type m_flags; + bool m_lookbehind; + bool m_greedy; + std::string m_alias; + std::shared_ptr m_inside; +}; + class Pattern { public: - Pattern(std::string_view pattern, boost::regex_constants::syntax_option_type flags, bool lookbehind, bool greedy, std::string alias, GrammarPtr inside) - : Pattern(pattern, flags, lookbehind, greedy, alias, std::make_shared(inside)) - { - - } - - Pattern(std::string_view pattern, boost::regex_constants::syntax_option_type flags, bool lookbehind = false, bool greedy = false, std::string alias = "", std::shared_ptr inside = nullptr) - : m_regex(boost::regex(std::string{pattern}, flags | boost::regex_constants::optimize)) + Pattern(std::string_view pattern, boost::regex_constants::syntax_option_type flags, bool lookbehind, bool greedy, std::string alias, std::shared_ptr inside) + : m_regex(boost::regex(std::string{ pattern }, flags | boost::regex_constants::optimize)) , m_lookbehind(lookbehind) , m_greedy(greedy) , m_alias(alias) diff --git a/libprisma/LanguageTree.cpp b/libprisma/LanguageTree.cpp index 1518bcb..87990db 100644 --- a/libprisma/LanguageTree.cpp +++ b/libprisma/LanguageTree.cpp @@ -96,6 +96,8 @@ void LanguageTree::parsePatterns(Buffer &buffer) { uint16_t count = freadUint16(buffer); + m_patterns.resize(count); + for (int i = 0; i < count; ++i) { std::string item = freadString(buffer); @@ -163,11 +165,11 @@ void LanguageTree::parsePatterns(Buffer &buffer) if (inside != std::string::npos) { - m_patterns.push_back(std::make_shared(pattern, flags, lookbehind, greedy, std::string{ alias }, std::make_shared(shared_from_this(), inside))); + m_patternsRaw.push_back(std::make_shared(pattern, flags, lookbehind, greedy, std::string{ alias }, std::make_shared(shared_from_this(), inside))); } else { - m_patterns.push_back(std::make_shared(pattern, flags, lookbehind, greedy, std::string{ alias })); + m_patternsRaw.push_back(std::make_shared(pattern, flags, lookbehind, greedy, std::string{ alias }, nullptr)); } } } @@ -175,7 +177,16 @@ void LanguageTree::parsePatterns(Buffer &buffer) const Pattern* LanguageTree::resolvePattern(size_t path) { - return m_patterns[path].get(); + std::shared_ptr &parsed = m_patterns[path]; + if (parsed == nullptr) + { + parsed = m_patternsRaw[path]->realize(); + + m_patternsRaw[path] = nullptr; + m_patterns[path] = parsed; + } + + return parsed.get(); } const Grammar* LanguageTree::resolveGrammar(size_t path) diff --git a/libprisma/LanguageTree.h b/libprisma/LanguageTree.h index 422a2ff..ce28d44 100644 --- a/libprisma/LanguageTree.h +++ b/libprisma/LanguageTree.h @@ -57,4 +57,5 @@ private: std::map> m_languages; std::vector> m_grammars; std::vector> m_patterns; + std::vector> m_patternsRaw; }; \ No newline at end of file diff --git a/libprisma/SyntaxHighlighter.cpp b/libprisma/SyntaxHighlighter.cpp index 5fe8535..09d1ba1 100644 --- a/libprisma/SyntaxHighlighter.cpp +++ b/libprisma/SyntaxHighlighter.cpp @@ -44,9 +44,9 @@ void SyntaxHighlighter::matchGrammar(std::string_view text, TokenList& tokenList return; } - const auto& pattern = *j; - const auto& inside = pattern->inside(); - const bool greedy = pattern->greedy(); + const auto& pattern = *j->get(); + const auto& inside = pattern.inside(); + const bool greedy = pattern.greedy(); size_t pos = startPos; @@ -81,7 +81,7 @@ void SyntaxHighlighter::matchGrammar(std::string_view text, TokenList& tokenList if (greedy) { - match = pattern->match(matchSuccess, matchIndex, text); + match = pattern.match(matchSuccess, matchIndex, text); if (!matchSuccess || matchIndex >= text.length()) { break; @@ -125,7 +125,7 @@ void SyntaxHighlighter::matchGrammar(std::string_view text, TokenList& tokenList else { matchIndex = 0; - match = pattern->match(matchSuccess, matchIndex, str); + match = pattern.match(matchSuccess, matchIndex, str); if (!matchSuccess) { continue; @@ -165,7 +165,7 @@ void SyntaxHighlighter::matchGrammar(std::string_view text, TokenList& tokenList currentNode = tokenList.addAfter(removeFrom, token.name(), std::move(tokenEntries), - pattern->alias(), + pattern.alias(), match.size()); if (after.size()) From 5dd5b637809e4ddce6a41dd29c0c9ca5aadab3f2 Mon Sep 17 00:00:00 2001 From: Fela Date: Mon, 29 Jan 2024 12:46:51 +0400 Subject: [PATCH 02/22] Language display name --- libprisma/LanguageTree.h | 11 +++++++++++ libprisma/SyntaxHighlighter.cpp | 5 +++++ libprisma/SyntaxHighlighter.h | 2 ++ 3 files changed, 18 insertions(+) diff --git a/libprisma/LanguageTree.h b/libprisma/LanguageTree.h index ce28d44..46b613b 100644 --- a/libprisma/LanguageTree.h +++ b/libprisma/LanguageTree.h @@ -38,6 +38,17 @@ public: return keys; } + std::string languageName(const std::string& language) const + { + const auto& find = m_languages.find(language); + if (find != m_languages.end()) + { + return find->second.first; + } + + return language; + } + const Grammar* find(const std::string& key) const { const auto& value = m_languages.find(key); diff --git a/libprisma/SyntaxHighlighter.cpp b/libprisma/SyntaxHighlighter.cpp index 09d1ba1..c12d0bc 100644 --- a/libprisma/SyntaxHighlighter.cpp +++ b/libprisma/SyntaxHighlighter.cpp @@ -24,6 +24,11 @@ std::map SyntaxHighlighter::languages() const return m_tree->keys(); } +std::string SyntaxHighlighter::languageName(const std::string& language) const +{ + return m_tree->languageName(language); +} + TokenList SyntaxHighlighter::tokenize(std::string_view text, const Grammar* grammar) { TokenList tokenList(text); diff --git a/libprisma/SyntaxHighlighter.h b/libprisma/SyntaxHighlighter.h index 2510d4c..b10b5a9 100644 --- a/libprisma/SyntaxHighlighter.h +++ b/libprisma/SyntaxHighlighter.h @@ -25,6 +25,8 @@ public: std::map languages() const; + std::string languageName(const std::string& language) const; + private: TokenList tokenize(std::string_view text, const Grammar* grammar); void matchGrammar(std::string_view text, TokenList& tokenList, const Grammar* grammar, TokenListPtr startNode, size_t startPos, RematchOptions* rematch); From bd15682b7b9a305ff81ccfd81191fe7aeb39ec6d Mon Sep 17 00:00:00 2001 From: Novus Nota <68142933+novusnota@users.noreply.github.com> Date: Tue, 28 May 2024 15:19:54 +0200 Subject: [PATCH 03/22] Added Tact, FunC, Fift, TL-B support (#13) * Added Tact, FunC, Fift, TL-B support Whose are the common languages of [TON](https://ton.org). * chore: Updated list of supported languages * feat: support Tact 1.3.0 --- README.md | 5 ++ components/prism-fift.js | 127 +++++++++++++++++++++++++++++ components/prism-func.js | 60 ++++++++++++++ components/prism-tact.js | 168 +++++++++++++++++++++++++++++++++++++++ components/prism-tlb.js | 44 ++++++++++ generate.js | 4 + 6 files changed, 408 insertions(+) create mode 100644 components/prism-fift.js create mode 100644 components/prism-func.js create mode 100644 components/prism-tact.js create mode 100644 components/prism-tlb.js diff --git a/README.md b/README.md index f5e307f..8fb403c 100644 --- a/README.md +++ b/README.md @@ -129,10 +129,12 @@ The new version of `grammars.dat` will appear in the `libprisma/grammars.dat`. |`F#`|`fsharp`| |`Factor`|`factor`| |`False`|`false`| +|`Fift`|`fift`| |`Firestore security rules`|`firestore-security-rules`| |`Flow`|`flow`| |`Fortran`|`fortran`| |`FreeMarker Template Language`|`ftl`| +|`FunC`|`func`| |`GameMaker Language`|`gml`,`gamemakerlanguage`| |`GAP (CAS)`|`gap`| |`G-code`|`gcode`| @@ -290,6 +292,7 @@ The new version of `grammars.dat` will appear in the `libprisma/grammars.dat`. |`SuperCollider`|`supercollider`,`sclang`| |`Swift`|`swift`| |`Systemd configuration file`|`systemd`| +|`Tact`|`tact`| |`T4 templating`|`t4-templating`| |`T4 Text Templates (C#)`|`t4-cs`,`t4`| |`VB.Net`|`vbnet`| @@ -299,6 +302,8 @@ The new version of `grammars.dat` will appear in the `libprisma/grammars.dat`. |`Template Toolkit 2`|`tt2`| |`TOML`|`toml`| |`Tremor`|`tremor`,`tremor`,`trickle`,`troy`| +|`Type Language`|`tl`| +|`Type Language - Binary`|`tlb`| |`TypoScript`|`typoscript`,`tsconfig`| |`UnrealScript`|`unrealscript`,`unrealscript`,`uscript`,`uc`| |`UO Razor Script`|`uorazor`| diff --git a/components/prism-fift.js b/components/prism-fift.js new file mode 100644 index 0000000..44f3376 --- /dev/null +++ b/components/prism-fift.js @@ -0,0 +1,127 @@ +/** + * @file Prism.js definition for Fift + * @link https://docs.ton.org/develop/fift/overview + * @author Nikita Sobolev (https://github.com/sobolevn) + * @license MIT + */ +Prism.languages.fift = { + 'symbol': [ + /[xX]\{[0-9a-fA-F_]*\}/, + /[bB]\{[01]*\}/, + /'\S+/, + ], + 'string': /"([^"\r\n\\]|\\.)*"/, + + 'comment': [ + { + pattern: /\/\*[\s\S]*?(?:\*\/|$)/, + lookbehind: true, + greedy: true, + }, + { + pattern: /\/\/.*/, + lookbehind: true, + greedy: true, + }, + ], + + 'operator': [ + // Full list can be found in + // Appendix A. List of Fift words + // Ordered the same way source code does this. + // Except: shorter words must follow + // longer ones with the same base part. + // Example: `#` comes after `#s` + /#>/, /#s/, /\$#/, /#/, + + /\$\+/, /\$,/, /\$\d/, /\$=/, /\$(?=\()/, + /\$>smca/, /\$>s/, + /\$@\+/, /\$@\?\+/, /\$@\?/, /\$@/, + /\$cmp/, /\$len/, /\$pos/, /\$reverse/, + + /%1<>c/, /\*>>r/, /\*>>/, /\*mod/, /\*/, + + /\+!/, /\+/, /,/, /-!/, /-/, /!/, + /-1</, /0=/, /0>/, + /1\+!/, /1\+/, /1-!/, /1-/, /1</, /=/, />>c/, />>r/, />>/, />/, + + /\?dup/, + + /@'/, /@/, + + /B\+/, /B,/, /B=/, /B>Li@\+/, /B>Li@/, /B>Lu@\+/, /B>Lu@/, /B>boc/, + /B>file/, /B>i@\+/, /B>i@/, /B>u@\+/, /B>u@/, + /B@\?\+/, /B@\+/, /B@\?/, /B@/, + /Bcmp/, /BhashB/, /Bhashu/, /Bhash/, /Blen/, /Bx\./, + /B\|/, /Li>B/, /Lu>B/, + + /\[\]/, /\[compile\]/, /\[/, /\]/, + + /atom\?/, + + /b\+/, /b\._/, /b\./, + /b>idict!\+/, /b>idict!/, /b>sdict!\+/, /b>sdict!/, + /b>udict!\+/, /b>udict!/, + /b>/, /boc\+>B/, /boc>B/, + + /csr\./, + /def\?/, + /empty\?/, /eq\?/, + /file-exists\?/, /file>B/, + + /i,/, /i>B/, /i@\+/, /i@\?\+/, /i@\?/, /i@/, + /idict!\+/, /idict!/, /idict-/, /idict@-/, /idict@/, + + /null!/, /null\?/, + /pfxdict!\+/, /pfxdict!/, /pfxdict@/, /priv>pub/, + /ref@\+/, /ref@/, /ref@\?\+/, /ref@\?/, + + /s,/, /s>c/, /s>/, + /sdict!\+/, /sdict!/, /sdict-/, /sdict@-/, /sdict@/, + /smca>\$/, /sr,/, + + /tuple\?/, + + /u,/, /u>B/, /u@\+/, /u@\?\+/, /u@\?/, + /udict!\+/, /udict!/, /udict-/, /udict@-/, /udict@/, + /undef\?/, + + /x\._/, /x\./, + + /\|\+/, /\|/, /\|_/, + + /\?\./, /'/, + + // Should be the last: + /\./, + ], + + 'keyword': /\b(?:-roll|-rot|-trailing|-trailing0|2constant|2drop|2dup|2over|2swap|abort|abs|allot|and|anon|atom|bbitrefs|bbits|bl|box|brefs|brembitrefs|brembits|bremrefs|bye|caddr|cadr|car|cddr|cdr|char|chr|cmp|cond|cons|constant|count|cr|create|depth|dictmap|dictmerge|dictnew|does|drop|dup|ed25519_chksign|ed25519_sign|ed25519_sign_uint|emit|exch|exch2|execute|explode|find|first|fits|forget|gasrunvm|gasrunvmcode|gasrunvmctx|gasrunvmdict|halt|hash|hashB|hashu|hold|hole|if|ifnot|include|list|max|min|minmax|mod|negate|newkeypair|nil|nip|nop|not|now|null|or|over|pair|pick|quit|remaining|reverse|roll|rot|runvm|runvmcode|runvmctx|runvmdict|sbitrefs|sbits|second|sgn|shash|sign|single|skipspc|space|srefs|swap|ten|third|times|triple|tuck|tuple|type|ufits|uncons|unpair|unsingle|until|untriple|untuple|variable|while|word|words|xor)\b/, + 'boolean': /\b(?:false|true)\b/, + + 'number': [ + /(0[xX][0-9a-fA-F]+)/, + /(0[bB][01]+)/, + /(-?\d+(\/-?\d+)?)/, + ], + 'variable': /[\w$-]+/, + + 'punctuation': /[\[\{\}\],\(\)]/, +}; \ No newline at end of file diff --git a/components/prism-func.js b/components/prism-func.js new file mode 100644 index 0000000..056e0cc --- /dev/null +++ b/components/prism-func.js @@ -0,0 +1,60 @@ +/** + * @file Prism.js definition for FunC + * @link https://docs.ton.org/develop/func/overview + * @version 0.2.0 + * @author Nikita Sobolev (https://github.com/sobolevn) + * @license MIT + */ +(function (Prism) { + // 1. Does not start from " + // 2. Can start from ` and end with `, containing any character + // 3. Starts with underscore or { or } and have more than 1 character after it + // 4. Starts with letter, contains letters, numbers and underscores + var identifier = /(?!")(`([^`]+)`|((?=_)_|(?=\{)\{|(?=\})\}|(?![_`{}]))([^;,\[\]\(\)\s~.]+))/; + var string = /"[^\n"]+"[Hhcusa]?/; + var number = /\b([\d_]+|0x[\d_a-fA-F]+|0b[1_0]+)\b/; + + Prism.languages.func = { + 'include': { + pattern: /#include(.*);/, + inside: { + 'keyword': /#include/, + 'string': string, + 'punctuation': /;/ + }, + }, + 'pragma': { + pattern: /#pragma(.*);/, + inside: { + 'keyword': /#pragma|not-version|version/, + 'number': /(\d+)(.\d+)?(.\d+)?/, + 'operator': [/>=/, /<=/, /=/, />/, /|>=|<=|!=|==|~>>=|~>>|\/%|\^%=|\^%|~%|\^\/=|\^\/|~\/=|~\/|\+=|-=|\*=|\/=|%=|<<=|>>=|\^>>=|\^>>|&=|>>|<<|\^=|\|=|\^|=|~|\/|%|-|\*|\+|>|<|&|\||:|\?)/, + 'punctuation': /[\.;\(\),\[\]~\{\}]/, + }; +}(Prism)); \ No newline at end of file diff --git a/components/prism-tact.js b/components/prism-tact.js new file mode 100644 index 0000000..80f0832 --- /dev/null +++ b/components/prism-tact.js @@ -0,0 +1,168 @@ +/** + * @file Prism.js definition for Tact + * @link https://tact-lang.org + * @version 1.2.0 + * @author Novus Nota (https://github.com/novusnota) + * @license MIT + */ +(function(Prism) { + Prism.languages.tact = { + // reserved keywords + 'keyword': [ + { + pattern: /\b(?:abstract|as|catch|const|contract(?!:)|do|else|extend|extends|foreach|fun|get|if|in|import|initOf|inline|let|message(?!:)|mutates|native|override|primitive|public|repeat|return|self|struct(?!:)|trait(?!:)|try|until|virtual|while|with)\b/, + }, + { // keyword after as + pattern: /(\bas\s+)\w+/, + lookbehind: true, + greedy: true, + }, + { // reserved function names + pattern: /\b(?:bounced|external|init|receive)\b/ + }, + ], + + // built-in types + 'builtin': { + pattern: /\b(?:Address|Bool|Builder|Cell|Int|Slice|String|StringBuilder)\b/, + }, + + // SCREAMING_SNAKE_CASE for null values and names of constants + 'constant': [ + { + pattern: /\bnull\b/, + }, + { + pattern: /\b[A-Z][A-Z0-9_]*\b/, + }, + ], + + // UpperCamelCase for names of contracts, traits, structs, messages + 'class-name': { + pattern: /\b[A-Z]\w*\b/, + }, + + // mappings to FunC + 'attribute': [ + { // functions + pattern: /@name/, + inside: { + 'function': /.+/, + }, + }, + { // contract interfaces + pattern: /@interface/, + inside: { + 'function': /.+/, + } + } + ], + + 'function': { + pattern: /\b\w+(?=\()/, + }, + + 'boolean': { + pattern: /\b(?:false|true)\b/, + }, + + 'number': [ + { // hexadecimal, case-insensitive /i + pattern: /\b0x[0-9a-f](?:_?[0-9a-f])*\b/i, + }, + { // octal, case-insensitive /i + pattern: /\b0o[0-7](?:_?[0-7])*\b/i, + }, + { // binary, case-insensitive /i + pattern: /\b0b[01](?:_?[01])*\b/i, + }, + { // decimal integers, starting with 0 + pattern: /\b0\d*\b/, + }, + { // other decimal integers + pattern: /\b[1-9](?:_?\d)*\b/, + }, + ], + + 'string': undefined, + + 'punctuation': { + pattern: /[{}[\]();,.:?]/, + }, + + 'comment': [ + { // single-line + pattern: /(^|[^\\:])\/\/.*/, + lookbehind: true, + greedy: true, + }, + { // multi-line + pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/, + lookbehind: true, + greedy: true, + } + ], + + 'operator': { + 'pattern': /![!=]?|[+\-*/%=]=?|[<>]=|<>?|\|\|?|&&?|\^/, + }, + + }; + + // strings, made this way to not collide with other entities + Prism.languages.insertBefore('tact', 'string', { + 'string-literal': { + pattern: /(?:(")(?:\\.|(?!\1)[^\\\r\n])*\1(?!\1))/, + greedy: true, + inside: { + 'regex': [ + { // \\ \" \n \r \t \v \b \f + pattern: /\\[\\"nrtvbf]/, + }, + { // hexEscape, \x00 through \xFF + pattern: /\\x[0-9a-fA-F]{2}/, + }, + { // unicodeEscape, \u0000 through \uFFFF + pattern: /\\u[0-9a-fA-F]{4}/, + }, + { // unicodeCodePoint, \u{0} through \u{FFFFFF} + pattern: /\\u\{[0-9a-fA-F]{1,6}\}/, + }, + ], + 'string': { + pattern: /[\s\S]+/, + }, + }, + }, + }); + + // map and bounced message generic type modifiers + Prism.languages.insertBefore('tact', 'keyword', { + 'generics': { + pattern: /(?:\b(?:bounced|map)\b<[^\\\r\n]*>)/, + greedy: true, + inside: { + 'builtin': [ + Prism.languages['tact']['builtin'], + { + pattern: /\b(?:bounced(?=<)|map(?=<))\b/ + }, + ], + 'class-name': Prism.languages['tact']['class-name'], + 'punctuation': { + pattern: /[<>(),.?]/, + }, + 'keyword': [ + { + pattern: /\bas\b/, + }, + { + pattern: /(\bas\s+)\w+/, + lookbehind: true, + greedy: true, + }, + ], + }, + }, + }); +}(Prism)); \ No newline at end of file diff --git a/components/prism-tlb.js b/components/prism-tlb.js new file mode 100644 index 0000000..9878908 --- /dev/null +++ b/components/prism-tlb.js @@ -0,0 +1,44 @@ +/** + * @file Prism.js definition for TL-B + * @link https://docs.ton.org/develop/data-formats/tl-b-language + * @author Nikita Sobolev (https://github.com/sobolevn) + * @license MIT + */ +Prism.languages.tlb = { + 'builtin': /\b(?:Bool|Both|Cell|Either|Maybe|Type|Unit|bits256|bits512|int16|int32|int64|int8|uint15|uint16|uint32|uint63|uint64|uint8)\b/, + 'keyword': /\b(?:BoolFalse|BoolTrue|False|Null|True)\b/, + + 'comment': { + pattern: /\/\/(?:[^\r\n\\]|\\(?:\r\n?|\n|(?![\r\n])))*|\/\*[\s\S]*?(?:\*\/|$)/, + greedy: true + }, + 'comment-multiline': [ + { + pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/, + lookbehind: true, + greedy: true, + alias: 'comment' + }, + { + pattern: /(^|[^\\:])\/\/.*/, + lookbehind: true, + greedy: true, + alias: 'comment' + } + ], + + 'symbol': [ + /#[0-9a-f]*_?/, + /\$[01]*_?/, + /\b(?:##|#<|#<=)\b/, + ], + 'variable': /[a-zA-Z_]\w*/, + 'operator': [ + /\+/, /-/, /\*/, /\//, + /!=/, /==/, /=/, + /\?/, /~/, /\./, /\^/, + /<=/, />=/, //, + ], + 'number': /\d+/, + 'punctuation': /[;\(\):\[\]\{\}]/, +}; \ No newline at end of file diff --git a/generate.js b/generate.js index df26e06..d8ea193 100644 --- a/generate.js +++ b/generate.js @@ -223,6 +223,10 @@ async function generate() { // Manually add local definitions loadLocalLanguage('./components/prism-tl.js', 'typelanguage', 'TypeLanguage', 'tl') + loadLocalLanguage('./components/prism-tlb.js', 'tlb', 'TypeLanguage-Binary', 'tlb') + loadLocalLanguage('./components/prism-fift.js', 'fift', 'Fift', 'fift') + loadLocalLanguage('./components/prism-func.js', 'func', 'FunC', 'func') + loadLocalLanguage('./components/prism-tact.js', 'tact', 'Tact', 'tact') Object.keys(Prism.languages).forEach(lng => { if (unsupported.includes(lng) || !components.languages[lng]) { From 3752c51e7c24728bf8cbda44e0d0107cad8b6d25 Mon Sep 17 00:00:00 2001 From: Danil Ovchinnikov Date: Mon, 21 Sep 2026 10:07:32 +0400 Subject: [PATCH 04/22] feat: add support Tolk grammar (#43) --- components/prism-tolk.js | 71 ++++++++++++++++++++++++++++++++++++++++ generate.js | 1 + 2 files changed, 72 insertions(+) create mode 100644 components/prism-tolk.js diff --git a/components/prism-tolk.js b/components/prism-tolk.js new file mode 100644 index 0000000..db4dbca --- /dev/null +++ b/components/prism-tolk.js @@ -0,0 +1,71 @@ +/** + * @file Prism.js definition for Tolk + * @link https://docs.ton.org/tolk/overview + * @version 1.4.0 + * @author Danil Ovchinnikov (https://github.com/Danil42Russia) + * @license MIT + */ +(function(Prism) { + Prism.languages.tolk = { + 'comment': { + pattern: /\/\/.*/, + greedy: true, + }, + + 'block-comment': { + pattern: /\/\*[\s\S]*?(?:\*\/|$)/, + greedy: true, + }, + + 'string': [ + { + pattern: /"""(?:\\[\s\S]|(?!""")[\s\S])*(?:"""|$)/, + greedy: true, + }, + { + pattern: /"(?:\\.|[^"\\\r\n])*(?:"|$)/, + greedy: true, + }, + ], + + 'attr-name': /@[a-zA-Z0-9_.]+/, + + 'number': [ + /\b0x[0-9A-Fa-f_]+\b/, + /\b0b[01_]+\b/, + /\b\d[\d_]*\b/, + ], + + 'boolean': /\b(?:false|null|true)\b/, + + 'constant': /\b[A-Z][A-Z0-9_]*_[A-Z0-9_]*\b/, + + 'keyword': [ + /!is\b/, + /\b(?:as|asm|assert|break|builtin|catch|const|continue|contract|do|else|enum|fun|get|global|if|import|is|lazy|match|mutate|private|readonly|repeat|return|self|struct|throw|tolk|try|type|val|var|while)\b/, + ], + + 'function': [ + /`[^`\r\n]+`(?=\s*(?:<[^(){};\r\n]*>\s*)?\()/, + /\b[a-zA-Z_$][a-zA-Z0-9_$]*\b(?=\s*(?:<[^(){};\r\n]*>\s*)?\()/, + ], + + 'builtin': [ + /\b(?:Cell|address|any_address|array|blockchain|bool|builder|cell|coins|continuation|contract|debug|dict|lisp_list|map|never|random|reflect|slice|string|tuple|unknown|void)\b/, + /\b(?:int\d*|uint\d+|varint\d+|varuint\d+|bits\d+|bytes\d+)\b/, + ], + + 'class-name': /\b[A-Z][a-zA-Z0-9_$]*\b/, + + 'property': { + pattern: /(\.)(?:`[^`\r\n]+`|[a-zA-Z_$][a-zA-Z0-9_$]*)/, + lookbehind: true, + }, + + 'operator': /<<=|>>=|<=>|~>>|\^>>|==|!=|<=|>=|<<|>>|&&|\|\||~\/|\^\/|\+=|-=|\*=|\/=|%=|&=|\|=|\^=|->|=>|\+\+|--|\?\?|[+\-*\/%?=<>!&|^~]/, + + 'punctuation': /[.,;:(){}\[\]]/, + + 'symbol': /`[^`\r\n]+`/, + }; +}(Prism)); diff --git a/generate.js b/generate.js index d8ea193..aa8a878 100644 --- a/generate.js +++ b/generate.js @@ -227,6 +227,7 @@ async function generate() { loadLocalLanguage('./components/prism-fift.js', 'fift', 'Fift', 'fift') loadLocalLanguage('./components/prism-func.js', 'func', 'FunC', 'func') loadLocalLanguage('./components/prism-tact.js', 'tact', 'Tact', 'tact') + loadLocalLanguage('./components/prism-tolk.js', 'tolk', 'Tolk', 'tolk') Object.keys(Prism.languages).forEach(lng => { if (unsupported.includes(lng) || !components.languages[lng]) { From 8e92679ccaf23aed6a34b0a4841c63d0e08224bb Mon Sep 17 00:00:00 2001 From: Fela Date: Mon, 21 Sep 2026 10:15:04 +0400 Subject: [PATCH 05/22] Update workflow actions to supported versions --- .github/workflows/build-grammars.yml | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/.github/workflows/build-grammars.yml b/.github/workflows/build-grammars.yml index ec56456..35c9b18 100644 --- a/.github/workflows/build-grammars.yml +++ b/.github/workflows/build-grammars.yml @@ -2,26 +2,27 @@ name: Update grammars on: [ workflow_dispatch ] +permissions: + contents: write + pull-requests: write + jobs: build: runs-on: ubuntu-latest - strategy: - matrix: - node-version: [18.x] steps: - - uses: actions/checkout@v3 - - uses: actions/setup-node@v3 + - uses: actions/checkout@v5 + - uses: actions/setup-node@v5 with: - node-version: 18 + node-version: 22 - run: npm install - run: npm start - name: Upload a Build Artifact - uses: actions/upload-artifact@v3.1.3 + uses: actions/upload-artifact@v7 with: name: grammars.dat path: ./libprisma/grammars.dat - name: Create Pull Request - uses: peter-evans/create-pull-request@v5 + uses: peter-evans/create-pull-request@v8 with: commit-message: Update grammars title: Update grammars From f59232fa12ceb4e4ff6595530372cbd60cd32f7a Mon Sep 17 00:00:00 2001 From: Fela Date: Mon, 21 Sep 2026 10:41:36 +0400 Subject: [PATCH 06/22] Regenerate grammars on push to master --- .github/workflows/build-grammars.yml | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/.github/workflows/build-grammars.yml b/.github/workflows/build-grammars.yml index 35c9b18..e3784a9 100644 --- a/.github/workflows/build-grammars.yml +++ b/.github/workflows/build-grammars.yml @@ -1,6 +1,15 @@ name: Update grammars -on: [ workflow_dispatch ] +on: + workflow_dispatch: + push: + branches: [ master ] + # grammars.dat itself is deliberately not listed: regenerating it must not trigger another run. + paths: + - components/** + - generate.js + - package.json + - package-lock.json permissions: contents: write From 4e929ca5ba411bae29d3d2415845177aae83033b Mon Sep 17 00:00:00 2001 From: Fela Date: Mon, 21 Sep 2026 10:41:36 +0400 Subject: [PATCH 07/22] Reject pull requests that modify grammars.dat --- .github/workflows/check-generated.yml | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 .github/workflows/check-generated.yml diff --git a/.github/workflows/check-generated.yml b/.github/workflows/check-generated.yml new file mode 100644 index 0000000..9e2dad0 --- /dev/null +++ b/.github/workflows/check-generated.yml @@ -0,0 +1,22 @@ +name: Check generated files + +# The path filter is the whole test: the job only exists when the pull request +# touches grammars.dat, so reaching it is already the failure. +on: + pull_request: + paths: + - libprisma/grammars.dat + +permissions: {} + +jobs: + grammars: + runs-on: ubuntu-latest + # A pull request opened with GITHUB_TOKEN cannot trigger this workflow at all, + # so the guard only matters if "Update grammars" is ever moved to a PAT. + if: github.event.pull_request.user.login != 'github-actions[bot]' + steps: + - name: Reject changes to the generated grammar table + run: | + echo "::error file=libprisma/grammars.dat::libprisma/grammars.dat is generated by generate.js and is regenerated on master by the Update grammars workflow. Please drop it from this pull request and keep only the components/ and generate.js changes." + exit 1 From 2060940e82346181f2e24e5dc4f7135e2016b38e Mon Sep 17 00:00:00 2001 From: Fela Date: Mon, 21 Sep 2026 10:41:36 +0400 Subject: [PATCH 08/22] Mark grammars.dat as generated --- .gitattributes | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitattributes b/.gitattributes index 63081ae..3b5a7e3 100644 --- a/.gitattributes +++ b/.gitattributes @@ -62,3 +62,4 @@ #*.rtf diff=astextplain #*.RTF diff=astextplain libprisma/grammars.json eol=lf +libprisma/grammars.dat linguist-generated From d458c1d5f42585ff27b67f2765b1a28f475dee15 Mon Sep 17 00:00:00 2001 From: Danil Ovchinnikov Date: Thu, 14 May 2026 02:18:52 +0300 Subject: [PATCH 09/22] feat: use local prismjs package for grammar generation --- generate.js | 14 +++++--------- package-lock.json | 12 +++++++++++- package.json | 3 ++- 3 files changed, 18 insertions(+), 11 deletions(-) diff --git a/generate.js b/generate.js index aa8a878..e509ef4 100644 --- a/generate.js +++ b/generate.js @@ -1,5 +1,9 @@ const fs = require('fs') const isEqual = require('lodash.isequal') +const Prism = require('prismjs') +const components = require('prismjs/components.js') + +global.Prism = Prism const SCRIPTS = {} const include = function (src) { @@ -7,12 +11,6 @@ const include = function (src) { (1, eval)(src.toString()) } -async function loadScript(src) { - const script = await fetch(src) - const text = await script.text() - include(text) -} - async function loadLanguages(lngs) { if (lngs) { lngs = Array.isArray(lngs) ? lngs : [lngs]; @@ -39,7 +37,7 @@ async function loadLanguage(lng) { console.log(`${langNumber} | Loading ${lng}`); // TODO: version should probably not be hardcoded - await loadScript(`https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-${lng}.min.js`) + require(`prismjs/components/prism-${lng}.js`) } } @@ -215,8 +213,6 @@ async function generate() { "sparql" // requires turtle ] - await loadScript("https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js") - await loadScript("https://prismjs.com/components.js") await loadLanguages(Object.keys(components.languages)) console.log(`\nLoaded all ${langNumber} languages`) console.log("Processing...") diff --git a/package-lock.json b/package-lock.json index 1f9a3ba..c10dd45 100644 --- a/package-lock.json +++ b/package-lock.json @@ -9,13 +9,23 @@ "version": "1.0.0", "license": "MIT", "dependencies": { - "lodash.isequal": "^4.5.0" + "lodash.isequal": "^4.5.0", + "prismjs": "1.29.0" } }, "node_modules/lodash.isequal": { "version": "4.5.0", "resolved": "https://registry.npmjs.org/lodash.isequal/-/lodash.isequal-4.5.0.tgz", "integrity": "sha512-pDo3lu8Jhfjqls6GkMgpahsF9kCyayhgykjyLMNFTKWrpVdAQtYyB4muAMWozBB4ig/dtWAmsMxLEI8wuz+DYQ==" + }, + "node_modules/prismjs": { + "version": "1.29.0", + "resolved": "https://registry.npmjs.org/prismjs/-/prismjs-1.29.0.tgz", + "integrity": "sha512-Kx/1w86q/epKcmte75LNrEoT+lX8pBpavuAbvJWRXar7Hz8jrtF+e3vY751p0R8H9HdArwaCTNDDzHg/ScJK1Q==", + "license": "MIT", + "engines": { + "node": ">=6" + } } } } diff --git a/package.json b/package.json index 828a9ac..094cf10 100644 --- a/package.json +++ b/package.json @@ -17,6 +17,7 @@ }, "homepage": "https://github.com/TelegramMessenger/libprisma#readme", "dependencies": { - "lodash.isequal": "^4.5.0" + "lodash.isequal": "^4.5.0", + "prismjs": "1.29.0" } } From a4fe237d3e6052fa4de077908a9bd6f55d23200f Mon Sep 17 00:00:00 2001 From: Novus Nota <68142933+novusnota@users.noreply.github.com> Date: Wed, 18 Sep 2024 22:03:57 +0200 Subject: [PATCH 10/22] feat: update FunC from 0.2.0 to 0.4.4 and significantly enhance its capabilities --- components/prism-func.js | 203 +++++++++++++++++++++++++++------------ 1 file changed, 143 insertions(+), 60 deletions(-) diff --git a/components/prism-func.js b/components/prism-func.js index 056e0cc..ad6b0ad 100644 --- a/components/prism-func.js +++ b/components/prism-func.js @@ -1,60 +1,143 @@ -/** - * @file Prism.js definition for FunC - * @link https://docs.ton.org/develop/func/overview - * @version 0.2.0 - * @author Nikita Sobolev (https://github.com/sobolevn) - * @license MIT - */ -(function (Prism) { - // 1. Does not start from " - // 2. Can start from ` and end with `, containing any character - // 3. Starts with underscore or { or } and have more than 1 character after it - // 4. Starts with letter, contains letters, numbers and underscores - var identifier = /(?!")(`([^`]+)`|((?=_)_|(?=\{)\{|(?=\})\}|(?![_`{}]))([^;,\[\]\(\)\s~.]+))/; - var string = /"[^\n"]+"[Hhcusa]?/; - var number = /\b([\d_]+|0x[\d_a-fA-F]+|0b[1_0]+)\b/; - - Prism.languages.func = { - 'include': { - pattern: /#include(.*);/, - inside: { - 'keyword': /#include/, - 'string': string, - 'punctuation': /;/ - }, - }, - 'pragma': { - pattern: /#pragma(.*);/, - inside: { - 'keyword': /#pragma|not-version|version/, - 'number': /(\d+)(.\d+)?(.\d+)?/, - 'operator': [/>=/, /<=/, /=/, />/, /|>=|<=|!=|==|~>>=|~>>|\/%|\^%=|\^%|~%|\^\/=|\^\/|~\/=|~\/|\+=|-=|\*=|\/=|%=|<<=|>>=|\^>>=|\^>>|&=|>>|<<|\^=|\|=|\^|=|~|\/|%|-|\*|\+|>|<|&|\||:|\?)/, - 'punctuation': /[\.;\(\),\[\]~\{\}]/, - }; -}(Prism)); \ No newline at end of file +/** + * @file Prism.js definition for FunC + * @link https://docs.ton.org/develop/func/overview + * @version 0.4.4 + * @author Novus Nota (https://github.com/novusnota) + * @author Nikita Sobolev (https://github.com/sobolevn) + * @license MIT + */ +(function(Prism) { + /** @type {Prism.GrammarValue} */ + var number = /-?\b(?:\d+|0x[\da-fA-F]+)\b(?![^\.~,;\[\]\(\)\s])/; + + /** @type {Prism.GrammarValue} */ + var string = [ + { // multi-line + pattern: /"""[\s\S]*?"""[Hhcusa]?/, + greedy: true, + inside: { + // string type + 'symbol': { + pattern: /("""[\s\S]*?""")[Hhcusa]/, + lookbehind: true, + greedy: true, + } + }, + }, + { // single-line + pattern: /"[^\n"]*"[Hhcusa]?/, + greedy: true, + inside: { + // string type + 'symbol': { + pattern: /("[^\n"]*")[Hhcusa]/, + lookbehind: true, + greedy: true, + } + }, + }, + ]; + + /** @type {Prism.GrammarValue} */ + var operator = /(?:!=|\?|:|%=|%|&=|&|\*=|\*|\+=|\+|->|-=|-|\/%|\/=|\/|<=>|<<=|<<|<=|<|==|=|>>=|>>|>=|>|\^>>=|\^>>|\^=|\^\/=|\^\/|\^%=|\^%|\^|\|=|\||~>>=|~>>|~\/=|~\/|~%|~)(?=\s)/; + + /** @type {RegExp[]} */ + var var_identifier = [ + // quoted + /`[^`\n]+`/, + // plain + /[^\.~,;\[\]\(\)\s]+/ + ]; + + /** Prism.js definition for FunC */ + Prism.languages.func = { + 'comment': [ + { // single-line + pattern: /;;.*/, + lookbehind: true, + greedy: true, + }, + { // multi-line, not nested (TODO: nesting) + // . isn't used, because it only applies to the single line + pattern: /\{-[\s\S]*?(?:-\}|$)/, + lookbehind: true, + greedy: true, + }, + { + // unused variable identifier + pattern: /\b_\b(?![^\.~,;\[\]\(\)\s])/ + }, + ], + + // Custom token for #pragma's + 'pragma': { + pattern: /#pragma(.*);/, + inside: { + 'keyword': /(?:#pragma|test-version-set|not-version|version|allow-post-modification|compute-asm-ltr)\b/, + 'number': /(?:\d+)(?:.\d+)?(?:.\d+)?/, + 'operator': /=|\^|<=|>=|<|>/, + 'string': string, + 'punctuation': /;/, + } + }, + + // Custom token for #include's + 'include': { + pattern: /#include(.*);/, + inside: { + 'keyword': /#include\b/, + 'string': string, + 'punctuation': /;/, + } + }, + + // builtin types + 'builtin': /\b(?:int|cell|slice|builder|cont|tuple|type)\b/, + + // builtin constants + 'boolean': /\b(?:false|true|nil|Nil)\b/, + + 'keyword': /\b(?:forall|extern|global|asm|impure|inline_ref|inline|auto_apply|method_id|operator|infixl|infixr|infix|const|return|var|repeat|do|while|until|try|catch|ifnot|if|then|elseifnot|elseif|else)\b/, + + 'number': number, + + 'string': string, + + 'operator': operator, + + 'punctuation': [/[\.,;\(\)\[\]]/, /[\{\}](?![^\.~,;\[\]\(\)\s])/], + + // Function and method names in declarations, definitions and calls + 'function': [ + { // quoted + pattern: new RegExp(var_identifier[0].source + /(?=\s*\()/.source), + greedy: true, + }, + { // bitwise not operator + pattern: /~_/, + greedy: true, + }, + { // remaining operators + pattern: new RegExp(/\^?_/.source + operator.source + /_/.source), + greedy: true, + }, + { // plain function or method name + pattern: new RegExp(/[\.~]?/.source + var_identifier[1].source + /(?=\s*\()/.source), + greedy: true, + }, + { // builtin functions and methods + pattern: /\b(?:divmod|moddiv|muldiv|muldivr|muldivc|muldivmod|null\?|throw|throw_if|throw_unless|throw_arg|throw_arg_if|throw_arg_unless|load_int|load_uint|preload_int|preload_uint|store_int|store_uint|load_bits|preload_bits|int_at|cell_at|slice_at|tuple_at|at|touch|touch2|run_method0|run_method1|run_method2|run_method3|~divmod|~moddiv|~store_int|~store_uint|~touch|~touch2|~dump|~stdump)\b/, + greedy: true, + }, + ], + + // Parametric polymorphism + 'class-name': /[A-Z][^\.~,;\[\]\(\)\s]*/, + + // All the rest of identifiers + 'variable': var_identifier.map(x => { return { pattern: x, greedy: true } }), + }; + + // Adding a fc alias + Prism.languages.fc = Prism.languages.func; +}(Prism)); From fb9726c9f7f6322823242fde6c15f18ddd0c9908 Mon Sep 17 00:00:00 2001 From: Novus Nota <68142933+novusnota@users.noreply.github.com> Date: Wed, 18 Sep 2024 22:04:12 +0200 Subject: [PATCH 11/22] feat: update Tact from 1.2.0 to 1.5.0 --- components/prism-tact.js | 339 ++++++++++++++++++++------------------- 1 file changed, 171 insertions(+), 168 deletions(-) diff --git a/components/prism-tact.js b/components/prism-tact.js index 80f0832..2c806c0 100644 --- a/components/prism-tact.js +++ b/components/prism-tact.js @@ -1,168 +1,171 @@ -/** - * @file Prism.js definition for Tact - * @link https://tact-lang.org - * @version 1.2.0 - * @author Novus Nota (https://github.com/novusnota) - * @license MIT - */ -(function(Prism) { - Prism.languages.tact = { - // reserved keywords - 'keyword': [ - { - pattern: /\b(?:abstract|as|catch|const|contract(?!:)|do|else|extend|extends|foreach|fun|get|if|in|import|initOf|inline|let|message(?!:)|mutates|native|override|primitive|public|repeat|return|self|struct(?!:)|trait(?!:)|try|until|virtual|while|with)\b/, - }, - { // keyword after as - pattern: /(\bas\s+)\w+/, - lookbehind: true, - greedy: true, - }, - { // reserved function names - pattern: /\b(?:bounced|external|init|receive)\b/ - }, - ], - - // built-in types - 'builtin': { - pattern: /\b(?:Address|Bool|Builder|Cell|Int|Slice|String|StringBuilder)\b/, - }, - - // SCREAMING_SNAKE_CASE for null values and names of constants - 'constant': [ - { - pattern: /\bnull\b/, - }, - { - pattern: /\b[A-Z][A-Z0-9_]*\b/, - }, - ], - - // UpperCamelCase for names of contracts, traits, structs, messages - 'class-name': { - pattern: /\b[A-Z]\w*\b/, - }, - - // mappings to FunC - 'attribute': [ - { // functions - pattern: /@name/, - inside: { - 'function': /.+/, - }, - }, - { // contract interfaces - pattern: /@interface/, - inside: { - 'function': /.+/, - } - } - ], - - 'function': { - pattern: /\b\w+(?=\()/, - }, - - 'boolean': { - pattern: /\b(?:false|true)\b/, - }, - - 'number': [ - { // hexadecimal, case-insensitive /i - pattern: /\b0x[0-9a-f](?:_?[0-9a-f])*\b/i, - }, - { // octal, case-insensitive /i - pattern: /\b0o[0-7](?:_?[0-7])*\b/i, - }, - { // binary, case-insensitive /i - pattern: /\b0b[01](?:_?[01])*\b/i, - }, - { // decimal integers, starting with 0 - pattern: /\b0\d*\b/, - }, - { // other decimal integers - pattern: /\b[1-9](?:_?\d)*\b/, - }, - ], - - 'string': undefined, - - 'punctuation': { - pattern: /[{}[\]();,.:?]/, - }, - - 'comment': [ - { // single-line - pattern: /(^|[^\\:])\/\/.*/, - lookbehind: true, - greedy: true, - }, - { // multi-line - pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/, - lookbehind: true, - greedy: true, - } - ], - - 'operator': { - 'pattern': /![!=]?|[+\-*/%=]=?|[<>]=|<>?|\|\|?|&&?|\^/, - }, - - }; - - // strings, made this way to not collide with other entities - Prism.languages.insertBefore('tact', 'string', { - 'string-literal': { - pattern: /(?:(")(?:\\.|(?!\1)[^\\\r\n])*\1(?!\1))/, - greedy: true, - inside: { - 'regex': [ - { // \\ \" \n \r \t \v \b \f - pattern: /\\[\\"nrtvbf]/, - }, - { // hexEscape, \x00 through \xFF - pattern: /\\x[0-9a-fA-F]{2}/, - }, - { // unicodeEscape, \u0000 through \uFFFF - pattern: /\\u[0-9a-fA-F]{4}/, - }, - { // unicodeCodePoint, \u{0} through \u{FFFFFF} - pattern: /\\u\{[0-9a-fA-F]{1,6}\}/, - }, - ], - 'string': { - pattern: /[\s\S]+/, - }, - }, - }, - }); - - // map and bounced message generic type modifiers - Prism.languages.insertBefore('tact', 'keyword', { - 'generics': { - pattern: /(?:\b(?:bounced|map)\b<[^\\\r\n]*>)/, - greedy: true, - inside: { - 'builtin': [ - Prism.languages['tact']['builtin'], - { - pattern: /\b(?:bounced(?=<)|map(?=<))\b/ - }, - ], - 'class-name': Prism.languages['tact']['class-name'], - 'punctuation': { - pattern: /[<>(),.?]/, - }, - 'keyword': [ - { - pattern: /\bas\b/, - }, - { - pattern: /(\bas\s+)\w+/, - lookbehind: true, - greedy: true, - }, - ], - }, - }, - }); -}(Prism)); \ No newline at end of file +/** + * @file Prism.js definition for Tact + * @link https://tact-lang.org + * @version 1.5.0 + * @author Novus Nota (https://github.com/novusnota) + * @license MIT + */ +(function(Prism) { + Prism.languages.tact = { + // reserved keywords + 'keyword': [ + { + pattern: /\b(?:abstract|asm|as|catch|const|contract(?!:)|do|else|extend|extends|foreach|fun|get|if|in|import|initOf|inline|let|message(?!:)|mutates|native|override|primitive|public|repeat|return|self|struct(?!:)|trait(?!:)|try|until|virtual|while|with)\b/, + }, + { // reserved function names + pattern: /\b(?:bounced|external|init|receive)\b(?=\()/ + }, + ], + + // built-in types + 'builtin': [ + { + pattern: /\b(?:Address|Bool|Builder|Cell|Int|Slice|String|StringBuilder)\b/, + }, + { // keyword after as, see: https://prismjs.com/extending.html#object-notation + pattern: /(\bas\s+)(?:coins|remaining|bytes32|bytes64|int257|u?int(?:2[0-5][0-6]|1[0-9][0-9]|[1-9][0-9]?))\b/, + lookbehind: true, + greedy: true, + }, + ], + + // SCREAMING_SNAKE_CASE for null values and names of constants + 'constant': [ + { + pattern: /\bnull\b/, + }, + { + pattern: /\b[A-Z][A-Z0-9_]*\b/, + }, + ], + + // UpperCamelCase for names of contracts, traits, structs, messages + 'class-name': { + pattern: /\b[A-Z]\w*\b/, + }, + + // mappings to FunC + 'attribute': [ + { // functions + pattern: /@name/, + inside: { + 'function': /.+/, + }, + }, + { // contract interfaces + pattern: /@interface/, + inside: { + 'function': /.+/, + } + } + ], + + 'function': { + pattern: /\b\w+(?=\()/, + }, + + 'boolean': { + pattern: /\b(?:false|true)\b/, + }, + + 'number': [ + { // hexadecimal, case-insensitive /i + pattern: /\b0x[0-9a-f](?:_?[0-9a-f])*\b/i, + }, + { // octal, case-insensitive /i + pattern: /\b0o[0-7](?:_?[0-7])*\b/i, + }, + { // binary, case-insensitive /i + pattern: /\b0b[01](?:_?[01])*\b/i, + }, + { // decimal integers, starting with 0 + pattern: /\b0\d*\b/, + }, + { // other decimal integers + pattern: /\b[1-9](?:_?\d)*\b/, + }, + ], + + 'string': undefined, + + 'punctuation': { + pattern: /[{}[\]();,.:?]/, + }, + + 'comment': [ + { // single-line + pattern: /(^|[^\\:])\/\/.*/, + lookbehind: true, + greedy: true, + }, + { // multi-line + pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/, + lookbehind: true, + greedy: true, + }, + { + // unused variable identifier + pattern: /\b_\b/ + } + ], + + 'operator': { + 'pattern': /![!=]?|->|[+\-*/%=]=?|[<>]=|<>?|~|\|[\|=]?|&[&=]?|\^=?/, + }, + + 'variable': { + 'pattern': /\b[a-zA-Z_]\w*\b/, + }, + + }; + + // strings, made this way to not collide with other entities + Prism.languages.insertBefore('tact', 'string', { + 'string-literal': { + pattern: /(?:(")(?:\\.|(?!\1)[^\\\r\n])*\1(?!\1))/, + greedy: true, + inside: { + 'regex': [ + { // \\ \" \n \r \t \v \b \f + pattern: /\\[\\"nrtvbf]/, + }, + { // hexEscape, \x00 through \xFF + pattern: /\\x[0-9a-fA-F]{2}/, + }, + { // unicodeEscape, \u0000 through \uFFFF + pattern: /\\u[0-9a-fA-F]{4}/, + }, + { // unicodeCodePoint, \u{0} through \u{FFFFFF} + pattern: /\\u\{[0-9a-fA-F]{1,6}\}/, + }, + ], + 'string': { + pattern: /[\s\S]+/, + }, + }, + }, + }); + + // map and bounced message generic type modifiers + Prism.languages.insertBefore('tact', 'keyword', { + 'generics': { + pattern: /(?:\b(?:bounced|map)\b<[^\\\r\n]*>)/, + greedy: true, + inside: { + 'builtin': [ + ...Prism.languages['tact']['builtin'], + { + pattern: /\b(?:bounced(?=<)|map(?=<))\b/ + }, + ], + 'class-name': Prism.languages['tact']['class-name'], + 'punctuation': { + pattern: /[<>(),.?]/, + }, + 'keyword': { + pattern: /\bas\b/, + }, + }, + }, + }); +}(Prism)); From 2236ba10f833ffb131e0debd1624047fe2e9f75f Mon Sep 17 00:00:00 2001 From: Novus Nota <68142933+novusnota@users.noreply.github.com> Date: Wed, 5 Mar 2025 10:06:32 +0100 Subject: [PATCH 12/22] feat: update Tact to 1.6.0 --- components/prism-tact.js | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/components/prism-tact.js b/components/prism-tact.js index 2c806c0..ab21fcf 100644 --- a/components/prism-tact.js +++ b/components/prism-tact.js @@ -1,7 +1,7 @@ /** * @file Prism.js definition for Tact * @link https://tact-lang.org - * @version 1.5.0 + * @version 1.6.0 * @author Novus Nota (https://github.com/novusnota) * @license MIT */ @@ -10,7 +10,7 @@ // reserved keywords 'keyword': [ { - pattern: /\b(?:abstract|asm|as|catch|const|contract(?!:)|do|else|extend|extends|foreach|fun|get|if|in|import|initOf|inline|let|message(?!:)|mutates|native|override|primitive|public|repeat|return|self|struct(?!:)|trait(?!:)|try|until|virtual|while|with)\b/, + pattern: /\b(?:abstract|asm|as|catch|codeOf|const|contract(?!:)|do|else|extend|extends|foreach|fun|get|if|in|import|initOf|inline|let|message(?!:)|mutates|native|override|primitive|public|repeat|return|self|struct(?!:)|trait(?!:)|try|until|virtual|while|with)\b/, }, { // reserved function names pattern: /\b(?:bounced|external|init|receive)\b(?=\()/ @@ -23,7 +23,7 @@ pattern: /\b(?:Address|Bool|Builder|Cell|Int|Slice|String|StringBuilder)\b/, }, { // keyword after as, see: https://prismjs.com/extending.html#object-notation - pattern: /(\bas\s+)(?:coins|remaining|bytes32|bytes64|int257|u?int(?:2[0-5][0-6]|1[0-9][0-9]|[1-9][0-9]?))\b/, + pattern: /(\bas\s+)(?:coins|varu?int(?:32|16)|remaining|bytes(?:32|64)|int257|u?int(?:25[0-6]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]?))\b/, lookbehind: true, greedy: true, }, @@ -110,7 +110,7 @@ ], 'operator': { - 'pattern': /![!=]?|->|[+\-*/%=]=?|[<>]=|<>?|~|\|[\|=]?|&[&=]?|\^=?/, + 'pattern': /![!=]?|->|[+\-*/%=]=?|[<>]=|<>?=?|~|\|\|=|\|[\|=]?|&&=|&[&=]?|\^=?/, }, 'variable': { From 58c31b687234ba91b511fd0ca9887b74199d2f15 Mon Sep 17 00:00:00 2001 From: Fela Date: Mon, 21 Sep 2026 10:33:35 +0400 Subject: [PATCH 13/22] Fix the FunC operator function pattern --- components/prism-func.js | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/components/prism-func.js b/components/prism-func.js index ad6b0ad..4dd2dc8 100644 --- a/components/prism-func.js +++ b/components/prism-func.js @@ -38,8 +38,12 @@ }, ]; + /** @type {RegExp} */ + var operator_body = /(?:!=|\?|:|%=|%|&=|&|\*=|\*|\+=|\+|->|-=|-|\/%|\/=|\/|<=>|<<=|<<|<=|<|==|=|>>=|>>|>=|>|\^>>=|\^>>|\^=|\^\/=|\^\/|\^%=|\^%|\^|\|=|\||~>>=|~>>|~\/=|~\/|~%|~)/; + + // An operator only counts as one when whitespace follows it, as identifiers may contain these characters. /** @type {Prism.GrammarValue} */ - var operator = /(?:!=|\?|:|%=|%|&=|&|\*=|\*|\+=|\+|->|-=|-|\/%|\/=|\/|<=>|<<=|<<|<=|<|==|=|>>=|>>|>=|>|\^>>=|\^>>|\^=|\^\/=|\^\/|\^%=|\^%|\^|\|=|\||~>>=|~>>|~\/=|~\/|~%|~)(?=\s)/; + var operator = new RegExp(operator_body.source + /(?=\s)/.source); /** @type {RegExp[]} */ var var_identifier = [ @@ -118,7 +122,8 @@ greedy: true, }, { // remaining operators - pattern: new RegExp(/\^?_/.source + operator.source + /_/.source), + // operator_body, not operator: its trailing lookahead would forbid the closing _ + pattern: new RegExp(/\^?_/.source + operator_body.source + /_/.source), greedy: true, }, { // plain function or method name From 79d5518b8dbd24f53d3aa9ba66a6fa667537c075 Mon Sep 17 00:00:00 2001 From: Fela Date: Mon, 21 Sep 2026 10:33:56 +0400 Subject: [PATCH 14/22] Register fc as a FunC alias --- generate.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/generate.js b/generate.js index e509ef4..9eb786a 100644 --- a/generate.js +++ b/generate.js @@ -221,7 +221,7 @@ async function generate() { loadLocalLanguage('./components/prism-tl.js', 'typelanguage', 'TypeLanguage', 'tl') loadLocalLanguage('./components/prism-tlb.js', 'tlb', 'TypeLanguage-Binary', 'tlb') loadLocalLanguage('./components/prism-fift.js', 'fift', 'Fift', 'fift') - loadLocalLanguage('./components/prism-func.js', 'func', 'FunC', 'func') + loadLocalLanguage('./components/prism-func.js', 'func', 'FunC', ['func', 'fc']) loadLocalLanguage('./components/prism-tact.js', 'tact', 'Tact', 'tact') loadLocalLanguage('./components/prism-tolk.js', 'tolk', 'Tolk', 'tolk') From a0f55d9ec7d43a98a006cff38bcb3301b5418d85 Mon Sep 17 00:00:00 2001 From: FrayxRulez <8152849+FrayxRulez@users.noreply.github.com> Date: Mon, 21 Sep 2026 06:47:54 +0000 Subject: [PATCH 15/22] Update grammars --- libprisma/grammars.dat | Bin 621241 -> 629963 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/libprisma/grammars.dat b/libprisma/grammars.dat index 532ed27b68cccc28bc87ea41a7fceb060d3693db..f86242559477b533ede2728e1cee47fc449d7305 100644 GIT binary patch delta 81919 zcmeFa2YegF@&K&8erHK`dO{$i6DL-bLP7|MorKUkB(&HuvL)L}WXX}_BnBl%?*u{s z(R+QA2QPr>y?1!@-g_^3^!Lr~-ffX>NPzc$|L^<$KZtd=cegt`J3BiwJ2QLpccUJ? zd9+$6A6D%3mO1pg5pV3i*4iV|il(laddH`uYV&pDDr*)Ls_QBj427GqV``?4fq%8x zn%Z=sHcLv^%)N6ADz0h0bC6P-Uvt!*Z{nYpyKaP^wVU3J5W0QMuzSA1g}v?_fq$ml zJ3@uZimSg>`>bibcWYdB-Mv+4n*ZJt_YI_F!`4(kP>wdoWNnjbpM*`o*BI6i05{|op|!O!SJ*8ljl~hDz?SZ?VXz^Q0@eCd~^(kyLk22XpC9u z-MsQO8evZMZnSSu#GK{bZ1D}6ZXUtE8BkpH4Qeqbc_lx8gR1;mI>&#Do-0Rt7Bx)) z^iC*NYs!E=ad@*fTbn*;OjR94SYVwIM*6(66dw3n7|g>+x1hs*3nj+HbohL&giy|CB@gLDE9hR zw96KX)4w)fTZ=n1opf64S=)%&dqtBeAiOovF$;IwbH096z~^)zELJ3bRxbVUTpqW*|(byCQqB( zP<-}VWfu&|UEeBI#a+KsruOYx^TdW?@jGRgZmO6zZA!fO!*|MVxXm5bDKC%j96L&_ z*r;<(jjB%U+@nn$V0WfF)ZrJRVa1;ZYXdvK9<1$F*}2^|+Wo^j2eoKz8(X^q(xA)v z;z@^Vql)!MYeS3A9M zmWPkj2Jrf;j`ZtqJ5qfAlq3E3Uq4dYNZS+YDGqx^8CtyhXsxQa?NQpm-ad>&>&8}A zPS3@1x#D?8YtxIDAEj-?0e$!=3h1!TilepusI%%A?VO<%mrV#nF$Y~(*orXE&KIxH zj-Tl4GZ2aiF?F`SqOIB$3s)p=P^2)qK zEMQG66(%NFV#llPXE;24fooy+jpcTJv zGqyHgi7v$8c5b!AC?e|w7<~f$OIhQ6>saBg&^ae>+~2PlI@Z|FszHJ1LKxKITgMn9 zEV!7yU?FhG(~mVa#+>qoV~wg{ZGN-iGe*{tWu^0zV~y!R5yu-XYUf!e8gsAi{Bnl* zm4dD)zFlJuAB2~r${MJrwxM>}xY`D|q8Kg4R;wEor_3^k;VHJyEb~a+de~zao$qdA z?%dZbVjyAuOx@pHZ4&t5&BymQPw3ydbcxwEuyfrpW@Alf{ln(>13MSKZB~?Z=07uE z>)W}nVr}6RPnvD)+WAq?dU0^)Lu0I0`xbAVXcgn;`g=9KEaVq{hnOslZ9A8f> zwBzzA^k*vhf#SX$}Ir*7ZS=%rnT2(ckgRpHZl}i8|nbf>&d!j&Zcg2zczK8dt z#Z`l~olsS=I%W

!@nXw6-SF`KnEdCskYhT>rKrI%2_u$d<84Q{CA58fYUFtsS{w z!bI<`A8m2Oh{A{&@c&F)aaC1CbU`d~;Oxl$^>ww&#zKJ+9X6Bv%%nfHxF$Wil9bgh zgda0n8y^S1eWMGusvT2XTRFXUL2X^_LA5LDpmb1l!Sa3K&I4t3WZU|>v9&AUNw4UF zhB@R3fJ92H=w`Kh;i?8ihmTpXa5!FnVKpk$){d_nI~>Y4E?#%FI>3$MMJO1ph5yEn zB{xQNL^V8zpB(%EL?cJQuO7vJEx4=2wc_F`zaZ`v;9fyhBSGe>9a9N6WpGoSYi*2q zZ&u?PZ77^YDuKr?T-J~qT8uG*>z?Jk*x1_UU8NFf@2V|>tHC3XO)O1ha|yV!qN66x zm_c6{vso=}yjQe#OeCL;B~!p&NQna_wd2VpfH@|X&$PPa4geX`;5{jaYZ&&nWGX?P zh4Fnh5zEtCXm(6I(F8!_HgGlZ_SQCXgTG8HPc*iBui`J8GTG)to>i1?Z*53q$t`Yk zd96#qA&?zJ%E{#latXDMt&KLeW-x*QKllc&;7hoorSz4o_(~RDfpLOYysxUO@mKi! z>T3UCH6CIpa>vq74R{JAfckO6;1_Q3DCmq*Wbr3(qJuspZ zFcfBV!VFAv_?MFG1WW?()GMvVzi^8mTG5HLZzjGVUrme*bIA)6anGRKqagV8N+x+& znMA%YqLb*0lL-7~bkfY}lW)sX7@6!9;g3=^@5kL06 z#%1JVDD$Sh3*!RUcs$5O4O|#dLhtG9hqqf|xt2M!GJM$%mjEEXq%TtD05vSH9SHe@i~??O`&QH&GY4N# zZcNJPV31J^Muncjdjx#=*1N>hqKuZ#!q;9gB^0cQ{3^A@Eomo~OhO|t!Kn9z<)s}2rTv*Z$y@k<= zCDR~Z!4(n33WSa@8PP70zob9(3OYkBNKbMNNtcoZTmeFI2{MK`Ky{9EkRUn-)kC*( zi<51+w#GuPE!GHkgfbz9pHB7xKwg7`}Wq2~)C=ZwDaB>@4K5!qHA}-kv5D z(w-(AX-~Ue?La5cb@)p^h6_Be3rjuCv#_iM_-O$vkK|9TusoBcQvQJGm~lMocy(8)Nw-OlT|| zgNPf6yDY@o^KPa-*4CElD6}T> zEtz^yrQMi<$r4);VE76XmM^G{gSrbkCQ$Eh5Z0zqJdAu4{XwjW zf?m1hq$wLk*)WzontBP)j5~c8kVZ{mdSTSe!l=UNnT64X+ObeH7S=KN8CQr@7a}tY zkwR^B6#RptD9}-LVFnP>j2W1uW)x=5EC6KzX;oKa0;>jE!*}>E{J|IGL--4q&<^~8 ze}!83%B?LFR^pf8Phll~4gM5Xj-opUwK+U@dc&+74>JnSCJ-L+q#O!GSSjyuz72>T zuwdZaNk$f)pX@5V9pl$_3L3^ z-6GTzPc8*^QGkDNRcLKb@t>@B+vxqmJ1$vXfB^C>Sy*ex-+EZV=tX-PjDEn;@w56^ zwwYh?cc8f5doPuV!3=^4OfJZp+?GwSQvaGf$iWOt)F)kdn_iMq@-A76{FliM)L9Rc z3^NS;OIQZJAd3XPz}J~}m~Q0nB)rDe(-}QMxSl9nd+)&d57T~fVWo$*l^)(!dhh{w z-X(!=C2fWNOoFdK<;E}IUp$L}vNnz`0FzT)*8#)&eVCIaes^Hh?fTw0{A3s%%mxsk z8WV9C>KTMp)U`FD7jX#8MWuhb$gP|u^ zNW)UMG(kk3Y!XB$&_O`B!$qKoz=BbH^Fpm3$S&y zHc*PXsDxZ^#enxPbimLX6VMR6i6o&586=SD1)}An$s?ME|m;5(D7b85@WWh?Thk z&?`!+K(Fu}wq@e-3cnnTrlcSkot2KYV*A3DlP4O{@mNyo6`hqFoQ9RQ38X>#1T=bV z2&Y&pUNF#>rUe70q zkv#&#Tf>CfIEAo3+>ri~*J|VB`>Lu|FhRnKQ9C@H%`a_e!t(?y#kD>_cx^ps(h9G% z-GhvjZjMU_!@KRGwYTn|iB(fq5c4jU8u30J#zhoQxG}?v!@gDrZwho=JF(K6Uz1?z zI%ox~Sz{``&UcET<+{J2q2Z$LVDh444;TeWroImLNB}fUUSv$gg4#HUJ3xTN`Af`UgltMEvmW0IL~2Ke zB`Ldm9O?s5fMZd{l}iAh0hKnkmdYq*XgiSR0{ z%VRbcOLx?>>ufgG0cL?r<6_Y10c8!C$1$NCZy`~Jg|Pr%DmI)WM2B2||!O@w3$%kMJsBj`MqYDdHV$KDu1ccz}m_&RjxSUE8Ku0bR z61;Pns+R*!K>vxQBDwYkP%Tj)U{Fk>WT>nS#0gjuu^x#Qh05ZYMogoTe5@HQ4r!Rn zqg2Q;y=^zt6f)Ytppa=s%^}l!8KHol%Xg#_=P6 zv2-)Kv3S62Yt*>sLhAC?6dJ^EB>|_r5PC7BXA{kd<>;kiuVq%>P};FzDiDhtdb{}a zY^&cu5!Q_3!}?jM`0H$Ikh(6U7Wdf4?vK_MC(f}p8eCsq@m~fhv@YcMAfQ`|W4E@3 z54bbPMqyJv3U?P9x3=b@RmID1a{io4AAZw5E|itXM=23-5vCSofqK1&X*zDn?r>5 zVHn*v;D5Sbzy|UM`z7A5NBalLa~(OjiLm*)Ai$?cZGZz(7pQ2>q+?)#jIdd}5Js^> zE~hDFJc@CqT@!X%V~yDi;j2o6)o9slhM>3=W;YSc z1yRD1CSa50fV~_G2zZTH9$;Jw)r9?~bW%Th9T~YwvWTO#K}L~)%0*TMSyljLU;>Y{ zfC&@5QQUPWtN)-kQD2{L;?ZZ1-zvV4mlD;QOyqlCG={)00{3C1&^zXSLnRHV@@3LmVK8I`+awO`K|eK*m{gEOrr{4CX&X}J+de4b2{VGVEr(?A&AC| z4p_in$65~EFjRrD2ebtw&V&kYQt>5c192qstfK?JO`EPDIZL$JJt3?L^zM0{yX!#+ zrPI7Omz8C@IFZxENy4mLEvz?xo-RzR3WDN?)&z9cugeXXDJ~h7Q#cT(G6~_VGHK2v zZ9$SdO;}zhDgKNr2IvxVdLZoWf<=A?!|G*$kS{{f75wtR6;PDP zM&SQk0xQtyZ-Fu@8%0uXqA8EA4A^*m1dBIx@G5_?(Ekxw8@N7jL*T}M)U8f|G;ZSq zcRQfi8|6DVw(ksdf&4B3gLeb|MWyl{hNF7}Dnk79{i^fDq~8-C+J;`u@ne<_wnvl zxeE%o4Of*zMa zc_JXIYEK4&OAyKvUbZDfE3n18x;Z-v*3iJ_Z{C=(|9W0FVQ> zjy5pI{42n<g(oX|t)X^@cw=+L;6jitF`I}*2;QXtHAO^DEHS;FxQr7OoHJH zs4=VTgD%t@d=&u$Y&)0^WaC#^*d`B&?I{%Q$JlREs5ekGBWjO~o(?#Ko|d#{@(J`z zKqr)mUJ7X7q8?8uF9%+SvSdD$P~Hr@9Z*`b=$(Lut)S@LKnN%!0=CaY7WAD2`mh@s z=^1+-S#@KF`;pk;Tu>JF0!54(;?C1#JKRq`za(}z#R5mKL_D5|qkl6z*Mlg_iV@UA z1udyq?Y>xtVoxrUUN^gc-4=@bGlWl4Y^=e;wj%I=pBY2?g#mcD|Bd~8V&lB87s; zOeF!JSPF%ZhP5FSMmpA7vZx%{pdW+z0$41na8ZS~YH~5O7t(X>&A_O8%gp86GQ$&R z`XHv=^hNSZgG=s*Ab|r7MSQvrBj35q@;SWZ!;vNTqme--M6v6v7jM z6k;MpBaqL!Mu8xM8OdfcfMbv@FmgAIHbI_2U^aY8oNUk>R0fVQDcBn%)|;)FBs3S9 z2AM>0v@rt74R8#|%mYPMGU^yB$cd|D8FHM^{~N=&JFY*$s{l{F;DiRrAa8`ko=1?p zkPYPU%MZpQ6BgW5raiCJpjoIw=yn=K5n%#q0!=L5y}#ARor1#PUZUoHkgcB4qyx&4f4NU@L>2ZxC&(k%JjZgi`2K4m3sj z#);p+da>6+tFOC_G;(P)p|ppylLgVHW`&cj8Y=&-EK}WIqG*XNf~YN%l)BCe-??-0B;Bx_rfAbq&RS) z720DP)UQkTy%l0&H+Wc2G)$gSGT^^SUIJ1UZ8%c?C>ngaQn7*pVxZ4gH+H1CvZ*5) z6|JBWqBB2}q6Y14+1#%$FRg0G?^XpOC~y(KuI+@nvGJ8lG_>WXht4B1Cecv(}&MpUegY+{*e7Emk1GK$A&IOFsMhZ;hQ*rU z%yg=q8fTU>+i9BPZ0#_+?OcZ~ZQ_pDyz){*H`-RP)o$mM<9g!}uE%aKBXo!2>ag8s z`c7)4=wv%?**Gms_QJqu^Dp7=tFp)pl9ucZX-Ktk8Y)XXi+v-&i%vEiK z6%sS@j$AJ4*27?Dke`W%!CoK$!H1r5GY{rr_iD~UU%n)2PH7hoKpcrKiXlE9Z?pLm z)WoLwN2Zy<;KmcE0XZ#+={lId8s!!KBb!f{YKTS4peURjK|sWC32I*o#+ zAJL4s(erkjZ*(ODPyrw(3nIB^w`@iXs1^yRHFzp<7EKEN81!2DQhS^sPT+`N z#X&hyXy+uNsE)x_e6FdkMs)dajDe-%WC1U0sAP8v!^5cp)tturgS%7Y$VVSC=aAE3 z?sAufGf*F2Ig1FM6=x#R&*Cgm#6V{w)Acud&k;alyBW&4=sW?c8|5v!^N}OC`S7KF z7K88tS9z&0#K3tgr3Es1%J%#WlM2u)8Pjl`B%Ysid&j44(>KP8ULjM%H zHeB;2jEfEk@v;0$7OdBWIL{aT3ZE6Zi1HkIp7X;OL^v!^fnr2Jeo<&!@-lRpgVIYf z;=q@L?Fzgs69ak`^@e_>aKHl0o>x$~A(_jhfg(I7w%54y)5QY>yVOuqB=M*j;=2O; zuXU+0Q6qXs>=1{a(u<3orrza4@U-PK!}nyAzK{MRULO7wmi?MOL_wVl3;I9=zQn=l zBY8B0!C*8jdnt9ZT)5~rU6N!Re1)NbA?!SslMc(%`xFZ)Ag>3lTKfS0$ie?&94b#clvUyT%smL!t<7M=IW( zB8E$}SXV=dY!)mgUPuzsp$gx(6d4jDHI*RuBGrm3mstH>OJOV$+03WGQA8_K8TSAM zcUj-f`R*X6oRH#Akgxz}xonxPP`CiuOQ9C~17NqYx5A<7!$5eR%dmX~ca?qsfG3If z7wQ|pK^!PRFi0uxG0Pq>W?e`U>^4$37apt#-rdAcdcnrLvQ2n@Wy6r)U%{U$m>E_X^%-{I=kU(iw3SV3z9F+0G z&_zYCeEdz2o0=%l0@pUf4rOwaUFbelzBcD=OyTwJ&lvSoq2Voru1%BM+ftG5e-XN| zI*3Y4zSCWWc|4;^CM$0xd^AItPcu1;)f~neMX-#{51*7&&v2T z+uD_(ovX0dwwIrL5cG#EkG5env#p}1AhsoiwiAg5?ZDyOk;AzYt9xe#WL*}rIPNMp zwVT4((VnIBysv^enlD$xP2U)@mr{z`eU<*jw=T2#Oy6B8Biq*4iU6?-dx*7*%2Bzu zVlXe~=ZbePwffGOr&N&bQL@)T-%;i(d;3UG_EGi|d*3xq!c99|QPK8S7AUn!oxp3} z77VHjIqK>;>O@u{Mpab!8%Yf2&$|&7{ndY6C`fJft$3?Diw;mqvD>J4${_4ymyl|s z-(Li~6CyJ|j*)Fb9>*r1DZ8;*;+V8k|IX@ z3BO2g6@*eIuP#=I_U(ER11Z=Y=Z-xGheen0R_I=13oM!_t!R)jCV?`F4!_{4(57g_ zM|=tVVkhn_14zj!dAaq;<%lnTOJR*&(jH608V%y#f%2PIg;ZF*GK-hRvI(?Ysqn9v zYj=kd#vkKvBh9dZ*oF>L3?tTxv&kS=(b_>OLI*45Fu|9?f)2a>uuTi2dWbTF6+w~~ z2!kq~-(giuJX8tePr!Q)Git1D9M%OQ2P(q5`dD;WQGBZdk`Jy_g0xK!h{F|4QmL;B zQAmzrb2^KTR;+kCv_Z@~iVC}Okl+R#sf7JfudZX25P8J~a{3_% zW_!k|Pp8`_bQkRmMFWdo4xK3s(%Ir5ox>i0fN;L}r0eiqBMhJ4Z8ShMAf?eoiUa;dcPTqd?!!YZ$!D@^yKa1AE~jW5Jc>r9ziD-E=JoZOS)<$ai}UKDY9 zmSV$hXe>=4R?bzZd~;qG61zaTP`N}VF-l=qC|61idlcp__c^w5wet5rMq56p^pGEib4&DcsoWHd5IyZf<-$7gj11PUCX-o}e=5&`A5&Bp|v(Z_XJwJN2PHx+JXdrPrA?}HqA zTf~#{j`A+U4rvc-#^BkwUJ<|_$k43|g@|L@hl2L-5$pBGirorJGS$;QQ8cjsCD5l# zE+&RfPY`rJV=$r5g`xR^5%5acL*Ywdn7$H+m`|jy6$e`!Bj7{@j&v)a-Vi0^UH2H&!haVMb*8eO&{iTc2@T=lC4DEt1UB>nDV4+PM zu8)EQ%vrZ8Y=}YNuD1iKseH5LC)TZhgT6#uD|Zi);R&cJgjyg)r4pvDvQ@xPDHCxa z+{A=yFT!?W$Zx@2LZbjC>^D2w zua8#uK~Upr!e)M7l=12q0Z0|E{4P&baAVkj&2KDJ=TIeUOB<_>Q>)Yn^Q=M>{rb>& zp+`}vW<`n@njn6RjMi9oF{m4pRZ#g|&n`Ggb(*uWwiasV+*}pC%BQG;Ys^#z8QMa{ z4uRMM5)$}ug%R(@_ePU74 z=nj6y<Q+#T1#Bq7B28@i8IHC#Z-8uq-na2b{VNlg=x3U2LLTsefbM@@J0_52J;}^mQqkx$d#^CMa|7sxwBoWJ%$dJ zo*shdaYF|>RAs^?+8ySTH~)XM%c;XW+crUmsbyXfA<4rz1qr*WNBCG#k5rFRj}{<5 zM&OOd@?NONsmH4)cx1jxEpx@Vz7tEB#3`yE1fDE+eptBF3};Xfy_5m~L;Jci~p@Dld&!cewc z1V)D!Qgjy360Y`azx(JMj-Dq3SB7(CpwCm~`wLYmJvB)b_-!0drez{k2ioA+ z>a~2B(RC`g2jdj7WI=`;LvWW+_1zFC}o!)KA}FTmH~>es~;E(bLc5Gycmp$kbJ_|Zl6|rDw~-yeX&+@2EkrC}U2Zj>jOy)4QVTaATOQ z3h&8Pybsfj@$e7iXRE?oY$0BChlRPG#Z3m!hbZs)5Y}yy>l1y%Y4>AJH{H%2Dbv&^ za{KE-eFph{FGXjK)w{9hBvYYsSim403bHnPME;rDbTX8Aa8X zvs4JwkBBGV`u`SQ1ce1yCzFl8RjrV>TzkCn8-|JRFV>QCy= zd@z(>)L$i%RMEfH)7DrUyPOb_>N}Junr3Kho|zic{pOc<4Pdkc`|SD5GImxOU%hR4 zE5y+R$&@-~=o(iK{>PvI9U+-@X*Mu~WEd5!*3fN{pe9>G?!~gG|41!s%BP64I&mY> zLim<1>}6UnT;NZAs?~-xCe131?)oIT3yUMbmsz%OBT-hWkb43fePm(5#^YW*MFr}u zDQa`9%|(6W_xoxHmJ^=15e?KFETVy!)Q{?VxToAPwm&D70o{YiyA#=aO4@P)I2|d zu^M}OoW}P0j4Canjn|^u1dZc=A_skv?+S@7lXpW-3W_ekQ#Ed+Io{Px&lZIyYupcF zbB6ILbkOlG%@z_taBVe$imA$6RzUnLnbA34%N@fL1t>d%#K+h3r zt}930S|H)98|1V)mjSwspj>S$lj?RF_c7jH6L(3jH!H9#jtxA(@?d`*tcg2l%;vMB z(CkjEC3k0`sa@ozcGXyi$!bq6LAx=8?9RKq2k-KpLOYBFs(WekwE03)dwWeS^xU#> z9wtxL-bdrCrMcYnvIn7kHK#e_pR9rQ<8ALRR6E^}Y{=&pubT*gf+rf{7%%8D#oAo2`N8%z-G z?9(0zV%dL^ASC)aP2W!2&CELv_hlN&Xe*CIS6W)k%vWKuk7s1c%Fjh30T!kv~Ec+>#)OmaVl%Y9_?p5&d&D@ht~KJkLVQ7`Q}u% zEp*y%#o)pQ5O^B_Asq`tjq_6A^O}Iy9Vc-2&C7(2Z(cTln%9r=BqZ$0)xwg$Do1O_ zFkBo@adCpiV}@6WxbW!?ohY>?b-lE^U3v=%=)mhq>~1;D73rN01f4la?%Qh3=BCq= z#R*IEK-CENUL$aoE& z6BM;SVJ47#FHhIb(9YD(61eT#Ozu|xu(g0s*e=02G~IPq!@y|_Z}sIqZ^{3@Vc`G8 zm{8nqcc{+xb2W+a`CfSbIa;@$oU8dBKj%v;*6&2=yBBEP2Zy8Zh9t?-RGe1eVjv-s z_97WamuMOmCD5f3H0Ux-wSYI#NDtMtbqbuZh{-%Lvi2u%2^0TWo4feCa8TLAj zzw-~uWN(yTT?=N7T&6t>&Z^f7FW(@&?D{G1J2mF%fo_s3`XI>7iCD7uAZYl>jP8YA zCew@2gPIPJ-mro_1k5s%$wORB0zIsmIN5T#qZK`(X;_{@k7_neoOH8BQz^NP=oU?D zgm^G?EBxYp;M)Yn>~@XmYjX&>JKG60O&@=%4IyBHMtT18W+6EbQIC zp!xm5$B&_xG@ODIR$oXo>8UHP&^KHtBYUT>u`hDC(KocP_XTDncnk6^&G(ggNAtZr z-i3Kb55Pe0(dgYzz1jJhR$|TmQpU+wFcNrolra`@ucN-48$Q1VeTX>%f5TS3ZELpSM)Er;qL_j@&`?EnF-`)`Mu#h;tBl-ox&;N57Yhqg~Pea z?N3_QUG`r9CQq&Yl>vGb-|tnA*1s{1(P4Xiw7(yCtj;YG$BF6T(g-{hiQLmFE7bq) zqCW)~eBfjT35_5e!aLAG(ZSIZ-+G)LPC23X9JiVt_W1^pC1{8jVpVqdNd$FW@N-lQ zeW~MbuF}0#Q|AtgmJVRBgEx`Q(dOua{hV8G%UGm8iDd)wBpYMFQjB;h18Iw%+r-vG`o5E1W1V5=2+Z@rJs z{IQh2dOwD-!9q){vv5cyV$e! za29(YKtf0_P2C(l*pkn;F>B}6x{3>2Ub2l|h7AJkIl7I%tqy@{F`S#At%XQP+v!~s z^6tbY*7~ZsC8|bo&ubw$=5ObR;$+yZ%(t^HXSLl$7X>`%B}pJnb8cvR>GSmY`rdk( zS4u3a?mjZN+{AHUNulT?9>R0+k^)v!@X#gxX6=wEQ16eA2KJ6!jtKI}4tj<31W<@} z)XT*(e45m*x`oA$2wb~pH{B*TID;+P-Ft#%l|6KaJOHZ{__FP(8(uo>eRa;g_hW;= zbIB~=45L=yBXzpxXT4Bh2lcMp{R7|>Bj0tC$KJ*m$8XTfJqdutr#0%LWtX>|5ZZ1M znrxO@bWw{gcup;1EiHx|!d@`S!MgMb8scXROzGUW(uJX?u`35NoE)NKKYDVCD9Y#% z@Ue2zcjg%Ah?;|zu?Y`k2d_hvA1Mz&HHJXgENF5A#Shw5EL z$*%I_5xgr$dIJq<$GR0D*GqonE)VDg-Sf^}C3kcc=_t+PaJ;UAr4lv*PSk_G^bL|2 zI*Ad?$!z--t$y0R=wvQUnX}lXnE+e7S;X0F}X*tf&sn~X=49!_kj7Q^a z9TIB5DSUZ|Wo#!h*=ik9K-0DNe+~#Gm?JI`z~~8Wo-0H9CM3a5rr~%ZFKN*QI!Dhr zI@=07PbW+F`To*^*Fgw&dUV|8E2>%Phx%B#uXl59%X=te9~#`o_+#n!W<21m7}cUiqDXXqRSyxl2Ir^Bf5n2crMV-MZ|GBL}eEuWJg}8Si0S z|6aXBGk<_}5(4+hfVjCf*xx}<$!!iV7d96Y=n=6q()O1e-KGg++@(e?7#|$wTIF5| zv^prF@+k}=Y_T_@r%Pe#z6M+Y3zp{Utn#2t(s4uapq|YdTK-Gst`^(!tLFn)3@9OXA@9Q6&b}Jk$_o4m~SH$$NQEpTiy^P+5-{1a%o-;u92pDK6 zy_k^&viQ!!{hF%m^AG zgV~CNVc-n5ufbK-e(N_p7EdyQ>K!3YV36U@OBZ^KHZr`!SZGL-GT7MI=!WSsGQLvI zI0uO<{OWLRn;HUh7%G#@@N$Mavj zOp}0IEnA=t3(GBn6F8@EV55w|x@fw=>_>#B`hwV0ss1hCkc?)?1kw!7+BvkP0mMXo zKjFj-fiP$Atei6q!2-m|xSI9726GnQ7C1}B*lhUNlYZvF0Q$UTYx%9YMyYXc8{Qf4 z*WnXpTV~tYP8iMYVgC6J8E6Ni!gokuW{(|tcXkrH<1@#dIdfEYF?Ka78a=JUkHSH_ z$q?^uKwMfL?P2usxSLCb^TkY=AY&jUAu92aH#DYr61p{XTPWqM??yOkbvzy6 zrBE*)yvWkxCd(`f(h)Jl9_=TmY;(GvHMqp#V=X$>Gm1l9 zw!}@>AL}e6_QtkH2uT3V-f?k3?Eu3l5F>*vOejeg6t@rp2HgUVe_lL+$U{H+5ZWY4Mx8g3i4k@ z8MiQlOwYKGQg0l<@DyXDgt(2lL8kQIwK3bQZrOUxa)j`zR|@m8Np7Z@b1~GdDcgil zDLBrqgW5-vz(HZ}km$^d1a7*R*GdA9KH!I@rwkp=LyP55t067aX+tT=E!iS3d>Ml= zM$~3_3~UKQV%DG%e~wLMl*dHxX1pXBKBI0Iy110XiM6g}!sJ;lEFT@Ll>-e0(x@C{ zP-An!;6mgILr=8Ek}0&(z;SAEV*UXBQ#|VdE9|;Lqc?{6P#r9^cnDh#59PBpEuZdm zn8Bhb(BTZKBaAXQk`r7w$l1^6NF(f7c6|ZCJ<6!?im;wVLxqnvg7`cSX1_ef=naM! zI1z=|;QUXIH6X!OYa5KRZ$&?j!FjyUs}p2Yt}+xB`xVOg%oiH$d`jga<6;KPB?2&) z%D`M^pbD_p`;O`$JmPF)AlLe4Z1-}*+a$Qcu>3cbD~+o-G*=rW^T;)Zg{g(uQ~u7; zg07WYybi*p{L24f*bux2(RFXa4kNWZRb@~ge&K=;0e*FXG)HH(}*~-#s zfR9e91NJ-O=q4lF%Rc}R1VXR$X3nkH33%8yz<0im|s47mC^5odS{E zXq2;_dYf;zv#A%Bj)S^`56N8uS>7!Z$vupA-Fpo_UG5V}P!m_@fiw#CN`h3}U<4vkX^d;-)9pY1&Q^`s@zgP|8h$vW2ia>z2z<%f zBED9FUI(D@##;it!A3!O(|F4OKRM9uKtFujpl1idsgX%I(c>KhL~Ack(7S9%-ZKoa zWq{s;-Zyl(YEPqo8U~$y=vhN;gePA~y;Qz7z5$JeK!bgaKsJBTFrfx~x*2-L;COx6 zDCs11kN!{hvgc014$B7hvWL<9RKf>%LH3A^mt<_X|AjFZvEf;ryBYH@*qDFWWtH8UOn)&A+|H!Js<;e{d{#fyI$l2RRLDA^NY)hu;$(xo*cSdb~ zMvTKSS|%ecX!h}?%a94FJU#m;95F^iXLYyStT20-z0E!*S1$URHut9KXA;q_zv-zd z15E7HSH3$Unjy>1WbHl?-3* zSpQ>G1=^TlR<1_&rF*uxC!=}rPZeX__+|@m%n`c0wcPq#QvyCYlmbdlDdwbsU4kkA(?#PC2 zC(~?ALUtXfVP^rfEH_M}U1ZR9HQ5*_yO}rnTD!T_TxKr!E9?MD#J(m6G9+9NO>mRxL9EkC z!CYZ_j&o?G0JSUk?qGpd4k5L|_&1|N{SifniNh`Kook1iN0>*NNAdAik2a4nk2Ogy zc#;bKI7-}Ddq19oV4PsCGEX#5GFO`?o8BqRYoHZR5q3{uoj|90Gw(EE{ulX_L8tRq z&oBk6`I*A|XR)q`XPccPqv2eWndq_ikZ+?uPk!tCkV00T3m9fEG}$VDC2Qw1abv+( z!-Q=I&L%IFw;V6SdjKiCIdHN0`5$%-{Ta_EG+J=BjiWC@9!vOAh`#+QRPOVWNURZ`zKp&ORkX%B8WKWJ z&^IC2RBJ`wVpCH(*B@-Z=sTHQdfvFWoT0kDd{b$!=RYyF)4>kWSAa!EknqsW`0}AT)aB z?(HV!40o8Nd(n3aYcfj&tK4SZCC%x(O~EVf9)TO*D+u-X3DDm!E;GI|_JAuu{Gb3a z0Q`{2_fQ^Y2zmrmfjBsX(rDC2#WmqEj)=#FhO=C^d4eJBNv~ZOXS#bzZun_o{dtDh z`A@L}Tv~sY)p?m91wJQN`I+TM`o3Tizsna*m6*+3oN=0ZkiKFJ5`R{`+jjwT*f#*R(!_G+w^pY>< zyzB`ME=Uelg_CGEMK8BJ{mHzCW1Y8cc>Uf<3z6Bs^1vut~@Y zPchod5(O(Xnr#Ja3&-5S;d7v&;&cS`2(38P-0QMu@ntrT7s6 z{Vgv2Z)`CsY=E#yG>}6y$YR?3M(n7w!BQ1GIbT2Vz@$xNNQPL#p^U>U*}Zp!#hLc3 zpzGT?Hnr$}?of;Kh2fUSs75lFMsb)&bA+MIWGKd1rEGbu#o1vcjnl)5>^KVxtV)#? zu|oKaC6+Z5jb}|>#&@)%0)!Jd%E0ZHfc-5PFw?B!&+kHFR`B-bM_5g_{F;>mthJyBVxAM@BV7}Az~qz7kO`tRSdHQU z#;q{R=NBOdTqWc#$cKe)Wnlx2=fKn@KiLc)5HynyRJG8n^$#-?PYSJ(AzBv_HW+7l z)HB;}TA5>Q?c+c!)mok~UMKWqq1==Dzm(Ek^qZvC%yHE<#kkb3f2l%`AUJwxR#I^;b5WFL*!NuwV3{k4r8NmIBg8h35ug5 zcx&iL*49x%l}F1}9%FTlwLF$py}q%Qc(D;Y%U4-^kM{(*y;T-FyW@C{q|*ds6ooFF z&gTt8HG3N&CtChWdxp@jlXj9DI@7X5LGRS{X^hodbU%Tt604;eA-T=+iq7?h%FV{L^Q`l&3#<#JYT1gfTw+~X+6WikuiztoHIR{K!~45HGXIc2 zUMtM$E1*l>!3UR%Ttoevb)|KcT(h^~e~r|L@9~RR-eToi>$=}+oGnz>Thxb#96Z3Y zvEE>T!x>4P;45A?ayU8#26hvlG&c+L>J|>)tyTqi5+q`cEqo2WO_+AK6MU06wL1im z@09U%mnCmrA zVtYic^=QG6bwrq{2aj+hJt*|$#;~3zo7<1dwLIpN8hRYkR`{FAPn3w$q9*br1L!FM z+fQ54)`h=w@r+1J=${<6XRQif!ts3tUG$tVCeL$d?q)d>L`R$#Zq(!2~Dlb_t z`#`F%Sg%^Id09x**R40KH#yYCTh`mwJJ!3_d)E7wvgk*PZY=#|c^gPSbM&EK zWKe!Bp&Hd@JFMv6{4*tBBep0iHq*YaxnHxnVg|wTzT=c(Gtx9|e_ga}PrkNo#v+kp zOA36M079$X%ZrN@3{yb{NyxRCO4KWCm)jL~FT1zh$L?$Qv-{fv?1Az>Q>W;95(_%*RE{_$q*T&gQu~kOeqkQO< z&FnF@U>B(D>1&2wrOJ+Q1dj)>*uisA8LkN&hf)BK%A%0xqNtaD)ivvNPps zj}EEA!y3DczDZ1XXqNo$Y+GjjTiapcB^dD!7)IOJsB4k!GQelp!KD!Y2K$|GS_xQb zs%^0HK}aKHsvzy=&>TDDmyo)Zx%Revh_(~@$hZ2p7wBmR8RQ*p@TB!mQ`^b*QornM z6HD4I^1Hj1bZ<|N+j%x~vF&;ImEG*!IjDPZ0&qnN;9%#1YHO?w?IkwT&yVj1k8{3{ zgy!4gzUtmWf0J@d+PaWN4~CBW6o5_(xs2e^QSzS6(V+_dY+p93AlWS0SzPE(EtIlL z{E5=GhL>uz*cL1!^}PEB*et7T%(W@sR2u9?+usHDljz1do6Q?1skJn1SMYu5ItlbY2)Qpa&{+tPO0bFl zXM0i734F#VnE2cHxCO@Uv<9>EuU%r#d7uZ7X=-T3@KS2b2 zv(1y^EMlz3xA&wt&RV-NDhZejmmT1UQwxGB=sre)6Yz51Cw}f&uVrR*6PL*MX ziG%q*nsP|+P?;Ma7L>DZ9tA5tc9?00mBvdFNlb-)`LZ6$JKP=~9MnVkiXO^)s^^d% z-apJM2eFi*$%pia9zHnQ7OX(>@_JZ!Qw^)1Xq9b1j!8Iu7M*BI-T*f+)>s<(+0x~- zCMiPq*-$sG9zJnMBAOif*@JgSU&*`U)zE99*F$d<59wp~aj`=Om*501j(2d(EA`@d zmxWsVju*#?T~UnInzE@p0g0CiXY?M{qsNs#g{}XMd#ZC z7`xBe;wgvJV41gl1{ce>rO;BFW#V;dD&FO`pQ$&oD2EQT{Zzcv_RxTXAquPxl8SdF zdnW~PH=beiV7p6x-b2}EIfx5HhqI<};2dw}fmW+((1M*OVnz9r~Bn|qkt&yfCr zfYJvA8HhLiJl$Hj)g}h{hoI>l5_He}VWH(mSdEVgH9jU&^SV%Z84g>Efmcpjq7gk_ zjOljY;1dG*6c5qu0m{=h%_{W_qo#ifZ9Qv?TZ_+OO7*j1JkKzLUf}xki=47vVsO4J z!1+okoHSB;7#CxoVvq7Xb7w}4AXh^@k#N?ug2*`;ycuM3^wa@jjF5{5b4LiwuQ z{i#uJu!`Py(D9xS;kZ`p72k$8urU$l74^OI@vVA6MmF?ml0=Y5;C^#P+7?L+$` z`(yhPcmx~!pwFXE3A;#;;F!_-mfPcl$H+uU*H7xwq{xBUkT%2DzmV!MTnon=>Y%Au@_kc@%hX|7z!Fh}8|IovTlpF=dl(JJsEqp(W> zF&cgx^hl0`xl$zgD7n_rj(AM?W{&1ZG>vikFfmZ5w^FKXtX~-%xs0RR$2siWHlnX} z%Q}?tPSndkFv0J*GRc|j2!{I2opRzEB+Qj54y3;a?>mUT0Tn`ta(el zlLOHfPS|(I^bT2`=1|vTvema`Nsj&Lj*!M~E3tpp3}>cO?bJB4oY~GCXKN9s!bS%S z3*Mx{2BX*QrMJb}06g=->~!p}2cVwUqjyFl!6=p@g!r17TOjH=1tb zc;|ua=m-uRJ39=zUZ6CPJav3w*v&D(11^axok}$ewXO?-6=*-g9 zHEI3^V{ue(qJz14$z`yPEv$ny!UZ}SnEi_7FsM14n1Amvsy~0g&!cbFI^m{sWZf+6GAQ{eS61-5sxeR zZEXnk{58b0KGAIdzqWUFKt{ z1yb_GdM;yh35@K8vwRixHP(Ri^`u$God0MZ%h+${vGijeNq}SXhGeVclIr>yoiBq_hf?o1C|Bp7=)I#Tu{>%JQfa}FFi>AVPr!_G z!9U^j?KV30kK*HxCN(YgU1s&#Ap8hco4+cTsr`HO(T;Y$$}iE0daXz0l;e(|sKB`fpna!Qq19)XD;9|9 z|7eNX`H)OY%uGrpKra$@m1o_^Irtb4n&%V3bn}kqnAtAc7?2Q$yi8PIeSc1JcAs~2 z-*QKG9D&me1-YUi3$eq6lOM&T+#QS)9>|4_gT$u!`nAG0;UP$5i#?OU&;wm@<(3Y1 zm>z`=VYMGBEMiZVad(!(93q_`&Kp01H-02*@F>AjhTqTXei2}GMF(_7Z(B_wmo2VxXxx3ep9*se# z@GhMyKz|y8o&aC$LBctn0ajnm6b;ByOrr_^>YliG=a%|(cJ0dg_5{xA5jWmWFS$Rn zI( zu6Bw)4TWvBzn4_~kCOXN$E1fSU+>UElpE0vPS}eX_k*f$bTqJbB+yMx1$Bf1dnMTV zh=0$`u*!HnCmp{!|Yz}?In%g=~U3;jFmH-vz!X?d+?5GLgzU+tMg(n87`o1Z{p3dQ6M&Lbrg1S^3+SOoKHmoBdjL+k!?{c9D!N;+ z@z3&z`yNL6_xkDb@8fgnewc&QquE6di1U$VM0?PozW5J0JTm@asF22cKEkH*qcR+i zi6?VB?(iL+N*-?fgkyvK3-Z$9GyqRJmJ0?VV1kfN;Gx*y2GO?x;}Gv z6SA3^GlbBkC?FuP2qIt?0TBeH7(r2iO^<96$RCioIa(y<@}Pd+!D7 zcW#?Gvq^y0*YA72Ki+?M!rk3F=bV{2bLN!aDKrt9_sk4`P#ACdI$zDU`2$i)fiG(L zYitmR)9NRqy%|x4joSj!-Xf&E9q98m2WsWrB8&y)ynelJcLP(zV%*jd@3hWJDzo6< z9jle0@?A_hY-~jQsSJCiFcF2yuqSjOc1=WSm0@S^412AxAmlH@UdOG6gJ; zD>#fk&RG^$K$l_!Sju=+#Z+|f`0g29Iz94I=jJH~_^ko>2@k^Bh^tG?D_YO>ScE2wCM(@U4G*k;^2!D?$fSe6Js&*81o5t+V2cn1t1S2Wa=p{ENC>Fnyk ziFoY>6A?={r5NKnp!#!DLxU3?)+KzyV|$+Op-^Kek`(@VGqOR{6hr~!90I&a$UZhWAHK#AU_D3GRbvRjscIJDy~gxe}PK92))`@md`orZbUotM3-S3 z^Awp%&g0mYbs-yM#Jrg$&uEZ-IM3wS zRn0=}#`WL*SPvf0tEuzQR(qM-tiOfBI(xnKd-|1oUZVoU2lCH?|s+P4)P`T<9(xUUQXs5pzyCuP~%ma*{P&rDc!BK*3IM(-rY*Uc>k2 z3&<>{@x<^PG5$5H)^MBCil|;Q+z?yH7x4yegr14$VU2VlIZb>q8EA=XNL@-eZPt_? zz~ep~)`5l!%pcTVwu5XjA8aVFe4kcn4Lbzi6`|%50uD7p*l9YtW#nO+Eb9I|+@=A& zfbl91FnyV^KAAzvI0E-;>Hc`fW=G;NbA$i({6kb~)qn&VYAd@`0rN2+d( zRz#=R6rE%?I9eIU;1LsI7^WKBDt0WMfI9E%I6WWE@%#k3cuw>W&A`pDoJ`fpdZO1v z>aV`ec|fc%Jdp`6izd9$4=KTJwp@3vRp<|NcwByOtO-&UOiIf>?|I* zV9wUlb&etCTtdQm+;&`_&kUy-bQBlMoscfxXQH5Z+5xR z1q0rd;}&Gdk5*tSf<|_`W+-+CzmwlZ7Qo$Fy7ySDMoWg>YqM}4w>_~B28!54Tw(8? z@=yy+{II5&B-}gq^9S&P>f0JHx9E z8_umQMZ@G}L&Pg&xK{}o4R!_TYh-T2jsS@I@J6^m-$dC32ku*j)wj(cx&_-i6E)B8 zT69h)Sc>o2T))rbIVHXyazFHv{K)>|$7BX`tAalbe&T*czLQ4~5dEX@3rexk(`G)t zvIjgy7Dx6w`yh9jIG^y(>C*q2BMzz?te|hW3fk+Ko$+mOCi?|&?7P zKT?`wb=aQpC#1x$t6s$Visre=R}A0nfj2va`u>=&$pcC=AK56^-M zT9X$D`a#d&10UAP{-ihkNu21a?t<#Td?5oIjLM3XhsMgGZP_KLAJ3>fZ*9{s@X};dXOpywT4#XNNvU%?)q6_p*~j`Il%*G)us?2wgrRyu-jdEq#i^y_gEz3=?7^Bi_ zxY<|W#R*F&`w2{GNLAIQSbtnM_z8AwVVeqVzYW0eA)pr<=(msZeB*48Ei(6NNoE*h zF3qW03@uf&!9u$d*$_QDLnAvnT@g!)VPbPKF~gCBz{+$+h%H3eb$+A~`j%woMulX! zA!_JoK>{IL3vUVn)aNmxlh-Ik*Gi(>(vKf+B|2F(l+p8T1ii++jNIuW%54oP+eO=K zU>&38K?%{i+Z$fl4%z8r(N@?|nE2FK5kv*qPQu@iSs(c{o1O47&?$!m&xM_s5zlu(eWS13KI= zonV^KXjgb7PA9LN5lGGlTbOA$F%6GOL~#TxO?laq%=j#O;msD>`^CxyUKWFC-N($) zzCy=m=8CxI)x^fao~bh5e5YIsIAy=S6xWls8Y;}R#r6_=i#dihXFoAd%d@Pt7gq{j ze^uf8U9Yk;T(H%IwHiTMzof|rIrd;JS=amPQSlm4hMxGUdhC3^KonrDOv*=;tP`Ql zT^}uJ*FQ)W8Y&kVMi>F8H}?;EZELh8)Rdzvm!c95H(daKycm^IunChHtShW$OI%HJ zvyhqkCM-Zhbg1SEED1kAsPI8}*UGR1MVlZV#zlRIVa7EJs|^&7q82b7*(u`^J)EON zl!4jJf<8%-x}{|zrx2SRowM;yh{Wtmd4(W#UdIbv=XGMvuTCZmtPsY#?R7*6E-OcB zsU2gDaIE>|afbChRm-mO%gHpG`^!ne85S5wryzxRmU=-Nb}Ctcr`eN^SY?qX;B>^| z_iNOX!Njp=r3(IUG-g&{u@{!HC%sll8TOn6qE64yO4`3J7GhG;l1K}WY5^+2&eCGA zoD=c0#W~_!ah?b@+4)8)7f`8~C8IGs*+qoWi-irKfHjo@0;2yapa}J>^g>HwyE+gmO zby`j}+Sy{g#VFY;gza0nQnXCqzlyxhI`rDi-?!5ITU1*WG}ZYCyX9=9=&%?&V%3+` zG-~p?zNsZTrGC@nc^lh4%Mt?U6g)MLE5Tr2jQ?Q!}R^ly2H@R4MsiVBB1c_kW zs+ZtxWXs-e%jFJYuG}fa;_C8rGQcFvu)Bl`(J?gKIea#-DA{WL?&l0^&qoZq~zgeB13KQdT z*=PPd_|x!%9>V!i{A6f1w$aZ-R=?O|tre~91UeQDMeZ4i&&3zwOILg)z82qzZ^d`w z`+tm*7%7YX%_j30sr=I%>wD3Ans%EoB>cNDDCWP4qVTl$6;og-{2>Ui5c^Xkq8*iC ze`%SqcE(U(5~8nQW>p%a{Ej5NvzQd#sgg_&58Z)rsSuzKi9+nq@KK&D@*W{f4_W~ql0hbFPZ?#R_OeOqE%OtNUPFx}VkWUc0fx(; z=oHcwkik*mS^)Kv?3d)66&<79)Cxd7>if=eU58da_Q0!IP{X;uLq?fn4vGlveY$E%bU~{aW>@PP((fe*sXMh|iL-xIb zyv=O321~QQ+#!0th8mAg(hJf0__J)7L|0O(ZUNg|sxVzjhYE(97K$UZfwF~JJ8Yyq zFlOpgAJ%Buy(SwwwV?aZF_PS~eG_pjO%}-mcea$JDnP~=C3D^2TT4?}w2dU&c3Zk% zobBZH#5UalOBFGTm+feHA8VL0+G;0a(Tzg}H6HSKo5KmM?1-H;D;u;Ua6?!dp@rGy z**zFYYh^M28*AA%W_PuRWK+o;PRsdhckeRomMqxpaAE^vW3QZV&&m1!z9e;{RXcOyI=5`-Ii)6AbgP-v$flUx$99t~aHnPv zy&a^5m&gv<8b_qCMx# zmnrHYt_YM_GqOvBykx#OJy@5{{ZPk;evz64*Jeoz)Tm%J@{8vCwpWn(r1+5d3>0eyTeVQ%n>q5e>&FJ{_HrC?{mB!-cCO< zA?oGyEIo+`uSM1oIvF=K?FjkF+HyFP?6<#3vCdG~aFYKsiX9R4+(?$;3USYhTFU$) z9jt9BOE-CNf&p5=+0y>GjMb=SxvAn`VXH8*gSOvQ(Sa+Sg&PlmN_u1!WCAxLI zNlKjqQ~;DJ4W78~|GLqqRz z$qF&gvuRwP6_phY6?J75&LggT6gM}*{$dQ^F)~J; zKZNt7d`i+bkxxsG>9yz*2zYo#uHTQiTITo>8SP`72)KA&_Kw`RR-~|P@ZlCt#(xCK zrDGd4xBq{^ILiJHz=yLlW+%F|#DjQ2YyNqv*Z=yo4MRK#a`pT#;PCnYhn-@5wixI` z_H%H;xGC1k5wljd`kP;KjPM*Nm8dcCU)IrsH-|iMNN%M=F94hPiNi9sHaxb47B#u>TpG@;^;>xD`b~Q937&waXwW8Z>7u3z zOumgS-$lA#Vn^`ev!3OOr$sSI7w-h|)Ka{Vch0Vuixoj#AUd&GS1?v$H-PZfkzv{$ zI)qO&tRU+FIw-UeLw+ajn~{UY|gfcp`tGkx%a~X!gOd1w(GF$ z;r2`WgSIxEO<_PJ17{!%f*_K%nIUvAgvr!HJQN=nO>6%Ui4BD$3~u`0m|ccbFDU37f9Ta%R9xC~%`WUA+gCz@9J*X2V{vH_U;3 zU|-k|=E6Lf4=E^xGAM@%sDvu0h8ox(7C;(mp$_U{AuNIh$Uq}B!D3hfOQ9JKfCJ$m zI2aBA7pXrC4u>P)NaSQ091X|7v2Yw54=2Eh;4X)g;AB_k@h0EY__!nFOSHe}W60U}8;93;L^>72+2sgpaD3VnunA_lX zxC4cA7u*f^z`bxE+z$`HgYXbM43EI0@EAM}Pr#G#6g=(1Gw>{|hUegUcmZC7mtYON z46nee@EW`hZ@`=I7Q7Abz`O7sybmA1hwu@644=TK@ELp#U%;2}6?_ffz_;)nd=Eds zkMI-x48Ooy_!WMG-{BAV6aIpBiYZ6MR9xk$eAQkRsDvt1TnXh$1xl$7sz`NI#j2C) zth%VKs+;PrdZ>+5Pt{BHR(;gQY7^C0+xDyREeNSz{T!w5>&+vz^-B?CrcA)Q)Pb+DVO5#1L`Wcq1}rg4$Wd zBPwE3)oyAc{W61`@erj$+E+UFTK?tpyVUzLaZh!~w z?5d_{_8o8F$XnFt?5?Ke5MdmY&J4AOVbKe08Fd}5i@aHCw%SYWt>&m)x95CiN8VF9 z01+!yWvZMkf(j!gR;l#&Se43gKUYV*IyGv4MGS}q(d@<2s#ev7l)9MXR&SVP3$;j{ zMXJHD=44c(5m1v_Y>8xvGX9FCgz9E{z79azg52H%)iUPyBgih8pIDszdVXS12v?Rj z(@UE;`qnO~#3kKJVvXt2;u3_*or<@-rc_l$avZvN8k*0E#Vczn8{-r4pL6kVOfQO0 jY^oc7QOv1~{)#tZa#p+q|G6v{Z>&!*h?n3$m&g7Gizy@j delta 73343 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 W67%d-S)D6 Date: Mon, 21 Sep 2026 11:28:43 +0400 Subject: [PATCH 16/22] Escape regex constructs that java.util.regex reads differently --- generate.js | 56 ++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 55 insertions(+), 1 deletion(-) diff --git a/generate.js b/generate.js index 9eb786a..26cc737 100644 --- a/generate.js +++ b/generate.js @@ -50,6 +50,60 @@ function loadLocalLanguage(path, code, title, alias) { } } +// Spell out the constructs whose meaning differs between regex engines, so one table can +// serve all of them. java.util.regex reads a [ inside a character class as the start of a +// nested class, requires a { outside one to open a quantifier, reads \0 as the start of an +// octal escape, and reads \v as the whole vertical whitespace class rather than as U+000B. +// All four rewrites are no-ops for ECMAScript and for Boost, which is what libprisma +// compiles the patterns with. +const QUANTIFIER = /^\{\d+(?:,\d*)?\}/ + +function normalizeEscapes(pattern) { + let result = '' + let inClass = false + + for (let i = 0; i < pattern.length; i++) { + const c = pattern[i] + + if (c === '\\') { + if (pattern[i + 1] === '0' && !/[0-7]/.test(pattern[i + 2] || '')) { + result += '\\x00' + } else if (pattern[i + 1] === 'v') { + result += '\\x0B' + } else { + result += pattern.substr(i, 2) + } + i++ + continue + } + + if (inClass) { + if (c === '[') { + result += '\\[' + continue + } + // && is set intersection in java.util.regex + if (c === '&' && pattern[i + 1] === '&') { + result += '\\&\\&' + i++ + continue + } + if (c === ']') { + inClass = false + } + } else if (c === '[') { + inClass = true + } else if (c === '{' && !QUANTIFIER.test(pattern.substr(i))) { + result += '\\{' + continue + } + + result += c + } + + return result +} + function unique(a, fn) { if (a.length === 0 || a.length === 1) { return a; @@ -135,7 +189,7 @@ async function generate() { pattern = pattern.replaceAll("|[])", ")"); pattern = pattern.replaceAll(":[]", ":"); - return pattern + return normalizeEscapes(pattern) } for (var token in copy) { From e84126af03c80c7ecfd9fde9d62d20ed05a86c3a Mon Sep 17 00:00:00 2001 From: Fela Date: Mon, 21 Sep 2026 12:09:36 +0400 Subject: [PATCH 17/22] Expand unicode escapes Boost does not read --- libprisma/LanguageTree.cpp | 5 +- libprisma/UnicodeEscapes.h | 354 +++++++++++++++++++++++++++++++++++++ 2 files changed, 357 insertions(+), 2 deletions(-) create mode 100644 libprisma/UnicodeEscapes.h diff --git a/libprisma/LanguageTree.cpp b/libprisma/LanguageTree.cpp index 87990db..01c9902 100644 --- a/libprisma/LanguageTree.cpp +++ b/libprisma/LanguageTree.cpp @@ -1,6 +1,7 @@ #include "LanguageTree.h" #include "TokenList.h" +#include "UnicodeEscapes.h" #include void LanguageTree::load(const std::string& content) @@ -165,11 +166,11 @@ void LanguageTree::parsePatterns(Buffer &buffer) if (inside != std::string::npos) { - m_patternsRaw.push_back(std::make_shared(pattern, flags, lookbehind, greedy, std::string{ alias }, std::make_shared(shared_from_this(), inside))); + m_patternsRaw.push_back(std::make_shared(libprisma::widenUnicodeClasses(pattern), flags, lookbehind, greedy, std::string{ alias }, std::make_shared(shared_from_this(), inside))); } else { - m_patternsRaw.push_back(std::make_shared(pattern, flags, lookbehind, greedy, std::string{ alias }, nullptr)); + m_patternsRaw.push_back(std::make_shared(libprisma::widenUnicodeClasses(pattern), flags, lookbehind, greedy, std::string{ alias }, nullptr)); } } } diff --git a/libprisma/UnicodeEscapes.h b/libprisma/UnicodeEscapes.h new file mode 100644 index 0000000..d72c450 --- /dev/null +++ b/libprisma/UnicodeEscapes.h @@ -0,0 +1,354 @@ +#pragma once + +#include +#include +#include + +namespace libprisma +{ + // Boost matches over bytes and does not read a \uXXXX escape at all: a pattern holding one + // simply never matches. Spell every escape as the bytes of its UTF-8 encoding instead, and + // where one sits inside a character class - whose members have to be a single byte each - + // lift it out into an alternation. This belongs here rather than in grammars.dat, which + // keeps the \u spelling for the clients that match over UTF-16 and read it correctly. + + inline bool isHexDigit(char c) + { + return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'); + } + + inline int hexValue(char c) + { + return c <= '9' ? c - '0' : (c | 0x20) - 'a' + 10; + } + + // the code point of the \uXXXX escape at begin, or -1 if there is not one there + inline int unicodeEscapeAt(std::string_view pattern, size_t begin) + { + if (begin + 6 > pattern.size() || pattern[begin] != '\\' || pattern[begin + 1] != 'u') + { + return -1; + } + + int value = 0; + for (size_t i = begin + 2; i < begin + 6; ++i) + { + if (!isHexDigit(pattern[i])) + { + return -1; + } + + value = value * 16 + hexValue(pattern[i]); + } + + return value; + } + + inline void appendByte(std::string& out, unsigned char byte) + { + static const char digits[] = "0123456789ABCDEF"; + + out += "\\x"; + out += digits[byte >> 4]; + out += digits[byte & 0x0F]; + } + + inline void appendUtf8(std::string& out, int codePoint) + { + if (codePoint < 0x80) + { + appendByte(out, static_cast(codePoint)); + } + else if (codePoint < 0x800) + { + appendByte(out, static_cast(0xC0 | (codePoint >> 6))); + appendByte(out, static_cast(0x80 | (codePoint & 0x3F))); + } + else if (codePoint < 0x10000) + { + appendByte(out, static_cast(0xE0 | (codePoint >> 12))); + appendByte(out, static_cast(0x80 | ((codePoint >> 6) & 0x3F))); + appendByte(out, static_cast(0x80 | (codePoint & 0x3F))); + } + else + { + appendByte(out, static_cast(0xF0 | (codePoint >> 18))); + appendByte(out, static_cast(0x80 | ((codePoint >> 12) & 0x3F))); + appendByte(out, static_cast(0x80 | ((codePoint >> 6) & 0x3F))); + appendByte(out, static_cast(0x80 | (codePoint & 0x3F))); + } + } + + // The code point at begin, joining a surrogate pair into the one character it spells, with + // the characters it occupies in length. A lone \uXXXX is left to Boost, which expands it + // to UTF-8 itself; a pair it would expand to two three byte sequences instead. + inline int codePointAt(std::string_view pattern, size_t begin, size_t& length) + { + const int value = unicodeEscapeAt(pattern, begin); + length = value < 0 ? 0 : 6; + + if (value >= 0xD800 && value <= 0xDBFF) + { + const int low = unicodeEscapeAt(pattern, begin + 6); + if (low >= 0xDC00 && low <= 0xDFFF) + { + length = 12; + return 0x10000 + ((value - 0xD800) << 10) + (low - 0xDC00); + } + } + + return value; + } + + struct ClassMember + { + std::string_view text; // as spelled in the pattern, "a", "\\n", "\\u2227", "a-z" + int low = -1; // code point, for a member that is a lone \u escape + int high = -1; // and the other end, when the member is a range of them + }; + + struct CharacterClass + { + size_t end = 0; // index just past the closing ] + bool negated = false; + bool wide = false; // holds a code point that cannot be a single byte + std::vector members; + }; + + // one class member starting at begin, or 0 if the class ends there + inline size_t readMember(std::string_view pattern, size_t begin, ClassMember& member) + { + auto unit = [&](size_t at, int& codePoint) -> size_t { + size_t length = 0; + codePoint = codePointAt(pattern, at, length); + if (codePoint >= 0) + { + return length; + } + return pattern[at] == '\\' && at + 1 < pattern.size() ? 2 : 1; + }; + + int low = -1; + size_t length = unit(begin, low); + size_t at = begin + length; + + // a - b, where a trailing - is a literal rather than the start of a range + if (at + 1 < pattern.size() && pattern[at] == '-' && pattern[at + 1] != ']') + { + int high = -1; + size_t tail = unit(at + 1, high); + member.low = low; + member.high = high; + member.text = pattern.substr(begin, length + 1 + tail); + return length + 1 + tail; + } + + member.low = low; + member.text = pattern.substr(begin, length); + return length; + } + + inline bool readClass(std::string_view pattern, size_t begin, CharacterClass& result) + { + size_t at = begin + 1; + if (at < pattern.size() && pattern[at] == '^') + { + result.negated = true; + ++at; + } + + while (at < pattern.size() && pattern[at] != ']') + { + ClassMember member; + size_t length = readMember(pattern, at, member); + if (length == 0) + { + return false; + } + + if (member.low > 0x7F || member.high > 0x7F) + { + result.wide = true; + } + + result.members.push_back(member); + at += length; + } + + if (at >= pattern.size()) + { + return false; + } + + result.end = at + 1; + return true; + } + + inline bool isRange(const CharacterClass& characters, int low, int high) + { + return characters.members.size() == 1 + && characters.members[0].low == low + && characters.members[0].high == high; + } + + // [\uD800-\uDBFF][\uDC00-\uDFFF] and [\uD800-\uDFFF]{2} are how a JavaScript regex spells + // one astral character, as its two UTF-16 halves. In UTF-8 that is one four byte sequence. + inline size_t appendSurrogatePair(std::string& out, std::string_view pattern, size_t begin) + { + CharacterClass lead; + if (!readClass(pattern, begin, lead) || lead.negated) + { + return 0; + } + + size_t end = 0; + if (isRange(lead, 0xD800, 0xDBFF)) + { + CharacterClass trail; + if (!readClass(pattern, lead.end, trail) || trail.negated || !isRange(trail, 0xDC00, 0xDFFF)) + { + return 0; + } + end = trail.end; + } + else if (isRange(lead, 0xD800, 0xDFFF) && pattern.substr(lead.end, 3) == "{2}") + { + end = lead.end + 3; + } + else + { + return 0; + } + + out += "(?:[\\xF0-\\xF4][\\x80-\\xBF]{3})"; + return end - begin; + } + + // the class at begin, with any member that cannot be a single byte moved out of it + inline size_t appendClass(std::string& out, std::string_view pattern, size_t begin) + { + CharacterClass characters; + if (!readClass(pattern, begin, characters) || !characters.wide) + { + return 0; + } + + std::vector wide; + std::string narrow; + + for (const auto& member : characters.members) + { + if (member.low <= 0x7F && member.high <= 0x7F) + { + narrow += member.text; + } + else if (member.high < 0) + { + wide.push_back(member.low); + } + else if (!characters.negated) + { + // a range of code points that is not the surrogate idiom; leave it be rather + // than expand what could be the whole of Unicode + return 0; + } + } + + // a negated class drops its wide members: they exclude characters that cannot occur + // as bytes in valid UTF-8 anyway, and as bytes they would exclude unrelated ones + if (characters.negated || wide.empty()) + { + out += '['; + if (characters.negated) + { + out += '^'; + } + out += narrow; + out += ']'; + return characters.end - begin; + } + + out += "(?:"; + if (!narrow.empty()) + { + out += '['; + out += narrow; + out += ']'; + out += '|'; + } + for (size_t i = 0; i < wide.size(); ++i) + { + if (i > 0) + { + out += '|'; + } + appendUtf8(out, wide[i]); + } + out += ')'; + + return characters.end - begin; + } + + inline std::string widenUnicodeClasses(std::string_view pattern) + { + if (pattern.find("\\u") == std::string_view::npos) + { + return std::string{ pattern }; + } + + std::string out; + out.reserve(pattern.size()); + + for (size_t i = 0; i < pattern.size(); ) + { + if (pattern[i] == '\\') + { + size_t length = 0; + const int codePoint = codePointAt(pattern, i, length); + + if (codePoint >= 0) + { + // grouped, because a quantifier after it has to apply to the whole + // character and not to the last byte of its encoding + const bool multiByte = codePoint > 0x7F; + if (multiByte) + { + out += "(?:"; + } + appendUtf8(out, codePoint); + if (multiByte) + { + out += ')'; + } + + i += length; + continue; + } + + out += pattern.substr(i, 2); + i += 2; + continue; + } + + if (pattern[i] == '[') + { + if (size_t consumed = appendSurrogatePair(out, pattern, i)) + { + i += consumed; + continue; + } + + if (size_t consumed = appendClass(out, pattern, i)) + { + i += consumed; + continue; + } + } + + out += pattern[i]; + ++i; + } + + return out; + } +} From 4578af1867d789fa0cef2585848d9f52c72c8461 Mon Sep 17 00:00:00 2001 From: Fela Date: Mon, 21 Sep 2026 12:27:44 +0400 Subject: [PATCH 18/22] Give an alias the language title when it has none of its own --- generate.js | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/generate.js b/generate.js index 26cc737..9cf08e5 100644 --- a/generate.js +++ b/generate.js @@ -393,11 +393,11 @@ async function generate() { for (const lng of alias) { allLanguages[lng] = allGrammars.indexOf(find) - if (components.languages[name].aliasTitles) { - languageNames[lng] = components.languages[name].aliasTitles[lng] - } else { - languageNames[lng] = components.languages[name].title - } + // aliasTitles only names the aliases whose title differs from the language's, + // so an alias missing from it takes the language title rather than no title: + // an empty one drops the alias out of SyntaxHighlighter::languages(). + const aliasTitles = components.languages[name].aliasTitles + languageNames[lng] = (aliasTitles && aliasTitles[lng]) || components.languages[name].title } } }) From 8b3e2ccf6ed544363234b1b6c025d162cd392cda Mon Sep 17 00:00:00 2001 From: FrayxRulez <8152849+FrayxRulez@users.noreply.github.com> Date: Mon, 21 Sep 2026 08:45:30 +0000 Subject: [PATCH 19/22] Update grammars --- libprisma/grammars.dat | Bin 629963 -> 630304 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/libprisma/grammars.dat b/libprisma/grammars.dat index f86242559477b533ede2728e1cee47fc449d7305..fc950e2142e919493f04724821689e31f9cb4340 100644 GIT binary patch delta 76425 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 delta 76113 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 From d007354e400ee1d03fe69a1f6a2d4a70ca4d5f8a Mon Sep 17 00:00:00 2001 From: Fela Date: Mon, 21 Sep 2026 12:37:50 +0400 Subject: [PATCH 20/22] Escape characters a pattern cannot carry as bytes --- generate.js | 38 +++++++++++++++++++++++++++++++------- 1 file changed, 31 insertions(+), 7 deletions(-) diff --git a/generate.js b/generate.js index 9cf08e5..c322550 100644 --- a/generate.js +++ b/generate.js @@ -104,6 +104,27 @@ function normalizeEscapes(pattern) { return result } +// A character written literally in a grammar - BQN's •, APL's ⍵ - has to reach the readers as +// an escape rather than as itself: they disagree about what the bytes of a pattern mean, and +// \uXXXX is the one spelling all of them read as a code point. An astral character is two code +// units here, so it becomes a surrogate pair, which UnicodeEscapes.h puts back together. +function escapeNonAscii(pattern) { + if (!/[^\x00-\x7F]/.test(pattern)) { + return pattern + } + + let result = '' + + for (let i = 0; i < pattern.length; i++) { + const code = pattern.charCodeAt(i) + result += code > 0x7F + ? '\\u' + code.toString(16).padStart(4, '0') + : pattern[i] + } + + return result +} + function unique(a, fn) { if (a.length === 0 || a.length === 1) { return a; @@ -189,7 +210,7 @@ async function generate() { pattern = pattern.replaceAll("|[])", ")"); pattern = pattern.replaceAll(":[]", ":"); - return normalizeEscapes(pattern) + return escapeNonAscii(normalizeEscapes(pattern)) } for (var token in copy) { @@ -413,15 +434,18 @@ async function generate() { const writeUint16 = i => chunks.push(new Uint16Array([i])) const writeUint8 = i => chunks.push(new Uint8Array([i])) const writeString = str => { - if (str.length < 253) { - writeUint8(str.length) + // one byte per code unit truncated anything above U+00FF; the length is the byte + // count, which is what the readers advance by + const bytes = new TextEncoder().encode(str) + if (bytes.length < 253) { + writeUint8(bytes.length) } else { writeUint8(254 & 0xFF) - writeUint8(str.length & 0xFF) - writeUint8((str.length >> 8) & 0xFF) - writeUint8((str.length >> 16) & 0xFF) + writeUint8(bytes.length & 0xFF) + writeUint8((bytes.length >> 8) & 0xFF) + writeUint8((bytes.length >> 16) & 0xFF) } - chunks.push(new Uint8Array(str.split('').map(char => char.charCodeAt(0)))) + chunks.push(bytes) } // Patterns From 2f9ca450d28421aa7bc4ea2fec753083bbda3a22 Mon Sep 17 00:00:00 2001 From: Fela Date: Mon, 21 Sep 2026 12:14:12 +0400 Subject: [PATCH 21/22] Check every pattern against both regex engines on a pull request --- .github/workflows/check-grammars.yml | 58 ++++++++++ tools/PatternProbe.java | 163 +++++++++++++++++++++++++++ tools/check-escapes.js | 87 ++++++++++++++ tools/corpus.txt | 13 +++ tools/probe.cpp | 132 ++++++++++++++++++++++ 5 files changed, 453 insertions(+) create mode 100644 .github/workflows/check-grammars.yml create mode 100644 tools/PatternProbe.java create mode 100644 tools/check-escapes.js create mode 100644 tools/corpus.txt create mode 100644 tools/probe.cpp diff --git a/.github/workflows/check-grammars.yml b/.github/workflows/check-grammars.yml new file mode 100644 index 0000000..3e7a4a2 --- /dev/null +++ b/.github/workflows/check-grammars.yml @@ -0,0 +1,58 @@ +name: Check grammars + +# grammars.dat is read by libprisma with Boost and by the Android client with java.util.regex, +# so every pattern in it has to mean the same thing to both. Regenerate the table and hold it +# to that, rather than waiting for a language to quietly stop highlighting. +on: + pull_request: + paths: + - components/** + - generate.js + - libprisma/** + - tools/** + - package.json + - package-lock.json + workflow_dispatch: + +permissions: {} + +jobs: + patterns: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v5 + with: + persist-credentials: false + - uses: actions/setup-node@v5 + with: + node-version: 22 + + # the committed table is regenerated on master, so a pull request is checked against what + # its own components and generate.js produce + - run: npm ci --ignore-scripts + - run: npm start + + - name: Escapes every engine agrees on + run: node tools/check-escapes.js libprisma/grammars.dat + + - name: Compile every pattern with java.util.regex + run: | + javac -d tools tools/PatternProbe.java + java -cp tools PatternProbe libprisma/grammars.dat tools/corpus.txt java.txt + + - name: Compile every pattern with Boost + run: | + sudo apt-get update + sudo apt-get install -y libboost-regex-dev + g++ -std=c++17 -O2 -o tools/probe tools/probe.cpp -lboost_regex + ./tools/probe libprisma/grammars.dat tools/corpus.txt boost.txt + + - name: Compare what the two engines matched + run: | + if ! diff -u boost.txt java.txt > engines.diff; then + echo "The two engines disagree about what these patterns match." + echo "Each line is a pattern index followed by its start:end offsets in tools/corpus.txt." + head -40 engines.diff + exit 1 + fi + echo "Boost and java.util.regex agree on every pattern." diff --git a/tools/PatternProbe.java b/tools/PatternProbe.java new file mode 100644 index 0000000..92296a6 --- /dev/null +++ b/tools/PatternProbe.java @@ -0,0 +1,163 @@ +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Paths; +import java.util.ArrayList; +import java.util.List; +import java.util.regex.Pattern; +import java.util.regex.PatternSyntaxException; + +/** + * Compiles every pattern of a grammars.dat with java.util.regex and writes down what each one + * matches in a corpus, for probe.cpp to be diffed against. Between them they hold the table to + * the one thing it promises: that a pattern means the same to every client that reads it. + * + * The corpus is deliberately ASCII. Boost matches bytes and java.util.regex matches chars, so + * anything above U+007F diverges on offsets alone and would drown out the escape bugs this is + * looking for. + */ +public class PatternProbe { + + /** A pattern record, "/source/flags,alias,inside", as LanguageTree.cpp reads it. */ + private static final class Entry { + String source; + int flags; + } + + private static final class Reader { + private final byte[] bytes; + private int offset; + + Reader(byte[] bytes) { + this.bytes = bytes; + } + + int uint8() { + return bytes[offset++] & 0xFF; + } + + int uint16() { + return uint8() | (uint8() << 8); + } + + String string() { + int length = uint8(); + if (length >= 254) { + length = uint8() | (uint8() << 8) | (uint8() << 16); + } + String value = new String(bytes, offset, length, StandardCharsets.ISO_8859_1); + offset += length; + return value; + } + } + + private static List read(String path) throws IOException { + Reader reader = new Reader(Files.readAllBytes(Paths.get(path))); + List entries = new ArrayList<>(); + + for (int count = reader.uint16(); count > 0; count--) { + String item = reader.string(); + int begin = item.indexOf('/'); + int end = item.lastIndexOf('/'); + if (begin < 0 || end <= begin) { + continue; + } + + String options = item.substring(end + 1); + int aliasBegin = options.indexOf(','); + + Entry entry = new Entry(); + entry.source = item.substring(begin + 1, end); + for (int i = 0; i < aliasBegin; ++i) { + switch (options.charAt(i)) { + case 'i': entry.flags |= Pattern.CASE_INSENSITIVE; break; + case 'm': entry.flags |= Pattern.MULTILINE; break; + default: break; // l and y are libprisma's, for Prism lookbehind and greedy + } + } + entries.add(entry); + } + + return entries; + } + + /** + * Outside MULTILINE, $ means end of input in ECMAScript but "end of input, or before a + * line terminator that ends it" in java.util.regex. \z is the Java spelling of the first. + * A Java client has to do this; it cannot go in the table, where \z would read as a z. + */ + private static String endOfInput(String source) { + if (source.indexOf('$') < 0) { + return source; + } + + StringBuilder result = new StringBuilder(source.length()); + boolean inClass = false; + for (int i = 0; i < source.length(); ++i) { + char c = source.charAt(i); + if (c == '\\' && i + 1 < source.length()) { + result.append(c).append(source.charAt(++i)); + } else if (c == '[') { + inClass = true; + result.append(c); + } else if (c == ']') { + inClass = false; + result.append(c); + } else if (c == '$' && !inClass) { + result.append("\\z"); + } else { + result.append(c); + } + } + return result.toString(); + } + + public static void main(String[] args) throws IOException { + List entries = read(args[0]); + String corpus = new String(Files.readAllBytes(Paths.get(args[1])), StandardCharsets.ISO_8859_1) + .replace(String.valueOf((char) 13), ""); + + StringBuilder out = new StringBuilder(); + int failed = 0; + + for (int i = 0; i < entries.size(); ++i) { + Entry entry = entries.get(i); + String source = entry.source; + if ((entry.flags & Pattern.MULTILINE) == 0) { + source = endOfInput(source); + } + + Pattern pattern; + try { + pattern = Pattern.compile(source, entry.flags | Pattern.UNIX_LINES); + } catch (PatternSyntaxException e) { + if (failed++ < 20) { + System.err.println("pattern " + i + ": " + e.getDescription()); + System.err.println(" " + entry.source.substring(0, Math.min(140, entry.source.length()))); + } + continue; + } + + out.append(i); + java.util.regex.Matcher matcher = pattern.matcher(corpus); + int at = 0; + while (matcher.find(at) && out.length() < Integer.MAX_VALUE) { + out.append(' ').append(matcher.start()).append(':').append(matcher.end()); + at = matcher.end() > matcher.start() ? matcher.end() : matcher.start() + 1; + if (at > corpus.length()) { + break; + } + } + out.append('\n'); + } + + Files.write(Paths.get(args[2]), out.toString().getBytes(StandardCharsets.US_ASCII)); + System.out.println("compiled " + (entries.size() - failed) + " of " + entries.size() + " patterns"); + + if (failed > 0) { + System.err.println(failed + " patterns java.util.regex will not take. " + + "Teach normalizeEscapes in generate.js to rewrite them."); + System.exit(1); + } + } +} diff --git a/tools/check-escapes.js b/tools/check-escapes.js new file mode 100644 index 0000000..a7d4afe --- /dev/null +++ b/tools/check-escapes.js @@ -0,0 +1,87 @@ +// Every escape in grammars.dat has to mean the same thing to every engine that reads it. +// A pattern that fails to compile is caught by the probes beside this script; this one is for +// the escapes that compile everywhere and quietly mean something else, which is the worse +// failure - \v was read as U+000B by Boost and as the whole vertical whitespace class, newline +// included, by java.util.regex, which made ini values run over the end of the line. +const fs = require('fs') + +// what generate.js is expected to emit, once normalizeEscapes has run over it +const ALLOWED = new Set('BSWbdfnrstuwx123456789'.split('')) + +const REASONS = { + v: 'the vertical whitespace class in java.util.regex, U+000B elsewhere - emit \\x0B', + h: 'the horizontal whitespace class in java.util.regex, a literal h elsewhere', + H: 'non-horizontal-whitespace in java.util.regex, a literal H elsewhere', + V: 'non-vertical-whitespace in java.util.regex, a literal V elsewhere', + R: 'any line break in java.util.regex, a literal R elsewhere', + X: 'a grapheme cluster in java.util.regex, a literal X elsewhere', + A: 'start of input in java.util.regex, a literal A elsewhere', + Z: 'end of input in java.util.regex, a literal Z elsewhere', + z: 'end of input in java.util.regex, a literal z elsewhere', + G: 'end of the previous match in java.util.regex, a literal G elsewhere', + Q: 'starts a quoted run in java.util.regex, a literal Q elsewhere', + E: 'ends one in java.util.regex, a literal E elsewhere', + p: 'a unicode property in both, but the property names differ', + N: 'a named character in java.util.regex', + 0: 'starts an octal escape in java.util.regex - emit \\x00', +} + +function readPatterns(path) { + const buffer = fs.readFileSync(path) + let offset = 0 + + const uint8 = () => buffer[offset++] + const uint16 = () => { const value = buffer.readUInt16LE(offset); offset += 2; return value } + const string = () => { + let length = uint8() + if (length >= 254) { + length = uint8() | (uint8() << 8) | (uint8() << 16) + } + const value = buffer.toString('latin1', offset, offset + length) + offset += length + return value + } + + const patterns = [] + for (let count = uint16(); count > 0; count--) { + patterns.push(string()) + } + return patterns +} + +const patterns = readPatterns(process.argv[2] || 'libprisma/grammars.dat') +const problems = [] + +for (const item of patterns) { + const end = item.lastIndexOf('/') + const source = item.slice(item.indexOf('/') + 1, end < 0 ? undefined : end) + + for (let i = 0; i < source.length; i++) { + if (source[i] !== '\\') { + continue + } + + const escaped = source[++i] + if (/[a-zA-Z0-9]/.test(escaped) && !ALLOWED.has(escaped)) { + problems.push([source, '\\' + escaped, REASONS[escaped] || 'not in the allowed set']) + } + } +} + +console.log(`${patterns.length} patterns checked`) + +if (problems.length === 0) { + process.exit(0) +} + +const seen = new Set() +for (const [source, escape, reason] of problems) { + if (seen.has(escape)) { + continue + } + seen.add(escape) + console.error(`\n${escape} is ${reason}`) + console.error(` e.g. ${source.slice(0, 120)}`) +} +console.error(`\n${problems.length} occurrences. Teach normalizeEscapes to rewrite them, or add the escape to ALLOWED once every engine is known to agree on it.`) +process.exit(1) diff --git a/tools/corpus.txt b/tools/corpus.txt new file mode 100644 index 0000000..2086075 --- /dev/null +++ b/tools/corpus.txt @@ -0,0 +1,13 @@ +class Foo where T : IBar { public int x = 1; } /* c */ // line +{{ tpl }} +def f(a, b=[1,2], *args, **kw): return {'k': a[0]} # py +let re = /ab[c\]]+/g; const s = `t${x}`; arr[0] ?? 3; +SELECT * FROM t WHERE a IN (1,2) -- sql +#include +key = value ; ini +[section] +- item: + nested: [1, 2] +0x1F 0b1010 1.5e-3 'c' "str" :sym @attr $var %h &&x ||y + tab and trailing spaces +#!/bin/sh diff --git a/tools/probe.cpp b/tools/probe.cpp new file mode 100644 index 0000000..4881df4 --- /dev/null +++ b/tools/probe.cpp @@ -0,0 +1,132 @@ +// Compiles every pattern of a grammars.dat with Boost, the way libprisma does, and writes down +// what each one matches in a corpus. PatternProbe.java does the same with java.util.regex and +// the two files are diffed, which is what holds the table to meaning one thing everywhere. +// +// The corpus is deliberately ASCII: Boost matches bytes where java.util.regex matches chars, so +// anything above U+007F diverges on offsets alone and would drown out the escape bugs. +#include + +#include "../libprisma/UnicodeEscapes.h" + +#include +#include +#include +#include +#include +#include +#include + +namespace { + + std::string readAll(const char* path) { + std::ifstream in(path, std::ios::binary); + return std::string((std::istreambuf_iterator(in)), std::istreambuf_iterator()); + } + + struct Reader { + const std::string& bytes; + size_t offset = 0; + + uint8_t uint8() { + return offset < bytes.size() ? static_cast(bytes[offset++]) : 0; + } + + uint16_t uint16() { + uint16_t low = uint8(); + return static_cast(low | (uint8() << 8)); + } + + std::string string() { + size_t length = uint8(); + if (length >= 254) { + size_t a = uint8(), b = uint8(), c = uint8(); + length = a | (b << 8) | (c << 16); + } + std::string value = bytes.substr(offset, length); + offset += length; + return value; + } + }; + + struct Entry { + std::string source; + boost::regex_constants::syntax_option_type flags; + }; + + // "/source/flags,alias,inside", the record LanguageTree::parsePatterns reads + std::vector read(const std::string& table) { + Reader reader{ table }; + std::vector entries; + + for (uint16_t count = reader.uint16(); count > 0; --count) { + const std::string item = reader.string(); + const size_t begin = item.find_first_of('/'); + const size_t end = item.find_last_of('/'); + if (begin == std::string::npos || end <= begin) { + continue; + } + + const std::string options = item.substr(end + 1); + const size_t aliasBegin = options.find_first_of(','); + + Entry entry; + entry.source = item.substr(begin + 1, end - (begin + 1)); + entry.flags = boost::regex_constants::ECMAScript | boost::regex_constants::no_mod_m; + + for (size_t i = 0; i < aliasBegin && i < options.size(); ++i) { + switch (options[i]) { + case 'i': entry.flags |= boost::regex_constants::icase; break; + case 'm': entry.flags &= ~boost::regex_constants::no_mod_m; break; + default: break; // l and y are libprisma's, for Prism lookbehind and greedy + } + } + + entries.push_back(entry); + } + + return entries; + } +} + +int main(int argc, char** argv) { + if (argc < 4) { + fprintf(stderr, "usage: probe \n"); + return 2; + } + + const std::vector entries = read(readAll(argv[1])); + + std::string corpus = readAll(argv[2]); + corpus.erase(std::remove(corpus.begin(), corpus.end(), '\r'), corpus.end()); + + std::ofstream out(argv[3], std::ios::binary); + int failed = 0; + + for (size_t i = 0; i < entries.size(); ++i) { + boost::regex re; + try { + re.assign(libprisma::widenUnicodeClasses(entries[i].source), entries[i].flags); + } catch (const std::exception& e) { + if (failed++ < 20) { + fprintf(stderr, "pattern %zu: %s\n %.140s\n", i, e.what(), entries[i].source.c_str()); + } + continue; + } + + out << i; + auto it = boost::sregex_iterator(corpus.begin(), corpus.end(), re, + boost::regex_constants::match_not_dot_newline); + for (auto end = boost::sregex_iterator(); it != end; ++it) { + out << ' ' << it->position() << ':' << (it->position() + it->length()); + } + out << '\n'; + } + + printf("compiled %zu of %zu patterns\n", entries.size() - failed, entries.size()); + + if (failed > 0) { + fprintf(stderr, "%d patterns Boost will not take.\n", failed); + return 1; + } + return 0; +} From 07ff1fcc7a881179d9f720f6920855db28d81219 Mon Sep 17 00:00:00 2001 From: FrayxRulez <8152849+FrayxRulez@users.noreply.github.com> Date: Mon, 21 Sep 2026 08:58:54 +0000 Subject: [PATCH 22/22] Update grammars --- libprisma/grammars.dat | Bin 630304 -> 631657 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/libprisma/grammars.dat b/libprisma/grammars.dat index fc950e2142e919493f04724821689e31f9cb4340..783d16838061dcdeed518aaec4297d323218587e 100644 GIT binary patch delta 2667 zcmb7G-)mb{95+puc5YP0eqgO^Yqq9Ma+7oKIXCx5Y@2ObC$iy2^~HOW_TJnZoZ56W z3AJmwJcv$*^CjX1MI87b%!x|D;PAyU{0BsI>_PV+Y#{pPlZfB%_jX+(Lno!*lkYj- z^Zot(oO|)>#O-erpC3!?9A?%;a&^saaMKV()%J6VqX#uMQL<~Prd>-;6!O+oGY^Mc zmVqiJw;Qr>-SsaLuRpo%VFm)QEplFaY9TTB8iP~WsRVNuBD)je?_$CB(#b+I948C1I)^#(SoNVtpMdhHi$YvITz@b&@l-@Hwr0Sa}}VuvO5Y(O9*okR<5a2 z)3oM@VoJEC5QW4*l2D(}(E{h8Zu2ZLXpVC-t>Xou;{~Cs5-u9u6CMhg8t$kjP{l-1 z#cZKx+#nNFDsG?@|vw5FIclV0*ymX9tjc@ng%Z9QfeCz5cKD`U{StfGS|v#5=Q9;Tln z)+voTrjg5(ASUp;al%dEr{?vg`LQu>`srR@yHhz+v-YxU+9DTQh$l6j~Q1PcuY z6p}2HmsQ5QWp*8aIZ5~DM<{b&8;wiKIyz64QqzMX08U#~TGd4toW9){=q^`{1h zrrBh^naR^&RE+f-H$S_iPa}~@V%nLB0EEm)F-VZ)_D{`=PB^*Z25D>rT zX$ENCWXvumr*|_wVrtikhEs7zf$DcNl`ckjA=4tOqDRhY&fQg^iMd`j85S37%NS0! zlQ}b2+zhcN@|2xrQq@`TYp0#EFO4w(6~vw_fs5tO6lcSPA=-dsW5M;8u!8@gmPxgh z1$Xgf=^Ek))D-)BGvPt$LS)ZmxKB9NoUsT=oXS064Kjgs`UkqT{=b4`VKauU>=2X6 zFE~rmZ}-44UM3(=sPRMek+Gs-!-j~{g2k8&aZ3(6f1~Fy)^7N6?&5=~qDn3ZH&gNJ2@)gqn8`1g}6nTB|zgQ0VlpCy^v|DquuyXVAebs;2zE% z_rN?DLnmaN;9jAbbRifx1;aqi?)xX`ZQw0J8}8yw9d#kB1BK@Tseurog-}YM56>aW zR0u!}r(5IWq!Dll1Qd^`V{Sa6x=#jt)3)p)oXd!nfB-t+0wPt%c{{TFOC%j!ul0=p zhQWJ80u=)hWGl0v{qffxe3mDVJn;;QIDTiS-uH;uwu6Xcx1yt6~ir3{Xnz{P0oq55&p1Rf^k7cD0y_H}N@^ z6=Qz97|*5(@sKrvWh;_&=-r{g-JSkR(Q030Ca7JGnwT6}F*~1Ljvii#h~W3J{ylp` zXTZt^{8VH_9InVZ@D46aDbNrE@$H+detgfKM08uJ13V=+lKT9bLsv zlR5URtcuQ}8+)ZMQV4E&v3;R^wKM3)jt}n`W@FZP9MV4xbAmI}an8o-5AK~|cFIn{ zM-2QGnxmr|pEJ-QAfyGi--w0i4;Qw)8GGlGIRNs5_NrA{T`Q*SwXUSt%T_52d44=h zSyzVOt<}}ceWbJVlREHYBrT(r<@Eii?|i2XTsyyW3Lgmz+W=}5`Vn0GX5hW2PlBp~ n6{js65n1tyDB8QT${`l0HJ;y*N~U^+&e>N7I`-AUYd8J|itH+& delta 1390 zcmZ`(Z%kWN6!*2zLPtUr2DC6nAEWJSUwe)C#wcxHVX}X?5to<|?|r2$eG@kRbfu-R zULX-O;*478*fS=*8|ACYR>#Tdo|_ z6#?RrGO)*@l|WW$Of&mSvXY1*4o<{bTuBoyWJR(n_dd-zP_X-KvX>n#22-%n`Ih7W zUHth(Z%4eVub1BkV7IS&Dj)%#KMJ7J@zX}0p&IuOiuU$(bG;|x^~u3d*pReyBR1=$ zSe(D$y?$~c^Um0n@w%3?x2E4bbMr=H(}_Oi)+EI+0*DX-qJO6Iu%(80`l50y6z_}i z{!##49l=Q15x-mBeNX_>fWIgYCHrC#p0I&n1Cngq+6u)h0WdXuIWaJ#znGDuO@$@^ zE#6>6wmXm$fsOh5(cg2yi!{i_x%s)-CBr_Nb{yDXikAqJlogw3MiCAr9oPn0>q2I8 z;0;|3iC73K(N;}q#-Gfek0*;G+Ip}wpMH2EFTWmm+}P>HoAZA@&VE@`3RsAeSy$z< zi3 zubUqMkYFnQG*iNE>i{=H$8JU7d_M?gPq#=3Dyu0B<2*F1WW^l#AFF)`2L5zy0?CVGC zzW2u4KYn&~=V+_g^bcRqIeGFFK_rRlin=(-B>!N{igQp?Zu)hTwmly}LMgR~By60g z>9y87>ZL)Asa9720?=8cUZ2&t=3WW{iv=U{V4`??pk`x9`R$yxnI*!qn#yT@32?hb zOk_oGvvCc)OQdd~1lzQnW*MkcZQ3VQOhOqM(l#@T>i0w1&s=1dktlvd8?`j)|%m)Dqlb*|oZaIdd zT{s>}a43wIu~3Nh)TZD+%Y!>nD+amTr zpH~vG4|?cEctXHykuV&YQ~&uucWw5V1E51F1p}#JqTS)`>QE8}j6v&m#gJH(w7R-i ztDjHAU-kM2Oof?(kpbP}Xb+0|cY}WAYJM%9HE1m}D)(0PpRgRs5FuM}K%#ECr(Pjn U5ug@lr;hRIHN85$mbdcoUq|K9q5uE@