@distri/react 0.3.0 → 0.3.1

package/dist/chunk-4K6U3KST.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-4LPMZE4K.js

@@ -1,50 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/clike.js
-var require_clike = __commonJS({
-  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/clike.js"(exports, module) {
-    module.exports = clike;
-    clike.displayName = "clike";
-    clike.aliases = [];
-    function clike(Prism) {
-      Prism.languages.clike = {
-        comment: [
-          {
-            pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
-            lookbehind: true,
-            greedy: true
-          },
-          {
-            pattern: /(^|[^\\:])\/\/.*/,
-            lookbehind: true,
-            greedy: true
-          }
-        ],
-        string: {
-          pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
-          greedy: true
-        },
-        "class-name": {
-          pattern: /(\b(?:class|extends|implements|instanceof|interface|new|trait)\s+|\bcatch\s+\()[\w.\\]+/i,
-          lookbehind: true,
-          inside: {
-            punctuation: /[.\\]/
-          }
-        },
-        keyword: /\b(?:break|catch|continue|do|else|finally|for|function|if|in|instanceof|new|null|return|throw|try|while)\b/,
-        boolean: /\b(?:false|true)\b/,
-        function: /\b\w+(?=\()/,
-        number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
-        operator: /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/,
-        punctuation: /[{}[\];(),.:]/
-      };
-    }
-  }
-});
-
-export {
-  require_clike
-};

package/dist/chunk-4LROSNN7.js

@@ -1,239 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/asciidoc.js
-var require_asciidoc = __commonJS({
-  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/asciidoc.js"(exports, module) {
-    module.exports = asciidoc;
-    asciidoc.displayName = "asciidoc";
-    asciidoc.aliases = ["adoc"];
-    function asciidoc(Prism) {
-      ;
-      (function(Prism2) {
-        var attributes = {
-          pattern: /(^[ \t]*)\[(?!\[)(?:(["'$`])(?:(?!\2)[^\\]|\\.)*\2|\[(?:[^\[\]\\]|\\.)*\]|[^\[\]\\"'$`]|\\.)*\]/m,
-          lookbehind: true,
-          inside: {
-            quoted: {
-              pattern: /([$`])(?:(?!\1)[^\\]|\\.)*\1/,
-              inside: {
-                punctuation: /^[$`]|[$`]$/
-              }
-            },
-            interpreted: {
-              pattern: /'(?:[^'\\]|\\.)*'/,
-              inside: {
-                punctuation: /^'|'$/
-                // See rest below
-              }
-            },
-            string: /"(?:[^"\\]|\\.)*"/,
-            variable: /\w+(?==)/,
-            punctuation: /^\[|\]$|,/,
-            operator: /=/,
-            // The negative look-ahead prevents blank matches
-            "attr-value": /(?!^\s+$).+/
-          }
-        };
-        var asciidoc2 = Prism2.languages.asciidoc = {
-          "comment-block": {
-            pattern: /^(\/{4,})(?:\r?\n|\r)(?:[\s\S]*(?:\r?\n|\r))??\1/m,
-            alias: "comment"
-          },
-          table: {
-            pattern: /^\|={3,}(?:(?:\r?\n|\r(?!\n)).*)*?(?:\r?\n|\r)\|={3,}$/m,
-            inside: {
-              specifiers: {
-                pattern: /(?:(?:(?:\d+(?:\.\d+)?|\.\d+)[+*](?:[<^>](?:\.[<^>])?|\.[<^>])?|[<^>](?:\.[<^>])?|\.[<^>])[a-z]*|[a-z]+)(?=\|)/,
-                alias: "attr-value"
-              },
-              punctuation: {
-                pattern: /(^|[^\\])[|!]=*/,
-                lookbehind: true
-              }
-              // See rest below
-            }
-          },
-          "passthrough-block": {
-            pattern: /^(\+{4,})(?:\r?\n|\r)(?:[\s\S]*(?:\r?\n|\r))??\1$/m,
-            inside: {
-              punctuation: /^\++|\++$/
-              // See rest below
-            }
-          },
-          // Literal blocks and listing blocks
-          "literal-block": {
-            pattern: /^(-{4,}|\.{4,})(?:\r?\n|\r)(?:[\s\S]*(?:\r?\n|\r))??\1$/m,
-            inside: {
-              punctuation: /^(?:-+|\.+)|(?:-+|\.+)$/
-              // See rest below
-            }
-          },
-          // Sidebar blocks, quote blocks, example blocks and open blocks
-          "other-block": {
-            pattern: /^(--|\*{4,}|_{4,}|={4,})(?:\r?\n|\r)(?:[\s\S]*(?:\r?\n|\r))??\1$/m,
-            inside: {
-              punctuation: /^(?:-+|\*+|_+|=+)|(?:-+|\*+|_+|=+)$/
-              // See rest below
-            }
-          },
-          // list-punctuation and list-label must appear before indented-block
-          "list-punctuation": {
-            pattern: /(^[ \t]*)(?:-|\*{1,5}|\.{1,5}|(?:[a-z]|\d+)\.|[xvi]+\))(?= )/im,
-            lookbehind: true,
-            alias: "punctuation"
-          },
-          "list-label": {
-            pattern: /(^[ \t]*)[a-z\d].+(?::{2,4}|;;)(?=\s)/im,
-            lookbehind: true,
-            alias: "symbol"
-          },
-          "indented-block": {
-            pattern: /((\r?\n|\r)\2)([ \t]+)\S.*(?:(?:\r?\n|\r)\3.+)*(?=\2{2}|$)/,
-            lookbehind: true
-          },
-          comment: /^\/\/.*/m,
-          title: {
-            pattern: /^.+(?:\r?\n|\r)(?:={3,}|-{3,}|~{3,}|\^{3,}|\+{3,})$|^={1,5} .+|^\.(?![\s.]).*/m,
-            alias: "important",
-            inside: {
-              punctuation: /^(?:\.|=+)|(?:=+|-+|~+|\^+|\++)$/
-              // See rest below
-            }
-          },
-          "attribute-entry": {
-            pattern: /^:[^:\r\n]+:(?: .*?(?: \+(?:\r?\n|\r).*?)*)?$/m,
-            alias: "tag"
-          },
-          attributes,
-          hr: {
-            pattern: /^'{3,}$/m,
-            alias: "punctuation"
-          },
-          "page-break": {
-            pattern: /^<{3,}$/m,
-            alias: "punctuation"
-          },
-          admonition: {
-            pattern: /^(?:CAUTION|IMPORTANT|NOTE|TIP|WARNING):/m,
-            alias: "keyword"
-          },
-          callout: [
-            {
-              pattern: /(^[ \t]*)<?\d*>/m,
-              lookbehind: true,
-              alias: "symbol"
-            },
-            {
-              pattern: /<\d+>/,
-              alias: "symbol"
-            }
-          ],
-          macro: {
-            pattern: /\b[a-z\d][a-z\d-]*::?(?:[^\s\[\]]*\[(?:[^\]\\"']|(["'])(?:(?!\1)[^\\]|\\.)*\1|\\.)*\])/,
-            inside: {
-              function: /^[a-z\d-]+(?=:)/,
-              punctuation: /^::?/,
-              attributes: {
-                pattern: /(?:\[(?:[^\]\\"']|(["'])(?:(?!\1)[^\\]|\\.)*\1|\\.)*\])/,
-                inside: attributes.inside
-              }
-            }
-          },
-          inline: {
-            /*
-            The initial look-behind prevents the highlighting of escaped quoted text.
-            Quoted text can be multi-line but cannot span an empty line.
-            All quoted text can have attributes before [foobar, 'foobar', baz="bar"].
-            First, we handle the constrained quotes.
-            Those must be bounded by non-word chars and cannot have spaces between the delimiter and the first char.
-            They are, in order: _emphasis_, ``double quotes'', `single quotes', `monospace`, 'emphasis', *strong*, +monospace+ and #unquoted#
-            Then we handle the unconstrained quotes.
-            Those do not have the restrictions of the constrained quotes.
-            They are, in order: __emphasis__, **strong**, ++monospace++, +++passthrough+++, ##unquoted##, $$passthrough$$, ~subscript~, ^superscript^, {attribute-reference}, [[anchor]], [[[bibliography anchor]]], <<xref>>, (((indexes))) and ((indexes))
-            */
-            pattern: /(^|[^\\])(?:(?:\B\[(?:[^\]\\"']|(["'])(?:(?!\2)[^\\]|\\.)*\2|\\.)*\])?(?:\b_(?!\s)(?: _|[^_\\\r\n]|\\.)+(?:(?:\r?\n|\r)(?: _|[^_\\\r\n]|\\.)+)*_\b|\B``(?!\s).+?(?:(?:\r?\n|\r).+?)*''\B|\B`(?!\s)(?:[^`'\s]|\s+\S)+['`]\B|\B(['*+#])(?!\s)(?: \3|(?!\3)[^\\\r\n]|\\.)+(?:(?:\r?\n|\r)(?: \3|(?!\3)[^\\\r\n]|\\.)+)*\3\B)|(?:\[(?:[^\]\\"']|(["'])(?:(?!\4)[^\\]|\\.)*\4|\\.)*\])?(?:(__|\*\*|\+\+\+?|##|\$\$|[~^]).+?(?:(?:\r?\n|\r).+?)*\5|\{[^}\r\n]+\}|\[\[\[?.+?(?:(?:\r?\n|\r).+?)*\]?\]\]|<<.+?(?:(?:\r?\n|\r).+?)*>>|\(\(\(?.+?(?:(?:\r?\n|\r).+?)*\)?\)\)))/m,
-            lookbehind: true,
-            inside: {
-              attributes,
-              url: {
-                pattern: /^(?:\[\[\[?.+?\]?\]\]|<<.+?>>)$/,
-                inside: {
-                  punctuation: /^(?:\[\[\[?|<<)|(?:\]\]\]?|>>)$/
-                }
-              },
-              "attribute-ref": {
-                pattern: /^\{.+\}$/,
-                inside: {
-                  variable: {
-                    pattern: /(^\{)[a-z\d,+_-]+/,
-                    lookbehind: true
-                  },
-                  operator: /^[=?!#%@$]|!(?=[:}])/,
-                  punctuation: /^\{|\}$|::?/
-                }
-              },
-              italic: {
-                pattern: /^(['_])[\s\S]+\1$/,
-                inside: {
-                  punctuation: /^(?:''?|__?)|(?:''?|__?)$/
-                }
-              },
-              bold: {
-                pattern: /^\*[\s\S]+\*$/,
-                inside: {
-                  punctuation: /^\*\*?|\*\*?$/
-                }
-              },
-              punctuation: /^(?:``?|\+{1,3}|##?|\$\$|[~^]|\(\(\(?)|(?:''?|\+{1,3}|##?|\$\$|[~^`]|\)?\)\))$/
-            }
-          },
-          replacement: {
-            pattern: /\((?:C|R|TM)\)/,
-            alias: "builtin"
-          },
-          entity: /&#?[\da-z]{1,8};/i,
-          "line-continuation": {
-            pattern: /(^| )\+$/m,
-            lookbehind: true,
-            alias: "punctuation"
-          }
-        };
-        function copyFromAsciiDoc(keys) {
-          keys = keys.split(" ");
-          var o = {};
-          for (var i = 0, l = keys.length; i < l; i++) {
-            o[keys[i]] = asciidoc2[keys[i]];
-          }
-          return o;
-        }
-        attributes.inside["interpreted"].inside.rest = copyFromAsciiDoc(
-          "macro inline replacement entity"
-        );
-        asciidoc2["passthrough-block"].inside.rest = copyFromAsciiDoc("macro");
-        asciidoc2["literal-block"].inside.rest = copyFromAsciiDoc("callout");
-        asciidoc2["table"].inside.rest = copyFromAsciiDoc(
-          "comment-block passthrough-block literal-block other-block list-punctuation indented-block comment title attribute-entry attributes hr page-break admonition list-label callout macro inline replacement entity line-continuation"
-        );
-        asciidoc2["other-block"].inside.rest = copyFromAsciiDoc(
-          "table list-punctuation indented-block comment attribute-entry attributes hr page-break admonition list-label macro inline replacement entity line-continuation"
-        );
-        asciidoc2["title"].inside.rest = copyFromAsciiDoc(
-          "macro inline replacement entity"
-        );
-        Prism2.hooks.add("wrap", function(env) {
-          if (env.type === "entity") {
-            env.attributes["title"] = env.content.value.replace(/&amp;/, "&");
-          }
-        });
-        Prism2.languages.adoc = Prism2.languages.asciidoc;
-      })(Prism);
-    }
-  }
-});
-
-export {
-  require_asciidoc
-};

package/dist/chunk-4TEDW65X.js

@@ -1,101 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/kotlin.js
-var require_kotlin = __commonJS({
-  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/kotlin.js"(exports, module) {
-    module.exports = kotlin;
-    kotlin.displayName = "kotlin";
-    kotlin.aliases = ["kt", "kts"];
-    function kotlin(Prism) {
-      ;
-      (function(Prism2) {
-        Prism2.languages.kotlin = Prism2.languages.extend("clike", {
-          keyword: {
-            // The lookbehind prevents wrong highlighting of e.g. kotlin.properties.get
-            pattern: /(^|[^.])\b(?:abstract|actual|annotation|as|break|by|catch|class|companion|const|constructor|continue|crossinline|data|do|dynamic|else|enum|expect|external|final|finally|for|fun|get|if|import|in|infix|init|inline|inner|interface|internal|is|lateinit|noinline|null|object|open|operator|out|override|package|private|protected|public|reified|return|sealed|set|super|suspend|tailrec|this|throw|to|try|typealias|val|var|vararg|when|where|while)\b/,
-            lookbehind: true
-          },
-          function: [
-            {
-              pattern: /(?:`[^\r\n`]+`|\b\w+)(?=\s*\()/,
-              greedy: true
-            },
-            {
-              pattern: /(\.)(?:`[^\r\n`]+`|\w+)(?=\s*\{)/,
-              lookbehind: true,
-              greedy: true
-            }
-          ],
-          number: /\b(?:0[xX][\da-fA-F]+(?:_[\da-fA-F]+)*|0[bB][01]+(?:_[01]+)*|\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?(?:[eE][+-]?\d+(?:_\d+)*)?[fFL]?)\b/,
-          operator: /\+[+=]?|-[-=>]?|==?=?|!(?:!|==?)?|[\/*%<>]=?|[?:]:?|\.\.|&&|\|\||\b(?:and|inv|or|shl|shr|ushr|xor)\b/
-        });
-        delete Prism2.languages.kotlin["class-name"];
-        var interpolationInside = {
-          "interpolation-punctuation": {
-            pattern: /^\$\{?|\}$/,
-            alias: "punctuation"
-          },
-          expression: {
-            pattern: /[\s\S]+/,
-            inside: Prism2.languages.kotlin
-          }
-        };
-        Prism2.languages.insertBefore("kotlin", "string", {
-          // https://kotlinlang.org/spec/expressions.html#string-interpolation-expressions
-          "string-literal": [
-            {
-              pattern: /"""(?:[^$]|\$(?:(?!\{)|\{[^{}]*\}))*?"""/,
-              alias: "multiline",
-              inside: {
-                interpolation: {
-                  pattern: /\$(?:[a-z_]\w*|\{[^{}]*\})/i,
-                  inside: interpolationInside
-                },
-                string: /[\s\S]+/
-              }
-            },
-            {
-              pattern: /"(?:[^"\\\r\n$]|\\.|\$(?:(?!\{)|\{[^{}]*\}))*"/,
-              alias: "singleline",
-              inside: {
-                interpolation: {
-                  pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:[a-z_]\w*|\{[^{}]*\})/i,
-                  lookbehind: true,
-                  inside: interpolationInside
-                },
-                string: /[\s\S]+/
-              }
-            }
-          ],
-          char: {
-            // https://kotlinlang.org/spec/expressions.html#character-literals
-            pattern: /'(?:[^'\\\r\n]|\\(?:.|u[a-fA-F0-9]{0,4}))'/,
-            greedy: true
-          }
-        });
-        delete Prism2.languages.kotlin["string"];
-        Prism2.languages.insertBefore("kotlin", "keyword", {
-          annotation: {
-            pattern: /\B@(?:\w+:)?(?:[A-Z]\w*|\[[^\]]+\])/,
-            alias: "builtin"
-          }
-        });
-        Prism2.languages.insertBefore("kotlin", "function", {
-          label: {
-            pattern: /\b\w+@|@\w+\b/,
-            alias: "symbol"
-          }
-        });
-        Prism2.languages.kt = Prism2.languages.kotlin;
-        Prism2.languages.kts = Prism2.languages.kotlin;
-      })(Prism);
-    }
-  }
-});
-
-export {
-  require_kotlin
-};

package/dist/chunk-4TTFS7AE.js

@@ -1,156 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/stylus.js
-var require_stylus = __commonJS({
-  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/stylus.js"(exports, module) {
-    module.exports = stylus;
-    stylus.displayName = "stylus";
-    stylus.aliases = [];
-    function stylus(Prism) {
-      ;
-      (function(Prism2) {
-        var unit = {
-          pattern: /(\b\d+)(?:%|[a-z]+)/,
-          lookbehind: true
-        };
-        var number = {
-          pattern: /(^|[^\w.-])-?(?:\d+(?:\.\d+)?|\.\d+)/,
-          lookbehind: true
-        };
-        var inside = {
-          comment: {
-            pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/,
-            lookbehind: true
-          },
-          url: {
-            pattern: /\burl\((["']?).*?\1\)/i,
-            greedy: true
-          },
-          string: {
-            pattern: /("|')(?:(?!\1)[^\\\r\n]|\\(?:\r\n|[\s\S]))*\1/,
-            greedy: true
-          },
-          interpolation: null,
-          // See below
-          func: null,
-          // See below
-          important: /\B!(?:important|optional)\b/i,
-          keyword: {
-            pattern: /(^|\s+)(?:(?:else|for|if|return|unless)(?=\s|$)|@[\w-]+)/,
-            lookbehind: true
-          },
-          hexcode: /#[\da-f]{3,6}/i,
-          color: [
-            /\b(?:AliceBlue|AntiqueWhite|Aqua|Aquamarine|Azure|Beige|Bisque|Black|BlanchedAlmond|Blue|BlueViolet|Brown|BurlyWood|CadetBlue|Chartreuse|Chocolate|Coral|CornflowerBlue|Cornsilk|Crimson|Cyan|DarkBlue|DarkCyan|DarkGoldenRod|DarkGr[ae]y|DarkGreen|DarkKhaki|DarkMagenta|DarkOliveGreen|DarkOrange|DarkOrchid|DarkRed|DarkSalmon|DarkSeaGreen|DarkSlateBlue|DarkSlateGr[ae]y|DarkTurquoise|DarkViolet|DeepPink|DeepSkyBlue|DimGr[ae]y|DodgerBlue|FireBrick|FloralWhite|ForestGreen|Fuchsia|Gainsboro|GhostWhite|Gold|GoldenRod|Gr[ae]y|Green|GreenYellow|HoneyDew|HotPink|IndianRed|Indigo|Ivory|Khaki|Lavender|LavenderBlush|LawnGreen|LemonChiffon|LightBlue|LightCoral|LightCyan|LightGoldenRodYellow|LightGr[ae]y|LightGreen|LightPink|LightSalmon|LightSeaGreen|LightSkyBlue|LightSlateGr[ae]y|LightSteelBlue|LightYellow|Lime|LimeGreen|Linen|Magenta|Maroon|MediumAquaMarine|MediumBlue|MediumOrchid|MediumPurple|MediumSeaGreen|MediumSlateBlue|MediumSpringGreen|MediumTurquoise|MediumVioletRed|MidnightBlue|MintCream|MistyRose|Moccasin|NavajoWhite|Navy|OldLace|Olive|OliveDrab|Orange|OrangeRed|Orchid|PaleGoldenRod|PaleGreen|PaleTurquoise|PaleVioletRed|PapayaWhip|PeachPuff|Peru|Pink|Plum|PowderBlue|Purple|Red|RosyBrown|RoyalBlue|SaddleBrown|Salmon|SandyBrown|SeaGreen|SeaShell|Sienna|Silver|SkyBlue|SlateBlue|SlateGr[ae]y|Snow|SpringGreen|SteelBlue|Tan|Teal|Thistle|Tomato|Transparent|Turquoise|Violet|Wheat|White|WhiteSmoke|Yellow|YellowGreen)\b/i,
-            {
-              pattern: /\b(?:hsl|rgb)\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*\)\B|\b(?:hsl|rgb)a\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*,\s*(?:0|0?\.\d+|1)\s*\)\B/i,
-              inside: {
-                unit,
-                number,
-                function: /[\w-]+(?=\()/,
-                punctuation: /[(),]/
-              }
-            }
-          ],
-          entity: /\\[\da-f]{1,8}/i,
-          unit,
-          boolean: /\b(?:false|true)\b/,
-          operator: [
-            // We want non-word chars around "-" because it is
-            // accepted in property names.
-            /~|[+!\/%<>?=]=?|[-:]=|\*[*=]?|\.{2,3}|&&|\|\||\B-\B|\b(?:and|in|is(?: a| defined| not|nt)?|not|or)\b/
-          ],
-          number,
-          punctuation: /[{}()\[\];:,]/
-        };
-        inside["interpolation"] = {
-          pattern: /\{[^\r\n}:]+\}/,
-          alias: "variable",
-          inside: {
-            delimiter: {
-              pattern: /^\{|\}$/,
-              alias: "punctuation"
-            },
-            rest: inside
-          }
-        };
-        inside["func"] = {
-          pattern: /[\w-]+\([^)]*\).*/,
-          inside: {
-            function: /^[^(]+/,
-            rest: inside
-          }
-        };
-        Prism2.languages.stylus = {
-          "atrule-declaration": {
-            pattern: /(^[ \t]*)@.+/m,
-            lookbehind: true,
-            inside: {
-              atrule: /^@[\w-]+/,
-              rest: inside
-            }
-          },
-          "variable-declaration": {
-            pattern: /(^[ \t]*)[\w$-]+\s*.?=[ \t]*(?:\{[^{}]*\}|\S.*|$)/m,
-            lookbehind: true,
-            inside: {
-              variable: /^\S+/,
-              rest: inside
-            }
-          },
-          statement: {
-            pattern: /(^[ \t]*)(?:else|for|if|return|unless)[ \t].+/m,
-            lookbehind: true,
-            inside: {
-              keyword: /^\S+/,
-              rest: inside
-            }
-          },
-          // A property/value pair cannot end with a comma or a brace
-          // It cannot have indented content unless it ended with a semicolon
-          "property-declaration": {
-            pattern: /((?:^|\{)([ \t]*))(?:[\w-]|\{[^}\r\n]+\})+(?:\s*:\s*|[ \t]+)(?!\s)[^{\r\n]*(?:;|[^{\r\n,]$(?!(?:\r?\n|\r)(?:\{|\2[ \t])))/m,
-            lookbehind: true,
-            inside: {
-              property: {
-                pattern: /^[^\s:]+/,
-                inside: {
-                  interpolation: inside.interpolation
-                }
-              },
-              rest: inside
-            }
-          },
-          // A selector can contain parentheses only as part of a pseudo-element
-          // It can span multiple lines.
-          // It must end with a comma or an accolade or have indented content.
-          selector: {
-            pattern: /(^[ \t]*)(?:(?=\S)(?:[^{}\r\n:()]|::?[\w-]+(?:\([^)\r\n]*\)|(?![\w-]))|\{[^}\r\n]+\})+)(?:(?:\r?\n|\r)(?:\1(?:(?=\S)(?:[^{}\r\n:()]|::?[\w-]+(?:\([^)\r\n]*\)|(?![\w-]))|\{[^}\r\n]+\})+)))*(?:,$|\{|(?=(?:\r?\n|\r)(?:\{|\1[ \t])))/m,
-            lookbehind: true,
-            inside: {
-              interpolation: inside.interpolation,
-              comment: inside.comment,
-              punctuation: /[{},]/
-            }
-          },
-          func: inside.func,
-          string: inside.string,
-          comment: {
-            pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/,
-            lookbehind: true,
-            greedy: true
-          },
-          interpolation: inside.interpolation,
-          punctuation: /[{}()\[\];:.]/
-        };
-      })(Prism);
-    }
-  }
-});
-
-export {
-  require_stylus
-};