@distri/react 0.2.7 → 0.2.8

package/dist/chunk-KFXYXJEI.js

@@ -0,0 +1,74 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/abnf.js
+var require_abnf = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/abnf.js"(exports, module) {
+    module.exports = abnf;
+    abnf.displayName = "abnf";
+    abnf.aliases = [];
+    function abnf(Prism) {
+      ;
+      (function(Prism2) {
+        var coreRules = "(?:ALPHA|BIT|CHAR|CR|CRLF|CTL|DIGIT|DQUOTE|HEXDIG|HTAB|LF|LWSP|OCTET|SP|VCHAR|WSP)";
+        Prism2.languages.abnf = {
+          comment: /;.*/,
+          string: {
+            pattern: /(?:%[is])?"[^"\n\r]*"/,
+            greedy: true,
+            inside: {
+              punctuation: /^%[is]/
+            }
+          },
+          range: {
+            pattern: /%(?:b[01]+-[01]+|d\d+-\d+|x[A-F\d]+-[A-F\d]+)/i,
+            alias: "number"
+          },
+          terminal: {
+            pattern: /%(?:b[01]+(?:\.[01]+)*|d\d+(?:\.\d+)*|x[A-F\d]+(?:\.[A-F\d]+)*)/i,
+            alias: "number"
+          },
+          repetition: {
+            pattern: /(^|[^\w-])(?:\d*\*\d*|\d+)/,
+            lookbehind: true,
+            alias: "operator"
+          },
+          definition: {
+            pattern: /(^[ \t]*)(?:[a-z][\w-]*|<[^<>\r\n]*>)(?=\s*=)/m,
+            lookbehind: true,
+            alias: "keyword",
+            inside: {
+              punctuation: /<|>/
+            }
+          },
+          "core-rule": {
+            pattern: RegExp(
+              "(?:(^|[^<\\w-])" + coreRules + "|<" + coreRules + ">)(?![\\w-])",
+              "i"
+            ),
+            lookbehind: true,
+            alias: ["rule", "constant"],
+            inside: {
+              punctuation: /<|>/
+            }
+          },
+          rule: {
+            pattern: /(^|[^<\w-])[a-z][\w-]*|<[^<>\r\n]*>/i,
+            lookbehind: true,
+            inside: {
+              punctuation: /<|>/
+            }
+          },
+          operator: /=\/?|\//,
+          punctuation: /[()\[\]]/
+        };
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_abnf
+};

package/dist/chunk-KMVKUGEN.js

@@ -0,0 +1,32 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/matlab.js
+var require_matlab = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/matlab.js"(exports, module) {
+    module.exports = matlab;
+    matlab.displayName = "matlab";
+    matlab.aliases = [];
+    function matlab(Prism) {
+      Prism.languages.matlab = {
+        comment: [/%\{[\s\S]*?\}%/, /%.+/],
+        string: {
+          pattern: /\B'(?:''|[^'\r\n])*'/,
+          greedy: true
+        },
+        // FIXME We could handle imaginary numbers as a whole
+        number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[eE][+-]?\d+)?(?:[ij])?|\b[ij]\b/,
+        keyword: /\b(?:NaN|break|case|catch|continue|else|elseif|end|for|function|if|inf|otherwise|parfor|pause|pi|return|switch|try|while)\b/,
+        function: /\b(?!\d)\w+(?=\s*\()/,
+        operator: /\.?[*^\/\\']|[+\-:@]|[<>=~]=?|&&?|\|\|?/,
+        punctuation: /\.{3}|[.,;\[\](){}!]/
+      };
+    }
+  }
+});
+
+export {
+  require_matlab
+};

package/dist/chunk-KSDU7X3Q.js

