@distri/react 0.3.1 → 0.3.2

package/dist/chunk-IKJLE5M7.js

@@ -0,0 +1,366 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/sas.js
+var require_sas = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/sas.js"(exports, module) {
+    module.exports = sas;
+    sas.displayName = "sas";
+    sas.aliases = [];
+    function sas(Prism) {
+      ;
+      (function(Prism2) {
+        var stringPattern = /(?:"(?:""|[^"])*"(?!")|'(?:''|[^'])*'(?!'))/.source;
+        var number = /\b(?:\d[\da-f]*x|\d+(?:\.\d+)?(?:e[+-]?\d+)?)\b/i;
+        var numericConstant = {
+          pattern: RegExp(stringPattern + "[bx]"),
+          alias: "number"
+        };
+        var macroVariable = {
+          pattern: /&[a-z_]\w*/i
+        };
+        var macroKeyword = {
+          pattern: /((?:^|\s|=|\())%(?:ABORT|BY|CMS|COPY|DISPLAY|DO|ELSE|END|EVAL|GLOBAL|GO|GOTO|IF|INC|INCLUDE|INDEX|INPUT|KTRIM|LENGTH|LET|LIST|LOCAL|PUT|QKTRIM|QSCAN|QSUBSTR|QSYSFUNC|QUPCASE|RETURN|RUN|SCAN|SUBSTR|SUPERQ|SYMDEL|SYMEXIST|SYMGLOBL|SYMLOCAL|SYSCALL|SYSEVALF|SYSEXEC|SYSFUNC|SYSGET|SYSRPUT|THEN|TO|TSO|UNQUOTE|UNTIL|UPCASE|WHILE|WINDOW)\b/i,
+          lookbehind: true,
+          alias: "keyword"
+        };
+        var step = {
+          pattern: /(^|\s)(?:proc\s+\w+|data(?!=)|quit|run)\b/i,
+          alias: "keyword",
+          lookbehind: true
+        };
+        var comment = [
+          /\/\*[\s\S]*?\*\//,
+          {
+            pattern: /(^[ \t]*|;\s*)\*[^;]*;/m,
+            lookbehind: true
+          }
+        ];
+        var string = {
+          pattern: RegExp(stringPattern),
+          greedy: true
+        };
+        var punctuation = /[$%@.(){}\[\];,\\]/;
+        var func = {
+          pattern: /%?\b\w+(?=\()/,
+          alias: "keyword"
+        };
+        var args = {
+          function: func,
+          "arg-value": {
+            pattern: /(=\s*)[A-Z\.]+/i,
+            lookbehind: true
+          },
+          operator: /=/,
+          "macro-variable": macroVariable,
+          arg: {
+            pattern: /[A-Z]+/i,
+            alias: "keyword"
+          },
+          number,
+          "numeric-constant": numericConstant,
+          punctuation,
+          string
+        };
+        var format = {
+          pattern: /\b(?:format|put)\b=?[\w'$.]+/i,
+          inside: {
+            keyword: /^(?:format|put)(?==)/i,
+            equals: /=/,
+            format: {
+              pattern: /(?:\w|\$\d)+\.\d?/,
+              alias: "number"
+            }
+          }
+        };
+        var altformat = {
+          pattern: /\b(?:format|put)\s+[\w']+(?:\s+[$.\w]+)+(?=;)/i,
+          inside: {
+            keyword: /^(?:format|put)/i,
+            format: {
+              pattern: /[\w$]+\.\d?/,
+              alias: "number"
+            }
+          }
+        };
+        var globalStatements = {
+          pattern: /((?:^|\s)=?)(?:catname|checkpoint execute_always|dm|endsas|filename|footnote|%include|libname|%list|lock|missing|options|page|resetline|%run|sasfile|skip|sysecho|title\d?)\b/i,
+          lookbehind: true,
+          alias: "keyword"
+        };
+        var submitStatement = {
+          pattern: /(^|\s)(?:submit(?:\s+(?:load|norun|parseonly))?|endsubmit)\b/i,
+          lookbehind: true,
+          alias: "keyword"
+        };
+        var actionSets = /aStore|accessControl|aggregation|audio|autotune|bayesianNetClassifier|bioMedImage|boolRule|builtins|cardinality|cdm|clustering|conditionalRandomFields|configuration|copula|countreg|dataDiscovery|dataPreprocess|dataSciencePilot|dataStep|decisionTree|deduplication|deepLearn|deepNeural|deepRnn|ds2|ecm|entityRes|espCluster|explainModel|factmac|fastKnn|fcmpact|fedSql|freqTab|gVarCluster|gam|gleam|graphSemiSupLearn|hiddenMarkovModel|hyperGroup|ica|image|iml|kernalPca|langModel|ldaTopic|loadStreams|mbc|mixed|mlTools|modelPublishing|network|neuralNet|nmf|nonParametricBayes|nonlinear|optNetwork|optimization|panel|pca|percentile|phreg|pls|qkb|qlim|quantreg|recommend|regression|reinforcementLearn|robustPca|ruleMining|sampling|sandwich|sccasl|search(?:Analytics)?|sentimentAnalysis|sequence|session(?:Prop)?|severity|simSystem|simple|smartData|sparkEmbeddedProcess|sparseML|spatialreg|spc|stabilityMonitoring|svDataDescription|svm|table|text(?:Filters|Frequency|Mining|Parse|Rule(?:Develop|Score)|Topic|Util)|timeData|transpose|tsInfo|tsReconcile|uniTimeSeries|varReduce/.source;
+        var casActions = {
+          pattern: RegExp(
+            /(^|\s)(?:action\s+)?(?:<act>)\.[a-z]+\b[^;]+/.source.replace(
+              /<act>/g,
+              function() {
+                return actionSets;
+              }
+            ),
+            "i"
+          ),
+          lookbehind: true,
+          inside: {
+            keyword: RegExp(
+              /(?:<act>)\.[a-z]+\b/.source.replace(/<act>/g, function() {
+                return actionSets;
+              }),
+              "i"
+            ),
+            action: {
+              pattern: /(?:action)/i,
+              alias: "keyword"
+            },
+            comment,
+            function: func,
+            "arg-value": args["arg-value"],
+            operator: args.operator,
+            argument: args.arg,
+            number,
+            "numeric-constant": numericConstant,
+            punctuation,
+            string
+          }
+        };
+        var keywords = {
+          pattern: /((?:^|\s)=?)(?:after|analysis|and|array|barchart|barwidth|begingraph|by|call|cas|cbarline|cfill|class(?:lev)?|close|column|computed?|contains|continue|data(?==)|define|delete|describe|document|do\s+over|do|dol|drop|dul|else|end(?:comp|source)?|entryTitle|eval(?:uate)?|exec(?:ute)?|exit|file(?:name)?|fill(?:attrs)?|flist|fnc|function(?:list)?|global|goto|group(?:by)?|headline|headskip|histogram|if|infile|keep|keylabel|keyword|label|layout|leave|legendlabel|length|libname|loadactionset|merge|midpoints|_?null_|name|noobs|nowd|ods|options|or|otherwise|out(?:put)?|over(?:lay)?|plot|print|put|raise|ranexp|rannor|rbreak|retain|return|select|session|sessref|set|source|statgraph|sum|summarize|table|temp|terminate|then\s+do|then|title\d?|to|var|when|where|xaxisopts|y2axisopts|yaxisopts)\b/i,
+          lookbehind: true
+        };
+        Prism2.languages.sas = {
+          datalines: {
+            pattern: /^([ \t]*)(?:cards|(?:data)?lines);[\s\S]+?^[ \t]*;/im,
+            lookbehind: true,
+            alias: "string",
+            inside: {
+              keyword: {
+                pattern: /^(?:cards|(?:data)?lines)/i
+              },
+              punctuation: /;/
+            }
+          },
+          "proc-sql": {
+            pattern: /(^proc\s+(?:fed)?sql(?:\s+[\w|=]+)?;)[\s\S]+?(?=^(?:proc\s+\w+|data|quit|run);|(?![\s\S]))/im,
+            lookbehind: true,
+            inside: {
+              sql: {
+                pattern: RegExp(
+                  /^[ \t]*(?:select|alter\s+table|(?:create|describe|drop)\s+(?:index|table(?:\s+constraints)?|view)|create\s+unique\s+index|insert\s+into|update)(?:<str>|[^;"'])+;/.source.replace(
+                    /<str>/g,
+                    function() {
+                      return stringPattern;
+                    }
+                  ),
+                  "im"
+                ),
+                alias: "language-sql",
+                inside: Prism2.languages.sql
+              },
+              "global-statements": globalStatements,
+              "sql-statements": {
+                pattern: /(^|\s)(?:disconnect\s+from|begin|commit|exec(?:ute)?|reset|rollback|validate)\b/i,
+                lookbehind: true,
+                alias: "keyword"
+              },
+              number,
+              "numeric-constant": numericConstant,
+              punctuation,
+              string
+            }
+          },
+          "proc-groovy": {
+            pattern: /(^proc\s+groovy(?:\s+[\w|=]+)?;)[\s\S]+?(?=^(?:proc\s+\w+|data|quit|run);|(?![\s\S]))/im,
+            lookbehind: true,
+            inside: {
+              comment,
+              groovy: {
+                pattern: RegExp(
+                  /(^[ \t]*submit(?:\s+(?:load|norun|parseonly))?)(?:<str>|[^"'])+?(?=endsubmit;)/.source.replace(
+                    /<str>/g,
+                    function() {
+                      return stringPattern;
+                    }
+                  ),
+                  "im"
+                ),
+                lookbehind: true,
+                alias: "language-groovy",
+                inside: Prism2.languages.groovy
+              },
+              keyword: keywords,
+              "submit-statement": submitStatement,
+              "global-statements": globalStatements,
+              number,
+              "numeric-constant": numericConstant,
+              punctuation,
+              string
+            }
+          },
+          "proc-lua": {
+            pattern: /(^proc\s+lua(?:\s+[\w|=]+)?;)[\s\S]+?(?=^(?:proc\s+\w+|data|quit|run);|(?![\s\S]))/im,
+            lookbehind: true,
+            inside: {
+              comment,
+              lua: {
+                pattern: RegExp(
+                  /(^[ \t]*submit(?:\s+(?:load|norun|parseonly))?)(?:<str>|[^"'])+?(?=endsubmit;)/.source.replace(
+                    /<str>/g,
+                    function() {
+                      return stringPattern;
+                    }
+                  ),
+                  "im"
+                ),
+                lookbehind: true,
+                alias: "language-lua",
+                inside: Prism2.languages.lua
+              },
+              keyword: keywords,
+              "submit-statement": submitStatement,
+              "global-statements": globalStatements,
+              number,
+              "numeric-constant": numericConstant,
+              punctuation,
+              string
+            }
+          },
+          "proc-cas": {
+            pattern: /(^proc\s+cas(?:\s+[\w|=]+)?;)[\s\S]+?(?=^(?:proc\s+\w+|quit|data);|(?![\s\S]))/im,
+            lookbehind: true,
+            inside: {
+              comment,
+              "statement-var": {
+                pattern: /((?:^|\s)=?)saveresult\s[^;]+/im,
+                lookbehind: true,
+                inside: {
+                  statement: {
+                    pattern: /^saveresult\s+\S+/i,
+                    inside: {
+                      keyword: /^(?:saveresult)/i
+                    }
+                  },
+                  rest: args
+                }
+              },
+              "cas-actions": casActions,
+              statement: {
+                pattern: /((?:^|\s)=?)(?:default|(?:un)?set|on|output|upload)[^;]+/im,
+                lookbehind: true,
+                inside: args
+              },
+              step,
+              keyword: keywords,
+              function: func,
+              format,
+              altformat,
+              "global-statements": globalStatements,
+              number,
+              "numeric-constant": numericConstant,
+              punctuation,
+              string
+            }
+          },
+          "proc-args": {
+            pattern: RegExp(
+              /(^proc\s+\w+\s+)(?!\s)(?:[^;"']|<str>)+;/.source.replace(
+                /<str>/g,
+                function() {
+                  return stringPattern;
+                }
+              ),
+              "im"
+            ),
+            lookbehind: true,
+            inside: args
+          },
+          /*Special keywords within macros*/
+          "macro-keyword": macroKeyword,
+          "macro-variable": macroVariable,
+          "macro-string-functions": {
+            pattern: /((?:^|\s|=))%(?:BQUOTE|NRBQUOTE|NRQUOTE|NRSTR|QUOTE|STR)\(.*?(?:[^%]\))/i,
+            lookbehind: true,
+            inside: {
+              function: {
+                pattern: /%(?:BQUOTE|NRBQUOTE|NRQUOTE|NRSTR|QUOTE|STR)/i,
+                alias: "keyword"
+              },
+              "macro-keyword": macroKeyword,
+              "macro-variable": macroVariable,
+              "escaped-char": {
+                pattern: /%['"()<>=¬^~;,#]/
+              },
+              punctuation
+            }
+          },
+          "macro-declaration": {
+            pattern: /^%macro[^;]+(?=;)/im,
+            inside: {
+              keyword: /%macro/i
+            }
+          },
+          "macro-end": {
+            pattern: /^%mend[^;]+(?=;)/im,
+            inside: {
+              keyword: /%mend/i
+            }
+          },
+          /*%_zscore(headcir, _lhc, _mhc, _shc, headcz, headcpct, _Fheadcz); */
+          macro: {
+            pattern: /%_\w+(?=\()/,
+            alias: "keyword"
+          },
+          input: {
+            pattern: /\binput\s[-\w\s/*.$&]+;/i,
+            inside: {
+              input: {
+                alias: "keyword",
+                pattern: /^input/i
+              },
+              comment,
+              number,
+              "numeric-constant": numericConstant
+            }
+          },
+          "options-args": {
+            pattern: /(^options)[-'"|/\\<>*+=:()\w\s]*(?=;)/im,
+            lookbehind: true,
+            inside: args
+          },
+          "cas-actions": casActions,
+          comment,
+          function: func,
+          format,
+          altformat,
+          "numeric-constant": numericConstant,
+          datetime: {
+            // '1jan2013'd, '9:25:19pm't, '18jan2003:9:27:05am'dt
+            pattern: RegExp(stringPattern + "(?:dt?|t)"),
+            alias: "number"
+          },
+          string,
+          step,
+          keyword: keywords,
+          // In SAS Studio syntax highlighting, these operators are styled like keywords
+          "operator-keyword": {
+            pattern: /\b(?:eq|ge|gt|in|le|lt|ne|not)\b/i,
+            alias: "operator"
+          },
+          // Decimal (1.2e23), hexadecimal (0c1x)
+          number,
+          operator: /\*\*?|\|\|?|!!?|¦¦?|<[>=]?|>[<=]?|[-+\/=&]|[~¬^]=?/,
+          punctuation
+        };
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_sas
+};

package/dist/chunk-IR7VL7RD.js

@@ -0,0 +1,82 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/dhall.js
+var require_dhall = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/dhall.js"(exports, module) {
+    module.exports = dhall;
+    dhall.displayName = "dhall";
+    dhall.aliases = [];
+    function dhall(Prism) {
+      Prism.languages.dhall = {
+        // Multi-line comments can be nested. E.g. {- foo {- bar -} -}
+        // The multi-line pattern is essentially this:
+        //   \{-(?:[^-{]|-(?!\})|\{(?!-)|<SELF>)*-\}
+        comment: /--.*|\{-(?:[^-{]|-(?!\})|\{(?!-)|\{-(?:[^-{]|-(?!\})|\{(?!-))*-\})*-\}/,
+        string: {
+          pattern: /"(?:[^"\\]|\\.)*"|''(?:[^']|'(?!')|'''|''\$\{)*''(?!'|\$)/,
+          greedy: true,
+          inside: {
+            interpolation: {
+              pattern: /\$\{[^{}]*\}/,
+              inside: {
+                expression: {
+                  pattern: /(^\$\{)[\s\S]+(?=\}$)/,
+                  lookbehind: true,
+                  alias: "language-dhall",
+                  inside: null
+                  // see blow
+                },
+                punctuation: /\$\{|\}/
+              }
+            }
+          }
+        },
+        label: {
+          pattern: /`[^`]*`/,
+          greedy: true
+        },
+        url: {
+          // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L596
+          pattern: /\bhttps?:\/\/[\w.:%!$&'*+;=@~-]+(?:\/[\w.:%!$&'*+;=@~-]*)*(?:\?[/?\w.:%!$&'*+;=@~-]*)?/,
+          greedy: true
+        },
+        env: {
+          // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L661
+          pattern: /\benv:(?:(?!\d)\w+|"(?:[^"\\=]|\\.)*")/,
+          greedy: true,
+          inside: {
+            function: /^env/,
+            operator: /^:/,
+            variable: /[\s\S]+/
+          }
+        },
+        hash: {
+          // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L725
+          pattern: /\bsha256:[\da-fA-F]{64}\b/,
+          inside: {
+            function: /sha256/,
+            operator: /:/,
+            number: /[\da-fA-F]{64}/
+          }
+        },
+        // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L359
+        keyword: /\b(?:as|assert|else|forall|if|in|let|merge|missing|then|toMap|using|with)\b|\u2200/,
+        builtin: /\b(?:None|Some)\b/,
+        boolean: /\b(?:False|True)\b/,
+        number: /\bNaN\b|-?\bInfinity\b|[+-]?\b(?:0x[\da-fA-F]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?)\b/,
+        operator: /\/\\|\/\/\\\\|&&|\|\||===|[!=]=|\/\/|->|\+\+|::|[+*#@=:?<>|\\\u2227\u2a53\u2261\u2afd\u03bb\u2192]/,
+        punctuation: /\.\.|[{}\[\](),./]/,
+        // we'll just assume that every capital word left is a type name
+        "class-name": /\b[A-Z]\w*\b/
+      };
+      Prism.languages.dhall.string.inside.interpolation.inside.expression.inside = Prism.languages.dhall;
+    }
+  }
+});
+
+export {
+  require_dhall
+};

package/dist/chunk-IRD7U5ZU.js

@@ -0,0 +1,51 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/iecst.js
+var require_iecst = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/iecst.js"(exports, module) {
+    module.exports = iecst;
+    iecst.displayName = "iecst";
+    iecst.aliases = [];
+    function iecst(Prism) {
+      Prism.languages.iecst = {
+        comment: [
+          {
+            pattern: /(^|[^\\])(?:\/\*[\s\S]*?(?:\*\/|$)|\(\*[\s\S]*?(?:\*\)|$)|\{[\s\S]*?(?:\}|$))/,
+            lookbehind: true,
+            greedy: true
+          },
+          {
+            pattern: /(^|[^\\:])\/\/.*/,
+            lookbehind: true,
+            greedy: true
+          }
+        ],
+        string: {
+          pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+          greedy: true
+        },
+        keyword: [
+          /\b(?:END_)?(?:PROGRAM|CONFIGURATION|INTERFACE|FUNCTION_BLOCK|FUNCTION|ACTION|TRANSITION|TYPE|STRUCT|(?:INITIAL_)?STEP|NAMESPACE|LIBRARY|CHANNEL|FOLDER|RESOURCE|VAR_(?:ACCESS|CONFIG|EXTERNAL|GLOBAL|INPUT|IN_OUT|OUTPUT|TEMP)|VAR|METHOD|PROPERTY)\b/i,
+          /\b(?:AT|BY|(?:END_)?(?:CASE|FOR|IF|REPEAT|WHILE)|CONSTANT|CONTINUE|DO|ELSE|ELSIF|EXIT|EXTENDS|FROM|GET|GOTO|IMPLEMENTS|JMP|NON_RETAIN|OF|PRIVATE|PROTECTED|PUBLIC|RETAIN|RETURN|SET|TASK|THEN|TO|UNTIL|USING|WITH|__CATCH|__ENDTRY|__FINALLY|__TRY)\b/
+        ],
+        "class-name": /\b(?:ANY|ARRAY|BOOL|BYTE|U?(?:D|L|S)?INT|(?:D|L)?WORD|DATE(?:_AND_TIME)?|DT|L?REAL|POINTER|STRING|TIME(?:_OF_DAY)?|TOD)\b/,
+        address: {
+          pattern: /%[IQM][XBWDL][\d.]*|%[IQ][\d.]*/,
+          alias: "symbol"
+        },
+        number: /\b(?:16#[\da-f]+|2#[01_]+|0x[\da-f]+)\b|\b(?:D|DT|T|TOD)#[\d_shmd:]*|\b[A-Z]*#[\d.,_]*|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
+        boolean: /\b(?:FALSE|NULL|TRUE)\b/,
+        operator: /S?R?:?=>?|&&?|\*\*?|<[=>]?|>=?|[-:^/+#]|\b(?:AND|EQ|EXPT|GE|GT|LE|LT|MOD|NE|NOT|OR|XOR)\b/,
+        function: /\b[a-z_]\w*(?=\s*\()/i,
+        punctuation: /[()[\].,;]/
+      };
+    }
+  }
+});
+
+export {
+  require_iecst
+};

package/dist/chunk-IYFR4CDA.js

@@ -0,0 +1,44 @@
+"use client";
+import {
+  require_json
+} from "./chunk-RDF5QBXB.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/json5.js
+var require_json5 = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/json5.js"(exports, module) {
+    var refractorJson = require_json();
+    module.exports = json5;
+    json5.displayName = "json5";
+    json5.aliases = [];
+    function json5(Prism) {
+      Prism.register(refractorJson);
+      (function(Prism2) {
+        var string = /("|')(?:\\(?:\r\n?|\n|.)|(?!\1)[^\\\r\n])*\1/;
+        Prism2.languages.json5 = Prism2.languages.extend("json", {
+          property: [
+            {
+              pattern: RegExp(string.source + "(?=\\s*:)"),
+              greedy: true
+            },
+            {
+              pattern: /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/,
+              alias: "unquoted"
+            }
+          ],
+          string: {
+            pattern: string,
+            greedy: true
+          },
+          number: /[+-]?\b(?:NaN|Infinity|0x[a-fA-F\d]+)\b|[+-]?(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[eE][+-]?\d+\b)?/
+        });
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_json5
+};

package/dist/chunk-J7AEKJ46.js

@@ -0,0 +1,144 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/nevod.js
+var require_nevod = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/nevod.js"(exports, module) {
+    module.exports = nevod;
+    nevod.displayName = "nevod";
+    nevod.aliases = [];
+    function nevod(Prism) {
+      Prism.languages.nevod = {
+        comment: /\/\/.*|(?:\/\*[\s\S]*?(?:\*\/|$))/,
+        string: {
+          pattern: /(?:"(?:""|[^"])*"(?!")|'(?:''|[^'])*'(?!'))!?\*?/,
+          greedy: true,
+          inside: {
+            "string-attrs": /!$|!\*$|\*$/
+          }
+        },
+        namespace: {
+          pattern: /(@namespace\s+)[a-zA-Z0-9\-.]+(?=\s*\{)/,
+          lookbehind: true
+        },
+        pattern: {
+          pattern: /(@pattern\s+)?#?[a-zA-Z0-9\-.]+(?:\s*\(\s*(?:~\s*)?[a-zA-Z0-9\-.]+\s*(?:,\s*(?:~\s*)?[a-zA-Z0-9\-.]*)*\))?(?=\s*=)/,
+          lookbehind: true,
+          inside: {
+            "pattern-name": {
+              pattern: /^#?[a-zA-Z0-9\-.]+/,
+              alias: "class-name"
+            },
+            fields: {
+              pattern: /\(.*\)/,
+              inside: {
+                "field-name": {
+                  pattern: /[a-zA-Z0-9\-.]+/,
+                  alias: "variable"
+                },
+                punctuation: /[,()]/,
+                operator: {
+                  pattern: /~/,
+                  alias: "field-hidden-mark"
+                }
+              }
+            }
+          }
+        },
+        search: {
+          pattern: /(@search\s+|#)[a-zA-Z0-9\-.]+(?:\.\*)?(?=\s*;)/,
+          alias: "function",
+          lookbehind: true
+        },
+        keyword: /@(?:having|inside|namespace|outside|pattern|require|search|where)\b/,
+        "standard-pattern": {
+          pattern: /\b(?:Alpha|AlphaNum|Any|Blank|End|LineBreak|Num|NumAlpha|Punct|Space|Start|Symbol|Word|WordBreak)\b(?:\([a-zA-Z0-9\-.,\s+]*\))?/,
+          inside: {
+            "standard-pattern-name": {
+              pattern: /^[a-zA-Z0-9\-.]+/,
+              alias: "builtin"
+            },
+            quantifier: {
+              pattern: /\b\d+(?:\s*\+|\s*-\s*\d+)?(?!\w)/,
+              alias: "number"
+            },
+            "standard-pattern-attr": {
+              pattern: /[a-zA-Z0-9\-.]+/,
+              alias: "builtin"
+            },
+            punctuation: /[,()]/
+          }
+        },
+        quantifier: {
+          pattern: /\b\d+(?:\s*\+|\s*-\s*\d+)?(?!\w)/,
+          alias: "number"
+        },
+        operator: [
+          {
+            pattern: /=/,
+            alias: "pattern-def"
+          },
+          {
+            pattern: /&/,
+            alias: "conjunction"
+          },
+          {
+            pattern: /~/,
+            alias: "exception"
+          },
+          {
+            pattern: /\?/,
+            alias: "optionality"
+          },
+          {
+            pattern: /[[\]]/,
+            alias: "repetition"
+          },
+          {
+            pattern: /[{}]/,
+            alias: "variation"
+          },
+          {
+            pattern: /[+_]/,
+            alias: "sequence"
+          },
+          {
+            pattern: /\.{2,3}/,
+            alias: "span"
+          }
+        ],
+        "field-capture": [
+          {
+            pattern: /([a-zA-Z0-9\-.]+\s*\()\s*[a-zA-Z0-9\-.]+\s*:\s*[a-zA-Z0-9\-.]+(?:\s*,\s*[a-zA-Z0-9\-.]+\s*:\s*[a-zA-Z0-9\-.]+)*(?=\s*\))/,
+            lookbehind: true,
+            inside: {
+              "field-name": {
+                pattern: /[a-zA-Z0-9\-.]+/,
+                alias: "variable"
+              },
+              colon: /:/
+            }
+          },
+          {
+            pattern: /[a-zA-Z0-9\-.]+\s*:/,
+            inside: {
+              "field-name": {
+                pattern: /[a-zA-Z0-9\-.]+/,
+                alias: "variable"
+              },
+              colon: /:/
+            }
+          }
+        ],
+        punctuation: /[:;,()]/,
+        name: /[a-zA-Z0-9\-.]+/
+      };
+    }
+  }
+});
+
+export {
+  require_nevod
+};