@distri/react 0.2.8 → 0.3.1

package/dist/chunk-NSMEMFKE.js

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

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

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

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

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