@distri/react 0.3.2 → 0.3.4

package/dist/chunk-4MGSP4TC.js

@@ -1,97 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/typoscript.js
-var require_typoscript = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/typoscript.js"(exports, module) {
-    module.exports = typoscript;
-    typoscript.displayName = "typoscript";
-    typoscript.aliases = ["tsconfig"];
-    function typoscript(Prism) {
-      ;
-      (function(Prism2) {
-        var keywords = /\b(?:ACT|ACTIFSUB|CARRAY|CASE|CLEARGIF|COA|COA_INT|CONSTANTS|CONTENT|CUR|EDITPANEL|EFFECT|EXT|FILE|FLUIDTEMPLATE|FORM|FRAME|FRAMESET|GIFBUILDER|GMENU|GMENU_FOLDOUT|GMENU_LAYERS|GP|HMENU|HRULER|HTML|IENV|IFSUB|IMAGE|IMGMENU|IMGMENUITEM|IMGTEXT|IMG_RESOURCE|INCLUDE_TYPOSCRIPT|JSMENU|JSMENUITEM|LLL|LOAD_REGISTER|NO|PAGE|RECORDS|RESTORE_REGISTER|TEMPLATE|TEXT|TMENU|TMENUITEM|TMENU_LAYERS|USER|USER_INT|_GIFBUILDER|global|globalString|globalVar)\b/;
-        Prism2.languages.typoscript = {
-          comment: [
-            {
-              // multiline comments /* */
-              pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
-              lookbehind: true
-            },
-            {
-              // double-slash comments - ignored when backslashes or colon is found in front
-              // also ignored whenever directly after an equal-sign, because it would probably be an url without protocol
-              pattern: /(^|[^\\:= \t]|(?:^|[^= \t])[ \t]+)\/\/.*/,
-              lookbehind: true,
-              greedy: true
-            },
-            {
-              // hash comments - ignored when leading quote is found for hex colors in strings
-              pattern: /(^|[^"'])#.*/,
-              lookbehind: true,
-              greedy: true
-            }
-          ],
-          function: [
-            {
-              // old include style
-              pattern: /<INCLUDE_TYPOSCRIPT:\s*source\s*=\s*(?:"[^"\r\n]*"|'[^'\r\n]*')\s*>/,
-              inside: {
-                string: {
-                  pattern: /"[^"\r\n]*"|'[^'\r\n]*'/,
-                  inside: {
-                    keyword: keywords
-                  }
-                },
-                keyword: {
-                  pattern: /INCLUDE_TYPOSCRIPT/
-                }
-              }
-            },
-            {
-              // new include style
-              pattern: /@import\s*(?:"[^"\r\n]*"|'[^'\r\n]*')/,
-              inside: {
-                string: /"[^"\r\n]*"|'[^'\r\n]*'/
-              }
-            }
-          ],
-          string: {
-            pattern: /^([^=]*=[< ]?)(?:(?!\]\n).)*/,
-            lookbehind: true,
-            inside: {
-              function: /\{\$.*\}/,
-              // constants include
-              keyword: keywords,
-              number: /^\d+$/,
-              punctuation: /[,|:]/
-            }
-          },
-          keyword: keywords,
-          number: {
-            // special highlighting for indexes of arrays in tags
-            pattern: /\b\d+\s*[.{=]/,
-            inside: {
-              operator: /[.{=]/
-            }
-          },
-          tag: {
-            pattern: /\.?[-\w\\]+\.?/,
-            inside: {
-              punctuation: /\./
-            }
-          },
-          punctuation: /[{}[\];(),.:|]/,
-          operator: /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/
-        };
-        Prism2.languages.tsconfig = Prism2.languages.typoscript;
-      })(Prism);
-    }
-  }
-});
-
-export {
-  require_typoscript
-};

package/dist/chunk-4PTEB3IM.js

