@distri/react 0.3.2 → 0.3.4

package/dist/chunk-72ZMT6AW.js

@@ -1,74 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/stan.js
-var require_stan = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/stan.js"(exports, module) {
-    module.exports = stan;
-    stan.displayName = "stan";
-    stan.aliases = [];
-    function stan(Prism) {
-      ;
-      (function(Prism2) {
-        var higherOrderFunctions = /\b(?:algebra_solver|algebra_solver_newton|integrate_1d|integrate_ode|integrate_ode_bdf|integrate_ode_rk45|map_rect|ode_(?:adams|bdf|ckrk|rk45)(?:_tol)?|ode_adjoint_tol_ctl|reduce_sum|reduce_sum_static)\b/;
-        Prism2.languages.stan = {
-          comment: /\/\/.*|\/\*[\s\S]*?\*\/|#(?!include).*/,
-          string: {
-            // String literals can contain spaces and any printable ASCII characters except for " and \
-            // https://mc-stan.org/docs/2_24/reference-manual/print-statements-section.html#string-literals
-            pattern: /"[\x20\x21\x23-\x5B\x5D-\x7E]*"/,
-            greedy: true
-          },
-          directive: {
-            pattern: /^([ \t]*)#include\b.*/m,
-            lookbehind: true,
-            alias: "property"
-          },
-          "function-arg": {
-            pattern: RegExp(
-              "(" + higherOrderFunctions.source + /\s*\(\s*/.source + ")" + /[a-zA-Z]\w*/.source
-            ),
-            lookbehind: true,
-            alias: "function"
-          },
-          constraint: {
-            pattern: /(\b(?:int|matrix|real|row_vector|vector)\s*)<[^<>]*>/,
-            lookbehind: true,
-            inside: {
-              expression: {
-                pattern: /(=\s*)\S(?:\S|\s+(?!\s))*?(?=\s*(?:>$|,\s*\w+\s*=))/,
-                lookbehind: true,
-                inside: null
-                // see below
-              },
-              property: /\b[a-z]\w*(?=\s*=)/i,
-              operator: /=/,
-              punctuation: /^<|>$|,/
-            }
-          },
-          keyword: [
-            {
-              pattern: /\bdata(?=\s*\{)|\b(?:functions|generated|model|parameters|quantities|transformed)\b/,
-              alias: "program-block"
-            },
-            /\b(?:array|break|cholesky_factor_corr|cholesky_factor_cov|complex|continue|corr_matrix|cov_matrix|data|else|for|if|in|increment_log_prob|int|matrix|ordered|positive_ordered|print|real|reject|return|row_vector|simplex|target|unit_vector|vector|void|while)\b/,
-            // these are functions that are known to take another function as their first argument.
-            higherOrderFunctions
-          ],
-          function: /\b[a-z]\w*(?=\s*\()/i,
-          number: /(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)(?:E[+-]?\d+(?:_\d+)*)?i?(?!\w)/i,
-          boolean: /\b(?:false|true)\b/,
-          operator: /<-|\.[*/]=?|\|\|?|&&|[!=<>+\-*/]=?|['^%~?:]/,
-          punctuation: /[()\[\]{},;]/
-        };
-        Prism2.languages.stan.constraint.inside.expression.inside = Prism2.languages.stan;
-      })(Prism);
-    }
-  }
-});
-
-export {
-  require_stan
-};

package/dist/chunk-74JQLVAI.js

@@ -1,53 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/autoit.js
-var require_autoit = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/autoit.js"(exports, module) {
-    module.exports = autoit;
-    autoit.displayName = "autoit";
-    autoit.aliases = [];
-    function autoit(Prism) {
-      Prism.languages.autoit = {
-        comment: [
-          /;.*/,
-          {
-            // The multi-line comments delimiters can actually be commented out with ";"
-            pattern: /(^[\t ]*)#(?:comments-start|cs)[\s\S]*?^[ \t]*#(?:ce|comments-end)/m,
-            lookbehind: true
-          }
-        ],
-        url: {
-          pattern: /(^[\t ]*#include\s+)(?:<[^\r\n>]+>|"[^\r\n"]+")/m,
-          lookbehind: true
-        },
-        string: {
-          pattern: /(["'])(?:\1\1|(?!\1)[^\r\n])*\1/,
-          greedy: true,
-          inside: {
-            variable: /([%$@])\w+\1/
-          }
-        },
-        directive: {
-          pattern: /(^[\t ]*)#[\w-]+/m,
-          lookbehind: true,
-          alias: "keyword"
-        },
-        function: /\b\w+(?=\()/,
-        // Variables and macros
-        variable: /[$@]\w+/,
-        keyword: /\b(?:Case|Const|Continue(?:Case|Loop)|Default|Dim|Do|Else(?:If)?|End(?:Func|If|Select|Switch|With)|Enum|Exit(?:Loop)?|For|Func|Global|If|In|Local|Next|Null|ReDim|Select|Static|Step|Switch|Then|To|Until|Volatile|WEnd|While|With)\b/i,
-        number: /\b(?:0x[\da-f]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?)\b/i,
-        boolean: /\b(?:False|True)\b/i,
-        operator: /<[=>]?|[-+*\/=&>]=?|[?^]|\b(?:And|Not|Or)\b/i,
-        punctuation: /[\[\]().,:]/
-      };
-    }
-  }
-});
-
-export {
-  require_autoit
-};

package/dist/chunk-7LE5EHO2.js

@@ -1,103 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/coffeescript.js
-var require_coffeescript = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/coffeescript.js"(exports, module) {
-    module.exports = coffeescript;
-    coffeescript.displayName = "coffeescript";
-    coffeescript.aliases = ["coffee"];
-    function coffeescript(Prism) {
-      ;
-      (function(Prism2) {
-        var comment = /#(?!\{).+/;
-        var interpolation = {
-          pattern: /#\{[^}]+\}/,
-          alias: "variable"
-        };
-        Prism2.languages.coffeescript = Prism2.languages.extend("javascript", {
-          comment,
-          string: [
-            // Strings are multiline
-            {
-              pattern: /'(?:\\[\s\S]|[^\\'])*'/,
-              greedy: true
-            },
-            {
-              // Strings are multiline
-              pattern: /"(?:\\[\s\S]|[^\\"])*"/,
-              greedy: true,
-              inside: {
-                interpolation
-              }
-            }
-          ],
-          keyword: /\b(?:and|break|by|catch|class|continue|debugger|delete|do|each|else|extend|extends|false|finally|for|if|in|instanceof|is|isnt|let|loop|namespace|new|no|not|null|of|off|on|or|own|return|super|switch|then|this|throw|true|try|typeof|undefined|unless|until|when|while|window|with|yes|yield)\b/,
-          "class-member": {
-            pattern: /@(?!\d)\w+/,
-            alias: "variable"
-          }
-        });
-        Prism2.languages.insertBefore("coffeescript", "comment", {
-          "multiline-comment": {
-            pattern: /###[\s\S]+?###/,
-            alias: "comment"
-          },
-          // Block regexp can contain comments and interpolation
-          "block-regex": {
-            pattern: /\/{3}[\s\S]*?\/{3}/,
-            alias: "regex",
-            inside: {
-              comment,
-              interpolation
-            }
-          }
-        });
-        Prism2.languages.insertBefore("coffeescript", "string", {
-          "inline-javascript": {
-            pattern: /`(?:\\[\s\S]|[^\\`])*`/,
-            inside: {
-              delimiter: {
-                pattern: /^`|`$/,
-                alias: "punctuation"
-              },
-              script: {
-                pattern: /[\s\S]+/,
-                alias: "language-javascript",
-                inside: Prism2.languages.javascript
-              }
-            }
-          },
-          // Block strings
-          "multiline-string": [
-            {
-              pattern: /'''[\s\S]*?'''/,
-              greedy: true,
-              alias: "string"
-            },
-            {
-              pattern: /"""[\s\S]*?"""/,
-              greedy: true,
-              alias: "string",
-              inside: {
-                interpolation
-              }
-            }
-          ]
-        });
-        Prism2.languages.insertBefore("coffeescript", "keyword", {
-          // Object property
-          property: /(?!\d)\w+(?=\s*:(?!:))/
-        });
-        delete Prism2.languages.coffeescript["template-string"];
-        Prism2.languages.coffee = Prism2.languages.coffeescript;
-      })(Prism);
-    }
-  }
-});
-
-export {
-  require_coffeescript
-};

package/dist/chunk-7VE4EHQE.js

@@ -1,32 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/ichigojam.js
-var require_ichigojam = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/ichigojam.js"(exports, module) {
-    module.exports = ichigojam;
-    ichigojam.displayName = "ichigojam";
-    ichigojam.aliases = [];
-    function ichigojam(Prism) {
-      Prism.languages.ichigojam = {
-        comment: /(?:\B'|REM)(?:[^\n\r]*)/i,
-        string: {
-          pattern: /"(?:""|[!#$%&'()*,\/:;<=>?^\w +\-.])*"/,
-          greedy: true
-        },
-        number: /\B#[0-9A-F]+|\B`[01]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i,
-        keyword: /\b(?:BEEP|BPS|CASE|CLEAR|CLK|CLO|CLP|CLS|CLT|CLV|CONT|COPY|ELSE|END|FILE|FILES|FOR|GOSUB|GOTO|GSB|IF|INPUT|KBD|LED|LET|LIST|LOAD|LOCATE|LRUN|NEW|NEXT|OUT|PLAY|POKE|PRINT|PWM|REM|RENUM|RESET|RETURN|RIGHT|RTN|RUN|SAVE|SCROLL|SLEEP|SRND|STEP|STOP|SUB|TEMPO|THEN|TO|UART|VIDEO|WAIT)(?:\$|\b)/i,
-        function: /\b(?:ABS|ANA|ASC|BIN|BTN|DEC|END|FREE|HELP|HEX|I2CR|I2CW|IN|INKEY|LEN|LINE|PEEK|RND|SCR|SOUND|STR|TICK|USR|VER|VPEEK|ZER)(?:\$|\b)/i,
-        label: /(?:\B@\S+)/,
-        operator: /<[=>]?|>=?|\|\||&&|[+\-*\/=|&^~!]|\b(?:AND|NOT|OR)\b/i,
-        punctuation: /[\[,;:()\]]/
-      };
-    }
-  }
-});
-
-export {
-  require_ichigojam
-};

