@forsakringskassan/docs-generator 3.6.0 → 3.6.1

package/dist/{vendor-C6ojgz0W.mjs → vendor-D7FIOE5G.mjs}

@@ -4,7 +4,7 @@ const require = $createRequire(import.meta.url);
 
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import * as path from 'node:path';
-import path__default, { win32, posix, resolve, join as join$1, relative, sep as sep$1 } from 'node:path';
+import path__default, { win32, posix, resolve, sep as sep$1, join as join$1 } from 'node:path';
 import * as require$$0$1 from 'fs';
 import require$$0__default, { realpathSync, readlinkSync, readdirSync, readdir as readdir$1, lstatSync, statSync } from 'fs';
 import * as fs$a from 'node:fs';
@@ -20978,14 +20978,17 @@ function requireCore () {
 	  return match && match.index === 0;
 	}
 
-	// BACKREF_RE matches an open parenthesis or backreference. To avoid
-	// an incorrect parse, it additionally matches the following:
-	// - [...] elements, where the meaning of parentheses and escapes change
-	// - other escape sequences, so we do not misparse escape sequences as
-	//   interesting elements
-	// - non-matching or lookahead parentheses, which do not capture. These
-	//   follow the '(' with a '?'.
-	const BACKREF_RE = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
+	// BACKREF_RE matches an open parenthesis or backreference. To avoid an
+	// incorrect parse, it also matches the constructs where the meaning of
+	// parentheses, escapes, or capture counting changes.
+	const BACKREF_RE = new RegExp(either(
+	  /\[(?:[^\\\]]|\\.)*\]/, // a character class, inside which ( and \ lose their meaning
+	  /\(\?<(?![=!])[^>]+>/, // a named capture group `(?<name>` (not a lookbehind `(?<=` / `(?<!`)
+	  /\(\?'[^']+'/, // a named capture group `(?'name'`
+	  /\(\??/, // an opening parenthesis, capturing or non-capturing / lookahead
+	  /\\([1-9][0-9]*)/, // a backreference like `\1`
+	  /\\./ // any other escape sequence
+	));
 
 	// **INTERNAL** Not intended for outside usage
 	// join logically computes regexps.join(separator), but fixes the
@@ -21020,7 +21023,7 @@ function requireCore () {
 	        out += '\\' + String(Number(match[1]) + offset);
 	      } else {
 	        out += match[0];
-	        if (match[0] === '(') {
+	        if (match[0] === '(' || /^\(\?[<']/.test(match[0])) {
 	          numCaptures++;
 	        }
 	      }
@@ -22062,7 +22065,7 @@ function requireCore () {
 	  return mode;
 	}
 
-	var version = "11.11.1";
+	var version = "11.12.0";
 
 	class HTMLInjectionError extends Error {
 	  constructor(reason, html) {
@@ -22584,12 +22587,15 @@ function requireCore () {
 	        }
 	      }
 
-	      // edge case for when illegal matches $ (end of line) which is technically
+	      // edge case for when illegal matches $ (end of line/text) which is technically
 	      // a 0 width match but not a begin/end match so it's not caught by the
-	      // first handler (when ignoreIllegals is true)
+	      // first handler (when `ignoreIllegals` is true)
 	      if (match.type === "illegal" && lexeme === "") {
-	        // advance so we aren't stuck in an infinite loop
-	        modeBuffer += "\n";
+	        if (match.index === codeToHighlight.length) ; else {
+	          // matched literal `\n` (with `$`) so we must manually add the newline
+	          // itself to the modeBuffer so it is not lost when we advance the cursor
+	          modeBuffer += "\n";
+	        }
 	        return 1;
 	      }
 
@@ -23279,10 +23285,7 @@ function requireXml () {
 	        starts: {
 	          end: /<\/style>/,
 	          returnEnd: true,
-	          subLanguage: [
-	            'css',
-	            'xml'
-	          ]
+	          subLanguage: 'css'
 	        }
 	      },
 	      {
@@ -23295,11 +23298,7 @@ function requireXml () {
 	        starts: {
 	          end: /<\/script>/,
 	          returnEnd: true,
-	          subLanguage: [
-	            'javascript',
-	            'handlebars',
-	            'xml'
-	          ]
+	          subLanguage: 'javascript'
 	        }
 	      },
 	      // we need this for now for jSX
@@ -23807,11 +23806,53 @@ function requireC () {
 	  + ')';
 
 
+	  // C11 <stdatomic.h> atomic type names. This is an explicit whitelist so that
+	  // C11 atomic *functions* (atomic_init, atomic_store, atomic_load,
+	  // atomic_fetch_add, ...) are not mistakenly highlighted as types. See #3837.
+	  const ATOMIC_TYPES = regex.concat(/\batomic_/, regex.either(
+	    'bool',
+	    'char',
+	    'schar',
+	    'uchar',
+	    'short',
+	    'ushort',
+	    'int',
+	    'uint',
+	    'long',
+	    'ulong',
+	    'llong',
+	    'ullong',
+	    'char16_t',
+	    'char32_t',
+	    'wchar_t',
+	    'int_least8_t',
+	    'uint_least8_t',
+	    'int_least16_t',
+	    'uint_least16_t',
+	    'int_least32_t',
+	    'uint_least32_t',
+	    'int_least64_t',
+	    'uint_least64_t',
+	    'int_fast8_t',
+	    'uint_fast8_t',
+	    'int_fast16_t',
+	    'uint_fast16_t',
+	    'int_fast32_t',
+	    'uint_fast32_t',
+	    'int_fast64_t',
+	    'uint_fast64_t',
+	    'intptr_t',
+	    'uintptr_t',
+	    'size_t',
+	    'ptrdiff_t',
+	    'intmax_t',
+	    'uintmax_t'
+	  ), /\b/);
 	  const TYPES = {
 	    className: 'type',
 	    variants: [
 	      { begin: '\\b[a-z\\d_]*_t\\b' },
-	      { match: /\batomic_[a-z]{3,6}\b/ }
+	      { match: ATOMIC_TYPES }
 	    ]
 
 	  };
@@ -23833,9 +23874,13 @@ function requireC () {
 	        end: '\'',
 	        illegal: '.'
 	      },
+	      // https://en.cppreference.com/w/cpp/language/string_literal
+	      // a d-char-sequence never contains parentheses, backslashes or whitespace;
+	      // quotes are excluded as well so the closing delimiter cannot swallow the
+	      // quote that actually terminates the literal
 	      hljs.END_SAME_AS_BEGIN({
-	        begin: /(?:u8?|U|L)?R"([^()\\ ]{0,16})\(/,
-	        end: /\)([^()\\ ]{0,16})"/
+	        begin: /(?:u8?|U|L)?R"([^()\\\s"]{0,16})\(/,
+	        end: /\)([^()\\\s"]{0,16})"/
 	      })
 	    ]
 	  };
@@ -23851,6 +23896,32 @@ function requireC () {
 	    relevance: 0
 	  };  
 	  
+	  // `#include` is the only preprocessor directive that takes an angle-bracket
+	  // quoted header (`#include <header>`). Scoping that rule to `#include` keeps
+	  // the greedy `<...>` match from eating a `>` that belongs to the body of
+	  // another directive (e.g. `#define what do { cout << ">"; } while (0)`),
+	  // which would otherwise leave an unbalanced `"` and break highlighting for
+	  // the rest of the file. See issue #3505.
+	  const PREPROCESSOR_INCLUDE = {
+	    scope: 'meta',
+	    begin: /#\s*include\b/,
+	    end: /$/,
+	    keywords: { keyword: 'include' },
+	    contains: [
+	      {
+	        // the `\` at the end of a line signaling continuation
+	        begin: /\\\n/,
+	      },
+	      STRINGS,
+	      {
+	        scope: 'string',
+	        begin: /<.*?>/
+	      },
+	      C_LINE_COMMENT_MODE,
+	      hljs.C_BLOCK_COMMENT_MODE
+	    ]
+	  };
+
 	  const PREPROCESSOR = {
 	    className: 'meta',
 	    begin: /#\s*[a-z]+\b/,
@@ -23864,15 +23935,16 @@ function requireC () {
 	        relevance: 0
 	      },
 	      hljs.inherit(STRINGS, { className: 'string' }),
-	      {
-	        className: 'string',
-	        begin: /<.*?>/
-	      },
 	      C_LINE_COMMENT_MODE,
 	      hljs.C_BLOCK_COMMENT_MODE
 	    ]
 	  };
 
+	  const PREPROCESSORS = [
+	    PREPROCESSOR_INCLUDE,
+	    PREPROCESSOR
+	  ];
+
 	  const TITLE_MODE = {
 	    className: 'title',
 	    begin: regex.optional(NAMESPACE_RE) + hljs.IDENT_RE,
@@ -23880,6 +23952,11 @@ function requireC () {
 	  };
 
 	  const FUNCTION_TITLE = regex.optional(NAMESPACE_RE) + hljs.IDENT_RE + '\\s*\\(';
+	  // Bounded on purpose: an unbounded quantifier here consumes an arbitrarily
+	  // long run of words, and when no function title follows it the engine retries
+	  // the title at every token boundary of that run - quadratic in the size of
+	  // the document.  See #4362.
+	  const MAX_FUNCTION_TYPE_TOKENS = 12;
 
 	  const C_KEYWORDS = [
 	    "asm",
@@ -23980,7 +24057,7 @@ function requireC () {
 	  };
 
 	  const EXPRESSION_CONTAINS = [
-	    PREPROCESSOR,
+	    ...PREPROCESSORS,
 	    TYPES,
 	    C_LINE_COMMENT_MODE,
 	    hljs.C_BLOCK_COMMENT_MODE,
@@ -24020,7 +24097,7 @@ function requireC () {
 	  };
 
 	  const FUNCTION_DECLARATION = {
-	    begin: '(' + FUNCTION_TYPE_RE + '[\\*&\\s]+)+' + FUNCTION_TITLE,
+	    begin: '(' + FUNCTION_TYPE_RE + '[\\*&\\s]+){1,' + MAX_FUNCTION_TYPE_TOKENS + '}' + FUNCTION_TITLE,
 	    returnBegin: true,
 	    end: /[{;=]/,
 	    excludeEnd: true,
@@ -24076,7 +24153,7 @@ function requireC () {
 	      TYPES,
 	      C_LINE_COMMENT_MODE,
 	      hljs.C_BLOCK_COMMENT_MODE,
-	      PREPROCESSOR
+	      ...PREPROCESSORS
 	    ]
 	  };
 
@@ -24093,7 +24170,7 @@ function requireC () {
 	      FUNCTION_DECLARATION,
 	      EXPRESSION_CONTAINS,
 	      [
-	        PREPROCESSOR,
+	        ...PREPROCESSORS,
 	        {
 	          begin: hljs.IDENT_RE + '::',
 	          keywords: KEYWORDS
@@ -24170,9 +24247,13 @@ function requireCpp () {
 	        end: '\'',
 	        illegal: '.'
 	      },
+	      // https://en.cppreference.com/w/cpp/language/string_literal
+	      // a d-char-sequence never contains parentheses, backslashes or whitespace;
+	      // quotes are excluded as well so the closing delimiter cannot swallow the
+	      // quote that actually terminates the literal
 	      hljs.END_SAME_AS_BEGIN({
-	        begin: /(?:u8?|U|L)?R"([^()\\ ]{0,16})\(/,
-	        end: /\)([^()\\ ]{0,16})"/
+	        begin: /(?:u8?|U|L)?R"([^()\\\s"]{0,16})\(/,
+	        end: /\)([^()\\\s"]{0,16})"/
 	      })
 	    ]
 	  };
@@ -24185,12 +24266,12 @@ function requireCpp () {
 	        "[+-]?(?:" // Leading sign.
 	          // Decimal.
 	          + "(?:"
-	            +"[0-9](?:'?[0-9])*\\.(?:[0-9](?:'?[0-9])*)?"
+	            + "\\b[0-9](?:'?[0-9])*\\.(?:[0-9](?:'?[0-9])*)?"
 	            + "|\\.[0-9](?:'?[0-9])*"
 	          + ")(?:[Ee][+-]?[0-9](?:'?[0-9])*)?"
-	          + "|[0-9](?:'?[0-9])*[Ee][+-]?[0-9](?:'?[0-9])*"
+	          + "|\\b[0-9](?:'?[0-9])*[Ee][+-]?[0-9](?:'?[0-9])*"
 	          // Hexadecimal.
-	          + "|0[Xx](?:"
+	          + "|\\b0[Xx](?:"
 	            +"[0-9A-Fa-f](?:'?[0-9A-Fa-f])*(?:\\.(?:[0-9A-Fa-f](?:'?[0-9A-Fa-f])*)?)?"
 	            + "|\\.[0-9A-Fa-f](?:'?[0-9A-Fa-f])*"
 	          + ")[Pp][+-]?[0-9](?:'?[0-9])*"
@@ -24222,6 +24303,32 @@ function requireCpp () {
 	    relevance: 0
 	  };
 
+	  // `#include` is the only preprocessor directive that takes an angle-bracket
+	  // quoted header (`#include <header>`). Scoping that rule to `#include` keeps
+	  // the greedy `<...>` match from eating a `>` that belongs to the body of
+	  // another directive (e.g. `#define what do { cout << ">"; } while (0)`),
+	  // which would otherwise leave an unbalanced `"` and break highlighting for
+	  // the rest of the file. See issue #3505.
+	  const PREPROCESSOR_INCLUDE = {
+	    scope: 'meta',
+	    begin: /#\s*include\b/,
+	    end: /$/,
+	    keywords: { keyword: 'include' },
+	    contains: [
+	      {
+	        // the `\` at the end of a line signaling continuation
+	        begin: /\\\n/,
+	      },
+	      STRINGS,
+	      {
+	        scope: 'string',
+	        begin: /<.*?>/
+	      },
+	      C_LINE_COMMENT_MODE,
+	      hljs.C_BLOCK_COMMENT_MODE
+	    ]
+	  };
+
 	  const PREPROCESSOR = {
 	    className: 'meta',
 	    begin: /#\s*[a-z]+\b/,
@@ -24235,15 +24342,16 @@ function requireCpp () {
 	        relevance: 0
 	      },
 	      hljs.inherit(STRINGS, { className: 'string' }),
-	      {
-	        className: 'string',
-	        begin: /<.*?>/
-	      },
 	      C_LINE_COMMENT_MODE,
 	      hljs.C_BLOCK_COMMENT_MODE
 	    ]
 	  };
 
+	  const PREPROCESSORS = [
+	    PREPROCESSOR_INCLUDE,
+	    PREPROCESSOR
+	  ];
+
 	  const TITLE_MODE = {
 	    className: 'title',
 	    begin: regex.optional(NAMESPACE_RE) + hljs.IDENT_RE,
@@ -24251,6 +24359,11 @@ function requireCpp () {
 	  };
 
 	  const FUNCTION_TITLE = regex.optional(NAMESPACE_RE) + hljs.IDENT_RE + '\\s*\\(';
+	  // Bounded on purpose: an unbounded quantifier here consumes an arbitrarily
+	  // long run of words, and when no function title follows it the engine retries
+	  // the title at every token boundary of that run - quadratic in the size of
+	  // the document.  See #4362.
+	  const MAX_FUNCTION_TYPE_TOKENS = 12;
 
 	  // https://en.cppreference.com/w/cpp/keyword
 	  const RESERVED_KEYWORDS = [
@@ -24553,18 +24666,14 @@ function requireCpp () {
 	      _hint: FUNCTION_HINTS },
 	    begin: regex.concat(
 	      /\b/,
-	      /(?!decltype)/,
-	      /(?!if)/,
-	      /(?!for)/,
-	      /(?!switch)/,
-	      /(?!while)/,
+	      `(?!${RESERVED_KEYWORDS.join('|')})`,
 	      hljs.IDENT_RE,
 	      regex.lookahead(/(<[^<>]+>|)\s*\(/))
 	  };
 
 	  const EXPRESSION_CONTAINS = [
 	    FUNCTION_DISPATCH,
-	    PREPROCESSOR,
+	    ...PREPROCESSORS,
 	    CPP_PRIMITIVE_TYPES,
 	    C_LINE_COMMENT_MODE,
 	    hljs.C_BLOCK_COMMENT_MODE,
@@ -24605,7 +24714,7 @@ function requireCpp () {
 
 	  const FUNCTION_DECLARATION = {
 	    className: 'function',
-	    begin: '(' + FUNCTION_TYPE_RE + '[\\*&\\s]+)+' + FUNCTION_TITLE,
+	    begin: '(' + FUNCTION_TYPE_RE + '[\\*&\\s]+){1,' + MAX_FUNCTION_TYPE_TOKENS + '}' + FUNCTION_TITLE,
 	    returnBegin: true,
 	    end: /[{;=]/,
 	    excludeEnd: true,
@@ -24676,7 +24785,7 @@ function requireCpp () {
 	      CPP_PRIMITIVE_TYPES,
 	      C_LINE_COMMENT_MODE,
 	      hljs.C_BLOCK_COMMENT_MODE,
-	      PREPROCESSOR
+	      ...PREPROCESSORS
 	    ]
 	  };
 
@@ -24700,7 +24809,7 @@ function requireCpp () {
 	      FUNCTION_DISPATCH,
 	      EXPRESSION_CONTAINS,
 	      [
-	        PREPROCESSOR,
+	        ...PREPROCESSORS,
 	        { // containers: ie, `vector <int> rooms (9);`
 	          begin: '\\b(deque|list|queue|priority_queue|pair|stack|vector|map|set|bitset|multiset|multimap|unordered_map|unordered_set|unordered_multiset|unordered_multimap|array|tuple|optional|variant|function|flat_map|flat_set)\\s*<(?!<)',
 	          end: '>',
@@ -24903,12 +25012,18 @@ function requireCsharp () {
 	    literal: LITERAL_KEYWORDS
 	  };
 	  const TITLE_MODE = hljs.inherit(hljs.TITLE_MODE, { begin: '[a-zA-Z](\\.?\\w)*' });
+	  // https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/integral-numeric-types
+	  // https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/floating-point-numeric-types
+	  // `_` separators sit between digits, and may also follow the `0x`/`0b` prefix
+	  const DIGITS = '\\d(_*\\d)*';
+	  const INTEGER_SUFFIX = '([uU][lL]?|[lL][uU]?)?';
+	  const REAL_SUFFIX = '([fFdDmM]|[uU][lL]?|[lL][uU]?)?';
 	  const NUMBERS = {
 	    className: 'number',
 	    variants: [
-	      { begin: '\\b(0b[01\']+)' },
-	      { begin: '(-?)\\b([\\d\']+(\\.[\\d\']*)?|\\.[\\d\']+)(u|U|l|L|ul|UL|f|F|b|B)' },
-	      { begin: '(-?)(\\b0[xX][a-fA-F0-9\']+|(\\b[\\d\']+(\\.[\\d\']*)?|\\.[\\d\']+)([eE][-+]?[\\d\']+)?)' }
+	      { begin: '\\b0[bB]_*[01](_*[01])*' + INTEGER_SUFFIX },
+	      { begin: '(-?)\\b0[xX]_*[a-fA-F0-9](_*[a-fA-F0-9])*' + INTEGER_SUFFIX },
+	      { begin: '(-?)(\\b' + DIGITS + '(\\.(' + DIGITS + ')?)?|\\.' + DIGITS + ')([eE][-+]?' + DIGITS + ')?' + REAL_SUFFIX }
 	    ],
 	    relevance: 0
 	  };
@@ -25172,6 +25287,10 @@ function requireCss () {
 	      scope: 'number',
 	      begin: /#(([0-9a-fA-F]{3,4})|(([0-9a-fA-F]{2}){3,4}))\b/
 	    },
+	    UNICODE_RANGE: {
+	      scope: 'number',
+	      begin: /\b[Uu]\+[0-9A-Fa-f][0-9A-Fa-f?]{0,5}(-[0-9A-Fa-f][0-9A-Fa-f]{0,5})?/
+	    },
 	    FUNCTION_DISPATCH: {
 	      className: "built_in",
 	      begin: /[\w-]+(?=\()/
@@ -25605,6 +25724,11 @@ function requireCss () {
 	  'container-type',
 	  'content',
 	  'content-visibility',
+	  'corner-bottom-left-shape',
+	  'corner-bottom-right-shape',
+	  'corner-shape',
+	  'corner-top-left-shape',
+	  'corner-top-right-shape',
 	  'counter-increment',
 	  'counter-reset',
 	  'counter-set',
@@ -25940,6 +26064,7 @@ function requireCss () {
 	  'transition-timing-function',
 	  'translate',
 	  'unicode-bidi',
+	  'unicode-range',
 	  'user-modify',
 	  'user-select',
 	  'vector-effect',
@@ -26046,9 +26171,10 @@ function requireCss () {
 	          modes.HEXCOLOR,
 	          modes.IMPORTANT,
 	          modes.CSS_NUMBER_MODE,
+	          modes.UNICODE_RANGE,
 	          ...STRINGS,
 	          // needed to highlight these as strings and to avoid issues with
-	          // illegal characters that might be inside urls that would tigger the
+	          // illegal characters that might be inside urls that would trigger the
 	          // languages illegal stack
 	          {
 	            begin: /(url|data-uri)\(/,
@@ -26135,10 +26261,10 @@ function requireMarkdown () {
 	    subLanguage: 'xml',
 	    relevance: 0
 	  };
-	  const HORIZONTAL_RULE = {
-	    begin: '^[-\\*]{3,}',
-	    end: '$'
-	  };
+	  // https://spec.commonmark.org/0.31.2/#thematic-breaks
+	  // three or more `-`, `*` or `_`, all the same character, optionally
+	  // separated and followed by spaces or tabs, and nothing else on the line
+	  const HORIZONTAL_RULE = { match: /^ {0,3}([-*_])[ \t]*(?:\1[ \t]*){2,}$/ };
 	  const CODE = {
 	    className: 'code',
 	    variants: [
@@ -26354,11 +26480,13 @@ function requireMarkdown () {
 	      HEADER,
 	      INLINE_HTML,
 	      LIST,
+	      // must come before BOLD/ITALIC so that a `***` or `___` thematic break
+	      // isn't mistaken for the start of bold text
+	      HORIZONTAL_RULE,
 	      BOLD,
 	      ITALIC,
 	      BLOCKQUOTE,
 	      CODE,
-	      HORIZONTAL_RULE,
 	      LINK,
 	      LINK_REFERENCE,
 	      ENTITY
@@ -26395,7 +26523,10 @@ function requireDiff () {
 	        className: 'meta',
 	        relevance: 10,
 	        match: regex.either(
-	          /^@@ +-\d+,\d+ +\+\d+,\d+ +@@/,
+	          /^@@ +-\d+,\d+ +\+\d+,\d+ +@@/, // @@ -1,2 +1,2 @@
+	          /^@@ +-\d+ +\+\d+,\d+ +@@/,     // @@ -1 +1,2 @@
+	          /^@@ +-\d+,\d+ +\+\d+ +@@/,     // @@ -1,2 +1 @@
+	          /^@@ +-\d+ +\+\d+ +@@/,         // @@ -1 +1 @@
 	          /^\*\*\* +\d+,\d+ +\*\*\*\*$/,
 	          /^--- +\d+,\d+ +----$/
 	        )
@@ -26774,8 +26905,9 @@ function requireRuby () {
 	    CLASS_REFERENCE,
 	    METHOD_DEFINITION,
 	    {
-	      // swallow namespace qualifiers before symbols
-	      begin: hljs.IDENT_RE + '::' },
+	      // swallow the scope resolution operator so `::` is not read as a symbol
+	      begin: '::'
+	    },
 	    {
 	      className: 'symbol',
 	      begin: hljs.UNDERSCORE_IDENT_RE + '(!|\\?)?:',
@@ -27026,6 +27158,10 @@ function requireGo () {
 	            match: /-?\b0[oO](_?[0-7])*i?/, // leading 0o octal
 	            relevance: 0
 	          },
+	          {
+	            match: /-?\b0[bB](_?[01])*i?/, // leading 0b binary
+	            relevance: 0
+	          },
 	          {
 	            match: /-?\.\d(_?\d)*([eE][+-]?\d(_?\d)*)?i?/, // decimal without a present digit before . (making a digit afterwards required)
 	            relevance: 0
@@ -27351,9 +27487,27 @@ function requireJava () {
 	/** @type LanguageFn */
 	function java(hljs) {
 	  const regex = hljs.regex;
+
+	  // A Java identifier consisting of letters, digits, underscore or dollar sign, not beginning with a digit
 	  const JAVA_IDENT_RE = '[\u00C0-\u02B8a-zA-Z_$][\u00C0-\u02B8a-zA-Z_$0-9]*';
-	  const GENERIC_IDENT_RE = JAVA_IDENT_RE
-	    + recurRegex('(?:<' + JAVA_IDENT_RE + '~~~(?:\\s*,\\s*' + JAVA_IDENT_RE + '~~~)*>)?', /~~~/g, 2);
+
+	  // Optional 1..n pairs of square brackets identifying an array type
+	  const ARRAY_BRACKETS_OPTIONAL_RE = '(?:(?:\\s*\\[\\s*])+)?';
+
+	  // A simple Java type: a type name, optionally followed by type arguments and/or array brackets
+	  // '<@@@>' is replaced with the pattern for optional type arguments by recurRegex below.
+	  const SIMPLE_TYPE_RE = JAVA_IDENT_RE + '<@@@>' + ARRAY_BRACKETS_OPTIONAL_RE;
+
+	  // A bounded (? extends Number) or unbounded (?) wildcard type
+	  const WILDCARD_TYPE_RE = '\\?(?:\\s+(?:extends|super)\\s+' + SIMPLE_TYPE_RE + ')?';
+
+	  // A Java type argument, consisting of a wildcard or simple type
+	  const TYPE_ARG_RE = '(?:' + WILDCARD_TYPE_RE + '|' + SIMPLE_TYPE_RE + ')';
+
+	  // Pattern for optional generic type arguments in angle brackets with up to 2 levels of nested type arguments
+	  const TYPE_ARGS_OPTIONAL_RE = recurRegex('(?:\\s*<\\s*' + TYPE_ARG_RE + '(?:\\s*,\\s*' + TYPE_ARG_RE + ')*\\s*>)?',
+	                                           /<@@@>/g, 2);
+
 	  const MAIN_KEYWORDS = [
 	    'synchronized',
 	    'abstract',
@@ -27507,18 +27661,25 @@ function requireJava () {
 	        match: /non-sealed/,
 	        scope: "keyword"
 	      },
+	      {
+	        // Expression keywords prevent keyword-led expressions from being
+	        // recognized as variable or method declarations.
+	        beginKeywords: 'new throw return else yield assert',
+	        relevance: 0
+	      },
 	      {
 	        begin: [
-	          regex.concat(/(?!else)/, JAVA_IDENT_RE),
-	          /\s+/,
 	          JAVA_IDENT_RE,
-	          /\s+/,
+	          regex.concat(TYPE_ARGS_OPTIONAL_RE, ARRAY_BRACKETS_OPTIONAL_RE, /\s+/),
+	          JAVA_IDENT_RE,
+	          ARRAY_BRACKETS_OPTIONAL_RE,
+	          /\s*/,
 	          /=(?!=)/
 	        ],
 	        className: {
 	          1: "type",
 	          3: "variable",
-	          5: "operator"
+	          6: "operator"
 	        }
 	      },
 	      {
@@ -27537,19 +27698,17 @@ function requireJava () {
 	          hljs.C_BLOCK_COMMENT_MODE
 	        ]
 	      },
-	      {
-	        // Expression keywords prevent 'keyword Name(...)' from being
-	        // recognized as a function definition
-	        beginKeywords: 'new throw return else',
-	        relevance: 0
-	      },
 	      {
 	        begin: [
-	          '(?:' + GENERIC_IDENT_RE + '\\s+)',
-	          hljs.UNDERSCORE_IDENT_RE,
+	          JAVA_IDENT_RE,
+	          regex.concat(TYPE_ARGS_OPTIONAL_RE, ARRAY_BRACKETS_OPTIONAL_RE, /\s+/),
+	          JAVA_IDENT_RE,
 	          /\s*(?=\()/
 	        ],
-	        className: { 2: "title.function" },
+	        className: {
+	          1: "type",
+	          3: "title.function"
+	        },
 	        keywords: KEYWORDS,
 	        contains: [
 	          {
@@ -27587,6 +27746,7 @@ function requireJavascript () {
 	if (hasRequiredJavascript) return javascript_1;
 	hasRequiredJavascript = 1;
 	const IDENT_RE = '[A-Za-z$_][0-9A-Za-z$_]*';
+
 	const KEYWORDS = [
 	  "as", // for exports
 	  "in",
@@ -27737,6 +27897,7 @@ function requireJavascript () {
 	  "localStorage",
 	  "sessionStorage",
 	  "module",
+	  "self",
 	  "global" // Node.js
 	];
 
@@ -28134,7 +28295,8 @@ function requireJavascript () {
 	      noneOf([
 	        ...BUILT_IN_GLOBALS,
 	        "super",
-	        "import"
+	        "import",
+	        "await",
 	      ].map(x => `${x}\\s*\\(`)),
 	      IDENT_RE$1, regex.lookahead(/\s*\(/)),
 	    className: "title.function",
@@ -28203,7 +28365,7 @@ function requireJavascript () {
 	    keywords: KEYWORDS$1,
 	    // this will be extended by TypeScript
 	    exports: { PARAMS_CONTAINS, CLASS_REFERENCE },
-	    illegal: /#(?![$_A-z])/,
+	    illegal: /#(?![$_A-Za-z])/,
 	    contains: [
 	      hljs.SHEBANG({
 	        label: "shebang",
@@ -28358,24 +28520,32 @@ function requireJavascript () {
 	return javascript_1;
 }
 
-/*
-Language: JSON
-Description: JSON (JavaScript Object Notation) is a lightweight data-interchange format.
-Author: Ivan Sagalaev <maniac@softwaremaniacs.org>
-Website: http://www.json.org
-Category: common, protocols, web
-*/
-
 var json_1;
 var hasRequiredJson$1;
 
 function requireJson$1 () {
 	if (hasRequiredJson$1) return json_1;
 	hasRequiredJson$1 = 1;
+	const EXTENDED_NUMBER_RE = '([-+]?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)|NaN|[-+]?Infinity'; // 0x..., 0..., decimal, float
+
+	const EXTENDED_NUMBER_MODE = {
+	  scope: 'number',
+	  match: EXTENDED_NUMBER_RE,
+	  relevance: 0
+	};
+
+	/*
+	Language: JSON
+	Description: JSON (JavaScript Object Notation) is a lightweight data-interchange format.
+	Websites: http://www.json.org, https://www.json5.org
+	Category: common, protocols, web
+	*/
+
+
 	function json(hljs) {
 	  const ATTRIBUTE = {
 	    className: 'attr',
-	    begin: /"(\\.|[^\\"\r\n])*"(?=\s*:)/,
+	    begin: /(("(\\.|[^\\"\r\n])*")|('(\\.|[^\\'\r\n])*'))(?=\s*:)/,
 	    relevance: 1.01
 	  };
 	  const PUNCTUATION = {
@@ -28400,16 +28570,17 @@ function requireJson$1 () {
 
 	  return {
 	    name: 'JSON',
-	    aliases: ['jsonc'],
+	    aliases: ['jsonc', 'json5'],
 	    keywords:{
 	      literal: LITERALS,
 	    },
 	    contains: [
 	      ATTRIBUTE,
 	      PUNCTUATION,
+	      hljs.APOS_STRING_MODE,
 	      hljs.QUOTE_STRING_MODE,
 	      LITERALS_MODE,
-	      hljs.C_NUMBER_MODE,
+	      EXTENDED_NUMBER_MODE,
 	      hljs.C_LINE_COMMENT_MODE,
 	      hljs.C_BLOCK_COMMENT_MODE
 	    ],
@@ -28590,7 +28761,9 @@ function requireKotlin () {
 	    name: 'Kotlin',
 	    aliases: [
 	      'kt',
-	      'kts'
+	      'kts',
+	      'ktm',
+	      'ktx'
 	    ],
 	    keywords: KEYWORDS,
 	    contains: [
@@ -28733,6 +28906,10 @@ function requireLess () {
 	      scope: 'number',
 	      begin: /#(([0-9a-fA-F]{3,4})|(([0-9a-fA-F]{2}){3,4}))\b/
 	    },
+	    UNICODE_RANGE: {
+	      scope: 'number',
+	      begin: /\b[Uu]\+[0-9A-Fa-f][0-9A-Fa-f?]{0,5}(-[0-9A-Fa-f][0-9A-Fa-f]{0,5})?/
+	    },
 	    FUNCTION_DISPATCH: {
 	      className: "built_in",
 	      begin: /[\w-]+(?=\()/
@@ -29166,6 +29343,11 @@ function requireLess () {
 	  'container-type',
 	  'content',
 	  'content-visibility',
+	  'corner-bottom-left-shape',
+	  'corner-bottom-right-shape',
+	  'corner-shape',
+	  'corner-top-left-shape',
+	  'corner-top-right-shape',
 	  'counter-increment',
 	  'counter-reset',
 	  'counter-set',
@@ -29501,6 +29683,7 @@ function requireLess () {
 	  'transition-timing-function',
 	  'translate',
 	  'unicode-bidi',
+	  'unicode-range',
 	  'user-modify',
 	  'user-select',
 	  'vector-effect',
@@ -29605,6 +29788,7 @@ function requireLess () {
 	        excludeEnd: true
 	      }
 	    },
+	    modes.UNICODE_RANGE,
 	    modes.HEXCOLOR,
 	    PARENS_MODE,
 	    IDENT_MODE('variable', '@@?' + IDENT_RE, 10),
@@ -29715,7 +29899,7 @@ function requireLess () {
 	      MIXIN_GUARD_MODE,
 	      IDENT_MODE('keyword', 'all\\b'),
 	      IDENT_MODE('variable', '@\\{' + IDENT_RE + '\\}'), // otherwise it’s identified as tag
-	      
+
 	      {
 	        begin: '\\b(' + TAGS.join('|') + ')\\b',
 	        className: 'selector-tag'
@@ -29814,7 +29998,7 @@ function requireLua () {
 	    keywords: {
 	      $pattern: hljs.UNDERSCORE_IDENT_RE,
 	      literal: "true false nil",
-	      keyword: "and break do else elseif end for goto if in local not or repeat return then until while",
+	      keyword: "and break do else elseif end for goto if in local global not or repeat return then until while",
 	      built_in:
 	        // Metatags and globals:
 	        '_G _ENV _VERSION __index __newindex __mode __call __metatable __tostring __len '
@@ -30743,6 +30927,10 @@ Language: PHP
 Author: Victor Karamzin <Victor.Karamzin@enterra-inc.com>
 Contributors: Evgeny Stepanischev <imbolk@gmail.com>, Ivan Sagalaev <maniac@softwaremaniacs.org>
 Website: https://www.php.net
+Description: Use this for plain PHP code, i.e. code that does not include the
+             surrounding `<?php ... ?>` tags. If your snippet mixes PHP with
+             HTML markup and the opening/closing tags, use `php-template`
+             instead.
 Category: common
 */
 
@@ -31160,6 +31348,8 @@ function requirePhp () {
 	      VARIABLE,
 	      LEFT_AND_RIGHT_SIDE_OF_DOUBLE_COLON,
 	      hljs.C_BLOCK_COMMENT_MODE,
+	      hljs.C_LINE_COMMENT_MODE,
+	      hljs.HASH_COMMENT_MODE,
 	      STRING,
 	      NUMBER,
 	      CONSTRUCTOR_CALL,
@@ -31184,6 +31374,8 @@ function requirePhp () {
 	    NAMED_ARGUMENT,
 	    LEFT_AND_RIGHT_SIDE_OF_DOUBLE_COLON,
 	    hljs.C_BLOCK_COMMENT_MODE,
+	    hljs.C_LINE_COMMENT_MODE,
+	    hljs.HASH_COMMENT_MODE,
 	    STRING,
 	    NUMBER,
 	    CONSTRUCTOR_CALL,
@@ -31312,6 +31504,8 @@ function requirePhp () {
 	              VARIABLE,
 	              LEFT_AND_RIGHT_SIDE_OF_DOUBLE_COLON,
 	              hljs.C_BLOCK_COMMENT_MODE,
+	              hljs.C_LINE_COMMENT_MODE,
+	              hljs.HASH_COMMENT_MODE,
 	              STRING,
 	              NUMBER
 	            ]
@@ -31377,6 +31571,9 @@ Language: PHP Template
 Requires: xml.js, php.js
 Author: Josh Goebel <hello@joshgoebel.com>
 Website: https://www.php.net
+Description: Use this for HTML (or other markup) with embedded PHP, i.e. code
+             that includes the `<?php ... ?>` (or `<?= ... ?>`) tags. For
+             plain PHP code without the surrounding tags, use `php` instead.
 Category: common
 */
 
@@ -31503,6 +31700,7 @@ function requirePython () {
 	    'in',
 	    'is',
 	    'lambda',
+	    'lazy',
 	    'match',
 	    'nonlocal|10',
 	    'not',
@@ -31519,7 +31717,9 @@ function requirePython () {
 	  const BUILT_INS = [
 	    '__import__',
 	    'abs',
+	    'aiter',
 	    'all',
+	    'anext',
 	    'any',
 	    'ascii',
 	    'bin',
@@ -31542,6 +31742,7 @@ function requirePython () {
 	    'filter',
 	    'float',
 	    'format',
+	    'frozendict',
 	    'frozenset',
 	    'getattr',
 	    'globals',
@@ -31574,6 +31775,7 @@ function requirePython () {
 	    'repr',
 	    'reversed',
 	    'round',
+	    'sentinel',
 	    'set',
 	    'setattr',
 	    'slice',
@@ -31665,7 +31867,7 @@ function requirePython () {
 	        relevance: 10
 	      },
 	      {
-	        begin: /([fF][rR]|[rR][fF]|[fF])'''/,
+	        begin: /([fFtT][rR]|[rR][fFtT]|[fFtT])'''/,
 	        end: /'''/,
 	        contains: [
 	          hljs.BACKSLASH_ESCAPE,
@@ -31675,7 +31877,7 @@ function requirePython () {
 	        ]
 	      },
 	      {
-	        begin: /([fF][rR]|[rR][fF]|[fF])"""/,
+	        begin: /([fFtT][rR]|[rR][fFtT]|[fFtT])"""/,
 	        end: /"""/,
 	        contains: [
 	          hljs.BACKSLASH_ESCAPE,
@@ -31703,7 +31905,7 @@ function requirePython () {
 	        end: /"/
 	      },
 	      {
-	        begin: /([fF][rR]|[rR][fF]|[fF])'/,
+	        begin: /([fFtT][rR]|[rR][fFtT]|[fFtT])'/,
 	        end: /'/,
 	        contains: [
 	          hljs.BACKSLASH_ESCAPE,
@@ -31712,7 +31914,7 @@ function requirePython () {
 	        ]
 	      },
 	      {
-	        begin: /([fF][rR]|[rR][fF]|[fF])"/,
+	        begin: /([fFtT][rR]|[rR][fFtT]|[fFtT])"/,
 	        end: /"/,
 	        contains: [
 	          hljs.BACKSLASH_ESCAPE,
@@ -32240,15 +32442,15 @@ function requireRust () {
 	  const IDENT_RE = regex.concat(RAW_IDENTIFIER, hljs.IDENT_RE);
 	  // ============================================
 	  const FUNCTION_INVOKE = {
-	    className: "title.function.invoke",
+	    scope: "title.function.invoke",
 	    relevance: 0,
 	    begin: regex.concat(
 	      /\b/,
-	      /(?!let|for|while|if|else|match\b)/,
+	      /(?!(?:let|for|while|if|else|match)\b)/,
 	      IDENT_RE,
 	      regex.lookahead(/\s*\(/))
 	  };
-	  const NUMBER_SUFFIX = '([ui](8|16|32|64|128|size)|f(32|64))\?';
+	  const NUMBER_SUFFIX = '([ui](8|16|32|64|128|size)|f(16|32|64|128))\?';
 	  const KEYWORDS = [
 	    "abstract",
 	    "as",
@@ -32282,6 +32484,7 @@ function requireRust () {
 	    "override",
 	    "priv",
 	    "pub",
+	    "raw",
 	    "ref",
 	    "return",
 	    "self",
@@ -32392,8 +32595,10 @@ function requireRust () {
 	    "u64",
 	    "u128",
 	    "usize",
+	    "f16",
 	    "f32",
 	    "f64",
+	    "f128",
 	    "str",
 	    "char",
 	    "bool",
@@ -32422,7 +32627,7 @@ function requireRust () {
 	        illegal: null
 	      }),
 	      {
-	        className: 'symbol',
+	        scope: 'symbol',
 	        // negative lookahead to avoid matching `'`
 	        begin: /'[a-zA-Z_][a-zA-Z0-9_]*(?!')/
 	      },
@@ -32436,14 +32641,14 @@ function requireRust () {
 	            contains: [
 	              {
 	                scope: "char.escape",
-	                match: /\\('|\w|x\w{2}|u\w{4}|U\w{8})/
+	                match: /\\('|"|\\|\w|x\w{2}|u\w{4}|U\w{8})/
 	              }
 	            ]
 	          }
 	        ]
 	      },
 	      {
-	        className: 'number',
+	        scope: 'number',
 	        variants: [
 	          { begin: '\\b0b([01_]+)' + NUMBER_SUFFIX },
 	          { begin: '\\b0o([0-7_]+)' + NUMBER_SUFFIX },
@@ -32453,24 +32658,35 @@ function requireRust () {
 	        ],
 	        relevance: 0
 	      },
+	      {
+	        begin: [
+	          /\bsafe/,
+	          /\s+/,
+	          /extern/,
+	        ],
+	        scope: {
+	          1: "keyword",
+	          3: "keyword",
+	        }
+	      },
 	      {
 	        begin: [
 	          /fn/,
 	          /\s+/,
 	          UNDERSCORE_IDENT_RE
 	        ],
-	        className: {
+	        scope: {
 	          1: "keyword",
 	          3: "title.function"
 	        }
 	      },
 	      {
-	        className: 'meta',
+	        scope: 'meta',
 	        begin: '#!?\\[',
 	        end: '\\]',
 	        contains: [
 	          {
-	            className: 'string',
+	            scope: 'string',
 	            begin: /"/,
 	            end: /"/,
 	            contains: [
@@ -32486,7 +32702,7 @@ function requireRust () {
 	          /(?:mut\s+)?/,
 	          UNDERSCORE_IDENT_RE
 	        ],
-	        className: {
+	        scope: {
 	          1: "keyword",
 	          3: "keyword",
 	          4: "variable"
@@ -32501,7 +32717,7 @@ function requireRust () {
 	          /\s+/,
 	          /in/
 	        ],
-	        className: {
+	        scope: {
 	          1: "keyword",
 	          3: "variable",
 	          5: "keyword"
@@ -32513,7 +32729,7 @@ function requireRust () {
 	          /\s+/,
 	          UNDERSCORE_IDENT_RE
 	        ],
-	        className: {
+	        scope: {
 	          1: "keyword",
 	          3: "title.class"
 	        }
@@ -32524,7 +32740,7 @@ function requireRust () {
 	          /\s+/,
 	          UNDERSCORE_IDENT_RE
 	        ],
-	        className: {
+	        scope: {
 	          1: "keyword",
 	          3: "title.class"
 	        }
@@ -32538,7 +32754,7 @@ function requireRust () {
 	        }
 	      },
 	      {
-	        className: "punctuation",
+	        scope: "punctuation",
 	        begin: '->'
 	      },
 	      FUNCTION_INVOKE
@@ -32567,6 +32783,10 @@ function requireScss () {
 	      scope: 'number',
 	      begin: /#(([0-9a-fA-F]{3,4})|(([0-9a-fA-F]{2}){3,4}))\b/
 	    },
+	    UNICODE_RANGE: {
+	      scope: 'number',
+	      begin: /\b[Uu]\+[0-9A-Fa-f][0-9A-Fa-f?]{0,5}(-[0-9A-Fa-f][0-9A-Fa-f]{0,5})?/
+	    },
 	    FUNCTION_DISPATCH: {
 	      className: "built_in",
 	      begin: /[\w-]+(?=\()/
@@ -33000,6 +33220,11 @@ function requireScss () {
 	  'container-type',
 	  'content',
 	  'content-visibility',
+	  'corner-bottom-left-shape',
+	  'corner-bottom-right-shape',
+	  'corner-shape',
+	  'corner-top-left-shape',
+	  'corner-top-right-shape',
 	  'counter-increment',
 	  'counter-reset',
 	  'counter-set',
@@ -33335,6 +33560,7 @@ function requireScss () {
 	  'transition-timing-function',
 	  'translate',
 	  'unicode-bidi',
+	  'unicode-range',
 	  'user-modify',
 	  'user-select',
 	  'vector-effect',
@@ -33448,6 +33674,7 @@ function requireScss () {
 	          VARIABLE,
 	          modes.HEXCOLOR,
 	          modes.CSS_NUMBER_MODE,
+	          modes.UNICODE_RANGE,
 	          hljs.QUOTE_STRING_MODE,
 	          hljs.APOS_STRING_MODE,
 	          modes.IMPORTANT,
@@ -33526,7 +33753,7 @@ function requireShell () {
 	        // We cannot add \s (spaces) in the regular expression otherwise it will be too broad and produce unexpected result.
 	        // For instance, in the following example, it would match "echo /path/to/home >" as a prompt:
 	        // echo /path/to/home > t.exe
-	        begin: /^\s{0,3}[/~\w\d[\]()@-]*[>%$#][ ]?/,
+	        begin: /^\s{0,3}[./~\w\d[\]()@-]*[>%$#][ ]?/,
 	        starts: {
 	          end: /[^\\](?=\s*$)/,
 	          subLanguage: 'bash'
@@ -34314,6 +34541,18 @@ function requireSwift () {
 	  return joined;
 	}
 
+	// BACKREF_RE matches an open parenthesis or backreference. To avoid an
+	// incorrect parse, it also matches the constructs where the meaning of
+	// parentheses, escapes, or capture counting changes.
+	new RegExp(either(
+	  /\[(?:[^\\\]]|\\.)*\]/, // a character class, inside which ( and \ lose their meaning
+	  /\(\?<(?![=!])[^>]+>/, // a named capture group `(?<name>` (not a lookbehind `(?<=` / `(?<!`)
+	  /\(\?'[^']+'/, // a named capture group `(?'name'`
+	  /\(\??/, // an opening parenthesis, capturing or non-capturing / lookahead
+	  /\\([1-9][0-9]*)/, // a backreference like `\1`
+	  /\\./ // any other escape sequence
+	));
+
 	const keywordWrapper = keyword => concat(
 	  /\b/,
 	  keyword,
@@ -35453,6 +35692,7 @@ function requireTypescript () {
 	if (hasRequiredTypescript) return typescript_1;
 	hasRequiredTypescript = 1;
 	const IDENT_RE = '[A-Za-z$_][0-9A-Za-z$_]*';
+
 	const KEYWORDS = [
 	  "as", // for exports
 	  "in",
@@ -35603,6 +35843,7 @@ function requireTypescript () {
 	  "localStorage",
 	  "sessionStorage",
 	  "module",
+	  "self",
 	  "global" // Node.js
 	];
 
@@ -36000,7 +36241,8 @@ function requireTypescript () {
 	      noneOf([
 	        ...BUILT_IN_GLOBALS,
 	        "super",
-	        "import"
+	        "import",
+	        "await",
 	      ].map(x => `${x}\\s*\\(`)),
 	      IDENT_RE$1, regex.lookahead(/\s*\(/)),
 	    className: "title.function",
@@ -36069,7 +36311,7 @@ function requireTypescript () {
 	    keywords: KEYWORDS$1,
 	    // this will be extended by TypeScript
 	    exports: { PARAMS_CONTAINS, CLASS_REFERENCE },
-	    illegal: /#(?![$_A-z])/,
+	    illegal: /#(?![$_A-Za-z])/,
 	    contains: [
 	      hljs.SHEBANG({
 	        label: "shebang",
@@ -36752,7 +36994,9 @@ const defaultOptions = {
     lstat: false,
     depth: 2147483648,
     alwaysStat: false,
-    highWaterMark: 4096,
+    // Throughput is flat from 16 to 65536 (traversal is I/O-bound), but
+    // batches of 1024+ entries survive young-gen GC and bloat RSS ~20-60%.
+    highWaterMark: 256,
 };
 Object.freeze(defaultOptions);
 const RECURSIVE_ERROR_CODE = 'READDIRP_RECURSIVE_ERROR';
@@ -36791,8 +37035,12 @@ const normalizeFilter = (filter) => {
     }
     return emptyFn;
 };
-/** Readable readdir stream, emitting new files as they're being listed. */
 class ReaddirpStream extends Readable {
+    /**
+     * Directories discovered but not yet emitted from. Listings are read
+     * lazily (on pop, plus one prefetch) instead of eagerly on discovery:
+     * keeping whole listings for every queued dir balloons RAM on wide trees.
+     */
     parents;
     reading;
     parent;
@@ -36807,14 +37055,17 @@ class ReaddirpStream extends Readable {
     _rdOptions;
     _fileFilter;
     _directoryFilter;
+    _relStart;
     constructor(options = {}) {
         super({
             objectMode: true,
             autoDestroy: true,
-            highWaterMark: options.highWaterMark,
+            highWaterMark: options.highWaterMark ?? defaultOptions.highWaterMark,
         });
         const opts = { ...defaultOptions, ...options };
-        const { root, type } = opts;
+        // Use ?? so an explicit `undefined` in user options doesn't shadow defaults.
+        const root = opts.root ?? defaultOptions.root;
+        const type = opts.type ?? defaultOptions.type;
         this._fileFilter = normalizeFilter(opts.fileFilter);
         this._directoryFilter = normalizeFilter(opts.directoryFilter);
         const statMethod = opts.lstat ? lstat : stat$1;
@@ -36827,15 +37078,23 @@ class ReaddirpStream extends Readable {
         }
         this._maxDepth =
             opts.depth != null && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions.depth;
-        this._wantsDir = type ? DIR_TYPES.has(type) : false;
-        this._wantsFile = type ? FILE_TYPES.has(type) : false;
+        this._wantsDir = DIR_TYPES.has(type);
+        this._wantsFile = FILE_TYPES.has(type);
         this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
         this._root = resolve(root);
+        // Every fullPath is `_root + sep + relative path` (see _formatEntry), so
+        // the relative path is a slice starting past the root and its trailing
+        // separator (which resolved paths lack, except fs roots like '/', 'C:\').
+        this._relStart = this._root.endsWith(sep$1) ? this._root.length : this._root.length + 1;
         this._isDirent = !opts.alwaysStat;
         this._statsProp = this._isDirent ? 'dirent' : 'stats';
         this._rdOptions = { encoding: 'utf8', withFileTypes: this._isDirent };
-        // Launch stream with one parent, the root dir.
-        this.parents = [this._exploreDir(root, 1)];
+        // Launch stream with one parent, the root dir, whose readdir starts
+        // right away. Explore the resolved root so all parent paths stay
+        // absolute even if process.cwd() changes mid-iteration.
+        const rootDir = { path: this._root, depth: 1 };
+        rootDir.pending = this._exploreDir(this._root, 1);
+        this.parents = [rootDir];
         this.reading = false;
         this.parent = undefined;
     }
@@ -36850,16 +37109,25 @@ class ReaddirpStream extends Readable {
                 if (fil && fil.length > 0) {
                     const { path, depth } = par;
                     const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path));
-                    const awaited = await Promise.all(slice);
+                    // In dirent mode _formatEntry is synchronous: skip Promise.all and
+                    // its per-entry microtask overhead.
+                    const awaited = this._isDirent
+                        ? slice
+                        : await Promise.all(slice);
                     for (const entry of awaited) {
                         if (!entry)
                             continue;
                         if (this.destroyed)
                             return;
-                        const entryType = await this._getEntryType(entry);
+                        // Only symlinks require async work; plain files / dirs resolve synchronously.
+                        let entryType = this._getEntryType(entry);
+                        if (typeof entryType !== 'string')
+                            entryType = await entryType;
                         if (entryType === 'directory' && this._directoryFilter(entry)) {
                             if (depth <= this._maxDepth) {
-                                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+                                // Lazy: don't readdir until this dir is popped. Keeping whole
+                                // listings for every queued dir would balloon RAM on wide trees.
+                                this.parents.push({ path: entry.fullPath, depth: depth + 1 });
                             }
                             if (this._wantsDir) {
                                 this.push(entry);
@@ -36881,7 +37149,15 @@ class ReaddirpStream extends Readable {
                         this.push(null);
                         break;
                     }
-                    this.parent = await parent;
+                    const dir = parent.pending ?? this._exploreDir(parent.path, parent.depth);
+                    // Prefetch the next dir so its readdir overlaps with processing
+                    // this one's entries. Only the stack top is prefetched, keeping at
+                    // most a handful of listings (~tree depth) in RAM at once.
+                    const next = this.parents[this.parents.length - 1];
+                    if (next && !next.pending) {
+                        next.pending = this._exploreDir(next.path, next.depth);
+                    }
+                    this.parent = await dir;
                     if (this.destroyed)
                         return;
                 }
@@ -36894,6 +37170,18 @@ class ReaddirpStream extends Readable {
             this.reading = false;
         }
     }
+    // NOTE: native `readdir(path, { recursive: true })` was evaluated as a
+    // replacement for this per-directory traversal and rejected:
+    // - Not faster: node implements it in JS, walking directories sequentially
+    //   just like this loop, but with extra path bookkeeping. Benchmarks
+    //   (node 24): ~10% slower on wide trees, ~40% slower on small ones,
+    //   parity on deep ones.
+    // - Much more RAM: it buffers the entire subtree listing in one array,
+    //   instead of one directory at a time, defeating streaming.
+    // - Semantics diverge: it can't limit depth, can't skip directories a
+    //   directoryFilter rejects, doesn't follow symlinked dirs, and fails
+    //   wholesale (all entries lost) if anything in the subtree is unreadable,
+    //   instead of emitting a 'warn' and continuing.
     async _exploreDir(path, depth) {
         let files;
         try {
@@ -36904,19 +37192,27 @@ class ReaddirpStream extends Readable {
         }
         return { files, depth, path };
     }
-    async _formatEntry(dirent, path) {
-        let entry;
+    // Synchronous in dirent mode; returns a promise only when stats are needed.
+    _formatEntry(dirent, path) {
         const basename = this._isDirent ? dirent.name : dirent;
-        try {
-            const fullPath = resolve(join$1(path, basename));
-            entry = { path: relative(this._root, fullPath), fullPath, basename };
-            entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
-        }
-        catch (err) {
+        // `path` is always an absolute, normalized parent dir (see _exploreDir
+        // seeding in the constructor), so a plain join is enough — resolve()
+        // would re-read cwd on every entry.
+        const fullPath = join$1(path, basename);
+        // Slice instead of path.relative(): equivalent here (fullPath is always
+        // under _root) and avoids several intermediate allocations per entry.
+        const entry = { path: fullPath.slice(this._relStart), fullPath, basename };
+        if (this._isDirent) {
+            entry.dirent = dirent;
+            return entry;
+        }
+        return this._stat(fullPath).then((stats) => {
+            entry.stats = stats;
+            return entry;
+        }, (err) => {
             this._onError(err);
-            return;
-        }
-        return entry;
+            return undefined;
+        });
     }
     _onError(err) {
         if (isNormalFlowError(err) && !this.destroyed) {
@@ -36926,10 +37222,12 @@ class ReaddirpStream extends Readable {
             this.destroy(err);
         }
     }
-    async _getEntryType(entry) {
+    // Synchronous for regular files and directories; returns a promise only for
+    // symlinks, which need realpath() to be classified.
+    _getEntryType(entry) {
         // entry may be undefined, because a warning or an error were emitted
         // and the statsProp is undefined
-        if (!entry && this._statsProp in entry) {
+        if (!entry || !(this._statsProp in entry)) {
             return '';
         }
         const stats = entry[this._statsProp];
@@ -36937,30 +37235,34 @@ class ReaddirpStream extends Readable {
             return 'file';
         if (stats.isDirectory())
             return 'directory';
-        if (stats && stats.isSymbolicLink()) {
-            const full = entry.fullPath;
-            try {
-                const entryRealPath = await realpath(full);
-                const entryRealPathStats = await lstat(entryRealPath);
-                if (entryRealPathStats.isFile()) {
-                    return 'file';
-                }
-                if (entryRealPathStats.isDirectory()) {
-                    const len = entryRealPath.length;
-                    if (full.startsWith(entryRealPath) && full.substr(len, 1) === sep$1) {
-                        const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
-                        // @ts-ignore
-                        recursiveError.code = RECURSIVE_ERROR_CODE;
-                        return this._onError(recursiveError);
-                    }
-                    return 'directory';
-                }
+        if (stats.isSymbolicLink())
+            return this._getSymlinkEntryType(entry);
+        return '';
+    }
+    async _getSymlinkEntryType(entry) {
+        const full = entry.fullPath;
+        try {
+            const entryRealPath = await realpath(full);
+            const entryRealPathStats = await lstat(entryRealPath);
+            if (entryRealPathStats.isFile()) {
+                return 'file';
             }
-            catch (error) {
-                this._onError(error);
-                return '';
+            if (entryRealPathStats.isDirectory()) {
+                const len = entryRealPath.length;
+                if (full.startsWith(entryRealPath) && full[len] === sep$1) {
+                    const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+                    // @ts-ignore
+                    recursiveError.code = RECURSIVE_ERROR_CODE;
+                    this._onError(recursiveError);
+                    return '';
+                }
+                return 'directory';
             }
         }
+        catch (error) {
+            this._onError(error);
+        }
+        return '';
     }
     _includeAsFile(entry) {
         const stats = entry && entry[this._statsProp];
@@ -36978,8 +37280,6 @@ function readdirp(root, options = {}) {
     let type = options.entryType || options.type;
     if (type === 'both')
         type = EntryTypes.FILE_DIR_TYPE; // backwards-compatibility
-    if (type)
-        options.type = type;
     if (!root) {
         throw new Error('readdirp: root argument is required. Usage: readdirp(root, options)');
     }
@@ -36989,8 +37289,11 @@ function readdirp(root, options = {}) {
     else if (type && !ALL_TYPES.includes(type)) {
         throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(', ')}`);
     }
-    options.root = root;
-    return new ReaddirpStream(options);
+    // Copy options instead of mutating the caller's object.
+    const opts = { ...options, root };
+    if (type)
+        opts.type = type;
+    return new ReaddirpStream(opts);
 }
 
 const STR_DATA = 'data';
@@ -68646,4 +68949,4 @@ var yaml = /*#__PURE__*/Object.freeze({
 });
 
 export { HighlightJS as H, MarkdownItCallable as M, Ze$b as Z, resolveConfig as a, createTwoFilesPatch$1 as b, createSyncFn as c, dedent$1 as d, deflist_plugin as e, format2 as f, strFromU8 as g, closest as h, distance as i, fm$3 as j, isCI as k, cliProgress as l, moduleImporter as m, tinylr as n, createInstance as o, fse as p, inter as q, runAsWorker as r, strToU8 as s, ts$9 as t, watch$1 as w, zlibSync as z };
-//# sourceMappingURL=vendor-C6ojgz0W.mjs.map
+//# sourceMappingURL=vendor-D7FIOE5G.mjs.map