@distri/react 0.2.5 → 0.2.8

package/dist/chunk-NSMEMFKE.js

@@ -0,0 +1,217 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/rest.js
+var require_rest = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/rest.js"(exports, module) {
+    module.exports = rest;
+    rest.displayName = "rest";
+    rest.aliases = [];
+    function rest(Prism) {
+      Prism.languages.rest = {
+        table: [
+          {
+            pattern: /(^[\t ]*)(?:\+[=-]+)+\+(?:\r?\n|\r)(?:\1[+|].+[+|](?:\r?\n|\r))+\1(?:\+[=-]+)+\+/m,
+            lookbehind: true,
+            inside: {
+              punctuation: /\||(?:\+[=-]+)+\+/
+            }
+          },
+          {
+            pattern: /(^[\t ]*)=+ [ =]*=(?:(?:\r?\n|\r)\1.+)+(?:\r?\n|\r)\1=+ [ =]*=(?=(?:\r?\n|\r){2}|\s*$)/m,
+            lookbehind: true,
+            inside: {
+              punctuation: /[=-]+/
+            }
+          }
+        ],
+        // Directive-like patterns
+        "substitution-def": {
+          pattern: /(^[\t ]*\.\. )\|(?:[^|\s](?:[^|]*[^|\s])?)\| [^:]+::/m,
+          lookbehind: true,
+          inside: {
+            substitution: {
+              pattern: /^\|(?:[^|\s]|[^|\s][^|]*[^|\s])\|/,
+              alias: "attr-value",
+              inside: {
+                punctuation: /^\||\|$/
+              }
+            },
+            directive: {
+              pattern: /( )(?! )[^:]+::/,
+              lookbehind: true,
+              alias: "function",
+              inside: {
+                punctuation: /::$/
+              }
+            }
+          }
+        },
+        "link-target": [
+          {
+            pattern: /(^[\t ]*\.\. )\[[^\]]+\]/m,
+            lookbehind: true,
+            alias: "string",
+            inside: {
+              punctuation: /^\[|\]$/
+            }
+          },
+          {
+            pattern: /(^[\t ]*\.\. )_(?:`[^`]+`|(?:[^:\\]|\\.)+):/m,
+            lookbehind: true,
+            alias: "string",
+            inside: {
+              punctuation: /^_|:$/
+            }
+          }
+        ],
+        directive: {
+          pattern: /(^[\t ]*\.\. )[^:]+::/m,
+          lookbehind: true,
+          alias: "function",
+          inside: {
+            punctuation: /::$/
+          }
+        },
+        comment: {
+          // The two alternatives try to prevent highlighting of blank comments
+          pattern: /(^[\t ]*\.\.)(?:(?: .+)?(?:(?:\r?\n|\r).+)+| .+)(?=(?:\r?\n|\r){2}|$)/m,
+          lookbehind: true
+        },
+        title: [
+          // Overlined and underlined
+          {
+            pattern: /^(([!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~])\2+)(?:\r?\n|\r).+(?:\r?\n|\r)\1$/m,
+            inside: {
+              punctuation: /^[!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~]+|[!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~]+$/,
+              important: /.+/
+            }
+          },
+          // Underlined only
+          {
+            pattern: /(^|(?:\r?\n|\r){2}).+(?:\r?\n|\r)([!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~])\2+(?=\r?\n|\r|$)/,
+            lookbehind: true,
+            inside: {
+              punctuation: /[!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~]+$/,
+              important: /.+/
+            }
+          }
+        ],
+        hr: {
+          pattern: /((?:\r?\n|\r){2})([!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~])\2{3,}(?=(?:\r?\n|\r){2})/,
+          lookbehind: true,
+          alias: "punctuation"
+        },
+        field: {
+          pattern: /(^[\t ]*):[^:\r\n]+:(?= )/m,
+          lookbehind: true,
+          alias: "attr-name"
+        },
+        "command-line-option": {
+          pattern: /(^[\t ]*)(?:[+-][a-z\d]|(?:--|\/)[a-z\d-]+)(?:[ =](?:[a-z][\w-]*|<[^<>]+>))?(?:, (?:[+-][a-z\d]|(?:--|\/)[a-z\d-]+)(?:[ =](?:[a-z][\w-]*|<[^<>]+>))?)*(?=(?:\r?\n|\r)? {2,}\S)/im,
+          lookbehind: true,
+          alias: "symbol"
+        },
+        "literal-block": {
+          pattern: /::(?:\r?\n|\r){2}([ \t]+)(?![ \t]).+(?:(?:\r?\n|\r)\1.+)*/,
+          inside: {
+            "literal-block-punctuation": {
+              pattern: /^::/,
+              alias: "punctuation"
+            }
+          }
+        },
+        "quoted-literal-block": {
+          pattern: /::(?:\r?\n|\r){2}([!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~]).*(?:(?:\r?\n|\r)\1.*)*/,
+          inside: {
+            "literal-block-punctuation": {
+              pattern: /^(?:::|([!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~])\1*)/m,
+              alias: "punctuation"
+            }
+          }
+        },
+        "list-bullet": {
+          pattern: /(^[\t ]*)(?:[*+\-•‣⁃]|\(?(?:\d+|[a-z]|[ivxdclm]+)\)|(?:\d+|[a-z]|[ivxdclm]+)\.)(?= )/im,
+          lookbehind: true,
+          alias: "punctuation"
+        },
+        "doctest-block": {
+          pattern: /(^[\t ]*)>>> .+(?:(?:\r?\n|\r).+)*/m,
+          lookbehind: true,
+          inside: {
+            punctuation: /^>>>/
+          }
+        },
+        inline: [
+          {
+            pattern: /(^|[\s\-:\/'"<(\[{])(?::[^:]+:`.*?`|`.*?`:[^:]+:|(\*\*?|``?|\|)(?!\s)(?:(?!\2).)*\S\2(?=[\s\-.,:;!?\\\/'")\]}]|$))/m,
+            lookbehind: true,
+            inside: {
+              bold: {
+                pattern: /(^\*\*).+(?=\*\*$)/,
+                lookbehind: true
+              },
+              italic: {
+                pattern: /(^\*).+(?=\*$)/,
+                lookbehind: true
+              },
+              "inline-literal": {
+                pattern: /(^``).+(?=``$)/,
+                lookbehind: true,
+                alias: "symbol"
+              },
+              role: {
+                pattern: /^:[^:]+:|:[^:]+:$/,
+                alias: "function",
+                inside: {
+                  punctuation: /^:|:$/
+                }
+              },
+              "interpreted-text": {
+                pattern: /(^`).+(?=`$)/,
+                lookbehind: true,
+                alias: "attr-value"
+              },
+              substitution: {
+                pattern: /(^\|).+(?=\|$)/,
+                lookbehind: true,
+                alias: "attr-value"
+              },
+              punctuation: /\*\*?|``?|\|/
+            }
+          }
+        ],
+        link: [
+          {
+            pattern: /\[[^\[\]]+\]_(?=[\s\-.,:;!?\\\/'")\]}]|$)/,
+            alias: "string",
+            inside: {
+              punctuation: /^\[|\]_$/
+            }
+          },
+          {
+            pattern: /(?:\b[a-z\d]+(?:[_.:+][a-z\d]+)*_?_|`[^`]+`_?_|_`[^`]+`)(?=[\s\-.,:;!?\\\/'")\]}]|$)/i,
+            alias: "string",
+            inside: {
+              punctuation: /^_?`|`$|`?_?_$/
+            }
+          }
+        ],
+        // Line block start,
+        // quote attribution,
+        // explicit markup start,
+        // and anonymous hyperlink target shortcut (__)
+        punctuation: {
+          pattern: /(^[\t ]*)(?:\|(?= |$)|(?:---?|—|\.\.|__)(?= )|\.\.$)/m,
+          lookbehind: true
+        }
+      };
+    }
+  }
+});
+
+export {
+  require_rest
+};