@@ -1,78 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/concurnas.js
-var require_concurnas = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/concurnas.js"(exports, module) {
-    module.exports = concurnas;
-    concurnas.displayName = "concurnas";
-    concurnas.aliases = ["conc"];
-    function concurnas(Prism) {
-      Prism.languages.concurnas = {
-        comment: {
-          pattern: /(^|[^\\])(?:\/\*[\s\S]*?(?:\*\/|$)|\/\/.*)/,
-          lookbehind: true,
-          greedy: true
-        },
-        langext: {
-          pattern: /\b\w+\s*\|\|[\s\S]+?\|\|/,
-          greedy: true,
-          inside: {
-            "class-name": /^\w+/,
-            string: {
-              pattern: /(^\s*\|\|)[\s\S]+(?=\|\|$)/,
-              lookbehind: true
-            },
-            punctuation: /\|\|/
-          }
-        },
-        function: {
-          pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/,
-          lookbehind: true
-        },
-        keyword: /\b(?:abstract|actor|also|annotation|assert|async|await|bool|boolean|break|byte|case|catch|changed|char|class|closed|constant|continue|def|default|del|double|elif|else|enum|every|extends|false|finally|float|for|from|global|gpudef|gpukernel|if|import|in|init|inject|int|lambda|local|long|loop|match|new|nodefault|null|of|onchange|open|out|override|package|parfor|parforsync|post|pre|private|protected|provide|provider|public|return|shared|short|single|size_t|sizeof|super|sync|this|throw|trait|trans|transient|true|try|typedef|unchecked|using|val|var|void|while|with)\b/,
-        boolean: /\b(?:false|true)\b/,
-        number: /\b0b[01][01_]*L?\b|\b0x(?:[\da-f_]*\.)?[\da-f_p+-]+\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?[dfls]?/i,
-        punctuation: /[{}[\];(),.:]/,
-        operator: /<==|>==|=>|->|<-|<>|&==|&<>|\?:?|\.\?|\+\+|--|[-+*/=<>]=?|[!^~]|\b(?:and|as|band|bor|bxor|comp|is|isnot|mod|or)\b=?/,
-        annotation: {
-          pattern: /@(?:\w+:)?(?:\w+|\[[^\]]+\])?/,
-          alias: "builtin"
-        }
-      };
-      Prism.languages.insertBefore("concurnas", "langext", {
-        "regex-literal": {
-          pattern: /\br("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
-          greedy: true,
-          inside: {
-            interpolation: {
-              pattern: /((?:^|[^\\])(?:\\{2})*)\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
-              lookbehind: true,
-              inside: Prism.languages.concurnas
-            },
-            regex: /[\s\S]+/
-          }
-        },
-        "string-literal": {
-          pattern: /(?:\B|\bs)("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
-          greedy: true,
-          inside: {
-            interpolation: {
-              pattern: /((?:^|[^\\])(?:\\{2})*)\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
-              lookbehind: true,
-              inside: Prism.languages.concurnas
-            },
-            string: /[\s\S]+/
-          }
-        }
-      });
-      Prism.languages.conc = Prism.languages.concurnas;
-    }
-  }
-});
-
-export {
-  require_concurnas
-};

package/dist/chunk-4QNMEJF3.js

@@ -1,59 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/jolie.js
-var require_jolie = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/jolie.js"(exports, module) {
-    module.exports = jolie;
-    jolie.displayName = "jolie";
-    jolie.aliases = [];
-    function jolie(Prism) {
-      Prism.languages.jolie = Prism.languages.extend("clike", {
-        string: {
-          pattern: /(^|[^\\])"(?:\\[\s\S]|[^"\\])*"/,
-          lookbehind: true,
-          greedy: true
-        },
-        "class-name": {
-          pattern: /((?:\b(?:as|courier|embed|in|inputPort|outputPort|service)\b|@)[ \t]*)\w+/,
-          lookbehind: true
-        },
-        keyword: /\b(?:as|cH|comp|concurrent|constants|courier|cset|csets|default|define|else|embed|embedded|execution|exit|extender|for|foreach|forward|from|global|if|import|in|include|init|inputPort|install|instanceof|interface|is_defined|linkIn|linkOut|main|new|nullProcess|outputPort|over|private|provide|public|scope|sequential|service|single|spawn|synchronized|this|throw|throws|type|undef|until|while|with)\b/,
-        function: /\b[a-z_]\w*(?=[ \t]*[@(])/i,
-        number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?l?/i,
-        operator: /-[-=>]?|\+[+=]?|<[<=]?|[>=*!]=?|&&|\|\||[?\/%^@|]/,
-        punctuation: /[()[\]{},;.:]/,
-        builtin: /\b(?:Byte|any|bool|char|double|enum|float|int|length|long|ranges|regex|string|undefined|void)\b/
-      });
-      Prism.languages.insertBefore("jolie", "keyword", {
-        aggregates: {
-          pattern: /(\bAggregates\s*:\s*)(?:\w+(?:\s+with\s+\w+)?\s*,\s*)*\w+(?:\s+with\s+\w+)?/,
-          lookbehind: true,
-          inside: {
-            keyword: /\bwith\b/,
-            "class-name": /\w+/,
-            punctuation: /,/
-          }
-        },
-        redirects: {
-          pattern: /(\bRedirects\s*:\s*)(?:\w+\s*=>\s*\w+\s*,\s*)*(?:\w+\s*=>\s*\w+)/,
-          lookbehind: true,
-          inside: {
-            punctuation: /,/,
-            "class-name": /\w+/,
-            operator: /=>/
-          }
-        },
-        property: {
-          pattern: /\b(?:Aggregates|[Ii]nterfaces|Java|Javascript|Jolie|[Ll]ocation|OneWay|[Pp]rotocol|Redirects|RequestResponse)\b(?=[ \t]*:)/
-        }
-      });
-    }
-  }
-});
-
-export {
-  require_jolie
-};