package/dist/chunk-7WCISJEQ.js

@@ -1,39 +0,0 @@
-"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-A4QKLBGO.js

@@ -1,42 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/al.js
-var require_al = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/al.js"(exports, module) {
-    module.exports = al;
-    al.displayName = "al";
-    al.aliases = [];
-    function al(Prism) {
-      Prism.languages.al = {
-        comment: /\/\/.*|\/\*[\s\S]*?\*\//,
-        string: {
-          pattern: /'(?:''|[^'\r\n])*'(?!')|"(?:""|[^"\r\n])*"(?!")/,
-          greedy: true
-        },
-        function: {
-          pattern: /(\b(?:event|procedure|trigger)\s+|(?:^|[^.])\.\s*)[a-z_]\w*(?=\s*\()/i,
-          lookbehind: true
-        },
-        keyword: [
-          // keywords
-          /\b(?:array|asserterror|begin|break|case|do|downto|else|end|event|exit|for|foreach|function|if|implements|in|indataset|interface|internal|local|of|procedure|program|protected|repeat|runonclient|securityfiltering|suppressdispose|temporary|then|to|trigger|until|var|while|with|withevents)\b/i,
-          // objects and metadata that are used like keywords
-          /\b(?:action|actions|addafter|addbefore|addfirst|addlast|area|assembly|chartpart|codeunit|column|controladdin|cuegroup|customizes|dataitem|dataset|dotnet|elements|enum|enumextension|extends|field|fieldattribute|fieldelement|fieldgroup|fieldgroups|fields|filter|fixed|grid|group|key|keys|label|labels|layout|modify|moveafter|movebefore|movefirst|movelast|page|pagecustomization|pageextension|part|profile|query|repeater|report|requestpage|schema|separator|systempart|table|tableelement|tableextension|textattribute|textelement|type|usercontrol|value|xmlport)\b/i
-        ],
-        number: /\b(?:0x[\da-f]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?)(?:F|LL?|U(?:LL?)?)?\b/i,
-        boolean: /\b(?:false|true)\b/i,
-        variable: /\b(?:Curr(?:FieldNo|Page|Report)|x?Rec|RequestOptionsPage)\b/,
-        "class-name": /\b(?:automation|biginteger|bigtext|blob|boolean|byte|char|clienttype|code|completiontriggererrorlevel|connectiontype|database|dataclassification|datascope|date|dateformula|datetime|decimal|defaultlayout|dialog|dictionary|dotnetassembly|dotnettypedeclaration|duration|errorinfo|errortype|executioncontext|executionmode|fieldclass|fieldref|fieldtype|file|filterpagebuilder|guid|httpclient|httpcontent|httpheaders|httprequestmessage|httpresponsemessage|instream|integer|joker|jsonarray|jsonobject|jsontoken|jsonvalue|keyref|list|moduledependencyinfo|moduleinfo|none|notification|notificationscope|objecttype|option|outstream|pageresult|record|recordid|recordref|reportformat|securityfilter|sessionsettings|tableconnectiontype|tablefilter|testaction|testfield|testfilterfield|testpage|testpermissions|testrequestpage|text|textbuilder|textconst|textencoding|time|transactionmodel|transactiontype|variant|verbosity|version|view|views|webserviceactioncontext|webserviceactionresultcode|xmlattribute|xmlattributecollection|xmlcdata|xmlcomment|xmldeclaration|xmldocument|xmldocumenttype|xmlelement|xmlnamespacemanager|xmlnametable|xmlnode|xmlnodelist|xmlprocessinginstruction|xmlreadoptions|xmltext|xmlwriteoptions)\b/i,
-        operator: /\.\.|:[=:]|[-+*/]=?|<>|[<>]=?|=|\b(?:and|div|mod|not|or|xor)\b/i,
-        punctuation: /[()\[\]{}:.;,]/
-      };
-    }
-  }
-});
-
-export {
-  require_al
-};

