@distri/react 0.2.7 → 0.2.8

package/dist/chunk-TEVPUTJN.js

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

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

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

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

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

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

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