@touchvue/chat 1.0.0-beta.1

package/es/node_modules/.pnpm/highlight.js@10.7.2/node_modules/highlight.js/lib/languages/r.mjs

@@ -0,0 +1,238 @@
+import { getDefaultExportFromCjs } from '../../../../../../../_virtual/_commonjsHelpers.mjs';
+
+/**
+ * @param {string} value
+ * @returns {RegExp}
+ * */
+
+/**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+function source(re) {
+  if (!re) return null;
+  if (typeof re === "string") return re;
+
+  return re.source;
+}
+
+/**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+function lookahead(re) {
+  return concat('(?=', re, ')');
+}
+
+/**
+ * @param {...(RegExp | string) } args
+ * @returns {string}
+ */
+function concat(...args) {
+  const joined = args.map((x) => source(x)).join("");
+  return joined;
+}
+
+/*
+Language: R
+Description: R is a free software environment for statistical computing and graphics.
+Author: Joe Cheng <joe@rstudio.org>
+Contributors: Konrad Rudolph <konrad.rudolph@gmail.com>
+Website: https://www.r-project.org
+Category: common,scientific
+*/
+
+/** @type LanguageFn */
+function r(hljs) {
+  // Identifiers in R cannot start with `_`, but they can start with `.` if it
+  // is not immediately followed by a digit.
+  // R also supports quoted identifiers, which are near-arbitrary sequences
+  // delimited by backticks (`…`), which may contain escape sequences. These are
+  // handled in a separate mode. See `test/markup/r/names.txt` for examples.
+  // FIXME: Support Unicode identifiers.
+  const IDENT_RE = /(?:(?:[a-zA-Z]|\.[._a-zA-Z])[._a-zA-Z0-9]*)|\.(?!\d)/;
+  const SIMPLE_IDENT = /[a-zA-Z][a-zA-Z_0-9]*/;
+
+  return {
+    name: 'R',
+
+    // only in Haskell, not R
+    illegal: /->/,
+    keywords: {
+      $pattern: IDENT_RE,
+      keyword:
+        'function if in break next repeat else for while',
+      literal:
+        'NULL NA TRUE FALSE Inf NaN NA_integer_|10 NA_real_|10 ' +
+        'NA_character_|10 NA_complex_|10',
+      built_in:
+        // Builtin constants
+        'LETTERS letters month.abb month.name pi T F ' +
+        // Primitive functions
+        // These are all the functions in `base` that are implemented as a
+        // `.Primitive`, minus those functions that are also keywords.
+        'abs acos acosh all any anyNA Arg as.call as.character ' +
+        'as.complex as.double as.environment as.integer as.logical ' +
+        'as.null.default as.numeric as.raw asin asinh atan atanh attr ' +
+        'attributes baseenv browser c call ceiling class Conj cos cosh ' +
+        'cospi cummax cummin cumprod cumsum digamma dim dimnames ' +
+        'emptyenv exp expression floor forceAndCall gamma gc.time ' +
+        'globalenv Im interactive invisible is.array is.atomic is.call ' +
+        'is.character is.complex is.double is.environment is.expression ' +
+        'is.finite is.function is.infinite is.integer is.language ' +
+        'is.list is.logical is.matrix is.na is.name is.nan is.null ' +
+        'is.numeric is.object is.pairlist is.raw is.recursive is.single ' +
+        'is.symbol lazyLoadDBfetch length lgamma list log max min ' +
+        'missing Mod names nargs nzchar oldClass on.exit pos.to.env ' +
+        'proc.time prod quote range Re rep retracemem return round ' +
+        'seq_along seq_len seq.int sign signif sin sinh sinpi sqrt ' +
+        'standardGeneric substitute sum switch tan tanh tanpi tracemem ' +
+        'trigamma trunc unclass untracemem UseMethod xtfrm',
+    },
+    compilerExtensions: [
+      // allow beforeMatch to act as a "qualifier" for the match
+      // the full match begin must be [beforeMatch][begin]
+      (mode, parent) => {
+        if (!mode.beforeMatch) return;
+        // starts conflicts with endsParent which we need to make sure the child
+        // rule is not matched multiple times
+        if (mode.starts) throw new Error("beforeMatch cannot be used with starts");
+
+        const originalMode = Object.assign({}, mode);
+        Object.keys(mode).forEach((key) => { delete mode[key]; });
+
+        mode.begin = concat(originalMode.beforeMatch, lookahead(originalMode.begin));
+        mode.starts = {
+          relevance: 0,
+          contains: [
+            Object.assign(originalMode, { endsParent: true })
+          ]
+        };
+        mode.relevance = 0;
+
+        delete originalMode.beforeMatch;
+      }
+    ],
+    contains: [
+      // Roxygen comments
+      hljs.COMMENT(
+        /#'/,
+        /$/,
+        {
+          contains: [
+            {
+              // Handle `@examples` separately to cause all subsequent code
+              // until the next `@`-tag on its own line to be kept as-is,
+              // preventing highlighting. This code is example R code, so nested
+              // doctags shouldn’t be treated as such. See
+              // `test/markup/r/roxygen.txt` for an example.
+              className: 'doctag',
+              begin: '@examples',
+              starts: {
+                contains: [
+                  { begin: /\n/ },
+                  {
+                    begin: /#'\s*(?=@[a-zA-Z]+)/,
+                    endsParent: true,
+                  },
+                  {
+                    begin: /#'/,
+                    end: /$/,
+                    excludeBegin: true,
+                  }
+                ]
+              }
+            },
+            {
+              // Handle `@param` to highlight the parameter name following
+              // after.
+              className: 'doctag',
+              begin: '@param',
+              end: /$/,
+              contains: [
+                {
+                  className: 'variable',
+                  variants: [
+                    { begin: IDENT_RE },
+                    { begin: /`(?:\\.|[^`\\])+`/ }
+                  ],
+                  endsParent: true
+                }
+              ]
+            },
+            {
+              className: 'doctag',
+              begin: /@[a-zA-Z]+/
+            },
+            {
+              className: 'meta-keyword',
+              begin: /\\[a-zA-Z]+/,
+            }
+          ]
+        }
+      ),
+
+      hljs.HASH_COMMENT_MODE,
+
+      {
+        className: 'string',
+        contains: [hljs.BACKSLASH_ESCAPE],
+        variants: [
+          hljs.END_SAME_AS_BEGIN({ begin: /[rR]"(-*)\(/, end: /\)(-*)"/ }),
+          hljs.END_SAME_AS_BEGIN({ begin: /[rR]"(-*)\{/, end: /\}(-*)"/ }),
+          hljs.END_SAME_AS_BEGIN({ begin: /[rR]"(-*)\[/, end: /\](-*)"/ }),
+          hljs.END_SAME_AS_BEGIN({ begin: /[rR]'(-*)\(/, end: /\)(-*)'/ }),
+          hljs.END_SAME_AS_BEGIN({ begin: /[rR]'(-*)\{/, end: /\}(-*)'/ }),
+          hljs.END_SAME_AS_BEGIN({ begin: /[rR]'(-*)\[/, end: /\](-*)'/ }),
+          {begin: '"', end: '"', relevance: 0},
+          {begin: "'", end: "'", relevance: 0}
+        ],
+      },
+      {
+        className: 'number',
+        relevance: 0,
+        beforeMatch: /([^a-zA-Z0-9._])/, // not part of an identifier
+        variants: [
+          // TODO: replace with negative look-behind when available
+          // { begin: /(?<![a-zA-Z0-9._])0[xX][0-9a-fA-F]+\.[0-9a-fA-F]*[pP][+-]?\d+i?/ },
+          // { begin: /(?<![a-zA-Z0-9._])0[xX][0-9a-fA-F]+([pP][+-]?\d+)?[Li]?/ },
+          // { begin: /(?<![a-zA-Z0-9._])(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?[Li]?/ }
+          {
+            // Special case: only hexadecimal binary powers can contain fractions.
+            match: /0[xX][0-9a-fA-F]+\.[0-9a-fA-F]*[pP][+-]?\d+i?/,
+          },
+          {
+            match: /0[xX][0-9a-fA-F]+([pP][+-]?\d+)?[Li]?/
+          },
+          {
+            match: /(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?[Li]?/,
+          }
+        ],
+      },
+      {
+        // infix operator
+        begin: '%',
+        end: '%'
+      },
+      // relevance boost for assignment
+      {
+        begin: concat(SIMPLE_IDENT, "\\s+<-\\s+")
+      },
+      {
+        // escaped identifier
+        begin: '`',
+        end: '`',
+        contains: [
+          { begin: /\\./ }
+        ]
+      }
+    ]
+  };
+}
+
+var r_1 = r;
+
+var R = /*@__PURE__*/getDefaultExportFromCjs(r_1);
+
+export { R as default };
+//# sourceMappingURL=r.mjs.map

package/es/node_modules/.pnpm/highlight.js@10.7.2/node_modules/highlight.js/lib/languages/r.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"r.mjs","sources":["../../../../../../../../../node_modules/.pnpm/highlight.js@10.7.2/node_modules/highlight.js/lib/languages/r.js"],"sourcesContent":["/**\n * @param {string} value\n * @returns {RegExp}\n * */\n\n/**\n * @param {RegExp | string } re\n * @returns {string}\n */\nfunction source(re) {\n  if (!re) return null;\n  if (typeof re === \"string\") return re;\n\n  return re.source;\n}\n\n/**\n * @param {RegExp | string } re\n * @returns {string}\n */\nfunction lookahead(re) {\n  return concat('(?=', re, ')');\n}\n\n/**\n * @param {...(RegExp | string) } args\n * @returns {string}\n */\nfunction concat(...args) {\n  const joined = args.map((x) => source(x)).join(\"\");\n  return joined;\n}\n\n/*\nLanguage: R\nDescription: R is a free software environment for statistical computing and graphics.\nAuthor: Joe Cheng <joe@rstudio.org>\nContributors: Konrad Rudolph <konrad.rudolph@gmail.com>\nWebsite: https://www.r-project.org\nCategory: common,scientific\n*/\n\n/** @type LanguageFn */\nfunction r(hljs) {\n  // Identifiers in R cannot start with `_`, but they can start with `.` if it\n  // is not immediately followed by a digit.\n  // R also supports quoted identifiers, which are near-arbitrary sequences\n  // delimited by backticks (`…`), which may contain escape sequences. These are\n  // handled in a separate mode. See `test/markup/r/names.txt` for examples.\n  // FIXME: Support Unicode identifiers.\n  const IDENT_RE = /(?:(?:[a-zA-Z]|\\.[._a-zA-Z])[._a-zA-Z0-9]*)|\\.(?!\\d)/;\n  const SIMPLE_IDENT = /[a-zA-Z][a-zA-Z_0-9]*/;\n\n  return {\n    name: 'R',\n\n    // only in Haskell, not R\n    illegal: /->/,\n    keywords: {\n      $pattern: IDENT_RE,\n      keyword:\n        'function if in break next repeat else for while',\n      literal:\n        'NULL NA TRUE FALSE Inf NaN NA_integer_|10 NA_real_|10 ' +\n        'NA_character_|10 NA_complex_|10',\n      built_in:\n        // Builtin constants\n        'LETTERS letters month.abb month.name pi T F ' +\n        // Primitive functions\n        // These are all the functions in `base` that are implemented as a\n        // `.Primitive`, minus those functions that are also keywords.\n        'abs acos acosh all any anyNA Arg as.call as.character ' +\n        'as.complex as.double as.environment as.integer as.logical ' +\n        'as.null.default as.numeric as.raw asin asinh atan atanh attr ' +\n        'attributes baseenv browser c call ceiling class Conj cos cosh ' +\n        'cospi cummax cummin cumprod cumsum digamma dim dimnames ' +\n        'emptyenv exp expression floor forceAndCall gamma gc.time ' +\n        'globalenv Im interactive invisible is.array is.atomic is.call ' +\n        'is.character is.complex is.double is.environment is.expression ' +\n        'is.finite is.function is.infinite is.integer is.language ' +\n        'is.list is.logical is.matrix is.na is.name is.nan is.null ' +\n        'is.numeric is.object is.pairlist is.raw is.recursive is.single ' +\n        'is.symbol lazyLoadDBfetch length lgamma list log max min ' +\n        'missing Mod names nargs nzchar oldClass on.exit pos.to.env ' +\n        'proc.time prod quote range Re rep retracemem return round ' +\n        'seq_along seq_len seq.int sign signif sin sinh sinpi sqrt ' +\n        'standardGeneric substitute sum switch tan tanh tanpi tracemem ' +\n        'trigamma trunc unclass untracemem UseMethod xtfrm',\n    },\n    compilerExtensions: [\n      // allow beforeMatch to act as a \"qualifier\" for the match\n      // the full match begin must be [beforeMatch][begin]\n      (mode, parent) => {\n        if (!mode.beforeMatch) return;\n        // starts conflicts with endsParent which we need to make sure the child\n        // rule is not matched multiple times\n        if (mode.starts) throw new Error(\"beforeMatch cannot be used with starts\");\n\n        const originalMode = Object.assign({}, mode);\n        Object.keys(mode).forEach((key) => { delete mode[key]; });\n\n        mode.begin = concat(originalMode.beforeMatch, lookahead(originalMode.begin));\n        mode.starts = {\n          relevance: 0,\n          contains: [\n            Object.assign(originalMode, { endsParent: true })\n          ]\n        };\n        mode.relevance = 0;\n\n        delete originalMode.beforeMatch;\n      }\n    ],\n    contains: [\n      // Roxygen comments\n      hljs.COMMENT(\n        /#'/,\n        /$/,\n        {\n          contains: [\n            {\n              // Handle `@examples` separately to cause all subsequent code\n              // until the next `@`-tag on its own line to be kept as-is,\n              // preventing highlighting. This code is example R code, so nested\n              // doctags shouldn’t be treated as such. See\n              // `test/markup/r/roxygen.txt` for an example.\n              className: 'doctag',\n              begin: '@examples',\n              starts: {\n                contains: [\n                  { begin: /\\n/ },\n                  {\n                    begin: /#'\\s*(?=@[a-zA-Z]+)/,\n                    endsParent: true,\n                  },\n                  {\n                    begin: /#'/,\n                    end: /$/,\n                    excludeBegin: true,\n                  }\n                ]\n              }\n            },\n            {\n              // Handle `@param` to highlight the parameter name following\n              // after.\n              className: 'doctag',\n              begin: '@param',\n              end: /$/,\n              contains: [\n                {\n                  className: 'variable',\n                  variants: [\n                    { begin: IDENT_RE },\n                    { begin: /`(?:\\\\.|[^`\\\\])+`/ }\n                  ],\n                  endsParent: true\n                }\n              ]\n            },\n            {\n              className: 'doctag',\n              begin: /@[a-zA-Z]+/\n            },\n            {\n              className: 'meta-keyword',\n              begin: /\\\\[a-zA-Z]+/,\n            }\n          ]\n        }\n      ),\n\n      hljs.HASH_COMMENT_MODE,\n\n      {\n        className: 'string',\n        contains: [hljs.BACKSLASH_ESCAPE],\n        variants: [\n          hljs.END_SAME_AS_BEGIN({ begin: /[rR]\"(-*)\\(/, end: /\\)(-*)\"/ }),\n          hljs.END_SAME_AS_BEGIN({ begin: /[rR]\"(-*)\\{/, end: /\\}(-*)\"/ }),\n          hljs.END_SAME_AS_BEGIN({ begin: /[rR]\"(-*)\\[/, end: /\\](-*)\"/ }),\n          hljs.END_SAME_AS_BEGIN({ begin: /[rR]'(-*)\\(/, end: /\\)(-*)'/ }),\n          hljs.END_SAME_AS_BEGIN({ begin: /[rR]'(-*)\\{/, end: /\\}(-*)'/ }),\n          hljs.END_SAME_AS_BEGIN({ begin: /[rR]'(-*)\\[/, end: /\\](-*)'/ }),\n          {begin: '\"', end: '\"', relevance: 0},\n          {begin: \"'\", end: \"'\", relevance: 0}\n        ],\n      },\n      {\n        className: 'number',\n        relevance: 0,\n        beforeMatch: /([^a-zA-Z0-9._])/, // not part of an identifier\n        variants: [\n          // TODO: replace with negative look-behind when available\n          // { begin: /(?<![a-zA-Z0-9._])0[xX][0-9a-fA-F]+\\.[0-9a-fA-F]*[pP][+-]?\\d+i?/ },\n          // { begin: /(?<![a-zA-Z0-9._])0[xX][0-9a-fA-F]+([pP][+-]?\\d+)?[Li]?/ },\n          // { begin: /(?<![a-zA-Z0-9._])(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?[Li]?/ }\n          {\n            // Special case: only hexadecimal binary powers can contain fractions.\n            match: /0[xX][0-9a-fA-F]+\\.[0-9a-fA-F]*[pP][+-]?\\d+i?/,\n          },\n          {\n            match: /0[xX][0-9a-fA-F]+([pP][+-]?\\d+)?[Li]?/\n          },\n          {\n            match: /(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?[Li]?/,\n          }\n        ],\n      },\n      {\n        // infix operator\n        begin: '%',\n        end: '%'\n      },\n      // relevance boost for assignment\n      {\n        begin: concat(SIMPLE_IDENT, \"\\\\s+<-\\\\s+\")\n      },\n      {\n        // escaped identifier\n        begin: '`',\n        end: '`',\n        contains: [\n          { begin: /\\\\./ }\n        ]\n      }\n    ]\n  };\n}\n\nmodule.exports = r;\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/es/node_modules/.pnpm/highlight.js@10.7.2/node_modules/highlight.js/lib/languages/ruby.mjs

@@ -0,0 +1,394 @@
+import { getDefaultExportFromCjs } from '../../../../../../../_virtual/_commonjsHelpers.mjs';
+
+/**
+ * @param {string} value
+ * @returns {RegExp}
+ * */
+
+/**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+function source(re) {
+  if (!re) return null;
+  if (typeof re === "string") return re;
+
+  return re.source;
+}
+
+/**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+function lookahead(re) {
+  return concat('(?=', re, ')');
+}
+
+/**
+ * @param {...(RegExp | string) } args
+ * @returns {string}
+ */
+function concat(...args) {
+  const joined = args.map((x) => source(x)).join("");
+  return joined;
+}
+
+/*
+Language: Ruby
+Description: Ruby is a dynamic, open source programming language with a focus on simplicity and productivity.
+Website: https://www.ruby-lang.org/
+Author: Anton Kovalyov <anton@kovalyov.net>
+Contributors: Peter Leonov <gojpeg@yandex.ru>, Vasily Polovnyov <vast@whiteants.net>, Loren Segal <lsegal@soen.ca>, Pascal Hurni <phi@ruby-reactive.org>, Cedric Sohrauer <sohrauer@googlemail.com>
+Category: common
+*/
+
+function ruby(hljs) {
+  const RUBY_METHOD_RE = '([a-zA-Z_]\\w*[!?=]?|[-+~]@|<<|>>|=~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~`|]|\\[\\]=?)';
+  const RUBY_KEYWORDS = {
+    keyword:
+      'and then defined module in return redo if BEGIN retry end for self when ' +
+      'next until do begin unless END rescue else break undef not super class case ' +
+      'require yield alias while ensure elsif or include attr_reader attr_writer attr_accessor ' +
+      '__FILE__',
+    built_in: 'proc lambda',
+    literal:
+      'true false nil'
+  };
+  const YARDOCTAG = {
+    className: 'doctag',
+    begin: '@[A-Za-z]+'
+  };
+  const IRB_OBJECT = {
+    begin: '#<',
+    end: '>'
+  };
+  const COMMENT_MODES = [
+    hljs.COMMENT(
+      '#',
+      '$',
+      {
+        contains: [ YARDOCTAG ]
+      }
+    ),
+    hljs.COMMENT(
+      '^=begin',
+      '^=end',
+      {
+        contains: [ YARDOCTAG ],
+        relevance: 10
+      }
+    ),
+    hljs.COMMENT('^__END__', '\\n$')
+  ];
+  const SUBST = {
+    className: 'subst',
+    begin: /#\{/,
+    end: /\}/,
+    keywords: RUBY_KEYWORDS
+  };
+  const STRING = {
+    className: 'string',
+    contains: [
+      hljs.BACKSLASH_ESCAPE,
+      SUBST
+    ],
+    variants: [
+      {
+        begin: /'/,
+        end: /'/
+      },
+      {
+        begin: /"/,
+        end: /"/
+      },
+      {
+        begin: /`/,
+        end: /`/
+      },
+      {
+        begin: /%[qQwWx]?\(/,
+        end: /\)/
+      },
+      {
+        begin: /%[qQwWx]?\[/,
+        end: /\]/
+      },
+      {
+        begin: /%[qQwWx]?\{/,
+        end: /\}/
+      },
+      {
+        begin: /%[qQwWx]?</,
+        end: />/
+      },
+      {
+        begin: /%[qQwWx]?\//,
+        end: /\//
+      },
+      {
+        begin: /%[qQwWx]?%/,
+        end: /%/
+      },
+      {
+        begin: /%[qQwWx]?-/,
+        end: /-/
+      },
+      {
+        begin: /%[qQwWx]?\|/,
+        end: /\|/
+      },
+      // in the following expressions, \B in the beginning suppresses recognition of ?-sequences
+      // where ? is the last character of a preceding identifier, as in: `func?4`
+      {
+        begin: /\B\?(\\\d{1,3})/
+      },
+      {
+        begin: /\B\?(\\x[A-Fa-f0-9]{1,2})/
+      },
+      {
+        begin: /\B\?(\\u\{?[A-Fa-f0-9]{1,6}\}?)/
+      },
+      {
+        begin: /\B\?(\\M-\\C-|\\M-\\c|\\c\\M-|\\M-|\\C-\\M-)[\x20-\x7e]/
+      },
+      {
+        begin: /\B\?\\(c|C-)[\x20-\x7e]/
+      },
+      {
+        begin: /\B\?\\?\S/
+      },
+      { // heredocs
+        begin: /<<[-~]?'?(\w+)\n(?:[^\n]*\n)*?\s*\1\b/,
+        returnBegin: true,
+        contains: [
+          {
+            begin: /<<[-~]?'?/
+          },
+          hljs.END_SAME_AS_BEGIN({
+            begin: /(\w+)/,
+            end: /(\w+)/,
+            contains: [
+              hljs.BACKSLASH_ESCAPE,
+              SUBST
+            ]
+          })
+        ]
+      }
+    ]
+  };
+
+  // Ruby syntax is underdocumented, but this grammar seems to be accurate
+  // as of version 2.7.2 (confirmed with (irb and `Ripper.sexp(...)`)
+  // https://docs.ruby-lang.org/en/2.7.0/doc/syntax/literals_rdoc.html#label-Numbers
+  const decimal = '[1-9](_?[0-9])*|0';
+  const digits = '[0-9](_?[0-9])*';
+  const NUMBER = {
+    className: 'number',
+    relevance: 0,
+    variants: [
+      // decimal integer/float, optionally exponential or rational, optionally imaginary
+      {
+        begin: `\\b(${decimal})(\\.(${digits}))?([eE][+-]?(${digits})|r)?i?\\b`
+      },
+
+      // explicit decimal/binary/octal/hexadecimal integer,
+      // optionally rational and/or imaginary
+      {
+        begin: "\\b0[dD][0-9](_?[0-9])*r?i?\\b"
+      },
+      {
+        begin: "\\b0[bB][0-1](_?[0-1])*r?i?\\b"
+      },
+      {
+        begin: "\\b0[oO][0-7](_?[0-7])*r?i?\\b"
+      },
+      {
+        begin: "\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*r?i?\\b"
+      },
+
+      // 0-prefixed implicit octal integer, optionally rational and/or imaginary
+      {
+        begin: "\\b0(_?[0-7])+r?i?\\b"
+      }
+    ]
+  };
+
+  const PARAMS = {
+    className: 'params',
+    begin: '\\(',
+    end: '\\)',
+    endsParent: true,
+    keywords: RUBY_KEYWORDS
+  };
+
+  const RUBY_DEFAULT_CONTAINS = [
+    STRING,
+    {
+      className: 'class',
+      beginKeywords: 'class module',
+      end: '$|;',
+      illegal: /=/,
+      contains: [
+        hljs.inherit(hljs.TITLE_MODE, {
+          begin: '[A-Za-z_]\\w*(::\\w+)*(\\?|!)?'
+        }),
+        {
+          begin: '<\\s*',
+          contains: [
+            {
+              begin: '(' + hljs.IDENT_RE + '::)?' + hljs.IDENT_RE,
+              // we already get points for <, we don't need poitns
+              // for the name also
+              relevance: 0
+            }
+          ]
+        }
+      ].concat(COMMENT_MODES)
+    },
+    {
+      className: 'function',
+      // def method_name(
+      // def method_name;
+      // def method_name (end of line)
+      begin: concat(/def\s+/, lookahead(RUBY_METHOD_RE + "\\s*(\\(|;|$)")),
+      relevance: 0, // relevance comes from kewords
+      keywords: "def",
+      end: '$|;',
+      contains: [
+        hljs.inherit(hljs.TITLE_MODE, {
+          begin: RUBY_METHOD_RE
+        }),
+        PARAMS
+      ].concat(COMMENT_MODES)
+    },
+    {
+      // swallow namespace qualifiers before symbols
+      begin: hljs.IDENT_RE + '::'
+    },
+    {
+      className: 'symbol',
+      begin: hljs.UNDERSCORE_IDENT_RE + '(!|\\?)?:',
+      relevance: 0
+    },
+    {
+      className: 'symbol',
+      begin: ':(?!\\s)',
+      contains: [
+        STRING,
+        {
+          begin: RUBY_METHOD_RE
+        }
+      ],
+      relevance: 0
+    },
+    NUMBER,
+    {
+      // negative-look forward attemps to prevent false matches like:
+      // @ident@ or $ident$ that might indicate this is not ruby at all
+      className: "variable",
+      begin: '(\\$\\W)|((\\$|@@?)(\\w+))(?=[^@$?])' + `(?![A-Za-z])(?![@$?'])`
+    },
+    {
+      className: 'params',
+      begin: /\|/,
+      end: /\|/,
+      relevance: 0, // this could be a lot of things (in other languages) other than params
+      keywords: RUBY_KEYWORDS
+    },
+    { // regexp container
+      begin: '(' + hljs.RE_STARTERS_RE + '|unless)\\s*',
+      keywords: 'unless',
+      contains: [
+        {
+          className: 'regexp',
+          contains: [
+            hljs.BACKSLASH_ESCAPE,
+            SUBST
+          ],
+          illegal: /\n/,
+          variants: [
+            {
+              begin: '/',
+              end: '/[a-z]*'
+            },
+            {
+              begin: /%r\{/,
+              end: /\}[a-z]*/
+            },
+            {
+              begin: '%r\\(',
+              end: '\\)[a-z]*'
+            },
+            {
+              begin: '%r!',
+              end: '![a-z]*'
+            },
+            {
+              begin: '%r\\[',
+              end: '\\][a-z]*'
+            }
+          ]
+        }
+      ].concat(IRB_OBJECT, COMMENT_MODES),
+      relevance: 0
+    }
+  ].concat(IRB_OBJECT, COMMENT_MODES);
+
+  SUBST.contains = RUBY_DEFAULT_CONTAINS;
+  PARAMS.contains = RUBY_DEFAULT_CONTAINS;
+
+  // >>
+  // ?>
+  const SIMPLE_PROMPT = "[>?]>";
+  // irb(main):001:0>
+  const DEFAULT_PROMPT = "[\\w#]+\\(\\w+\\):\\d+:\\d+>";
+  const RVM_PROMPT = "(\\w+-)?\\d+\\.\\d+\\.\\d+(p\\d+)?[^\\d][^>]+>";
+
+  const IRB_DEFAULT = [
+    {
+      begin: /^\s*=>/,
+      starts: {
+        end: '$',
+        contains: RUBY_DEFAULT_CONTAINS
+      }
+    },
+    {
+      className: 'meta',
+      begin: '^(' + SIMPLE_PROMPT + "|" + DEFAULT_PROMPT + '|' + RVM_PROMPT + ')(?=[ ])',
+      starts: {
+        end: '$',
+        contains: RUBY_DEFAULT_CONTAINS
+      }
+    }
+  ];
+
+  COMMENT_MODES.unshift(IRB_OBJECT);
+
+  return {
+    name: 'Ruby',
+    aliases: [
+      'rb',
+      'gemspec',
+      'podspec',
+      'thor',
+      'irb'
+    ],
+    keywords: RUBY_KEYWORDS,
+    illegal: /\/\*/,
+    contains: [
+      hljs.SHEBANG({
+        binary: "ruby"
+      })
+    ]
+      .concat(IRB_DEFAULT)
+      .concat(COMMENT_MODES)
+      .concat(RUBY_DEFAULT_CONTAINS)
+  };
+}
+
+var ruby_1 = ruby;
+
+var Ruby = /*@__PURE__*/getDefaultExportFromCjs(ruby_1);
+
+export { Ruby as default };
+//# sourceMappingURL=ruby.mjs.map