@distri/react 0.2.8 → 0.3.1

package/dist/chunk-TEVPUTJN.js

@@ -1,116 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/elixir.js
-var require_elixir = __commonJS({
-  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/elixir.js"(exports, module) {
-    module.exports = elixir;
-    elixir.displayName = "elixir";
-    elixir.aliases = [];
-    function elixir(Prism) {
-      Prism.languages.elixir = {
-        doc: {
-          pattern: /@(?:doc|moduledoc)\s+(?:("""|''')[\s\S]*?\1|("|')(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2)/,
-          inside: {
-            attribute: /^@\w+/,
-            string: /['"][\s\S]+/
-          }
-        },
-        comment: {
-          pattern: /#.*/,
-          greedy: true
-        },
-        // ~r"""foo""" (multi-line), ~r'''foo''' (multi-line), ~r/foo/, ~r|foo|, ~r"foo", ~r'foo', ~r(foo), ~r[foo], ~r{foo}, ~r<foo>
-        regex: {
-          pattern: /~[rR](?:("""|''')(?:\\[\s\S]|(?!\1)[^\\])+\1|([\/|"'])(?:\\.|(?!\2)[^\\\r\n])+\2|\((?:\\.|[^\\)\r\n])+\)|\[(?:\\.|[^\\\]\r\n])+\]|\{(?:\\.|[^\\}\r\n])+\}|<(?:\\.|[^\\>\r\n])+>)[uismxfr]*/,
-          greedy: true
-        },
-        string: [
-          {
-            // ~s"""foo""" (multi-line), ~s'''foo''' (multi-line), ~s/foo/, ~s|foo|, ~s"foo", ~s'foo', ~s(foo), ~s[foo], ~s{foo} (with interpolation care), ~s<foo>
-            pattern: /~[cCsSwW](?:("""|''')(?:\\[\s\S]|(?!\1)[^\\])+\1|([\/|"'])(?:\\.|(?!\2)[^\\\r\n])+\2|\((?:\\.|[^\\)\r\n])+\)|\[(?:\\.|[^\\\]\r\n])+\]|\{(?:\\.|#\{[^}]+\}|#(?!\{)|[^#\\}\r\n])+\}|<(?:\\.|[^\\>\r\n])+>)[csa]?/,
-            greedy: true,
-            inside: {
-              // See interpolation below
-            }
-          },
-          {
-            pattern: /("""|''')[\s\S]*?\1/,
-            greedy: true,
-            inside: {
-              // See interpolation below
-            }
-          },
-          {
-            // Multi-line strings are allowed
-            pattern: /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
-            greedy: true,
-            inside: {
-              // See interpolation below
-            }
-          }
-        ],
-        atom: {
-          // Look-behind prevents bad highlighting of the :: operator
-          pattern: /(^|[^:]):\w+/,
-          lookbehind: true,
-          alias: "symbol"
-        },
-        module: {
-          pattern: /\b[A-Z]\w*\b/,
-          alias: "class-name"
-        },
-        // Look-ahead prevents bad highlighting of the :: operator
-        "attr-name": /\b\w+\??:(?!:)/,
-        argument: {
-          // Look-behind prevents bad highlighting of the && operator
-          pattern: /(^|[^&])&\d+/,
-          lookbehind: true,
-          alias: "variable"
-        },
-        attribute: {
-          pattern: /@\w+/,
-          alias: "variable"
-        },
-        function: /\b[_a-zA-Z]\w*[?!]?(?:(?=\s*(?:\.\s*)?\()|(?=\/\d))/,
-        number: /\b(?:0[box][a-f\d_]+|\d[\d_]*)(?:\.[\d_]+)?(?:e[+-]?[\d_]+)?\b/i,
-        keyword: /\b(?:after|alias|and|case|catch|cond|def(?:callback|delegate|exception|impl|macro|module|n|np|p|protocol|struct)?|do|else|end|fn|for|if|import|not|or|quote|raise|require|rescue|try|unless|unquote|use|when)\b/,
-        boolean: /\b(?:false|nil|true)\b/,
-        operator: [
-          /\bin\b|&&?|\|[|>]?|\\\\|::|\.\.\.?|\+\+?|-[->]?|<[-=>]|>=|!==?|\B!|=(?:==?|[>~])?|[*\/^]/,
-          {
-            // We don't want to match <<
-            pattern: /([^<])<(?!<)/,
-            lookbehind: true
-          },
-          {
-            // We don't want to match >>
-            pattern: /([^>])>(?!>)/,
-            lookbehind: true
-          }
-        ],
-        punctuation: /<<|>>|[.,%\[\]{}()]/
-      };
-      Prism.languages.elixir.string.forEach(function(o) {
-        o.inside = {
-          interpolation: {
-            pattern: /#\{[^}]+\}/,
-            inside: {
-              delimiter: {
-                pattern: /^#\{|\}$/,
-                alias: "punctuation"
-              },
-              rest: Prism.languages.elixir
-            }
-          }
-        };
-      });
-    }
-  }
-});
-
-export {
-  require_elixir
-};

package/dist/chunk-TMPJ5OQC.js

@@ -1,39 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/yang.js
-var require_yang = __commonJS({
-  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/yang.js"(exports, module) {
-    module.exports = yang;
-    yang.displayName = "yang";
-    yang.aliases = [];
-    function yang(Prism) {
-      Prism.languages.yang = {
-        // https://tools.ietf.org/html/rfc6020#page-34
-        // http://www.yang-central.org/twiki/bin/view/Main/YangExamples
-        comment: /\/\*[\s\S]*?\*\/|\/\/.*/,
-        string: {
-          pattern: /"(?:[^\\"]|\\.)*"|'[^']*'/,
-          greedy: true
-        },
-        keyword: {
-          pattern: /(^|[{};\r\n][ \t]*)[a-z_][\w.-]*/i,
-          lookbehind: true
-        },
-        namespace: {
-          pattern: /(\s)[a-z_][\w.-]*(?=:)/i,
-          lookbehind: true
-        },
-        boolean: /\b(?:false|true)\b/,
-        operator: /\+/,
-        punctuation: /[{};:]/
-      };
-    }
-  }
-});
-
-export {
-  require_yang
-};

package/dist/chunk-TPASKEDY.js

@@ -1,71 +0,0 @@
-"use client";
-import {
-  require_java
-} from "./chunk-53MOB7QD.js";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/scala.js
-var require_scala = __commonJS({
-  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/scala.js"(exports, module) {
-    var refractorJava = require_java();
-    module.exports = scala;
-    scala.displayName = "scala";
-    scala.aliases = [];
-    function scala(Prism) {
-      Prism.register(refractorJava);
-      Prism.languages.scala = Prism.languages.extend("java", {
-        "triple-quoted-string": {
-          pattern: /"""[\s\S]*?"""/,
-          greedy: true,
-          alias: "string"
-        },
-        string: {
-          pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
-          greedy: true
-        },
-        keyword: /<-|=>|\b(?:abstract|case|catch|class|def|do|else|extends|final|finally|for|forSome|if|implicit|import|lazy|match|new|null|object|override|package|private|protected|return|sealed|self|super|this|throw|trait|try|type|val|var|while|with|yield)\b/,
-        number: /\b0x(?:[\da-f]*\.)?[\da-f]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e\d+)?[dfl]?/i,
-        builtin: /\b(?:Any|AnyRef|AnyVal|Boolean|Byte|Char|Double|Float|Int|Long|Nothing|Short|String|Unit)\b/,
-        symbol: /'[^\d\s\\]\w*/
-      });
-      Prism.languages.insertBefore("scala", "triple-quoted-string", {
-        "string-interpolation": {
-          pattern: /\b[a-z]\w*(?:"""(?:[^$]|\$(?:[^{]|\{(?:[^{}]|\{[^{}]*\})*\}))*?"""|"(?:[^$"\r\n]|\$(?:[^{]|\{(?:[^{}]|\{[^{}]*\})*\}))*")/i,
-          greedy: true,
-          inside: {
-            id: {
-              pattern: /^\w+/,
-              greedy: true,
-              alias: "function"
-            },
-            escape: {
-              pattern: /\\\$"|\$[$"]/,
-              greedy: true,
-              alias: "symbol"
-            },
-            interpolation: {
-              pattern: /\$(?:\w+|\{(?:[^{}]|\{[^{}]*\})*\})/,
-              greedy: true,
-              inside: {
-                punctuation: /^\$\{?|\}$/,
-                expression: {
-                  pattern: /[\s\S]+/,
-                  inside: Prism.languages.scala
-                }
-              }
-            },
-            string: /[\s\S]+/
-          }
-        }
-      });
-      delete Prism.languages.scala["class-name"];
-      delete Prism.languages.scala["function"];
-    }
-  }
-});
-
-export {
-  require_scala
-};

package/dist/chunk-TUWKJH67.js

@@ -1,141 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/rust.js
-var require_rust = __commonJS({
-  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/rust.js"(exports, module) {
-    module.exports = rust;
-    rust.displayName = "rust";
-    rust.aliases = [];
-    function rust(Prism) {
-      ;
-      (function(Prism2) {
-        var multilineComment = /\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|<self>)*\*\//.source;
-        for (var i = 0; i < 2; i++) {
-          multilineComment = multilineComment.replace(/<self>/g, function() {
-            return multilineComment;
-          });
-        }
-        multilineComment = multilineComment.replace(/<self>/g, function() {
-          return /[^\s\S]/.source;
-        });
-        Prism2.languages.rust = {
-          comment: [
-            {
-              pattern: RegExp(/(^|[^\\])/.source + multilineComment),
-              lookbehind: true,
-              greedy: true
-            },
-            {
-              pattern: /(^|[^\\:])\/\/.*/,
-              lookbehind: true,
-              greedy: true
-            }
-          ],
-          string: {
-            pattern: /b?"(?:\\[\s\S]|[^\\"])*"|b?r(#*)"(?:[^"]|"(?!\1))*"\1/,
-            greedy: true
-          },
-          char: {
-            pattern: /b?'(?:\\(?:x[0-7][\da-fA-F]|u\{(?:[\da-fA-F]_*){1,6}\}|.)|[^\\\r\n\t'])'/,
-            greedy: true
-          },
-          attribute: {
-            pattern: /#!?\[(?:[^\[\]"]|"(?:\\[\s\S]|[^\\"])*")*\]/,
-            greedy: true,
-            alias: "attr-name",
-            inside: {
-              string: null
-              // see below
-            }
-          },
-          // Closure params should not be confused with bitwise OR |
-          "closure-params": {
-            pattern: /([=(,:]\s*|\bmove\s*)\|[^|]*\||\|[^|]*\|(?=\s*(?:\{|->))/,
-            lookbehind: true,
-            greedy: true,
-            inside: {
-              "closure-punctuation": {
-                pattern: /^\||\|$/,
-                alias: "punctuation"
-              },
-              rest: null
-              // see below
-            }
-          },
-          "lifetime-annotation": {
-            pattern: /'\w+/,
-            alias: "symbol"
-          },
-          "fragment-specifier": {
-            pattern: /(\$\w+:)[a-z]+/,
-            lookbehind: true,
-            alias: "punctuation"
-          },
-          variable: /\$\w+/,
-          "function-definition": {
-            pattern: /(\bfn\s+)\w+/,
-            lookbehind: true,
-            alias: "function"
-          },
-          "type-definition": {
-            pattern: /(\b(?:enum|struct|trait|type|union)\s+)\w+/,
-            lookbehind: true,
-            alias: "class-name"
-          },
-          "module-declaration": [
-            {
-              pattern: /(\b(?:crate|mod)\s+)[a-z][a-z_\d]*/,
-              lookbehind: true,
-              alias: "namespace"
-            },
-            {
-              pattern: /(\b(?:crate|self|super)\s*)::\s*[a-z][a-z_\d]*\b(?:\s*::(?:\s*[a-z][a-z_\d]*\s*::)*)?/,
-              lookbehind: true,
-              alias: "namespace",
-              inside: {
-                punctuation: /::/
-              }
-            }
-          ],
-          keyword: [
-            // https://github.com/rust-lang/reference/blob/master/src/keywords.md
-            /\b(?:Self|abstract|as|async|await|become|box|break|const|continue|crate|do|dyn|else|enum|extern|final|fn|for|if|impl|in|let|loop|macro|match|mod|move|mut|override|priv|pub|ref|return|self|static|struct|super|trait|try|type|typeof|union|unsafe|unsized|use|virtual|where|while|yield)\b/,
-            // primitives and str
-            // https://doc.rust-lang.org/stable/rust-by-example/primitives.html
-            /\b(?:bool|char|f(?:32|64)|[ui](?:8|16|32|64|128|size)|str)\b/
-          ],
-          // functions can technically start with an upper-case letter, but this will introduce a lot of false positives
-          // and Rust's naming conventions recommend snake_case anyway.
-          // https://doc.rust-lang.org/1.0.0/style/style/naming/README.html
-          function: /\b[a-z_]\w*(?=\s*(?:::\s*<|\())/,
-          macro: {
-            pattern: /\b\w+!/,
-            alias: "property"
-          },
-          constant: /\b[A-Z_][A-Z_\d]+\b/,
-          "class-name": /\b[A-Z]\w*\b/,
-          namespace: {
-            pattern: /(?:\b[a-z][a-z_\d]*\s*::\s*)*\b[a-z][a-z_\d]*\s*::(?!\s*<)/,
-            inside: {
-              punctuation: /::/
-            }
-          },
-          // Hex, oct, bin, dec numbers with visual separators and type suffix
-          number: /\b(?:0x[\dA-Fa-f](?:_?[\dA-Fa-f])*|0o[0-7](?:_?[0-7])*|0b[01](?:_?[01])*|(?:(?:\d(?:_?\d)*)?\.)?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)(?:_?(?:f32|f64|[iu](?:8|16|32|64|size)?))?\b/,
-          boolean: /\b(?:false|true)\b/,
-          punctuation: /->|\.\.=|\.{1,3}|::|[{}[\];(),:]/,
-          operator: /[-+*\/%!^]=?|=[=>]?|&[&=]?|\|[|=]?|<<?=?|>>?=?|[@?]/
-        };
-        Prism2.languages.rust["closure-params"].inside.rest = Prism2.languages.rust;
-        Prism2.languages.rust["attribute"].inside["string"] = Prism2.languages.rust["string"];
-      })(Prism);
-    }
-  }
-});
-
-export {
-  require_rust
-};

package/dist/chunk-TVWUYRIS.js

@@ -1,69 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/nginx.js
-var require_nginx = __commonJS({
-  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/nginx.js"(exports, module) {
-    module.exports = nginx;
-    nginx.displayName = "nginx";
-    nginx.aliases = [];
-    function nginx(Prism) {
-      ;
-      (function(Prism2) {
-        var variable = /\$(?:\w[a-z\d]*(?:_[^\x00-\x1F\s"'\\()$]*)?|\{[^}\s"'\\]+\})/i;
-        Prism2.languages.nginx = {
-          comment: {
-            pattern: /(^|[\s{};])#.*/,
-            lookbehind: true,
-            greedy: true
-          },
-          directive: {
-            pattern: /(^|\s)\w(?:[^;{}"'\\\s]|\\.|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\s+(?:#.*(?!.)|(?![#\s])))*?(?=\s*[;{])/,
-            lookbehind: true,
-            greedy: true,
-            inside: {
-              string: {
-                pattern: /((?:^|[^\\])(?:\\\\)*)(?:"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')/,
-                lookbehind: true,
-                greedy: true,
-                inside: {
-                  escape: {
-                    pattern: /\\["'\\nrt]/,
-                    alias: "entity"
-                  },
-                  variable
-                }
-              },
-              comment: {
-                pattern: /(\s)#.*/,
-                lookbehind: true,
-                greedy: true
-              },
-              keyword: {
-                pattern: /^\S+/,
-                greedy: true
-              },
-              // other patterns
-              boolean: {
-                pattern: /(\s)(?:off|on)(?!\S)/,
-                lookbehind: true
-              },
-              number: {
-                pattern: /(\s)\d+[a-z]*(?!\S)/i,
-                lookbehind: true
-              },
-              variable
-            }
-          },
-          punctuation: /[{};]/
-        };
-      })(Prism);
-    }
-  }
-});
-
-export {
-  require_nginx
-};

package/dist/chunk-TWAI6FLP.js

@@ -1,46 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/gdscript.js
-var require_gdscript = __commonJS({
-  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/gdscript.js"(exports, module) {
-    module.exports = gdscript;
-    gdscript.displayName = "gdscript";
-    gdscript.aliases = [];
-    function gdscript(Prism) {
-      Prism.languages.gdscript = {
-        comment: /#.*/,
-        string: {
-          pattern: /@?(?:("|')(?:(?!\1)[^\n\\]|\\[\s\S])*\1(?!"|')|"""(?:[^\\]|\\[\s\S])*?""")/,
-          greedy: true
-        },
-        "class-name": {
-          // class_name Foo, extends Bar, class InnerClass
-          // export(int) var baz, export(int, 0) var i
-          // as Node
-          // const FOO: int = 9, var bar: bool = true
-          // func add(reference: Item, amount: int) -> Item:
-          pattern: /(^(?:class|class_name|extends)[ \t]+|^export\([ \t]*|\bas[ \t]+|(?:\b(?:const|var)[ \t]|[,(])[ \t]*\w+[ \t]*:[ \t]*|->[ \t]*)[a-zA-Z_]\w*/m,
-          lookbehind: true
-        },
-        keyword: /\b(?:and|as|assert|break|breakpoint|class|class_name|const|continue|elif|else|enum|export|extends|for|func|if|in|is|master|mastersync|match|not|null|onready|or|pass|preload|puppet|puppetsync|remote|remotesync|return|self|setget|signal|static|tool|var|while|yield)\b/,
-        function: /\b[a-z_]\w*(?=[ \t]*\()/i,
-        variable: /\$\w+/,
-        number: [
-          /\b0b[01_]+\b|\b0x[\da-fA-F_]+\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.[\d_]+)(?:e[+-]?[\d_]+)?\b/,
-          /\b(?:INF|NAN|PI|TAU)\b/
-        ],
-        constant: /\b[A-Z][A-Z_\d]*\b/,
-        boolean: /\b(?:false|true)\b/,
-        operator: /->|:=|&&|\|\||<<|>>|[-+*/%&|!<>=]=?|[~^]/,
-        punctuation: /[.:,;()[\]{}]/
-      };
-    }
-  }
-});
-
-export {
-  require_gdscript
-};

package/dist/chunk-TWMU5FT4.js

@@ -1,98 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/d.js
-var require_d = __commonJS({
-  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/d.js"(exports, module) {
-    module.exports = d;
-    d.displayName = "d";
-    d.aliases = [];
-    function d(Prism) {
-      Prism.languages.d = Prism.languages.extend("clike", {
-        comment: [
-          {
-            // Shebang
-            pattern: /^\s*#!.+/,
-            greedy: true
-          },
-          {
-            pattern: RegExp(
-              /(^|[^\\])/.source + "(?:" + [
-                // /+ comment +/
-                // Allow one level of nesting
-                /\/\+(?:\/\+(?:[^+]|\+(?!\/))*\+\/|(?!\/\+)[\s\S])*?\+\//.source,
-                // // comment
-                /\/\/.*/.source,
-                // /* comment */
-                /\/\*[\s\S]*?\*\//.source
-              ].join("|") + ")"
-            ),
-            lookbehind: true,
-            greedy: true
-          }
-        ],
-        string: [
-          {
-            pattern: RegExp(
-              [
-                // r"", x""
-                /\b[rx]"(?:\\[\s\S]|[^\\"])*"[cwd]?/.source,
-                // q"[]", q"()", q"<>", q"{}"
-                /\bq"(?:\[[\s\S]*?\]|\([\s\S]*?\)|<[\s\S]*?>|\{[\s\S]*?\})"/.source,
-                // q"IDENT
-                // ...
-                // IDENT"
-                /\bq"((?!\d)\w+)$[\s\S]*?^\1"/.source,
-                // q"//", q"||", etc.
-                // eslint-disable-next-line regexp/strict
-                /\bq"(.)[\s\S]*?\2"/.source,
-                // eslint-disable-next-line regexp/strict
-                /(["`])(?:\\[\s\S]|(?!\3)[^\\])*\3[cwd]?/.source
-              ].join("|"),
-              "m"
-            ),
-            greedy: true
-          },
-          {
-            pattern: /\bq\{(?:\{[^{}]*\}|[^{}])*\}/,
-            greedy: true,
-            alias: "token-string"
-          }
-        ],
-        // In order: $, keywords and special tokens, globally defined symbols
-        keyword: /\$|\b(?:__(?:(?:DATE|EOF|FILE|FUNCTION|LINE|MODULE|PRETTY_FUNCTION|TIMESTAMP|TIME|VENDOR|VERSION)__|gshared|parameters|traits|vector)|abstract|alias|align|asm|assert|auto|body|bool|break|byte|case|cast|catch|cdouble|cent|cfloat|char|class|const|continue|creal|dchar|debug|default|delegate|delete|deprecated|do|double|dstring|else|enum|export|extern|false|final|finally|float|for|foreach|foreach_reverse|function|goto|idouble|if|ifloat|immutable|import|inout|int|interface|invariant|ireal|lazy|long|macro|mixin|module|new|nothrow|null|out|override|package|pragma|private|protected|ptrdiff_t|public|pure|real|ref|return|scope|shared|short|size_t|static|string|struct|super|switch|synchronized|template|this|throw|true|try|typedef|typeid|typeof|ubyte|ucent|uint|ulong|union|unittest|ushort|version|void|volatile|wchar|while|with|wstring)\b/,
-        number: [
-          // The lookbehind and the negative look-ahead try to prevent bad highlighting of the .. operator
-          // Hexadecimal numbers must be handled separately to avoid problems with exponent "e"
-          /\b0x\.?[a-f\d_]+(?:(?!\.\.)\.[a-f\d_]*)?(?:p[+-]?[a-f\d_]+)?[ulfi]{0,4}/i,
-          {
-            pattern: /((?:\.\.)?)(?:\b0b\.?|\b|\.)\d[\d_]*(?:(?!\.\.)\.[\d_]*)?(?:e[+-]?\d[\d_]*)?[ulfi]{0,4}/i,
-            lookbehind: true
-          }
-        ],
-        operator: /\|[|=]?|&[&=]?|\+[+=]?|-[-=]?|\.?\.\.|=[>=]?|!(?:i[ns]\b|<>?=?|>=?|=)?|\bi[ns]\b|(?:<[<>]?|>>?>?|\^\^|[*\/%^~])=?/
-      });
-      Prism.languages.insertBefore("d", "string", {
-        // Characters
-        // 'a', '\\', '\n', '\xFF', '\377', '\uFFFF', '\U0010FFFF', '\quot'
-        char: /'(?:\\(?:\W|\w+)|[^\\])'/
-      });
-      Prism.languages.insertBefore("d", "keyword", {
-        property: /\B@\w*/
-      });
-      Prism.languages.insertBefore("d", "function", {
-        register: {
-          // Iasm registers
-          pattern: /\b(?:[ABCD][LHX]|E?(?:BP|DI|SI|SP)|[BS]PL|[ECSDGF]S|CR[0234]|[DS]IL|DR[012367]|E[ABCD]X|X?MM[0-7]|R(?:1[0-5]|[89])[BWD]?|R[ABCD]X|R[BS]P|R[DS]I|TR[3-7]|XMM(?:1[0-5]|[89])|YMM(?:1[0-5]|\d))\b|\bST(?:\([0-7]\)|\b)/,
-          alias: "variable"
-        }
-      });
-    }
-  }
-});
-
-export {
-  require_d
-};