package/dist/chunk-AAY72PHZ.js

@@ -1,96 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/scss.js
-var require_scss = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/scss.js"(exports, module) {
-    module.exports = scss;
-    scss.displayName = "scss";
-    scss.aliases = [];
-    function scss(Prism) {
-      Prism.languages.scss = Prism.languages.extend("css", {
-        comment: {
-          pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/,
-          lookbehind: true
-        },
-        atrule: {
-          pattern: /@[\w-](?:\([^()]+\)|[^()\s]|\s+(?!\s))*?(?=\s+[{;])/,
-          inside: {
-            rule: /@[\w-]+/
-            // See rest below
-          }
-        },
-        // url, compassified
-        url: /(?:[-a-z]+-)?url(?=\()/i,
-        // CSS selector regex is not appropriate for Sass
-        // since there can be lot more things (var, @ directive, nesting..)
-        // a selector must start at the end of a property or after a brace (end of other rules or nesting)
-        // it can contain some characters that aren't used for defining rules or end of selector, & (parent selector), or interpolated variable
-        // the end of a selector is found when there is no rules in it ( {} or {\s}) or if there is a property (because an interpolated var
-        // can "pass" as a selector- e.g: proper#{$erty})
-        // this one was hard to do, so please be careful if you edit this one :)
-        selector: {
-          // Initial look-ahead is used to prevent matching of blank selectors
-          pattern: /(?=\S)[^@;{}()]?(?:[^@;{}()\s]|\s+(?!\s)|#\{\$[-\w]+\})+(?=\s*\{(?:\}|\s|[^}][^:{}]*[:{][^}]))/,
-          inside: {
-            parent: {
-              pattern: /&/,
-              alias: "important"
-            },
-            placeholder: /%[-\w]+/,
-            variable: /\$[-\w]+|#\{\$[-\w]+\}/
-          }
-        },
-        property: {
-          pattern: /(?:[-\w]|\$[-\w]|#\{\$[-\w]+\})+(?=\s*:)/,
-          inside: {
-            variable: /\$[-\w]+|#\{\$[-\w]+\}/
-          }
-        }
-      });
-      Prism.languages.insertBefore("scss", "atrule", {
-        keyword: [
-          /@(?:content|debug|each|else(?: if)?|extend|for|forward|function|if|import|include|mixin|return|use|warn|while)\b/i,
-          {
-            pattern: /( )(?:from|through)(?= )/,
-            lookbehind: true
-          }
-        ]
-      });
-      Prism.languages.insertBefore("scss", "important", {
-        // var and interpolated vars
-        variable: /\$[-\w]+|#\{\$[-\w]+\}/
-      });
-      Prism.languages.insertBefore("scss", "function", {
-        "module-modifier": {
-          pattern: /\b(?:as|hide|show|with)\b/i,
-          alias: "keyword"
-        },
-        placeholder: {
-          pattern: /%[-\w]+/,
-          alias: "selector"
-        },
-        statement: {
-          pattern: /\B!(?:default|optional)\b/i,
-          alias: "keyword"
-        },
-        boolean: /\b(?:false|true)\b/,
-        null: {
-          pattern: /\bnull\b/,
-          alias: "keyword"
-        },
-        operator: {
-          pattern: /(\s)(?:[-+*\/%]|[=!]=|<=?|>=?|and|not|or)(?=\s)/,
-          lookbehind: true
-        }
-      });
-      Prism.languages.scss["atrule"].inside.rest = Prism.languages.scss;
-    }
-  }
-});
-
-export {
-  require_scss
-};

package/dist/chunk-AG5QUY4G.js

@@ -1,205 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/pug.js
-var require_pug = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/pug.js"(exports, module) {
-    module.exports = pug;
-    pug.displayName = "pug";
-    pug.aliases = [];
-    function pug(Prism) {
-      ;
-      (function(Prism2) {
-        Prism2.languages.pug = {
-          // Multiline stuff should appear before the rest
-          // This handles both single-line and multi-line comments
-          comment: {
-            pattern: /(^([\t ]*))\/\/.*(?:(?:\r?\n|\r)\2[\t ].+)*/m,
-            lookbehind: true
-          },
-          // All the tag-related part is in lookbehind
-          // so that it can be highlighted by the "tag" pattern
-          "multiline-script": {
-            pattern: /(^([\t ]*)script\b.*\.[\t ]*)(?:(?:\r?\n|\r(?!\n))(?:\2[\t ].+|\s*?(?=\r?\n|\r)))+/m,
-            lookbehind: true,
-            inside: Prism2.languages.javascript
-          },
-          // See at the end of the file for known filters
-          filter: {
-            pattern: /(^([\t ]*)):.+(?:(?:\r?\n|\r(?!\n))(?:\2[\t ].+|\s*?(?=\r?\n|\r)))+/m,
-            lookbehind: true,
-            inside: {
-              "filter-name": {
-                pattern: /^:[\w-]+/,
-                alias: "variable"
-              },
-              text: /\S[\s\S]*/
-            }
-          },
-          "multiline-plain-text": {
-            pattern: /(^([\t ]*)[\w\-#.]+\.[\t ]*)(?:(?:\r?\n|\r(?!\n))(?:\2[\t ].+|\s*?(?=\r?\n|\r)))+/m,
-            lookbehind: true
-          },
-          markup: {
-            pattern: /(^[\t ]*)<.+/m,
-            lookbehind: true,
-            inside: Prism2.languages.markup
-          },
-          doctype: {
-            pattern: /((?:^|\n)[\t ]*)doctype(?: .+)?/,
-            lookbehind: true
-          },
-          // This handle all conditional and loop keywords
-          "flow-control": {
-            pattern: /(^[\t ]*)(?:case|default|each|else|if|unless|when|while)\b(?: .+)?/m,
-            lookbehind: true,
-            inside: {
-              each: {
-                pattern: /^each .+? in\b/,
-                inside: {
-                  keyword: /\b(?:each|in)\b/,
-                  punctuation: /,/
-                }
-              },
-              branch: {
-                pattern: /^(?:case|default|else|if|unless|when|while)\b/,
-                alias: "keyword"
-              },
-              rest: Prism2.languages.javascript
-            }
-          },
-          keyword: {
-            pattern: /(^[\t ]*)(?:append|block|extends|include|prepend)\b.+/m,
-            lookbehind: true
-          },
-          mixin: [
-            // Declaration
-            {
-              pattern: /(^[\t ]*)mixin .+/m,
-              lookbehind: true,
-              inside: {
-                keyword: /^mixin/,
-                function: /\w+(?=\s*\(|\s*$)/,
-                punctuation: /[(),.]/
-              }
-            },
-            // Usage
-            {
-              pattern: /(^[\t ]*)\+.+/m,
-              lookbehind: true,
-              inside: {
-                name: {
-                  pattern: /^\+\w+/,
-                  alias: "function"
-                },
-                rest: Prism2.languages.javascript
-              }
-            }
-          ],
-          script: {
-            pattern: /(^[\t ]*script(?:(?:&[^(]+)?\([^)]+\))*[\t ]).+/m,
-            lookbehind: true,
-            inside: Prism2.languages.javascript
-          },
-          "plain-text": {
-            pattern: /(^[\t ]*(?!-)[\w\-#.]*[\w\-](?:(?:&[^(]+)?\([^)]+\))*\/?[\t ]).+/m,
-            lookbehind: true
-          },
-          tag: {
-            pattern: /(^[\t ]*)(?!-)[\w\-#.]*[\w\-](?:(?:&[^(]+)?\([^)]+\))*\/?:?/m,
-            lookbehind: true,
-            inside: {
-              attributes: [
-                {
-                  pattern: /&[^(]+\([^)]+\)/,
-                  inside: Prism2.languages.javascript
-                },
-                {
-                  pattern: /\([^)]+\)/,
-                  inside: {
-                    "attr-value": {
-                      pattern: /(=\s*(?!\s))(?:\{[^}]*\}|[^,)\r\n]+)/,
-                      lookbehind: true,
-                      inside: Prism2.languages.javascript
-                    },
-                    "attr-name": /[\w-]+(?=\s*!?=|\s*[,)])/,
-                    punctuation: /[!=(),]+/
-                  }
-                }
-              ],
-              punctuation: /:/,
-              "attr-id": /#[\w\-]+/,
-              "attr-class": /\.[\w\-]+/
-            }
-          },
-          code: [
-            {
-              pattern: /(^[\t ]*(?:-|!?=)).+/m,
-              lookbehind: true,
-              inside: Prism2.languages.javascript
-            }
-          ],
-          punctuation: /[.\-!=|]+/
-        };
-        var filter_pattern = /(^([\t ]*)):<filter_name>(?:(?:\r?\n|\r(?!\n))(?:\2[\t ].+|\s*?(?=\r?\n|\r)))+/.source;
-        var filters = [
-          {
-            filter: "atpl",
-            language: "twig"
-          },
-          {
-            filter: "coffee",
-            language: "coffeescript"
-          },
-          "ejs",
-          "handlebars",
-          "less",
-          "livescript",
-          "markdown",
-          {
-            filter: "sass",
-            language: "scss"
-          },
-          "stylus"
-        ];
-        var all_filters = {};
-        for (var i = 0, l = filters.length; i < l; i++) {
-          var filter = filters[i];
-          filter = typeof filter === "string" ? {
-            filter,
-            language: filter
-          } : filter;
-          if (Prism2.languages[filter.language]) {
-            all_filters["filter-" + filter.filter] = {
-              pattern: RegExp(
-                filter_pattern.replace("<filter_name>", function() {
-                  return filter.filter;
-                }),
-                "m"
-              ),
-              lookbehind: true,
-              inside: {
-                "filter-name": {
-                  pattern: /^:[\w-]+/,
-                  alias: "variable"
-                },
-                text: {
-                  pattern: /\S[\s\S]*/,
-                  alias: [filter.language, "language-" + filter.language],
-                  inside: Prism2.languages[filter.language]
-                }
-              }
-            };
-          }
-        }
-        Prism2.languages.insertBefore("pug", "filter", all_filters);
-      })(Prism);
-    }
-  }
-});
-
-export {
-  require_pug
-};