package/dist/chunk-4U2VUXPS.js

@@ -1,90 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/jq.js
-var require_jq = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/jq.js"(exports, module) {
-    module.exports = jq;
-    jq.displayName = "jq";
-    jq.aliases = [];
-    function jq(Prism) {
-      ;
-      (function(Prism2) {
-        var interpolation = /\\\((?:[^()]|\([^()]*\))*\)/.source;
-        var string = RegExp(
-          /(^|[^\\])"(?:[^"\r\n\\]|\\[^\r\n(]|__)*"/.source.replace(
-            /__/g,
-            function() {
-              return interpolation;
-            }
-          )
-        );
-        var stringInterpolation = {
-          interpolation: {
-            pattern: RegExp(/((?:^|[^\\])(?:\\{2})*)/.source + interpolation),
-            lookbehind: true,
-            inside: {
-              content: {
-                pattern: /^(\\\()[\s\S]+(?=\)$)/,
-                lookbehind: true,
-                inside: null
-                // see below
-              },
-              punctuation: /^\\\(|\)$/
-            }
-          }
-        };
-        var jq2 = Prism2.languages.jq = {
-          comment: /#.*/,
-          property: {
-            pattern: RegExp(string.source + /(?=\s*:(?!:))/.source),
-            lookbehind: true,
-            greedy: true,
-            inside: stringInterpolation
-          },
-          string: {
-            pattern: string,
-            lookbehind: true,
-            greedy: true,
-            inside: stringInterpolation
-          },
-          function: {
-            pattern: /(\bdef\s+)[a-z_]\w+/i,
-            lookbehind: true
-          },
-          variable: /\B\$\w+/,
-          "property-literal": {
-            pattern: /\b[a-z_]\w*(?=\s*:(?!:))/i,
-            alias: "property"
-          },
-          keyword: /\b(?:as|break|catch|def|elif|else|end|foreach|if|import|include|label|module|modulemeta|null|reduce|then|try|while)\b/,
-          boolean: /\b(?:false|true)\b/,
-          number: /(?:\b\d+\.|\B\.)?\b\d+(?:[eE][+-]?\d+)?\b/,
-          operator: [
-            {
-              pattern: /\|=?/,
-              alias: "pipe"
-            },
-            /\.\.|[!=<>]?=|\?\/\/|\/\/=?|[-+*/%]=?|[<>?]|\b(?:and|not|or)\b/
-          ],
-          "c-style-function": {
-            pattern: /\b[a-z_]\w*(?=\s*\()/i,
-            alias: "function"
-          },
-          punctuation: /::|[()\[\]{},:;]|\.(?=\s*[\[\w$])/,
-          dot: {
-            pattern: /\./,
-            alias: "important"
-          }
-        };
-        stringInterpolation.interpolation.inside.content.inside = jq2;
-      })(Prism);
-    }
-  }
-});
-
-export {
-  require_jq
-};

package/dist/chunk-4VWP7BGD.js

@@ -1,32 +0,0 @@
-"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-56HGBXBL.js

