@distri/react 0.2.7 → 0.2.8

package/dist/chunk-4K6U3KST.js

@@ -0,0 +1,97 @@
+"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

@@ -0,0 +1,50 @@
+"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

@@ -0,0 +1,239 @@
+"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

@@ -0,0 +1,101 @@
+"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

@@ -0,0 +1,156 @@
+"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
+};