@@ -0,0 +1,97 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/wiki.js
+var require_wiki = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/wiki.js"(exports, module) {
+    module.exports = wiki;
+    wiki.displayName = "wiki";
+    wiki.aliases = [];
+    function wiki(Prism) {
+      Prism.languages.wiki = Prism.languages.extend("markup", {
+        "block-comment": {
+          pattern: /(^|[^\\])\/\*[\s\S]*?\*\//,
+          lookbehind: true,
+          alias: "comment"
+        },
+        heading: {
+          pattern: /^(=+)[^=\r\n].*?\1/m,
+          inside: {
+            punctuation: /^=+|=+$/,
+            important: /.+/
+          }
+        },
+        emphasis: {
+          // TODO Multi-line
+          pattern: /('{2,5}).+?\1/,
+          inside: {
+            "bold-italic": {
+              pattern: /(''''').+?(?=\1)/,
+              lookbehind: true,
+              alias: ["bold", "italic"]
+            },
+            bold: {
+              pattern: /(''')[^'](?:.*?[^'])?(?=\1)/,
+              lookbehind: true
+            },
+            italic: {
+              pattern: /('')[^'](?:.*?[^'])?(?=\1)/,
+              lookbehind: true
+            },
+            punctuation: /^''+|''+$/
+          }
+        },
+        hr: {
+          pattern: /^-{4,}/m,
+          alias: "punctuation"
+        },
+        url: [
+          /ISBN +(?:97[89][ -]?)?(?:\d[ -]?){9}[\dx]\b|(?:PMID|RFC) +\d+/i,
+          /\[\[.+?\]\]|\[.+?\]/
+        ],
+        variable: [
+          /__[A-Z]+__/,
+          // FIXME Nested structures should be handled
+          // {{formatnum:{{#expr:{{{3}}}}}}}
+          /\{{3}.+?\}{3}/,
+          /\{\{.+?\}\}/
+        ],
+        symbol: [/^#redirect/im, /~{3,5}/],
+        // Handle table attrs:
+        // {|
+        // ! style="text-align:left;"| Item
+        // |}
+        "table-tag": {
+          pattern: /((?:^|[|!])[|!])[^|\r\n]+\|(?!\|)/m,
+          lookbehind: true,
+          inside: {
+            "table-bar": {
+              pattern: /\|$/,
+              alias: "punctuation"
+            },
+            rest: Prism.languages.markup["tag"].inside
+          }
+        },
+        punctuation: /^(?:\{\||\|\}|\|-|[*#:;!|])|\|\||!!/m
+      });
+      Prism.languages.insertBefore("wiki", "tag", {
+        // Prevent highlighting inside <nowiki>, <source> and <pre> tags
+        nowiki: {
+          pattern: /<(nowiki|pre|source)\b[^>]*>[\s\S]*?<\/\1>/i,
+          inside: {
+            tag: {
+              pattern: /<(?:nowiki|pre|source)\b[^>]*>|<\/(?:nowiki|pre|source)>/i,
+              inside: Prism.languages.markup["tag"].inside
+            }
+          }
+        }
+      });
+    }
+  }
+});
+
+export {
+  require_wiki
+};

package/dist/chunk-L2OROVEO.js