@@ -1,77 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/groovy.js
-var require_groovy = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/groovy.js"(exports, module) {
-    module.exports = groovy;
-    groovy.displayName = "groovy";
-    groovy.aliases = [];
-    function groovy(Prism) {
-      Prism.languages.groovy = Prism.languages.extend("clike", {
-        string: [
-          {
-            // https://groovy-lang.org/syntax.html#_dollar_slashy_string
-            pattern: /("""|''')(?:[^\\]|\\[\s\S])*?\1|\$\/(?:[^/$]|\$(?:[/$]|(?![/$]))|\/(?!\$))*\/\$/,
-            greedy: true
-          },
-          {
-            // TODO: Slash strings (e.g. /foo/) can contain line breaks but this will cause a lot of trouble with
-            // simple division (see JS regex), so find a fix maybe?
-            pattern: /(["'/])(?:\\.|(?!\1)[^\\\r\n])*\1/,
-            greedy: true
-          }
-        ],
-        keyword: /\b(?:abstract|as|assert|boolean|break|byte|case|catch|char|class|const|continue|def|default|do|double|else|enum|extends|final|finally|float|for|goto|if|implements|import|in|instanceof|int|interface|long|native|new|package|private|protected|public|return|short|static|strictfp|super|switch|synchronized|this|throw|throws|trait|transient|try|void|volatile|while)\b/,
-        number: /\b(?:0b[01_]+|0x[\da-f_]+(?:\.[\da-f_p\-]+)?|[\d_]+(?:\.[\d_]+)?(?:e[+-]?\d+)?)[glidf]?\b/i,
-        operator: {
-          pattern: /(^|[^.])(?:~|==?~?|\?[.:]?|\*(?:[.=]|\*=?)?|\.[@&]|\.\.<|\.\.(?!\.)|-[-=>]?|\+[+=]?|!=?|<(?:<=?|=>?)?|>(?:>>?=?|=)?|&[&=]?|\|[|=]?|\/=?|\^=?|%=?)/,
-          lookbehind: true
-        },
-        punctuation: /\.+|[{}[\];(),:$]/
-      });
-      Prism.languages.insertBefore("groovy", "string", {
-        shebang: {
-          pattern: /#!.+/,
-          alias: "comment"
-        }
-      });
-      Prism.languages.insertBefore("groovy", "punctuation", {
-        "spock-block": /\b(?:and|cleanup|expect|given|setup|then|when|where):/
-      });
-      Prism.languages.insertBefore("groovy", "function", {
-        annotation: {
-          pattern: /(^|[^.])@\w+/,
-          lookbehind: true,
-          alias: "punctuation"
-        }
-      });
-      Prism.hooks.add("wrap", function(env) {
-        if (env.language === "groovy" && env.type === "string") {
-          var delimiter = env.content.value[0];
-          if (delimiter != "'") {
-            var pattern = /([^\\])(?:\$(?:\{.*?\}|[\w.]+))/;
-            if (delimiter === "$") {
-              pattern = /([^\$])(?:\$(?:\{.*?\}|[\w.]+))/;
-            }
-            env.content.value = env.content.value.replace(/&lt;/g, "<").replace(/&amp;/g, "&");
-            env.content = Prism.highlight(env.content.value, {
-              expression: {
-                pattern,
-                lookbehind: true,
-                inside: Prism.languages.groovy
-              }
-            });
-            env.classes.push(delimiter === "/" ? "regex" : "gstring");
-          }
-        }
-      });
-    }
-  }
-});
-
-export {
-  require_groovy
-};

package/dist/chunk-5BU6V2BX.js

@@ -1,39 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/lua.js
-var require_lua = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/lua.js"(exports, module) {
-    module.exports = lua;
-    lua.displayName = "lua";
-    lua.aliases = [];
-    function lua(Prism) {
-      Prism.languages.lua = {
-        comment: /^#!.+|--(?:\[(=*)\[[\s\S]*?\]\1\]|.*)/m,
-        // \z may be used to skip the following space
-        string: {
-          pattern: /(["'])(?:(?!\1)[^\\\r\n]|\\z(?:\r\n|\s)|\\(?:\r\n|[^z]))*\1|\[(=*)\[[\s\S]*?\]\2\]/,
-          greedy: true
-        },
-        number: /\b0x[a-f\d]+(?:\.[a-f\d]*)?(?:p[+-]?\d+)?\b|\b\d+(?:\.\B|(?:\.\d*)?(?:e[+-]?\d+)?\b)|\B\.\d+(?:e[+-]?\d+)?\b/i,
-        keyword: /\b(?:and|break|do|else|elseif|end|false|for|function|goto|if|in|local|nil|not|or|repeat|return|then|true|until|while)\b/,
-        function: /(?!\d)\w+(?=\s*(?:[({]))/,
-        operator: [
-          /[-+*%^&|#]|\/\/?|<[<=]?|>[>=]?|[=~]=?/,
-          {
-            // Match ".." but don't break "..."
-            pattern: /(^|[^.])\.\.(?!\.)/,
-            lookbehind: true
-          }
-        ],
-        punctuation: /[\[\](){},;]|\.+|:+/
-      };
-    }
-  }
-});
-
-export {
-  require_lua
-};

package/dist/chunk-5C74WHTB.js

@@ -1,39 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/brainfuck.js
-var require_brainfuck = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/brainfuck.js"(exports, module) {
-    module.exports = brainfuck;
-    brainfuck.displayName = "brainfuck";
-    brainfuck.aliases = [];
-    function brainfuck(Prism) {
-      Prism.languages.brainfuck = {
-        pointer: {
-          pattern: /<|>/,
-          alias: "keyword"
-        },
-        increment: {
-          pattern: /\+/,
-          alias: "inserted"
-        },
-        decrement: {
-          pattern: /-/,
-          alias: "deleted"
-        },
-        branching: {
-          pattern: /\[|\]/,
-          alias: "important"
-        },
-        operator: /[.,]/,
-        comment: /\S+/
-      };
-    }
-  }
-});
-
-export {
-  require_brainfuck
-};

package/dist/chunk-5EG2VRYF.js

@@ -1,151 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/perl.js
-var require_perl = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/perl.js"(exports, module) {
-    module.exports = perl;
-    perl.displayName = "perl";
-    perl.aliases = [];
-    function perl(Prism) {
-      ;
-      (function(Prism2) {
-        var brackets = /(?:\((?:[^()\\]|\\[\s\S])*\)|\{(?:[^{}\\]|\\[\s\S])*\}|\[(?:[^[\]\\]|\\[\s\S])*\]|<(?:[^<>\\]|\\[\s\S])*>)/.source;
-        Prism2.languages.perl = {
-          comment: [
-            {
-              // POD
-              pattern: /(^\s*)=\w[\s\S]*?=cut.*/m,
-              lookbehind: true,
-              greedy: true
-            },
-            {
-              pattern: /(^|[^\\$])#.*/,
-              lookbehind: true,
-              greedy: true
-            }
-          ],
-          // TODO Could be nice to handle Heredoc too.
-          string: [
-            {
-              pattern: RegExp(
-                /\b(?:q|qq|qw|qx)(?![a-zA-Z0-9])\s*/.source + "(?:" + [
-                  // q/.../
-                  /([^a-zA-Z0-9\s{(\[<])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source,
-                  // q a...a
-                  // eslint-disable-next-line regexp/strict
-                  /([a-zA-Z0-9])(?:(?!\2)[^\\]|\\[\s\S])*\2/.source,
-                  // q(...)
-                  // q{...}
-                  // q[...]
-                  // q<...>
-                  brackets
-                ].join("|") + ")"
-              ),
-              greedy: true
-            },
-            // "...", `...`
-            {
-              pattern: /("|`)(?:(?!\1)[^\\]|\\[\s\S])*\1/,
-              greedy: true
-            },
-            // '...'
-            // FIXME Multi-line single-quoted strings are not supported as they would break variables containing '
-            {
-              pattern: /'(?:[^'\\\r\n]|\\.)*'/,
-              greedy: true
-            }
-          ],
-          regex: [
-            {
-              pattern: RegExp(
-                /\b(?:m|qr)(?![a-zA-Z0-9])\s*/.source + "(?:" + [
-                  // m/.../
-                  /([^a-zA-Z0-9\s{(\[<])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source,
-                  // m a...a
-                  // eslint-disable-next-line regexp/strict
-                  /([a-zA-Z0-9])(?:(?!\2)[^\\]|\\[\s\S])*\2/.source,
-                  // m(...)
-                  // m{...}
-                  // m[...]
-                  // m<...>
-                  brackets
-                ].join("|") + ")" + /[msixpodualngc]*/.source
-              ),
-              greedy: true
-            },
-            // The lookbehinds prevent -s from breaking
-            {
-              pattern: RegExp(
-                /(^|[^-])\b(?:s|tr|y)(?![a-zA-Z0-9])\s*/.source + "(?:" + [
-                  // s/.../.../
-                  // eslint-disable-next-line regexp/strict
-                  /([^a-zA-Z0-9\s{(\[<])(?:(?!\2)[^\\]|\\[\s\S])*\2(?:(?!\2)[^\\]|\\[\s\S])*\2/.source,
-                  // s a...a...a
-                  // eslint-disable-next-line regexp/strict
-                  /([a-zA-Z0-9])(?:(?!\3)[^\\]|\\[\s\S])*\3(?:(?!\3)[^\\]|\\[\s\S])*\3/.source,
-                  // s(...)(...)
-                  // s{...}{...}
-                  // s[...][...]
-                  // s<...><...>
-                  // s(...)[...]
-                  brackets + /\s*/.source + brackets
-                ].join("|") + ")" + /[msixpodualngcer]*/.source
-              ),
-              lookbehind: true,
-              greedy: true
-            },
-            // /.../
-            // The look-ahead tries to prevent two divisions on
-            // the same line from being highlighted as regex.
-            // This does not support multi-line regex.
-            {
-              pattern: /\/(?:[^\/\\\r\n]|\\.)*\/[msixpodualngc]*(?=\s*(?:$|[\r\n,.;})&|\-+*~<>!?^]|(?:and|cmp|eq|ge|gt|le|lt|ne|not|or|x|xor)\b))/,
-              greedy: true
-            }
-          ],
-          // FIXME Not sure about the handling of ::, ', and #
-          variable: [
-            // ${^POSTMATCH}
-            /[&*$@%]\{\^[A-Z]+\}/,
-            // $^V
-            /[&*$@%]\^[A-Z_]/,
-            // ${...}
-            /[&*$@%]#?(?=\{)/,
-            // $foo
-            /[&*$@%]#?(?:(?:::)*'?(?!\d)[\w$]+(?![\w$]))+(?:::)*/,
-            // $1
-            /[&*$@%]\d+/,
-            // $_, @_, %!
-            // The negative lookahead prevents from breaking the %= operator
-            /(?!%=)[$@%][!"#$%&'()*+,\-.\/:;<=>?@[\\\]^_`{|}~]/
-          ],
-          filehandle: {
-            // <>, <FOO>, _
-            pattern: /<(?![<=])\S*?>|\b_\b/,
-            alias: "symbol"
-          },
-          "v-string": {
-            // v1.2, 1.2.3
-            pattern: /v\d+(?:\.\d+)*|\d+(?:\.\d+){2,}/,
-            alias: "string"
-          },
-          function: {
-            pattern: /(\bsub[ \t]+)\w+/,
-            lookbehind: true
-          },
-          keyword: /\b(?:any|break|continue|default|delete|die|do|else|elsif|eval|for|foreach|given|goto|if|last|local|my|next|our|package|print|redo|require|return|say|state|sub|switch|undef|unless|until|use|when|while)\b/,
-          number: /\b(?:0x[\dA-Fa-f](?:_?[\dA-Fa-f])*|0b[01](?:_?[01])*|(?:(?:\d(?:_?\d)*)?\.)?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)\b/,
-          operator: /-[rwxoRWXOezsfdlpSbctugkTBMAC]\b|\+[+=]?|-[-=>]?|\*\*?=?|\/\/?=?|=[=~>]?|~[~=]?|\|\|?=?|&&?=?|<(?:=>?|<=?)?|>>?=?|![~=]?|[%^]=?|\.(?:=|\.\.?)?|[\\?]|\bx(?:=|\b)|\b(?:and|cmp|eq|ge|gt|le|lt|ne|not|or|xor)\b/,
-          punctuation: /[{}[\];(),:]/
-        };
-      })(Prism);
-    }
-  }
-});
-
-export {
-  require_perl
-};