package/dist/chunk-NY53DQIO.js

@@ -0,0 +1,93 @@
+"use client";
+import {
+  require_sql
+} from "./chunk-XZLPFOLS.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/apex.js
+var require_apex = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/apex.js"(exports, module) {
+    var refractorSql = require_sql();
+    module.exports = apex;
+    apex.displayName = "apex";
+    apex.aliases = [];
+    function apex(Prism) {
+      Prism.register(refractorSql);
+      (function(Prism2) {
+        var keywords = /\b(?:(?:after|before)(?=\s+[a-z])|abstract|activate|and|any|array|as|asc|autonomous|begin|bigdecimal|blob|boolean|break|bulk|by|byte|case|cast|catch|char|class|collect|commit|const|continue|currency|date|datetime|decimal|default|delete|desc|do|double|else|end|enum|exception|exit|export|extends|final|finally|float|for|from|get(?=\s*[{};])|global|goto|group|having|hint|if|implements|import|in|inner|insert|instanceof|int|integer|interface|into|join|like|limit|list|long|loop|map|merge|new|not|null|nulls|number|object|of|on|or|outer|override|package|parallel|pragma|private|protected|public|retrieve|return|rollback|select|set|short|sObject|sort|static|string|super|switch|synchronized|system|testmethod|then|this|throw|time|transaction|transient|trigger|try|undelete|update|upsert|using|virtual|void|webservice|when|where|while|(?:inherited|with|without)\s+sharing)\b/i;
+        var className = /\b(?:(?=[a-z_]\w*\s*[<\[])|(?!<keyword>))[A-Z_]\w*(?:\s*\.\s*[A-Z_]\w*)*\b(?:\s*(?:\[\s*\]|<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>))*/.source.replace(
+          /<keyword>/g,
+          function() {
+            return keywords.source;
+          }
+        );
+        function insertClassName(pattern) {
+          return RegExp(
+            pattern.replace(/<CLASS-NAME>/g, function() {
+              return className;
+            }),
+            "i"
+          );
+        }
+        var classNameInside = {
+          keyword: keywords,
+          punctuation: /[()\[\]{};,:.<>]/
+        };
+        Prism2.languages.apex = {
+          comment: Prism2.languages.clike.comment,
+          string: Prism2.languages.clike.string,
+          sql: {
+            pattern: /((?:[=,({:]|\breturn)\s*)\[[^\[\]]*\]/i,
+            lookbehind: true,
+            greedy: true,
+            alias: "language-sql",
+            inside: Prism2.languages.sql
+          },
+          annotation: {
+            pattern: /@\w+\b/,
+            alias: "punctuation"
+          },
+          "class-name": [
+            {
+              pattern: insertClassName(
+                /(\b(?:class|enum|extends|implements|instanceof|interface|new|trigger\s+\w+\s+on)\s+)<CLASS-NAME>/.source
+              ),
+              lookbehind: true,
+              inside: classNameInside
+            },
+            {
+              // cast
+              pattern: insertClassName(
+                /(\(\s*)<CLASS-NAME>(?=\s*\)\s*[\w(])/.source
+              ),
+              lookbehind: true,
+              inside: classNameInside
+            },
+            {
+              // variable/parameter declaration and return types
+              pattern: insertClassName(/<CLASS-NAME>(?=\s*\w+\s*[;=,(){:])/.source),
+              inside: classNameInside
+            }
+          ],
+          trigger: {
+            pattern: /(\btrigger\s+)\w+\b/i,
+            lookbehind: true,
+            alias: "class-name"
+          },
+          keyword: keywords,
+          function: /\b[a-z_]\w*(?=\s*\()/i,
+          boolean: /\b(?:false|true)\b/i,
+          number: /(?:\B\.\d+|\b\d+(?:\.\d+|L)?)\b/i,
+          operator: /[!=](?:==?)?|\?\.?|&&|\|\||--|\+\+|[-+*/^&|]=?|:|<<?=?|>{1,3}=?/,
+          punctuation: /[()\[\]{};,.]/
+        };
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_apex
+};

package/dist/chunk-NZY5EZK5.js

@@ -0,0 +1,43 @@
+"use client";
+import {
+  require_c
+} from "./chunk-RSMTA6GK.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/hlsl.js
+var require_hlsl = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/hlsl.js"(exports, module) {
+    var refractorC = require_c();
+    module.exports = hlsl;
+    hlsl.displayName = "hlsl";
+    hlsl.aliases = [];
+    function hlsl(Prism) {
+      Prism.register(refractorC);
+      Prism.languages.hlsl = Prism.languages.extend("c", {
+        // Regarding keywords and class names:
+        // The list of all keywords was split into 'keyword' and 'class-name' tokens based on whether they are capitalized.
+        // https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-appendix-keywords
+        // https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-appendix-reserved-words
+        "class-name": [
+          Prism.languages.c["class-name"],
+          /\b(?:AppendStructuredBuffer|BlendState|Buffer|ByteAddressBuffer|CompileShader|ComputeShader|ConsumeStructuredBuffer|DepthStencilState|DepthStencilView|DomainShader|GeometryShader|Hullshader|InputPatch|LineStream|OutputPatch|PixelShader|PointStream|RWBuffer|RWByteAddressBuffer|RWStructuredBuffer|RWTexture(?:1D|1DArray|2D|2DArray|3D)|RasterizerState|RenderTargetView|SamplerComparisonState|SamplerState|StructuredBuffer|Texture(?:1D|1DArray|2D|2DArray|2DMS|2DMSArray|3D|Cube|CubeArray)|TriangleStream|VertexShader)\b/
+        ],
+        keyword: [
+          // HLSL keyword
+          /\b(?:asm|asm_fragment|auto|break|case|catch|cbuffer|centroid|char|class|column_major|compile|compile_fragment|const|const_cast|continue|default|delete|discard|do|dynamic_cast|else|enum|explicit|export|extern|for|friend|fxgroup|goto|groupshared|if|in|inline|inout|interface|line|lineadj|linear|long|matrix|mutable|namespace|new|nointerpolation|noperspective|operator|out|packoffset|pass|pixelfragment|point|precise|private|protected|public|register|reinterpret_cast|return|row_major|sample|sampler|shared|short|signed|sizeof|snorm|stateblock|stateblock_state|static|static_cast|string|struct|switch|tbuffer|technique|technique10|technique11|template|texture|this|throw|triangle|triangleadj|try|typedef|typename|uniform|union|unorm|unsigned|using|vector|vertexfragment|virtual|void|volatile|while)\b/,
+          // scalar, vector, and matrix types
+          /\b(?:bool|double|dword|float|half|int|min(?:10float|12int|16(?:float|int|uint))|uint)(?:[1-4](?:x[1-4])?)?\b/
+        ],
+        // https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-appendix-grammar#floating-point-numbers
+        number: /(?:(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[eE][+-]?\d+)?|\b0x[\da-fA-F]+)[fFhHlLuU]?\b/,
+        boolean: /\b(?:false|true)\b/
+      });
+    }
+  }
+});
+
+export {
+  require_hlsl
+};

package/dist/chunk-O2OFPBPK.js

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

package/dist/chunk-O374MFIY.js

@@ -0,0 +1,238 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/bash.js
+var require_bash = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/bash.js"(exports, module) {
+    module.exports = bash;
+    bash.displayName = "bash";
+    bash.aliases = ["shell"];
+    function bash(Prism) {
+      ;
+      (function(Prism2) {
+        var envVars = "\\b(?:BASH|BASHOPTS|BASH_ALIASES|BASH_ARGC|BASH_ARGV|BASH_CMDS|BASH_COMPLETION_COMPAT_DIR|BASH_LINENO|BASH_REMATCH|BASH_SOURCE|BASH_VERSINFO|BASH_VERSION|COLORTERM|COLUMNS|COMP_WORDBREAKS|DBUS_SESSION_BUS_ADDRESS|DEFAULTS_PATH|DESKTOP_SESSION|DIRSTACK|DISPLAY|EUID|GDMSESSION|GDM_LANG|GNOME_KEYRING_CONTROL|GNOME_KEYRING_PID|GPG_AGENT_INFO|GROUPS|HISTCONTROL|HISTFILE|HISTFILESIZE|HISTSIZE|HOME|HOSTNAME|HOSTTYPE|IFS|INSTANCE|JOB|LANG|LANGUAGE|LC_ADDRESS|LC_ALL|LC_IDENTIFICATION|LC_MEASUREMENT|LC_MONETARY|LC_NAME|LC_NUMERIC|LC_PAPER|LC_TELEPHONE|LC_TIME|LESSCLOSE|LESSOPEN|LINES|LOGNAME|LS_COLORS|MACHTYPE|MAILCHECK|MANDATORY_PATH|NO_AT_BRIDGE|OLDPWD|OPTERR|OPTIND|ORBIT_SOCKETDIR|OSTYPE|PAPERSIZE|PATH|PIPESTATUS|PPID|PS1|PS2|PS3|PS4|PWD|RANDOM|REPLY|SECONDS|SELINUX_INIT|SESSION|SESSIONTYPE|SESSION_MANAGER|SHELL|SHELLOPTS|SHLVL|SSH_AUTH_SOCK|TERM|UID|UPSTART_EVENTS|UPSTART_INSTANCE|UPSTART_JOB|UPSTART_SESSION|USER|WINDOWID|XAUTHORITY|XDG_CONFIG_DIRS|XDG_CURRENT_DESKTOP|XDG_DATA_DIRS|XDG_GREETER_DATA_DIR|XDG_MENU_PREFIX|XDG_RUNTIME_DIR|XDG_SEAT|XDG_SEAT_PATH|XDG_SESSION_DESKTOP|XDG_SESSION_ID|XDG_SESSION_PATH|XDG_SESSION_TYPE|XDG_VTNR|XMODIFIERS)\\b";
+        var commandAfterHeredoc = {
+          pattern: /(^(["']?)\w+\2)[ \t]+\S.*/,
+          lookbehind: true,
+          alias: "punctuation",
+          // this looks reasonably well in all themes
+          inside: null
+          // see below
+        };
+        var insideString = {
+          bash: commandAfterHeredoc,
+          environment: {
+            pattern: RegExp("\\$" + envVars),
+            alias: "constant"
+          },
+          variable: [
+            // [0]: Arithmetic Environment
+            {
+              pattern: /\$?\(\([\s\S]+?\)\)/,
+              greedy: true,
+              inside: {
+                // If there is a $ sign at the beginning highlight $(( and )) as variable
+                variable: [
+                  {
+                    pattern: /(^\$\(\([\s\S]+)\)\)/,
+                    lookbehind: true
+                  },
+                  /^\$\(\(/
+                ],
+                number: /\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee]-?\d+)?/,
+                // Operators according to https://www.gnu.org/software/bash/manual/bashref.html#Shell-Arithmetic
+                operator: /--|\+\+|\*\*=?|<<=?|>>=?|&&|\|\||[=!+\-*/%<>^&|]=?|[?~:]/,
+                // If there is no $ sign at the beginning highlight (( and )) as punctuation
+                punctuation: /\(\(?|\)\)?|,|;/
+              }
+            },
+            // [1]: Command Substitution
+            {
+              pattern: /\$\((?:\([^)]+\)|[^()])+\)|`[^`]+`/,
+              greedy: true,
+              inside: {
+                variable: /^\$\(|^`|\)$|`$/
+              }
+            },
+            // [2]: Brace expansion
+            {
+              pattern: /\$\{[^}]+\}/,
+              greedy: true,
+              inside: {
+                operator: /:[-=?+]?|[!\/]|##?|%%?|\^\^?|,,?/,
+                punctuation: /[\[\]]/,
+                environment: {
+                  pattern: RegExp("(\\{)" + envVars),
+                  lookbehind: true,
+                  alias: "constant"
+                }
+              }
+            },
+            /\$(?:\w+|[#?*!@$])/
+          ],
+          // Escape sequences from echo and printf's manuals, and escaped quotes.
+          entity: /\\(?:[abceEfnrtv\\"]|O?[0-7]{1,3}|U[0-9a-fA-F]{8}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{1,2})/
+        };
+        Prism2.languages.bash = {
+          shebang: {
+            pattern: /^#!\s*\/.*/,
+            alias: "important"
+          },
+          comment: {
+            pattern: /(^|[^"{\\$])#.*/,
+            lookbehind: true
+          },
+          "function-name": [
+            // a) function foo {
+            // b) foo() {
+            // c) function foo() {
+            // but not “foo {”
+            {
+              // a) and c)
+              pattern: /(\bfunction\s+)[\w-]+(?=(?:\s*\(?:\s*\))?\s*\{)/,
+              lookbehind: true,
+              alias: "function"
+            },
+            {
+              // b)
+              pattern: /\b[\w-]+(?=\s*\(\s*\)\s*\{)/,
+              alias: "function"
+            }
+          ],
+          // Highlight variable names as variables in for and select beginnings.
+          "for-or-select": {
+            pattern: /(\b(?:for|select)\s+)\w+(?=\s+in\s)/,
+            alias: "variable",
+            lookbehind: true
+          },
+          // Highlight variable names as variables in the left-hand part
+          // of assignments (“=” and “+=”).
+          "assign-left": {
+            pattern: /(^|[\s;|&]|[<>]\()\w+(?=\+?=)/,
+            inside: {
+              environment: {
+                pattern: RegExp("(^|[\\s;|&]|[<>]\\()" + envVars),
+                lookbehind: true,
+                alias: "constant"
+              }
+            },
+            alias: "variable",
+            lookbehind: true
+          },
+          string: [
+            // Support for Here-documents https://en.wikipedia.org/wiki/Here_document
+            {
+              pattern: /((?:^|[^<])<<-?\s*)(\w+)\s[\s\S]*?(?:\r?\n|\r)\2/,
+              lookbehind: true,
+              greedy: true,
+              inside: insideString
+            },
+            // Here-document with quotes around the tag
+            // → No expansion (so no “inside”).
+            {
+              pattern: /((?:^|[^<])<<-?\s*)(["'])(\w+)\2\s[\s\S]*?(?:\r?\n|\r)\3/,
+              lookbehind: true,
+              greedy: true,
+              inside: {
+                bash: commandAfterHeredoc
+              }
+            },
+            // “Normal” string
+            {
+              // https://www.gnu.org/software/bash/manual/html_node/Double-Quotes.html
+              pattern: /(^|[^\\](?:\\\\)*)"(?:\\[\s\S]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^"\\`$])*"/,
+              lookbehind: true,
+              greedy: true,
+              inside: insideString
+            },
+            {
+              // https://www.gnu.org/software/bash/manual/html_node/Single-Quotes.html
+              pattern: /(^|[^$\\])'[^']*'/,
+              lookbehind: true,
+              greedy: true
+            },
+            {
+              // https://www.gnu.org/software/bash/manual/html_node/ANSI_002dC-Quoting.html
+              pattern: /\$'(?:[^'\\]|\\[\s\S])*'/,
+              greedy: true,
+              inside: {
+                entity: insideString.entity
+              }
+            }
+          ],
+          environment: {
+            pattern: RegExp("\\$?" + envVars),
+            alias: "constant"
+          },
+          variable: insideString.variable,
+          function: {
+            pattern: /(^|[\s;|&]|[<>]\()(?:add|apropos|apt|apt-cache|apt-get|aptitude|aspell|automysqlbackup|awk|basename|bash|bc|bconsole|bg|bzip2|cal|cat|cfdisk|chgrp|chkconfig|chmod|chown|chroot|cksum|clear|cmp|column|comm|composer|cp|cron|crontab|csplit|curl|cut|date|dc|dd|ddrescue|debootstrap|df|diff|diff3|dig|dir|dircolors|dirname|dirs|dmesg|docker|docker-compose|du|egrep|eject|env|ethtool|expand|expect|expr|fdformat|fdisk|fg|fgrep|file|find|fmt|fold|format|free|fsck|ftp|fuser|gawk|git|gparted|grep|groupadd|groupdel|groupmod|groups|grub-mkconfig|gzip|halt|head|hg|history|host|hostname|htop|iconv|id|ifconfig|ifdown|ifup|import|install|ip|jobs|join|kill|killall|less|link|ln|locate|logname|logrotate|look|lpc|lpr|lprint|lprintd|lprintq|lprm|ls|lsof|lynx|make|man|mc|mdadm|mkconfig|mkdir|mke2fs|mkfifo|mkfs|mkisofs|mknod|mkswap|mmv|more|most|mount|mtools|mtr|mutt|mv|nano|nc|netstat|nice|nl|node|nohup|notify-send|npm|nslookup|op|open|parted|passwd|paste|pathchk|ping|pkill|pnpm|podman|podman-compose|popd|pr|printcap|printenv|ps|pushd|pv|quota|quotacheck|quotactl|ram|rar|rcp|reboot|remsync|rename|renice|rev|rm|rmdir|rpm|rsync|scp|screen|sdiff|sed|sendmail|seq|service|sftp|sh|shellcheck|shuf|shutdown|sleep|slocate|sort|split|ssh|stat|strace|su|sudo|sum|suspend|swapon|sync|tac|tail|tar|tee|time|timeout|top|touch|tr|traceroute|tsort|tty|umount|uname|unexpand|uniq|units|unrar|unshar|unzip|update-grub|uptime|useradd|userdel|usermod|users|uudecode|uuencode|v|vcpkg|vdir|vi|vim|virsh|vmstat|wait|watch|wc|wget|whereis|which|who|whoami|write|xargs|xdg-open|yarn|yes|zenity|zip|zsh|zypper)(?=$|[)\s;|&])/,
+            lookbehind: true
+          },
+          keyword: {
+            pattern: /(^|[\s;|&]|[<>]\()(?:case|do|done|elif|else|esac|fi|for|function|if|in|select|then|until|while)(?=$|[)\s;|&])/,
+            lookbehind: true
+          },
+          // https://www.gnu.org/software/bash/manual/html_node/Shell-Builtin-Commands.html
+          builtin: {
+            pattern: /(^|[\s;|&]|[<>]\()(?:\.|:|alias|bind|break|builtin|caller|cd|command|continue|declare|echo|enable|eval|exec|exit|export|getopts|hash|help|let|local|logout|mapfile|printf|pwd|read|readarray|readonly|return|set|shift|shopt|source|test|times|trap|type|typeset|ulimit|umask|unalias|unset)(?=$|[)\s;|&])/,
+            lookbehind: true,
+            // Alias added to make those easier to distinguish from strings.
+            alias: "class-name"
+          },
+          boolean: {
+            pattern: /(^|[\s;|&]|[<>]\()(?:false|true)(?=$|[)\s;|&])/,
+            lookbehind: true
+          },
+          "file-descriptor": {
+            pattern: /\B&\d\b/,
+            alias: "important"
+          },
+          operator: {
+            // Lots of redirections here, but not just that.
+            pattern: /\d?<>|>\||\+=|=[=~]?|!=?|<<[<-]?|[&\d]?>>|\d[<>]&?|[<>][&=]?|&[>&]?|\|[&|]?/,
+            inside: {
+              "file-descriptor": {
+                pattern: /^\d/,
+                alias: "important"
+              }
+            }
+          },
+          punctuation: /\$?\(\(?|\)\)?|\.\.|[{}[\];\\]/,
+          number: {
+            pattern: /(^|\s)(?:[1-9]\d*|0)(?:[.,]\d+)?\b/,
+            lookbehind: true
+          }
+        };
+        commandAfterHeredoc.inside = Prism2.languages.bash;
+        var toBeCopied = [
+          "comment",
+          "function-name",
+          "for-or-select",
+          "assign-left",
+          "string",
+          "environment",
+          "function",
+          "keyword",
+          "builtin",
+          "boolean",
+          "file-descriptor",
+          "operator",
+          "punctuation",
+          "number"
+        ];
+        var inside = insideString.variable[1].inside;
+        for (var i = 0; i < toBeCopied.length; i++) {
+          inside[toBeCopied[i]] = Prism2.languages.bash[toBeCopied[i]];
+        }
+        Prism2.languages.shell = Prism2.languages.bash;
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_bash
+};