@mxmweb/rtext 1.6.12 → 1.6.13

package/prism-php-BQcudfaM.js

@@ -0,0 +1,347 @@
+import { g as c } from "./lib_enter-Dc5XyCCf.js";
+function f(e, r) {
+  for (var n = 0; n < r.length; n++) {
+    const t = r[n];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const a in t)
+        if (a !== "default" && !(a in e)) {
+          const i = Object.getOwnPropertyDescriptor(t, a);
+          i && Object.defineProperty(e, a, i.get ? i : {
+            enumerable: !0,
+            get: () => t[a]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var u = {}, d;
+function g() {
+  return d || (d = 1, (function(e) {
+    var r = /\/\*[\s\S]*?\*\/|\/\/.*|#(?!\[).*/, n = [
+      {
+        pattern: /\b(?:false|true)\b/i,
+        alias: "boolean"
+      },
+      {
+        pattern: /(::\s*)\b[a-z_]\w*\b(?!\s*\()/i,
+        greedy: !0,
+        lookbehind: !0
+      },
+      {
+        pattern: /(\b(?:case|const)\s+)\b[a-z_]\w*(?=\s*[;=])/i,
+        greedy: !0,
+        lookbehind: !0
+      },
+      /\b(?:null)\b/i,
+      /\b[A-Z_][A-Z0-9_]*\b(?!\s*\()/
+    ], t = /\b0b[01]+(?:_[01]+)*\b|\b0o[0-7]+(?:_[0-7]+)*\b|\b0x[\da-f]+(?:_[\da-f]+)*\b|(?:\b\d+(?:_\d+)*\.?(?:\d+(?:_\d+)*)?|\B\.\d+)(?:e[+-]?\d+)?/i, a = /<?=>|\?\?=?|\.{3}|\??->|[!=]=?=?|::|\*\*=?|--|\+\+|&&|\|\||<<|>>|[?~]|[/^|%*&<>.+-]=?/, i = /[{}\[\](),:;]/;
+    e.languages.php = {
+      delimiter: {
+        pattern: /\?>$|^<\?(?:php(?=\s)|=)?/i,
+        alias: "important"
+      },
+      comment: r,
+      variable: /\$+(?:\w+\b|(?=\{))/,
+      package: {
+        pattern: /(namespace\s+|use\s+(?:function\s+)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
+        lookbehind: !0,
+        inside: {
+          punctuation: /\\/
+        }
+      },
+      "class-name-definition": {
+        pattern: /(\b(?:class|enum|interface|trait)\s+)\b[a-z_]\w*(?!\\)\b/i,
+        lookbehind: !0,
+        alias: "class-name"
+      },
+      "function-definition": {
+        pattern: /(\bfunction\s+)[a-z_]\w*(?=\s*\()/i,
+        lookbehind: !0,
+        alias: "function"
+      },
+      keyword: [
+        {
+          pattern: /(\(\s*)\b(?:array|bool|boolean|float|int|integer|object|string)\b(?=\s*\))/i,
+          alias: "type-casting",
+          greedy: !0,
+          lookbehind: !0
+        },
+        {
+          pattern: /([(,?]\s*)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|object|self|static|string)\b(?=\s*\$)/i,
+          alias: "type-hint",
+          greedy: !0,
+          lookbehind: !0
+        },
+        {
+          pattern: /(\)\s*:\s*(?:\?\s*)?)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|never|object|self|static|string|void)\b/i,
+          alias: "return-type",
+          greedy: !0,
+          lookbehind: !0
+        },
+        {
+          pattern: /\b(?:array(?!\s*\()|bool|float|int|iterable|mixed|object|string|void)\b/i,
+          alias: "type-declaration",
+          greedy: !0
+        },
+        {
+          pattern: /(\|\s*)(?:false|null)\b|\b(?:false|null)(?=\s*\|)/i,
+          alias: "type-declaration",
+          greedy: !0,
+          lookbehind: !0
+        },
+        {
+          pattern: /\b(?:parent|self|static)(?=\s*::)/i,
+          alias: "static-context",
+          greedy: !0
+        },
+        {
+          // yield from
+          pattern: /(\byield\s+)from\b/i,
+          lookbehind: !0
+        },
+        // `class` is always a keyword unlike other keywords
+        /\bclass\b/i,
+        {
+          // https://www.php.net/manual/en/reserved.keywords.php
+          //
+          // keywords cannot be preceded by "->"
+          // the complex lookbehind means `(?<!(?:->|::)\s*)`
+          pattern: /((?:^|[^\s>:]|(?:^|[^-])>|(?:^|[^:]):)\s*)\b(?:abstract|and|array|as|break|callable|case|catch|clone|const|continue|declare|default|die|do|echo|else|elseif|empty|enddeclare|endfor|endforeach|endif|endswitch|endwhile|enum|eval|exit|extends|final|finally|fn|for|foreach|function|global|goto|if|implements|include|include_once|instanceof|insteadof|interface|isset|list|match|namespace|never|new|or|parent|print|private|protected|public|readonly|require|require_once|return|self|static|switch|throw|trait|try|unset|use|var|while|xor|yield|__halt_compiler)\b/i,
+          lookbehind: !0
+        }
+      ],
+      "argument-name": {
+        pattern: /([(,]\s*)\b[a-z_]\w*(?=\s*:(?!:))/i,
+        lookbehind: !0
+      },
+      "class-name": [
+        {
+          pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self|\s+static))\s+|\bcatch\s*\()\b[a-z_]\w*(?!\\)\b/i,
+          greedy: !0,
+          lookbehind: !0
+        },
+        {
+          pattern: /(\|\s*)\b[a-z_]\w*(?!\\)\b/i,
+          greedy: !0,
+          lookbehind: !0
+        },
+        {
+          pattern: /\b[a-z_]\w*(?!\\)\b(?=\s*\|)/i,
+          greedy: !0
+        },
+        {
+          pattern: /(\|\s*)(?:\\?\b[a-z_]\w*)+\b/i,
+          alias: "class-name-fully-qualified",
+          greedy: !0,
+          lookbehind: !0,
+          inside: {
+            punctuation: /\\/
+          }
+        },
+        {
+          pattern: /(?:\\?\b[a-z_]\w*)+\b(?=\s*\|)/i,
+          alias: "class-name-fully-qualified",
+          greedy: !0,
+          inside: {
+            punctuation: /\\/
+          }
+        },
+        {
+          pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self\b|\s+static\b))\s+|\bcatch\s*\()(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
+          alias: "class-name-fully-qualified",
+          greedy: !0,
+          lookbehind: !0,
+          inside: {
+            punctuation: /\\/
+          }
+        },
+        {
+          pattern: /\b[a-z_]\w*(?=\s*\$)/i,
+          alias: "type-declaration",
+          greedy: !0
+        },
+        {
+          pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
+          alias: ["class-name-fully-qualified", "type-declaration"],
+          greedy: !0,
+          inside: {
+            punctuation: /\\/
+          }
+        },
+        {
+          pattern: /\b[a-z_]\w*(?=\s*::)/i,
+          alias: "static-context",
+          greedy: !0
+        },
+        {
+          pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*::)/i,
+          alias: ["class-name-fully-qualified", "static-context"],
+          greedy: !0,
+          inside: {
+            punctuation: /\\/
+          }
+        },
+        {
+          pattern: /([(,?]\s*)[a-z_]\w*(?=\s*\$)/i,
+          alias: "type-hint",
+          greedy: !0,
+          lookbehind: !0
+        },
+        {
+          pattern: /([(,?]\s*)(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
+          alias: ["class-name-fully-qualified", "type-hint"],
+          greedy: !0,
+          lookbehind: !0,
+          inside: {
+            punctuation: /\\/
+          }
+        },
+        {
+          pattern: /(\)\s*:\s*(?:\?\s*)?)\b[a-z_]\w*(?!\\)\b/i,
+          alias: "return-type",
+          greedy: !0,
+          lookbehind: !0
+        },
+        {
+          pattern: /(\)\s*:\s*(?:\?\s*)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
+          alias: ["class-name-fully-qualified", "return-type"],
+          greedy: !0,
+          lookbehind: !0,
+          inside: {
+            punctuation: /\\/
+          }
+        }
+      ],
+      constant: n,
+      function: {
+        pattern: /(^|[^\\\w])\\?[a-z_](?:[\w\\]*\w)?(?=\s*\()/i,
+        lookbehind: !0,
+        inside: {
+          punctuation: /\\/
+        }
+      },
+      property: {
+        pattern: /(->\s*)\w+/,
+        lookbehind: !0
+      },
+      number: t,
+      operator: a,
+      punctuation: i
+    };
+    var l = {
+      pattern: /\{\$(?:\{(?:\{[^{}]+\}|[^{}]+)\}|[^{}])+\}|(^|[^\\{])\$+(?:\w+(?:\[[^\r\n\[\]]+\]|->\w+)?)/,
+      lookbehind: !0,
+      inside: e.languages.php
+    }, o = [
+      {
+        pattern: /<<<'([^']+)'[\r\n](?:.*[\r\n])*?\1;/,
+        alias: "nowdoc-string",
+        greedy: !0,
+        inside: {
+          delimiter: {
+            pattern: /^<<<'[^']+'|[a-z_]\w*;$/i,
+            alias: "symbol",
+            inside: {
+              punctuation: /^<<<'?|[';]$/
+            }
+          }
+        }
+      },
+      {
+        pattern: /<<<(?:"([^"]+)"[\r\n](?:.*[\r\n])*?\1;|([a-z_]\w*)[\r\n](?:.*[\r\n])*?\2;)/i,
+        alias: "heredoc-string",
+        greedy: !0,
+        inside: {
+          delimiter: {
+            pattern: /^<<<(?:"[^"]+"|[a-z_]\w*)|[a-z_]\w*;$/i,
+            alias: "symbol",
+            inside: {
+              punctuation: /^<<<"?|[";]$/
+            }
+          },
+          interpolation: l
+        }
+      },
+      {
+        pattern: /`(?:\\[\s\S]|[^\\`])*`/,
+        alias: "backtick-quoted-string",
+        greedy: !0
+      },
+      {
+        pattern: /'(?:\\[\s\S]|[^\\'])*'/,
+        alias: "single-quoted-string",
+        greedy: !0
+      },
+      {
+        pattern: /"(?:\\[\s\S]|[^\\"])*"/,
+        alias: "double-quoted-string",
+        greedy: !0,
+        inside: {
+          interpolation: l
+        }
+      }
+    ];
+    e.languages.insertBefore("php", "variable", {
+      string: o,
+      attribute: {
+        pattern: /#\[(?:[^"'\/#]|\/(?![*/])|\/\/.*$|#(?!\[).*$|\/\*(?:[^*]|\*(?!\/))*\*\/|"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*')+\](?=\s*[a-z$#])/im,
+        greedy: !0,
+        inside: {
+          "attribute-content": {
+            pattern: /^(#\[)[\s\S]+(?=\]$)/,
+            lookbehind: !0,
+            // inside can appear subset of php
+            inside: {
+              comment: r,
+              string: o,
+              "attribute-class-name": [
+                {
+                  pattern: /([^:]|^)\b[a-z_]\w*(?!\\)\b/i,
+                  alias: "class-name",
+                  greedy: !0,
+                  lookbehind: !0
+                },
+                {
+                  pattern: /([^:]|^)(?:\\?\b[a-z_]\w*)+/i,
+                  alias: [
+                    "class-name",
+                    "class-name-fully-qualified"
+                  ],
+                  greedy: !0,
+                  lookbehind: !0,
+                  inside: {
+                    punctuation: /\\/
+                  }
+                }
+              ],
+              constant: n,
+              number: t,
+              operator: a,
+              punctuation: i
+            }
+          },
+          delimiter: {
+            pattern: /^#\[|\]$/,
+            alias: "punctuation"
+          }
+        }
+      }
+    }), e.hooks.add("before-tokenize", function(s) {
+      if (/<\?/.test(s.code)) {
+        var p = /<\?(?:[^"'/#]|\/(?![*/])|("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|(?:\/\/|#(?!\[))(?:[^?\n\r]|\?(?!>))*(?=$|\?>|[\r\n])|#\[|\/\*(?:[^*]|\*(?!\/))*(?:\*\/|$))*?(?:\?>|$)/g;
+        e.languages["markup-templating"].buildPlaceholders(s, "php", p);
+      }
+    }), e.hooks.add("after-tokenize", function(s) {
+      e.languages["markup-templating"].tokenizePlaceholders(s, "php");
+    });
+  })(Prism)), u;
+}
+var b = g();
+const y = /* @__PURE__ */ c(b), m = /* @__PURE__ */ f({
+  __proto__: null,
+  default: y
+}, [b]);
+export {
+  m as p
+};

package/prism-python-DERGD9Re.js

@@ -0,0 +1,89 @@
+import { g as p } from "./lib_enter-Dc5XyCCf.js";
+function u(r, a) {
+  for (var n = 0; n < a.length; n++) {
+    const e = a[n];
+    if (typeof e != "string" && !Array.isArray(e)) {
+      for (const t in e)
+        if (t !== "default" && !(t in r)) {
+          const i = Object.getOwnPropertyDescriptor(e, t);
+          i && Object.defineProperty(r, t, i.get ? i : {
+            enumerable: !0,
+            get: () => e[t]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(r, Symbol.toStringTag, { value: "Module" }));
+}
+var o = {}, s;
+function d() {
+  return s || (s = 1, Prism.languages.python = {
+    comment: {
+      pattern: /(^|[^\\])#.*/,
+      lookbehind: !0,
+      greedy: !0
+    },
+    "string-interpolation": {
+      pattern: /(?:f|fr|rf)(?:("""|''')[\s\S]*?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2)/i,
+      greedy: !0,
+      inside: {
+        interpolation: {
+          // "{" <expression> <optional "!s", "!r", or "!a"> <optional ":" format specifier> "}"
+          pattern: /((?:^|[^{])(?:\{\{)*)\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}])+\})+\})+\}/,
+          lookbehind: !0,
+          inside: {
+            "format-spec": {
+              pattern: /(:)[^:(){}]+(?=\}$)/,
+              lookbehind: !0
+            },
+            "conversion-option": {
+              pattern: /![sra](?=[:}]$)/,
+              alias: "punctuation"
+            },
+            rest: null
+          }
+        },
+        string: /[\s\S]+/
+      }
+    },
+    "triple-quoted-string": {
+      pattern: /(?:[rub]|br|rb)?("""|''')[\s\S]*?\1/i,
+      greedy: !0,
+      alias: "string"
+    },
+    string: {
+      pattern: /(?:[rub]|br|rb)?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/i,
+      greedy: !0
+    },
+    function: {
+      pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g,
+      lookbehind: !0
+    },
+    "class-name": {
+      pattern: /(\bclass\s+)\w+/i,
+      lookbehind: !0
+    },
+    decorator: {
+      pattern: /(^[\t ]*)@\w+(?:\.\w+)*/m,
+      lookbehind: !0,
+      alias: ["annotation", "punctuation"],
+      inside: {
+        punctuation: /\./
+      }
+    },
+    keyword: /\b(?:_(?=\s*:)|and|as|assert|async|await|break|case|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|match|nonlocal|not|or|pass|print|raise|return|try|while|with|yield)\b/,
+    builtin: /\b(?:__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\b/,
+    boolean: /\b(?:False|None|True)\b/,
+    number: /\b0(?:b(?:_?[01])+|o(?:_?[0-7])+|x(?:_?[a-f0-9])+)\b|(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)(?:e[+-]?\d+(?:_\d+)*)?j?(?!\w)/i,
+    operator: /[-+%=]=?|!=|:=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
+    punctuation: /[{}[\];(),.:]/
+  }, Prism.languages.python["string-interpolation"].inside.interpolation.inside.rest = Prism.languages.python, Prism.languages.py = Prism.languages.python), o;
+}
+var l = d();
+const c = /* @__PURE__ */ p(l), m = /* @__PURE__ */ u({
+  __proto__: null,
+  default: c
+}, [l]);
+export {
+  m as p
+};

package/prism-ruby-DfaHE8ro.js

@@ -0,0 +1,195 @@
+import { g as l } from "./lib_enter-Dc5XyCCf.js";
+function d(e, r) {
+  for (var n = 0; n < r.length; n++) {
+    const t = r[n];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const i in t)
+        if (i !== "default" && !(i in e)) {
+          const s = Object.getOwnPropertyDescriptor(t, i);
+          s && Object.defineProperty(e, i, s.get ? s : {
+            enumerable: !0,
+            get: () => t[i]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var a = {}, o;
+function g() {
+  return o || (o = 1, (function(e) {
+    e.languages.ruby = e.languages.extend("clike", {
+      comment: {
+        pattern: /#.*|^=begin\s[\s\S]*?^=end/m,
+        greedy: !0
+      },
+      "class-name": {
+        pattern: /(\b(?:class|module)\s+|\bcatch\s+\()[\w.\\]+|\b[A-Z_]\w*(?=\s*\.\s*new\b)/,
+        lookbehind: !0,
+        inside: {
+          punctuation: /[.\\]/
+        }
+      },
+      keyword: /\b(?:BEGIN|END|alias|and|begin|break|case|class|def|define_method|defined|do|each|else|elsif|end|ensure|extend|for|if|in|include|module|new|next|nil|not|or|prepend|private|protected|public|raise|redo|require|rescue|retry|return|self|super|then|throw|undef|unless|until|when|while|yield)\b/,
+      operator: /\.{2,3}|&\.|===|<?=>|[!=]?~|(?:&&|\|\||<<|>>|\*\*|[+\-*/%<>!^&|=])=?|[?:]/,
+      punctuation: /[(){}[\].,;]/
+    }), e.languages.insertBefore("ruby", "operator", {
+      "double-colon": {
+        pattern: /::/,
+        alias: "punctuation"
+      }
+    });
+    var r = {
+      pattern: /((?:^|[^\\])(?:\\{2})*)#\{(?:[^{}]|\{[^{}]*\})*\}/,
+      lookbehind: !0,
+      inside: {
+        content: {
+          pattern: /^(#\{)[\s\S]+(?=\}$)/,
+          lookbehind: !0,
+          inside: e.languages.ruby
+        },
+        delimiter: {
+          pattern: /^#\{|\}$/,
+          alias: "punctuation"
+        }
+      }
+    };
+    delete e.languages.ruby.function;
+    var n = "(?:" + [
+      /([^a-zA-Z0-9\s{(\[<=])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source,
+      /\((?:[^()\\]|\\[\s\S]|\((?:[^()\\]|\\[\s\S])*\))*\)/.source,
+      /\{(?:[^{}\\]|\\[\s\S]|\{(?:[^{}\\]|\\[\s\S])*\})*\}/.source,
+      /\[(?:[^\[\]\\]|\\[\s\S]|\[(?:[^\[\]\\]|\\[\s\S])*\])*\]/.source,
+      /<(?:[^<>\\]|\\[\s\S]|<(?:[^<>\\]|\\[\s\S])*>)*>/.source
+    ].join("|") + ")", t = /(?:"(?:\\.|[^"\\\r\n])*"|(?:\b[a-zA-Z_]\w*|[^\s\0-\x7F]+)[?!]?|\$.)/.source;
+    e.languages.insertBefore("ruby", "keyword", {
+      "regex-literal": [
+        {
+          pattern: RegExp(/%r/.source + n + /[egimnosux]{0,6}/.source),
+          greedy: !0,
+          inside: {
+            interpolation: r,
+            regex: /[\s\S]+/
+          }
+        },
+        {
+          pattern: /(^|[^/])\/(?!\/)(?:\[[^\r\n\]]+\]|\\.|[^[/\\\r\n])+\/[egimnosux]{0,6}(?=\s*(?:$|[\r\n,.;})#]))/,
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            interpolation: r,
+            regex: /[\s\S]+/
+          }
+        }
+      ],
+      variable: /[@$]+[a-zA-Z_]\w*(?:[?!]|\b)/,
+      symbol: [
+        {
+          pattern: RegExp(/(^|[^:]):/.source + t),
+          lookbehind: !0,
+          greedy: !0
+        },
+        {
+          pattern: RegExp(/([\r\n{(,][ \t]*)/.source + t + /(?=:(?!:))/.source),
+          lookbehind: !0,
+          greedy: !0
+        }
+      ],
+      "method-definition": {
+        pattern: /(\bdef\s+)\w+(?:\s*\.\s*\w+)?/,
+        lookbehind: !0,
+        inside: {
+          function: /\b\w+$/,
+          keyword: /^self\b/,
+          "class-name": /^\w+/,
+          punctuation: /\./
+        }
+      }
+    }), e.languages.insertBefore("ruby", "string", {
+      "string-literal": [
+        {
+          pattern: RegExp(/%[qQiIwWs]?/.source + n),
+          greedy: !0,
+          inside: {
+            interpolation: r,
+            string: /[\s\S]+/
+          }
+        },
+        {
+          pattern: /("|')(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|(?!\1)[^\\#\r\n])*\1/,
+          greedy: !0,
+          inside: {
+            interpolation: r,
+            string: /[\s\S]+/
+          }
+        },
+        {
+          pattern: /<<[-~]?([a-z_]\w*)[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
+          alias: "heredoc-string",
+          greedy: !0,
+          inside: {
+            delimiter: {
+              pattern: /^<<[-~]?[a-z_]\w*|\b[a-z_]\w*$/i,
+              inside: {
+                symbol: /\b\w+/,
+                punctuation: /^<<[-~]?/
+              }
+            },
+            interpolation: r,
+            string: /[\s\S]+/
+          }
+        },
+        {
+          pattern: /<<[-~]?'([a-z_]\w*)'[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
+          alias: "heredoc-string",
+          greedy: !0,
+          inside: {
+            delimiter: {
+              pattern: /^<<[-~]?'[a-z_]\w*'|\b[a-z_]\w*$/i,
+              inside: {
+                symbol: /\b\w+/,
+                punctuation: /^<<[-~]?'|'$/
+              }
+            },
+            string: /[\s\S]+/
+          }
+        }
+      ],
+      "command-literal": [
+        {
+          pattern: RegExp(/%x/.source + n),
+          greedy: !0,
+          inside: {
+            interpolation: r,
+            command: {
+              pattern: /[\s\S]+/,
+              alias: "string"
+            }
+          }
+        },
+        {
+          pattern: /`(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|[^\\`#\r\n])*`/,
+          greedy: !0,
+          inside: {
+            interpolation: r,
+            command: {
+              pattern: /[\s\S]+/,
+              alias: "string"
+            }
+          }
+        }
+      ]
+    }), delete e.languages.ruby.string, e.languages.insertBefore("ruby", "number", {
+      builtin: /\b(?:Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Fixnum|Float|Hash|IO|Integer|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|Stat|String|Struct|Symbol|TMS|Thread|ThreadGroup|Time|TrueClass)\b/,
+      constant: /\b[A-Z][A-Z0-9_]*(?:[?!]|\b)/
+    }), e.languages.rb = e.languages.ruby;
+  })(Prism)), a;
+}
+var u = g();
+const p = /* @__PURE__ */ l(u), b = /* @__PURE__ */ d({
+  __proto__: null,
+  default: p
+}, [u]);
+export {
+  b as p
+};