@@ -0,0 +1,59 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/protobuf.js
+var require_protobuf = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/protobuf.js"(exports, module) {
+    module.exports = protobuf;
+    protobuf.displayName = "protobuf";
+    protobuf.aliases = [];
+    function protobuf(Prism) {
+      ;
+      (function(Prism2) {
+        var builtinTypes = /\b(?:bool|bytes|double|s?fixed(?:32|64)|float|[su]?int(?:32|64)|string)\b/;
+        Prism2.languages.protobuf = Prism2.languages.extend("clike", {
+          "class-name": [
+            {
+              pattern: /(\b(?:enum|extend|message|service)\s+)[A-Za-z_]\w*(?=\s*\{)/,
+              lookbehind: true
+            },
+            {
+              pattern: /(\b(?:rpc\s+\w+|returns)\s*\(\s*(?:stream\s+)?)\.?[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*(?=\s*\))/,
+              lookbehind: true
+            }
+          ],
+          keyword: /\b(?:enum|extend|extensions|import|message|oneof|option|optional|package|public|repeated|required|reserved|returns|rpc(?=\s+\w)|service|stream|syntax|to)\b(?!\s*=\s*\d)/,
+          function: /\b[a-z_]\w*(?=\s*\()/i
+        });
+        Prism2.languages.insertBefore("protobuf", "operator", {
+          map: {
+            pattern: /\bmap<\s*[\w.]+\s*,\s*[\w.]+\s*>(?=\s+[a-z_]\w*\s*[=;])/i,
+            alias: "class-name",
+            inside: {
+              punctuation: /[<>.,]/,
+              builtin: builtinTypes
+            }
+          },
+          builtin: builtinTypes,
+          "positional-class-name": {
+            pattern: /(?:\b|\B\.)[a-z_]\w*(?:\.[a-z_]\w*)*(?=\s+[a-z_]\w*\s*[=;])/i,
+            alias: "class-name",
+            inside: {
+              punctuation: /\./
+            }
+          },
+          annotation: {
+            pattern: /(\[\s*)[a-z_]\w*(?=\s*=)/i,
+            lookbehind: true
+          }
+        });
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_protobuf
+};

package/dist/chunk-L35GVMS6.js

@@ -0,0 +1,39 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/llvm.js
+var require_llvm = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/llvm.js"(exports, module) {
+    module.exports = llvm;
+    llvm.displayName = "llvm";
+    llvm.aliases = [];
+    function llvm(Prism) {
+      ;
+      (function(Prism2) {
+        Prism2.languages.llvm = {
+          comment: /;.*/,
+          string: {
+            pattern: /"[^"]*"/,
+            greedy: true
+          },
+          boolean: /\b(?:false|true)\b/,
+          variable: /[%@!#](?:(?!\d)(?:[-$.\w]|\\[a-f\d]{2})+|\d+)/i,
+          label: /(?!\d)(?:[-$.\w]|\\[a-f\d]{2})+:/i,
+          type: {
+            pattern: /\b(?:double|float|fp128|half|i[1-9]\d*|label|metadata|ppc_fp128|token|void|x86_fp80|x86_mmx)\b/,
+            alias: "class-name"
+          },
+          keyword: /\b[a-z_][a-z_0-9]*\b/,
+          number: /[+-]?\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b|\b0x[\dA-Fa-f]+\b|\b0xK[\dA-Fa-f]{20}\b|\b0x[ML][\dA-Fa-f]{32}\b|\b0xH[\dA-Fa-f]{4}\b/,
+          punctuation: /[{}[\];(),.!*=<>]/
+        };
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_llvm
+};

package/dist/chunk-L4KT7DFF.js

@@ -0,0 +1,49 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/magma.js
+var require_magma = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/magma.js"(exports, module) {
+    module.exports = magma;
+    magma.displayName = "magma";
+    magma.aliases = [];
+    function magma(Prism) {
+      Prism.languages.magma = {
+        output: {
+          pattern: /^(>.*(?:\r(?:\n|(?!\n))|\n))(?!>)(?:.+|(?:\r(?:\n|(?!\n))|\n)(?!>).*)(?:(?:\r(?:\n|(?!\n))|\n)(?!>).*)*/m,
+          lookbehind: true,
+          greedy: true
+        },
+        comment: {
+          pattern: /\/\/.*|\/\*[\s\S]*?\*\//,
+          greedy: true
+        },
+        string: {
+          pattern: /(^|[^\\"])"(?:[^\r\n\\"]|\\.)*"/,
+          lookbehind: true,
+          greedy: true
+        },
+        // http://magma.maths.usyd.edu.au/magma/handbook/text/82
+        keyword: /\b(?:_|adj|and|assert|assert2|assert3|assigned|break|by|case|cat|catch|clear|cmpeq|cmpne|continue|declare|default|delete|diff|div|do|elif|else|end|eq|error|eval|exists|exit|for|forall|forward|fprintf|freeze|function|ge|gt|if|iload|import|in|intrinsic|is|join|le|load|local|lt|meet|mod|ne|not|notadj|notin|notsubset|or|print|printf|procedure|quit|random|read|readi|repeat|require|requirege|requirerange|restore|return|save|sdiff|select|subset|then|time|to|try|until|vprint|vprintf|vtime|when|where|while|xor)\b/,
+        boolean: /\b(?:false|true)\b/,
+        generator: {
+          pattern: /\b[a-z_]\w*(?=\s*<)/i,
+          alias: "class-name"
+        },
+        function: /\b[a-z_]\w*(?=\s*\()/i,
+        number: {
+          pattern: /(^|[^\w.]|\.\.)(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?(?:_[a-z]?)?(?=$|[^\w.]|\.\.)/,
+          lookbehind: true
+        },
+        operator: /->|[-+*/^~!|#=]|:=|\.\./,
+        punctuation: /[()[\]{}<>,;.:]/
+      };
+    }
+  }
+});
+
+export {
+  require_magma
+};

package/dist/chunk-L4OBEVKY.js

@@ -0,0 +1,117 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/robotframework.js
+var require_robotframework = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/robotframework.js"(exports, module) {
+    module.exports = robotframework;
+    robotframework.displayName = "robotframework";
+    robotframework.aliases = [];
+    function robotframework(Prism) {
+      ;
+      (function(Prism2) {
+        var comment = {
+          pattern: /(^[ \t]*| {2}|\t)#.*/m,
+          lookbehind: true,
+          greedy: true
+        };
+        var variable = {
+          pattern: /((?:^|[^\\])(?:\\{2})*)[$@&%]\{(?:[^{}\r\n]|\{[^{}\r\n]*\})*\}/,
+          lookbehind: true,
+          inside: {
+            punctuation: /^[$@&%]\{|\}$/
+          }
+        };
+        function createSection(name, inside) {
+          var extendecInside = {};
+          extendecInside["section-header"] = {
+            pattern: /^ ?\*{3}.+?\*{3}/,
+            alias: "keyword"
+          };
+          for (var token in inside) {
+            extendecInside[token] = inside[token];
+          }
+          extendecInside["tag"] = {
+            pattern: /([\r\n](?: {2}|\t)[ \t]*)\[[-\w]+\]/,
+            lookbehind: true,
+            inside: {
+              punctuation: /\[|\]/
+            }
+          };
+          extendecInside["variable"] = variable;
+          extendecInside["comment"] = comment;
+          return {
+            pattern: RegExp(
+              /^ ?\*{3}[ \t]*<name>[ \t]*\*{3}(?:.|[\r\n](?!\*{3}))*/.source.replace(
+                /<name>/g,
+                function() {
+                  return name;
+                }
+              ),
+              "im"
+            ),
+            alias: "section",
+            inside: extendecInside
+          };
+        }
+        var docTag = {
+          pattern: /(\[Documentation\](?: {2}|\t)[ \t]*)(?![ \t]|#)(?:.|(?:\r\n?|\n)[ \t]*\.{3})+/,
+          lookbehind: true,
+          alias: "string"
+        };
+        var testNameLike = {
+          pattern: /([\r\n] ?)(?!#)(?:\S(?:[ \t]\S)*)+/,
+          lookbehind: true,
+          alias: "function",
+          inside: {
+            variable
+          }
+        };
+        var testPropertyLike = {
+          pattern: /([\r\n](?: {2}|\t)[ \t]*)(?!\[|\.{3}|#)(?:\S(?:[ \t]\S)*)+/,
+          lookbehind: true,
+          inside: {
+            variable
+          }
+        };
+        Prism2.languages["robotframework"] = {
+          settings: createSection("Settings", {
+            documentation: {
+              pattern: /([\r\n] ?Documentation(?: {2}|\t)[ \t]*)(?![ \t]|#)(?:.|(?:\r\n?|\n)[ \t]*\.{3})+/,
+              lookbehind: true,
+              alias: "string"
+            },
+            property: {
+              pattern: /([\r\n] ?)(?!\.{3}|#)(?:\S(?:[ \t]\S)*)+/,
+              lookbehind: true
+            }
+          }),
+          variables: createSection("Variables"),
+          "test-cases": createSection("Test Cases", {
+            "test-name": testNameLike,
+            documentation: docTag,
+            property: testPropertyLike
+          }),
+          keywords: createSection("Keywords", {
+            "keyword-name": testNameLike,
+            documentation: docTag,
+            property: testPropertyLike
+          }),
+          tasks: createSection("Tasks", {
+            "task-name": testNameLike,
+            documentation: docTag,
+            property: testPropertyLike
+          }),
+          comment
+        };
+        Prism2.languages.robot = Prism2.languages["robotframework"];
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_robotframework
+};

package/dist/chunk-L7KTXJ5T.js

@@ -0,0 +1,42 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/vhdl.js
+var require_vhdl = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/vhdl.js"(exports, module) {
+    module.exports = vhdl;
+    vhdl.displayName = "vhdl";
+    vhdl.aliases = [];
+    function vhdl(Prism) {
+      Prism.languages.vhdl = {
+        comment: /--.+/,
+        // support for all logic vectors
+        "vhdl-vectors": {
+          pattern: /\b[oxb]"[\da-f_]+"|"[01uxzwlh-]+"/i,
+          alias: "number"
+        },
+        // support for operator overloading included
+        "quoted-function": {
+          pattern: /"\S+?"(?=\()/,
+          alias: "function"
+        },
+        string: /"(?:[^\\"\r\n]|\\(?:\r\n|[\s\S]))*"/,
+        constant: /\b(?:library|use)\b/i,
+        // support for predefined attributes included
+        keyword: /\b(?:'active|'ascending|'base|'delayed|'driving|'driving_value|'event|'high|'image|'instance_name|'last_active|'last_event|'last_value|'left|'leftof|'length|'low|'path_name|'pos|'pred|'quiet|'range|'reverse_range|'right|'rightof|'simple_name|'stable|'succ|'transaction|'val|'value|access|after|alias|all|architecture|array|assert|attribute|begin|block|body|buffer|bus|case|component|configuration|constant|disconnect|downto|else|elsif|end|entity|exit|file|for|function|generate|generic|group|guarded|if|impure|in|inertial|inout|is|label|library|linkage|literal|loop|map|new|next|null|of|on|open|others|out|package|port|postponed|procedure|process|pure|range|record|register|reject|report|return|select|severity|shared|signal|subtype|then|to|transport|type|unaffected|units|until|use|variable|wait|when|while|with)\b/i,
+        boolean: /\b(?:false|true)\b/i,
+        function: /\w+(?=\()/,
+        // decimal, based, physical, and exponential numbers supported
+        number: /'[01uxzwlh-]'|\b(?:\d+#[\da-f_.]+#|\d[\d_.]*)(?:e[-+]?\d+)?/i,
+        operator: /[<>]=?|:=|[-+*/&=]|\b(?:abs|and|mod|nand|nor|not|or|rem|rol|ror|sla|sll|sra|srl|xnor|xor)\b/i,
+        punctuation: /[{}[\];(),.:]/
+      };
+    }
+  }
+});
+
+export {
+  require_vhdl
+};

package/dist/chunk-LNJTL4XT.js

@@ -0,0 +1,59 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/fortran.js
+var require_fortran = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/fortran.js"(exports, module) {
+    module.exports = fortran;
+    fortran.displayName = "fortran";
+    fortran.aliases = [];
+    function fortran(Prism) {
+      Prism.languages.fortran = {
+        "quoted-number": {
+          pattern: /[BOZ](['"])[A-F0-9]+\1/i,
+          alias: "number"
+        },
+        string: {
+          pattern: /(?:\b\w+_)?(['"])(?:\1\1|&(?:\r\n?|\n)(?:[ \t]*!.*(?:\r\n?|\n)|(?![ \t]*!))|(?!\1).)*(?:\1|&)/,
+          inside: {
+            comment: {
+              pattern: /(&(?:\r\n?|\n)\s*)!.*/,
+              lookbehind: true
+            }
+          }
+        },
+        comment: {
+          pattern: /!.*/,
+          greedy: true
+        },
+        boolean: /\.(?:FALSE|TRUE)\.(?:_\w+)?/i,
+        number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[ED][+-]?\d+)?(?:_\w+)?/i,
+        keyword: [
+          // Types
+          /\b(?:CHARACTER|COMPLEX|DOUBLE ?PRECISION|INTEGER|LOGICAL|REAL)\b/i,
+          // END statements
+          /\b(?:END ?)?(?:BLOCK ?DATA|DO|FILE|FORALL|FUNCTION|IF|INTERFACE|MODULE(?! PROCEDURE)|PROGRAM|SELECT|SUBROUTINE|TYPE|WHERE)\b/i,
+          // Statements
+          /\b(?:ALLOCATABLE|ALLOCATE|BACKSPACE|CALL|CASE|CLOSE|COMMON|CONTAINS|CONTINUE|CYCLE|DATA|DEALLOCATE|DIMENSION|DO|END|EQUIVALENCE|EXIT|EXTERNAL|FORMAT|GO ?TO|IMPLICIT(?: NONE)?|INQUIRE|INTENT|INTRINSIC|MODULE PROCEDURE|NAMELIST|NULLIFY|OPEN|OPTIONAL|PARAMETER|POINTER|PRINT|PRIVATE|PUBLIC|READ|RETURN|REWIND|SAVE|SELECT|STOP|TARGET|WHILE|WRITE)\b/i,
+          // Others
+          /\b(?:ASSIGNMENT|DEFAULT|ELEMENTAL|ELSE|ELSEIF|ELSEWHERE|ENTRY|IN|INCLUDE|INOUT|KIND|NULL|ONLY|OPERATOR|OUT|PURE|RECURSIVE|RESULT|SEQUENCE|STAT|THEN|USE)\b/i
+        ],
+        operator: [
+          /\*\*|\/\/|=>|[=\/]=|[<>]=?|::|[+\-*=%]|\.[A-Z]+\./i,
+          {
+            // Use lookbehind to prevent confusion with (/ /)
+            pattern: /(^|(?!\().)\/(?!\))/,
+            lookbehind: true
+          }
+        ],
+        punctuation: /\(\/|\/\)|[(),;:&]/
+      };
+    }
+  }
+});
+
+export {
+  require_fortran
+};