cloudcmd 19.21.3 → 19.21.4

package/dist-dev/modules/menu.js

@@ -712,7 +712,7 @@ eval("{// shim for using process in browser\nvar process = module.exports = {};\
   !*** ./node_modules/putout/node_modules/ignore/index.js ***!
   \**********************************************************/
 (module, __unused_rspack_exports, __webpack_require__) {
-eval("{/* provided dependency */ var process = __webpack_require__(/*! process/browser */ \"./node_modules/process/browser.js\");\n// A simple implementation of make-array\nfunction makeArray (subject) {\n  return Array.isArray(subject)\n    ? subject\n    : [subject]\n}\n\nconst UNDEFINED = undefined\nconst EMPTY = ''\nconst SPACE = ' '\nconst ESCAPE = '\\\\'\n\n// The characters that carry a meaning of their own inside a regular\n//   expression, so a literal one has to be escaped before it is emitted.\nconst REGEX_LITERAL_SPECIAL = /[.*+?()[\\]{}^$|\\\\/]/\nconst BOM = '\\uFEFF'\nconst REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\\\]|^)\\\\$/\nconst REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\\\!/\nconst REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\\\#/\nconst REGEX_SPLITALL_CRLF = /\\r?\\n/g\n\n// Invalid:\n// - /foo,\n// - ./foo,\n// - ../foo,\n// - .\n// - ..\n// Valid:\n// - .foo\nconst DOUBLE_SLASH = '//'\nconst SLASH_CODE = 47\nconst DOT_CODE = 46\n\n\nconst SLASH = '/'\n\n// Do not use ternary expression here, since \"istanbul ignore next\" is buggy\nlet TMP_KEY_IGNORE = 'node-ignore'\n/* istanbul ignore else */\nif (typeof Symbol !== 'undefined') {\n  TMP_KEY_IGNORE = Symbol.for('node-ignore')\n}\nconst KEY_IGNORE = TMP_KEY_IGNORE\n\nconst define = (object, key, value) => {\n  Object.defineProperty(object, key, {value})\n  return value\n}\n\nconst RETURN_FALSE = () => false\n\n// > The range notation, e.g. [a-zA-Z],\n// > can be used to match one of the characters in a range.\n//\n// gitignore(5) defers to fnmatch(3) for this, and git implements it in\n//   `wildmatch.c`.  A bracket expression has a sub-grammar of its own, which\n//   is neither the surrounding pattern grammar nor the JavaScript one:\n//\n//   - a `]` right after `[` or `[!` is a literal member, not the terminator\n//   - `[:alpha:]` names one of twelve POSIX classes\n//   - `\\` escapes the next member, `]` included\n//   - `*`, `?` and `.` are plain literal members\n//   - an unterminated expression makes the whole pattern match nothing\n//\n// which means the expression can not be located -- let alone translated -- by\n//   a regular expression.  It is scanned out of the pattern before the\n//   replacers below run, and put back once they are done, so that neither the\n//   metacharacter escaper nor the `?` / `*` replacers ever see its body.\n\n// git classifies with its own ASCII-only ctype macros (`wildmatch.c`), never\n//   with the C library ones, so these must not be mapped onto `\\d` / `\\w` /\n//   `\\s`, which are wider.  `/` is left out of every expansion, because a\n//   bracket expression never matches a path separator.\nconst POSIX_CLASSES = {\n  alnum: '0-9A-Za-z',\n  alpha: 'A-Za-z',\n  blank: ' \\\\t',\n  cntrl: '\\\\x00-\\\\x1f\\\\x7f',\n  digit: '0-9',\n  graph: '!-.0-~',\n  lower: 'a-z',\n  print: ' -.0-~',\n  punct: '!-.:-@\\\\[-`{-~',\n  // git's `sane-ctype.h` classifies \\v and \\f as control, not space,\n  //   unlike C's `isspace`\n  space: ' \\\\t\\\\n\\\\r',\n  upper: 'A-Z',\n  xdigit: '0-9A-Fa-f'\n}\n\nconst CLASS_MEMBERS_TO_ESCAPE = '\\\\]^-['\n\nconst escapeMember = char => CLASS_MEMBERS_TO_ESCAPE.indexOf(char) < 0\n  ? char\n  : ESCAPE + char\n\n// > if (matched == negated || ((flags & WM_PATHNAME) && text_ch == '/'))\n// >   return WM_ABORT_TO_STARSTAR;                     (git, `wildmatch.c`)\n// A bracket expression never matches a path separator, whatever its members\n//   say, so a negated class gets `/` as one more excluded character, while a\n//   plain one -- where a literal member or a range could still let `/` in --\n//   is guarded with a lookahead, `/` being impossible to subtract from a\n//   JavaScript character class.\nconst NON_SLASH = '(?!\\\\/)'\n\nconst classSource = (negated, body) => {\n  if (negated) {\n    return `[^\\\\/${body}]`\n  }\n\n  const source = `[${body}]`\n\n  return new RegExp(source).test('/')\n    ? NON_SLASH + source\n    : source\n}\n\n// Scan the bracket expression that starts at `pattern[start] === '['`,\n//   mirroring the member loop of git's `wildmatch.c`.\n// @returns {{end: number, source: string} | null} `null` if the expression is\n//   never terminated, which makes the whole pattern match nothing.\nconst scanBracket = (pattern, start) => {\n  const {length} = pattern\n  let index = start + 1\n  let negated = EMPTY\n\n  const lead = pattern[index]\n  if (lead === '!' || lead === '^') {\n    negated = '^'\n    index ++\n  }\n\n  let body = EMPTY\n\n  // The member a `-` could start a range from, or EMPTY when the previous\n  //   member can not open one (start of the body, or a range / POSIX class\n  //   that has just closed)\n  let prev = EMPTY\n\n  // git scans the members with a do-while, so the first one is consumed\n  //   unconditionally.  That is the whole reason a leading `]` is a member\n  //   and not the terminator.\n  for (;;) {\n    const char = pattern[index]\n\n    if (char === UNDEFINED) {\n      return null\n    }\n\n    if (char === ESCAPE) {\n      const escaped = pattern[index + 1]\n      if (escaped === UNDEFINED) {\n        return null\n      }\n      body += escapeMember(escaped)\n      prev = escaped\n      index ++\n    } else if (\n      char === '-'\n      && prev\n      && index + 1 < length\n      && pattern[index + 1] !== ']'\n    ) {\n      index ++\n      let to = pattern[index]\n      if (to === ESCAPE) {\n        // A pattern can not end on a lone backslash -- `checkPattern` has\n        //   already thrown it away -- so there is an upper bound to read.\n        to = pattern[index += 1]\n      }\n      // An out-of-order range matches nothing in git but is a syntax error in\n      //   JavaScript, so it is dropped.  Its lower bound stays: git tests it\n      //   as a plain member before it ever looks at the `-`, so `[c-a]` does\n      //   match `c`.\n      if (prev <= to) {\n        body += `-${escapeMember(to)}`\n      }\n      prev = EMPTY\n    } else if (char === '[' && pattern[index + 1] === ':') {\n      const nameStart = index + 2\n      let end = nameStart\n      while (end < length && pattern[end] !== ']') {\n        end ++\n      }\n\n      if (end === length) {\n        return null\n      }\n\n      if (end > nameStart && pattern[end - 1] === ':') {\n        const name = pattern.slice(nameStart, end - 1)\n\n        // An unknown class name makes the whole pattern match nothing\n        if (!Object.prototype.hasOwnProperty.call(POSIX_CLASSES, name)) {\n          return null\n        }\n\n        body += POSIX_CLASSES[name]\n        prev = EMPTY\n        index = end\n      } else {\n        // No `:]` to close it, so the `[` is a plain member and scanning\n        //   resumes right after it.\n        body += escapeMember('[')\n        prev = '['\n        index = nameStart - 2\n      }\n    } else {\n      body += escapeMember(char)\n      prev = char\n    }\n\n    index ++\n\n    if (pattern[index] === ']') {\n      return {\n        end: index,\n        source: classSource(negated, body)\n      }\n    }\n  }\n}\n\n// An empty JavaScript class can never match, which is how a pattern that git\n//   gives up on (`WM_ABORT_ALL`) is expressed here.\nconst NEVER_MATCH = '[]'\n\n// A NUL can appear in neither a `.gitignore` line nor a path, which makes it\n//   the one safe placeholder character.  A literal one in the pattern is\n//   held aside all the same, so a collision is impossible by construction.\nconst PLACEHOLDER = '\\u0000'\nconst REGEX_RESTORE_PLACEHOLDER = new RegExp(\n  `${PLACEHOLDER}(\\\\d+)${PLACEHOLDER}`, 'g'\n)\n\n// The one wildcard the chain does not expand for itself is a trailing `*`. How\n//   it expands depends on the mode (`regex` vs `checkRegex`), so `_make` is\n//   left to do it, and until then the pending wildcard travels as this marker.\n//   That is what keeps it apart from a user-escaped literal `\\*`: the unescape\n//   steps collapse the escaped one to the exact `\\*` a wildcard would leave\n//   behind, so by the time `_make` runs the two are otherwise the same string\n//   and a literal star gets wrongly rewritten into a wildcard. The marker is a\n//   private-use character, and `extractBrackets` keeps one that came out of the\n//   pattern apart from it, so the only marker `_make` ever turns back into a\n//   real wildcard is the one this chain put there itself.\nconst TRAILING_WILDCARD = '\\uE000'\n\n// A trailing \"/**\" is deferred the same way, because `checkRegex` has to tell\n//   it apart from a trailing \"/*\" (see `checkSourceOf`). For `.ignores()` it\n//   still never matches the folder itself (#21).\nconst TRAILING_DOUBLESTAR = '\\uE001'\n\n// The three characters above mean something to the chain that builds the\n//   source rather than to the path, so one that came out of the pattern is\n//   held aside like a bracket expression instead of going straight out. Being\n//   held is what makes it safe: the restore runs after the step that anchors\n//   the source, so the character comes back in the middle of the source and\n//   not at its end, which is the one place `_make` and `checkSourceOf` look\n//   for a marker. Without it a pattern's own character lands where a pending\n//   marker sits, and `_make` turns it into a real trailing wildcard.\n//\n// It is held as a one-member class rather than bare, in both of the branches\n//   a reserved character can reach, so that the property can be\n//   read off this function alone -- a reserved character never goes out on\n//   its own -- rather than depending on where in the chain the restore\n//   happens to run. In the expression built here `[x]` matches exactly what\n//   `x` matches, none of the three being special to a regular expression or\n//   inside a class, so no test can tell the two apart: the class is insurance,\n//   and the paragraph above is the reason it is not needed.\nconst isReserved = char =>\n  char === PLACEHOLDER\n  || char === TRAILING_WILDCARD\n  || char === TRAILING_DOUBLESTAR\n\n// Replace every bracket expression with a placeholder the replacers below\n//   leave alone, and translate it separately.\nconst extractBrackets = pattern => {\n  const sources = []\n  const hold = source =>\n    `${PLACEHOLDER}${sources.push(source) - 1}${PLACEHOLDER}`\n\n  const {length} = pattern\n  let out = EMPTY\n  let index = 0\n\n  while (index < length) {\n    const char = pattern[index]\n\n    if (char === ESCAPE) {\n      // > Put a backslash (\"\\\") in front of ... a character to make it literal.\n      //                                            (gitignore(5) -> fnmatch(3))\n      // A backslash quotes the next character, whatever it is, so `\\d` is a\n      //   literal `d`, not the regex digit class, and `\\?` is a literal `?`,\n      //   not a wildcard. Held aside as its literal here, the escape never\n      //   reaches the replacers below, which would otherwise let `\\d`, `\\b`,\n      //   `\\1`, `\\/` keep their regular-expression meaning, and would turn a\n      //   `\\?` into `[^\\/]`.\n      //\n      // Three escapes are still left for the chain: `\\*` (a literal star,\n      //   told apart from a wildcard by `TRAILING_WILDCARD` and the wildcard\n      //   replacers), `\\[` (a literal bracket, the one `[` the bracket\n      //   replacer still expects), and `\\ ` (a quoted space, which one pass\n      //   below rewrites in bulk -- holding each one aside instead costs more\n      //   on a pattern built out of them). A lone trailing backslash can reach\n      //   here after line-ending cleanup.\n      //\n      // A quoted backslash is not among them. The chain doubles every\n      //   backslash, then takes the doubling back out again, and a quoted one\n      //   standing next to a character the chain also escapes left the two\n      //   counts sharing a run, so one of the escapes was lost. Held here as\n      //   the literal it means, it never joins that run.\n      const escaped = pattern[index + 1]\n\n      if (\n        escaped === UNDEFINED\n        || escaped === SLASH && index + 2 === length\n      ) {\n        // Git removes a final directory slash before matching. An escape\n        //   without a character after that removal makes the pattern invalid.\n        out += hold(NEVER_MATCH)\n      } else if (\n        escaped === '*'\n        || escaped === '['\n        || escaped === SPACE\n      ) {\n        out += pattern.slice(index, index + 2)\n      } else {\n        out += hold(\n          REGEX_LITERAL_SPECIAL.test(escaped)\n            ? ESCAPE + escaped\n            : isReserved(escaped)\n              ? `[${escaped}]`\n              : escaped\n        )\n      }\n\n      index += 2\n    } else if (isReserved(char)) {\n      out += hold(`[${char}]`)\n      index ++\n    } else if (char === '[') {\n      const scanned = scanBracket(pattern, index)\n\n      if (scanned === null) {\n        // git gives up on the whole pattern (`WM_ABORT_ALL`), so whatever\n        //   follows can not make it match either.\n        out += hold(NEVER_MATCH)\n        index = length\n      } else {\n        out += hold(scanned.source)\n        index = scanned.end + 1\n      }\n    } else {\n      out += char\n      index ++\n    }\n  }\n\n  return {\n    source: out,\n    sources\n  }\n}\n\n// A step of the chain below is normally a `[matcher, replacer]` pair handed\n//   to `String.replace`. `DIRECT` marks the ones that are plain string work\n//   instead, and take `(source, pattern)`.\n//\n// Anchoring the two ends is exactly that -- a test of one character and a\n//   concatenation -- and putting it through the regular expression engine\n//   cost a third of this chain for nothing: 167ns where 10ns does the same\n//   job. The two are still steps in the same list, in the same places,\n//   because their position in the order is part of what they mean.\nconst DIRECT = null\n\n// A separator at the beginning or in the middle of a pattern, as opposed to\n//   one at the very end.\nconst REGEX_INNER_SLASH = /\\/(?!$)/\n\n// > If the pattern ends with a slash,\n// > it is removed for the purpose of the following description,\n// > but it would only find a match with a directory.\n// > In other words, foo/ will match a directory foo and paths underneath it,\n// > but will not match a regular file or a symbolic link foo\n// >  (this is consistent with the way how pathspec works in general in Git).\n// '`foo/`' will not match regular file '`foo`' or symbolic link '`foo`'\n// -> ignore-rules will not deal with it, because it costs extra `fs.stat` call\n//      you could use option `mark: true` with `glob`\n\n// '`foo/`' should not continue with the '`..`'\n// The chain that turns one gitignore pattern into a regular expression\n//   source, in order. A step is either\n//\n//   [matcher, replacer]            handed to `String.replace`\n//   [matcher, replacer, required]  the same, but skipped outright unless\n//                                    `required` appears in the string, which\n//                                    the matcher cannot match without\n//   [DIRECT, transform]            plain string work, taking (source, pattern)\n//\n// The `required` character is only ever a shortcut: finding it does not mean\n//   the matcher will match, and not finding it means it cannot. It is there\n//   because scanning for one character costs a fraction of running a matcher\n//   that then finds nothing -- for the wildcard step, whose `[^\\\\]+`\n//   backtracks its way through the whole string before giving up, 11ns\n//   against 400ns.\nconst REPLACERS = [\n\n  // Replace (\\ ) with ' '\n  // Only a space: an escaped tab or other whitespace is already a literal by\n  //   the time it reaches here, and a bare tab must be left as one, not turned\n  //   into a space.\n  // (\\ ) -> ' '\n  // (\\\\ ) -> '\\\\ '\n  // (\\\\\\ ) -> '\\\\ '\n  [\n    // A run of backslashes is taken whole, from its first one, so no match\n    //   ever starts again inside it -- `(\\\\+?) ` did, which made a long run\n    //   quadratic.\n    /(\\\\+)( ?)/g,\n    (_, run, space) => space\n      ? run.slice(0, run.length - run.length % 2) + SPACE\n      : run,\n    ESCAPE + SPACE\n  ],\n\n  // Escape metacharacters\n  // which is written down by users but means special for regular expressions.\n\n  // > There are 12 characters with special meanings:\n  // > - the backslash \\,\n  // > - the caret ^,\n  // > - the dollar sign $,\n  // > - the period or dot .,\n  // > - the vertical bar or pipe symbol |,\n  // > - the question mark ?,\n  // > - the asterisk or star *,\n  // > - the plus sign +,\n  // > - the opening parenthesis (,\n  // > - the closing parenthesis ),\n  // > - and the opening square bracket [,\n  // > - the opening curly brace {,\n  // > These special characters are often called \"metacharacters\".\n  [\n    /[\\\\$.|*+(){^]/g,\n    match => `\\\\${match}`\n  ],\n\n  [\n    // > a question mark (?) matches a single character\n    /(?!\\\\)\\?/g,\n    () => '[^/]',\n    '?'\n  ],\n\n  // leading slash\n  [\n\n    // > A leading slash matches the beginning of the pathname.\n    // > For example, \"/*.c\" matches \"cat-file.c\" but not \"mozilla-sha1/sha1.c\".\n    // A leading slash matches the beginning of the pathname\n    /^\\//,\n    () => '^',\n    SLASH\n  ],\n\n  // replace special metacharacter slash after the leading slash\n  [\n    /\\//g,\n    () => '\\\\/',\n    SLASH\n  ],\n\n  [\n    // > A leading \"**\" followed by a slash means match in all directories.\n    // > For example, \"**/foo\" matches file or directory \"foo\" anywhere,\n    // > the same as pattern \"foo\".\n    // > \"**/foo/bar\" matches file or directory \"bar\" anywhere that is directly\n    // >   under directory \"foo\".\n    // Notice that the '*'s have been replaced as '\\\\*'\n    /^\\^*(?:\\\\\\*\\\\\\*\\\\\\/)+/,\n\n    // '**/foo' <-> 'foo'\n    () => '^(?:.*\\\\/)?',\n    '*'\n  ],\n\n  // starting\n  [\n    // there will be no leading '/'\n    //   (which has been replaced by section \"leading slash\")\n    // If starts with '**', adding a '^' to the regular expression also works\n    DIRECT,\n    (source, pattern) => {\n      // Nothing to anchor to, or already anchored\n      if (!source || source[0] === '^') {\n        return source\n      }\n\n      // If has a slash `/` at the beginning or middle\n      const anchor = !REGEX_INNER_SLASH.test(pattern)\n        // > Prior to 2.22.1\n        // > If the pattern does not contain a slash /,\n        // >   Git treats it as a shell glob pattern\n        // Actually, if there is only a trailing slash,\n        //   git also treats it as a shell glob pattern\n\n        // After 2.22.1 (compatible but clearer)\n        // > If there is a separator at the beginning or middle (or both)\n        // > of the pattern, then the pattern is relative to the directory\n        // > level of the particular .gitignore file itself.\n        // > Otherwise the pattern may also match at any level below\n        // > the .gitignore level.\n        ? '(?:^|\\\\/)'\n\n        // > Otherwise, Git treats the pattern as a shell glob suitable for\n        // >   consumption by fnmatch(3)\n        : '^'\n\n      return anchor + source\n    }\n  ],\n\n  // two globstars\n  [\n    // Use lookahead assertions so that we could match more than one `'/**'`\n    /\\\\\\/\\\\\\*\\\\\\*(?=\\\\\\/|$)/g,\n\n    // Zero, one or several directories\n    // should not use '*', or it will be replaced by the next replacer\n\n    // Check if it is not the last `'/**'`\n    (_, index, str) => index + 6 < str.length\n\n      // case: /**/ at the end of the pattern, i.e. a trailing `'/**/'`\n      // > A trailing `\"/**/\"` (a trailing `\"/**\"` restricted to directories)\n      // >   matches everything inside, but it should not match the current\n      // >   folder itself, so it requires at least one directory segment.\n      // 'a/**/' matches 'a/b/', 'a/x/y/' but not 'a/'\n      ? str.slice(index + 6) === '\\\\/'\n        ? '(?:\\\\/[^\\\\/]+)+'\n\n        // case: /**/\n        // > A slash followed by two consecutive asterisks then a slash matches\n        // >   zero or more directories.\n        // > For example, \"a/**/b\" matches \"a/b\", \"a/x/b\", \"a/x/y/b\" and so on.\n        // '/**/'\n        : '(?:\\\\/[^\\\\/]+)*'\n\n      // case: /**\n      // > A trailing `\"/**\"` matches everything inside.\n\n      // #21: everything inside but it should not include the current folder,\n      //   resolved by `_make`\n      : `\\\\/${TRAILING_DOUBLESTAR}`,\n    '*'\n  ],\n\n  // normal intermediate wildcards\n  [\n    // Never replace escaped '*'\n    // ignore rule '\\*' will match the path '*'\n\n    // 'abc.*/' -> go\n    // 'abc.*'  -> skip this rule,\n    //    coz trailing single wildcard will be handed by [trailing wildcard]\n    /(^|[^\\\\]+)(\\\\\\*)+(?=.+)/g,\n\n    // '*.js' matches '.js'\n    // '*.js' doesn't match 'abc'\n    (_, p1, p2) => {\n      // 1.\n      // > An asterisk \"*\" matches anything except a slash.\n      // 2.\n      // > Other consecutive asterisks are considered regular asterisks\n      // > and will match according to the previous rules.\n      const unescaped = p2.replace(/\\\\\\*/g, '[^\\\\/]*')\n      return p1 + unescaped\n    },\n    '*'\n  ],\n\n  // trailing wildcard, held apart from a literal star\n  [\n    // The step above leaves a trailing `*` alone, so a single `\\*` is all that\n    //   can be left at the end here, and what stands in front of it says which\n    //   kind it is. A wildcard arrives as the escaper wrote it, `\\*` with\n    //   nothing before it; a literal arrives as the user's own escape, which\n    //   the escaper doubled, and then the star's own -- `\\\\` and then `\\*`.\n    //   There is no third case: every backslash still reaching the chain is\n    //   one `\\*`, `\\[` or `\\ ` carries itself, and each is followed by its\n    //   own character, so a longer run can never form. This runs while the\n    //   two are still distinct, before the unescape steps below collapse the\n    //   literal onto the very `\\*` a wildcard leaves behind.\n    /(^|[^\\\\])((?:\\\\\\\\)*)\\\\\\*$/,\n\n    (match, p1, p2) =>\n      p2 === EMPTY\n        // A real wildcard: carry it to `_make` as the marker, so the unescape\n        //   steps and the trailing-wildcard rewrite can never mistake it for a\n        //   literal `\\*` (nor the reverse).\n        ? p1 + TRAILING_WILDCARD\n        // A literal star: leave it exactly as it stands for the unescape steps.\n        : match,\n    '*'\n  ],\n\n  [\n    // unescape, revert step 3 except for back slash\n    // For example, if a user escape a '\\\\*',\n    // after step 3, the result will be '\\\\\\\\\\\\*'\n    /\\\\\\\\\\\\(?=[$.|*+(){^])/g,\n    () => ESCAPE,\n    ESCAPE + ESCAPE\n  ],\n\n  [\n    // '\\\\\\\\' -> '\\\\'\n    /\\\\\\\\/g,\n    () => ESCAPE,\n    ESCAPE + ESCAPE\n  ],\n\n  [\n    // Every real bracket expression -- POSIX classes included -- has already\n    //   been held aside by `extractBrackets`, so the only `[` left in the\n    //   pattern is an escaped, literal one.\n\n    // A backslash could only stand at the end of the range if it quoted the\n    //   `]`, and `\\]` is held aside long before this.\n    /\\\\\\[([^\\]/]*?)($|\\])/g,\n\n    // '\\\\[bar]' -> '\\\\\\\\[bar]'\n    (match, range, close) => `\\\\[${range}${close}`,\n    '['\n  ],\n\n  // ending\n  [\n    // 'js' will not match 'js.'\n    // 'ab' will not match 'abc'\n    DIRECT,\n\n    // WTF!\n    // https://git-scm.com/docs/gitignore\n    // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)\n    // which re-fixes #24, #38\n\n    // > If there is a separator at the end of the pattern then the pattern\n    // > will only match directories, otherwise the pattern can match both\n    // > files and directories.\n\n    // 'js*' will not match 'a.js'\n    // 'js/' will not match 'a.js'\n    // 'js' will match 'a.js' and 'a.js/'\n    source => {\n      const last = source[source.length - 1]\n\n      // The pattern is empty, or ends in a pending marker `_make` owns --\n      //   the trailing wildcard, or a trailing \"/**\". A trailing `*` that is\n      //   not the marker is a literal star, which anchors like any other\n      //   final character.\n      if (!last || last === TRAILING_WILDCARD || last === TRAILING_DOUBLESTAR) {\n        return source\n      }\n\n      return last === SLASH\n        // foo/ will not match 'foo'\n        ? `${source}$`\n        // foo matches 'foo' and 'foo/'\n        : `${source}(?=$|\\\\/$)`\n    }\n  ]\n]\n\nconst REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\\\\/)?\\uE000$/\nconst MODE_IGNORE = 'regex'\nconst MODE_CHECK_IGNORE = 'checkRegex'\nconst UNDERSCORE = '_'\n\nconst replaceTrailingWildcard = (_, p1) => {\n  const prefix = p1\n    // '\\^':\n    // '/*' does not match EMPTY\n    // '/*' does not match everything\n\n    // '\\\\\\/':\n    // 'abc/*' does not match 'abc/'\n    ? `${p1}[^/]+`\n\n    // 'a*' matches 'a'\n    // 'a*' matches 'aa'\n    : '[^/]*'\n\n  return `${prefix}(?=$|\\\\/$)`\n}\n\nconst REGEX_REPLACE_TRAILING_DOUBLESTAR = /\\uE001$/\n\n// 'abc/**' matches everything under 'abc', but not 'abc/' itself (#21)\nconst replaceTrailingDoublestar = () => '.+(?=$|\\\\/$)'\n\nconst WILDCARD = '[^\\\\/]*'\n\n// The fixed piece between the wildcard at `at` and the next wildcard of the\n//   run: the tokens that separate them, joined as they appear in the source.\n//   A run never holds two wildcards in a row, so there is always at least one\n//   token.\nconst separatorAfter = (run, at) => {\n  let separator = EMPTY\n\n  for (let index = at + 1; index < run.length && !run[index].wildcard; index ++) {\n    separator += run[index].single\n  }\n\n  return separator\n}\n\n// Where a run of non-slash wildcards is split by fixed pieces --\n//   `[^/]*ab[^/]*cd...` -- the engine has many equivalent ways to lay the\n//   input across the wildcards, and on input that does not match it works\n//   through all of them, so the time grows with the number of wildcards\n//   rather than the length of the path. Every wildcard but the last in such a\n//   run can be pinned to stop where the piece after it begins, which leaves\n//   one way to lay out the input and no rewinding, without changing which\n//   paths match: the fixed pieces still bound the count, and the last\n//   wildcard still absorbs the rest.\n//\n// A wildcard is pinned to the whole piece, never to the piece's first\n//   character. The pin leaves no way back, so a wildcard that stopped at that\n//   first character would hand over wherever the character happens to turn\n//   up, including the places the rest of the piece cannot follow -- which is\n//   how `f*o/*/*` came to miss `foo/b/c`, the first `o` of `foo` not being\n//   the one the `o/` after it needs. Every token of a piece matches exactly\n//   one character, so the first place the whole piece fits is the leftmost\n//   place it can sit, and whatever is left over goes to the wildcards that\n//   follow.\n//\n// The source is read one token at a time -- a wildcard, a single-character\n//   piece (a literal, an escape, a class), or a parenthesised group or anchor\n//   that ends the run -- so only a genuine wildcard is touched.\nconst pinWildcards = source => {\n  if (source.indexOf(WILDCARD) < 0) {\n    return source\n  }\n\n  const tokens = []\n  const {length} = source\n  let index = 0\n\n  while (index < length) {\n    const char = source[index]\n\n    if (source.startsWith(WILDCARD, index)) {\n      tokens.push({wildcard: true})\n      index += WILDCARD.length\n    } else if (char === '[') {\n      let end = index + 1\n\n      if (source[end] === '^') {\n        end ++\n      }\n\n      if (source[end] === ']') {\n        end ++\n      }\n\n      while (end < length && source[end] !== ']') {\n        end += source[end] === ESCAPE\n          ? 2\n          : 1\n      }\n\n      end ++\n      tokens.push({single: source.slice(index, end)})\n      index = end\n    } else if (char === ESCAPE) {\n      tokens.push({single: source.slice(index, index + 2)})\n      index += 2\n    } else if (char === '(') {\n      let depth = 0\n      let end = index\n\n      do {\n        if (source[end] === ESCAPE) {\n          end ++\n        } else if (source[end] === '(') {\n          depth ++\n        } else if (source[end] === ')') {\n          depth --\n        }\n\n        end ++\n      } while (end < length && depth > 0)\n\n      if ('*+?'.indexOf(source[end]) >= 0) {\n        end ++\n      }\n\n      tokens.push({boundary: source.slice(index, end)})\n      index = end\n    } else if (char === '^' || char === '$') {\n      tokens.push({boundary: char})\n      index ++\n    } else {\n      tokens.push({single: char})\n      index ++\n    }\n  }\n\n  let out = EMPTY\n  let run = []\n\n  const flush = () => {\n    let lastWildcard\n\n    run.forEach((token, at) => {\n      if (token.wildcard) {\n        lastWildcard = at\n      }\n    })\n\n    run.forEach((token, at) => {\n      if (!token.wildcard) {\n        out += token.single\n        return\n      }\n\n      // Every wildcard but the last is pinned to the whole piece that\n      //   follows it, for the reason set out above this function. The last\n      //   one stays as it is and takes up the rest.\n      out += at === lastWildcard\n        ? WILDCARD\n        : `(?:(?!${separatorAfter(run, at)})[^\\\\/])*`\n    })\n\n    run = []\n  }\n\n  tokens.forEach(token => {\n    if (token.boundary === undefined) {\n      run.push(token)\n      return\n    }\n\n    flush()\n    out += token.boundary\n  })\n\n  flush()\n\n  return out\n}\n\n// @param {pattern}\nconst makeRegexPrefix = pattern => {\n  const {source, sources} = extractBrackets(pattern)\n\n  const replaced = REPLACERS.reduce(\n    // A pass whose matcher finds nothing hands back the very string it was\n    //   given, so asking first costs a search and saves a rewrite. Ten of the\n    //   fifteen passes never fire for a typical .gitignore line, and between\n    //   them they were 45% of this chain.\n    (prev, [matcher, replacer, required]) => {\n      if (matcher === DIRECT) {\n        return replacer(prev, pattern)\n      }\n\n      if (required !== UNDEFINED && prev.indexOf(required) < 0) {\n        return prev\n      }\n\n      // A pass whose matcher finds nothing hands back the very string it was\n      //   given, so asking first costs a search and saves a rewrite.\n      return matcher.test(prev)\n        ? prev.replace(matcher, replacer.bind(pattern))\n        : prev\n    },\n    source\n  )\n\n  // Most patterns hold no bracket expression at all, and then there is\n  //   nothing to put back.\n  return sources.length\n    ? replaced.replace(\n      REGEX_RESTORE_PLACEHOLDER,\n      (match, index) => sources[index]\n    )\n    : replaced\n}\n\n// `checkRegex` tests a path with a trailing slash, 'abc/', the way\n//   `git check-ignore` matches that literal string once the directory itself\n//   is known not to be excluded (see `checkIgnore`): a trailing '/' of the\n//   pattern is dropped, a basename pattern sees an empty basename, and only a\n//   pattern whose last segment is a pending wildcard can match what is left\n//   after the final slash -- 'abc/*' and 'abc/**' match 'abc/', and 'abc/**'\n//   also matches 'abc/d/' (#77, #169).\nconst checkSourceOf = (body, prefix) => {\n  if (body[body.length - 1] === SLASH) {\n    prefix = makeRegexPrefix(body.slice(0, - 1))\n  }\n\n  const head = prefix.slice(0, - 1)\n  const last = prefix[prefix.length - 1]\n\n  return last === TRAILING_WILDCARD\n    ? `${head}$`\n    : last === TRAILING_DOUBLESTAR\n      ? `${head}.*$`\n      : NEVER_MATCH\n}\n\n// A trailing slash does not stop a pattern being basename-only: it restricts\n//   the match to a directory, it does not let the pattern reach across one.\n//   Everything else a pattern can hold -- a wildcard, a character class, an\n//   escape -- stays inside a single path segment too, so a pattern with no\n//   separator in it can only ever describe the last one.\nconst matchesBasename = body => {\n  const index = body.indexOf(SLASH)\n\n  return index < 0 || index === body.length - 1\n}\n\n// The last segment of a path, keeping a trailing slash, because a pattern that\n//   ends in one matches only a directory.\n// 'a/b/c.js' -> 'c.js';  'a/b/' -> 'b/';  'c.js' -> 'c.js' (no copy made)\nconst basenameOf = path => {\n  const end = path.length - 1\n\n  const index = path.lastIndexOf(\n    SLASH,\n    path[end] === SLASH\n      ? end - 1\n      : end\n  )\n\n  return index < 0\n    ? path\n    : path.slice(index + 1)\n}\n\n// The parent directory of a path, with its trailing separator, or EMPTY when\n//   the path has none.\n// 'a/b/c' -> 'a/b/';  'a/b/' -> 'a/';  'a' -> EMPTY;  'a/' -> EMPTY\n//\n// A path holding an empty segment has to be taken apart, because its\n//   ancestors are not prefixes of it: the parent of 'a//b' is 'a/', not\n//   'a//', and the parent of '/a/' is nothing at all. Both shapes reach here\n//   -- 'a//b' is accepted outright, and `checkIgnore` does not put the path\n//   it is given through the relative-path check.\n//\n// Every other path is a prefix of itself, and cutting one costs a fraction of\n//   splitting it into an array and joining that back at every level: 73ns\n//   against 207ns.\nconst parentOf = path => {\n  if (\n    path.charCodeAt(0) === SLASH_CODE\n    || path.indexOf(DOUBLE_SLASH) >= 0\n  ) {\n    const slices = path.split(SLASH).filter(Boolean)\n\n    slices.pop()\n\n    return slices.length\n      ? slices.join(SLASH) + SLASH\n      : EMPTY\n  }\n\n  const end = path.length - 1\n\n  // Look back from before a trailing separator, since that one belongs to the\n  //   path itself.\n  //\n  // A negative place to start would be a trap here: `lastIndexOf` clamps one\n  //   to 0 and searches there rather than reporting no match, so '/' would\n  //   come back as its own parent and the walk would never end. It cannot\n  //   happen -- that is the only path short enough to produce one, and the\n  //   test above has already sent it the other way.\n  const cut = path.lastIndexOf(\n    SLASH,\n    path.charCodeAt(end) === SLASH_CODE\n      ? end - 1\n      : end\n  )\n\n  return cut < 0\n    ? EMPTY\n    : path.slice(0, cut + 1)\n}\n\nconst isString = subject => typeof subject === 'string'\n\n// Blank lines and comments are told by `createRule`, once the pattern is\n//   normalized.\nconst checkPattern = pattern => pattern\n  && isString(pattern)\n  && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern)\n\nconst splitPattern = pattern => pattern\n.split(REGEX_SPLITALL_CRLF)\n.filter(Boolean)\n\nclass IgnoreRule {\n  constructor (\n    pattern,\n    mark,\n    body,\n    ignoreCase,\n    negative,\n    prefix\n  ) {\n    this.pattern = pattern\n    this.mark = mark\n    this.negative = negative\n\n    define(this, 'body', body)\n    define(this, 'ignoreCase', ignoreCase)\n    define(this, 'regexPrefix', prefix)\n  }\n\n  // Worked out on first use and kept behind an own property, the way `regex`\n  //   caches itself in `_regex`. Deciding it in the constructor instead would\n  //   add a fourth `defineProperty` to every rule ever built, which cost 4% of\n  //   every compile -- including the compiles of rules that are never matched\n  //   against anything.\n  get _basenameOnly () {\n    return define(this, '_basenameOnly', matchesBasename(this.body))\n  }\n\n  get regex () {\n    const key = UNDERSCORE + MODE_IGNORE\n\n    if (this[key]) {\n      return this[key]\n    }\n\n    return this._make(MODE_IGNORE, key)\n  }\n\n  get checkRegex () {\n    const key = UNDERSCORE + MODE_CHECK_IGNORE\n\n    if (this[key]) {\n      return this[key]\n    }\n\n    return this._make(MODE_CHECK_IGNORE, key)\n  }\n\n  _make (mode, key) {\n    const str = pinWildcards(\n      mode === MODE_IGNORE\n        ? this.regexPrefix\n        .replace(REGEX_REPLACE_TRAILING_WILDCARD, replaceTrailingWildcard)\n        .replace(REGEX_REPLACE_TRAILING_DOUBLESTAR, replaceTrailingDoublestar)\n        : checkSourceOf(this.body, this.regexPrefix)\n    )\n\n    const regex = this.ignoreCase\n      ? new RegExp(str, 'i')\n      : new RegExp(str)\n\n    return define(this, key, regex)\n  }\n}\n\nconst isLineEnd = char => char === '\\r' || char === '\\n'\n\n// Drop a line terminator, which can remain when patterns are passed as an\n//   array, and then the trailing spaces. Git trims spaces only, and a space\n//   escaped by an odd run of backslashes stays, unescaped, as the last one.\n// Scanned from the end: a regular expression can only try each start in\n//   turn, which is quadratic over a long run of spaces or backslashes.\n// 'a  ' -> 'a';  'a\\ ' -> 'a ';  'a\\\\ ' -> 'a\\\\';  'a\\t' -> 'a\\t'\nconst trimEnd = body => {\n  let end = body.length\n\n  while (end && isLineEnd(body[end - 1])) {\n    end --\n  }\n\n  const lineEnd = end\n\n  while (end && body[end - 1] === SPACE) {\n    end --\n  }\n\n  if (end === lineEnd) {\n    return body.slice(0, end)\n  }\n\n  let backslashes = 0\n\n  while (backslashes < end && body[end - backslashes - 1] === ESCAPE) {\n    backslashes ++\n  }\n\n  return backslashes % 2\n    ? body.slice(0, end - 1) + SPACE\n    : body.slice(0, end)\n}\n\nconst createRule = ({\n  pattern,\n  mark\n}, ignoreCase) => {\n  // Git drops a BOM before it reads the first line, so before anything else.\n  let body = pattern[0] === BOM\n    ? pattern.slice(1)\n    : pattern\n\n  // > A line starting with # serves as a comment.\n  if (body[0] === '#') {\n    return\n  }\n\n  let negative = false\n\n  // > An optional prefix \"!\" which negates the pattern;\n  if (body[0] === '!') {\n    negative = true\n    body = body.slice(1)\n  }\n\n  // Normalize the body before checking which slashes anchor the pattern.\n  //   Otherwise `bar/ ` is mistaken for a pattern containing an inner slash.\n  //   Only a body ending in a space or a line terminator has anything to trim.\n  const last = body[body.length - 1]\n\n  if (last === SPACE || last === '\\r' || last === '\\n') {\n    body = trimEnd(body)\n  }\n\n  // > A blank line matches no files, so it can serve as a separator for\n  // >   readability.\n  // Nor does a lone \"!\", or anything else left empty here: an empty pattern\n  //   would compile to a regex matching every path.\n  if (!body) {\n    return\n  }\n\n  body = body\n  // > Put a backslash (\"\\\") in front of the first \"!\" for patterns that\n  // >   begin with a literal \"!\", for example, `\"\\!important!.txt\"`.\n  .replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, '!')\n  // > Put a backslash (\"\\\") in front of the first hash for patterns that\n  // >   begin with a hash.\n  .replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, '#')\n\n  const regexPrefix = makeRegexPrefix(body)\n\n  return new IgnoreRule(\n    pattern,\n    mark,\n    body,\n    ignoreCase,\n    negative,\n    regexPrefix\n  )\n}\n\nclass RuleManager {\n  constructor (ignoreCase) {\n    this._ignoreCase = ignoreCase\n    this._rules = []\n\n    // How many of the rules git would tag `EXC_FLAG_NODIR`.\n    //\n    // The scan uses it to decide, once for the whole set, whether handing\n    //   those rules the basename is worth what it costs the others. The\n    //   shortcut saves a full-path scan on every rule it applies to and costs\n    //   a check on every rule it does not, so a set where almost nothing is\n    //   basename-only comes out behind -- a 955 pattern set with 44 of them\n    //   measured 19% slower with the shortcut always on.\n    //\n    // Deciding this by measurement rather than by meaning is safe: a\n    //   basename-only pattern gives the very same answer against the whole\n    //   path, it just takes longer to say so. The choice can only change how\n    //   fast the scan runs, never what it returns.\n    this._basenameCount = 0\n  }\n\n  _add (pattern) {\n    // #32\n    if (pattern && pattern[KEY_IGNORE]) {\n      this._rules = this._rules.concat(pattern._rules._rules)\n      this._basenameCount += pattern._rules._basenameCount\n      this._added = true\n      return\n    }\n\n    if (isString(pattern)) {\n      pattern = {\n        pattern\n      }\n    }\n\n    const rule = checkPattern(pattern.pattern)\n      && createRule(pattern, this._ignoreCase)\n\n    if (rule) {\n      this._added = true\n      this._rules.push(rule)\n\n      // Deliberately not `rule._basenameOnly`: reading that would materialise\n      //   the rule's own copy, and the whole point of leaving it lazy is that\n      //   a rule which is compiled and never matched never pays for it.\n      if (matchesBasename(rule.body)) {\n        this._basenameCount ++\n      }\n    }\n  }\n\n  // @param {Array<string> | string | Ignore} pattern\n  add (pattern) {\n    this._added = false\n\n    makeArray(\n      isString(pattern)\n        ? splitPattern(pattern)\n        : pattern\n    ).forEach(this._add, this)\n\n    if (this._added) {\n      this._literalRules = UNDEFINED\n    }\n\n    return this._added\n  }\n\n  // Match the literal 'abc/' for `checkIgnore`, last rule wins. Only a rule\n  //   ending in a wildcard can match it (see `checkSourceOf`), so the rest\n  //   are left out once, rather than tested or compiled for every path.\n  testLiteral (path) {\n    const rules = this._literalRules || (\n      this._literalRules = this._rules.filter(\n        ({body}) => body[body.length - (\n          body[body.length - 1] === SLASH ? 2 : 1\n        )] === '*'\n      )\n    )\n\n    let ignored = false\n    let unignored = false\n    let matchedRule\n\n    for (let index = rules.length - 1; index >= 0; index --) {\n      const rule = rules[index]\n\n      if (rule.checkRegex.test(path)) {\n        ignored = !rule.negative\n        unignored = rule.negative\n        matchedRule = rule.negative\n          ? UNDEFINED\n          : rule\n        break\n      }\n    }\n\n    const ret = {\n      ignored,\n      unignored\n    }\n\n    if (matchedRule) {\n      ret.rule = matchedRule\n    }\n\n    return ret\n  }\n\n  // Test one single path without recursively checking parent directories\n  //\n  // - checkUnignored `boolean` whether should check if the path is unignored,\n  //   setting `checkUnignored` to `false` could reduce additional\n  //   path matching.\n  // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`\n\n  // @returns {TestResult} true if a file is ignored\n  test (path, checkUnignored, mode) {\n    let ignored = false\n    let unignored = false\n    let matchedRule\n\n    // Most of a .gitignore is patterns with no slash in them, and running\n    //   those against the whole path makes the regular expression engine walk\n    //   every directory name on the way to the only segment that could match.\n    //   Handing them the basename instead is what git does, and it is where\n    //   the time in a directory walk goes: the rule scan was two thirds of it.\n    const rules = this._rules\n    const {length} = rules\n\n    const shortcut = this._basenameCount * 2 >= length\n\n    const basename = shortcut\n      ? basenameOf(path)\n      : path\n\n    // A plain loop rather than `forEach`, so that `path`, `basename` and\n    //   `shortcut` are locals. As a callback they became closure variables,\n    //   and reaching for one of those once per rule cost 10% of a scan over a\n    //   large rule set -- more than the shortcut they were there to serve.\n    for (let index = 0; index < length; index ++) {\n      const rule = rules[index]\n      const {negative} = rule\n\n      //          |           ignored : unignored\n      // -------- | ---------------------------------------\n      // negative |   0:0   |   0:1   |   1:0   |   1:1\n      // -------- | ------- | ------- | ------- | --------\n      //     0    |  TEST   |  TEST   |  SKIP   |    X\n      //     1    |  TESTIF |  SKIP   |  TEST   |    X\n\n      // - SKIP: always skip\n      // - TEST: always test\n      // - TESTIF: only test if checkUnignored\n      // - X: that never happen\n      const skip = unignored === negative && ignored !== unignored\n        || negative && !ignored && !unignored && !checkUnignored\n\n      if (!skip && rule[mode].test(\n        shortcut && rule._basenameOnly\n          ? basename\n          : path\n      )) {\n        ignored = !negative\n        unignored = negative\n\n        matchedRule = negative\n          ? UNDEFINED\n          : rule\n      }\n    }\n\n    const ret = {\n      ignored,\n      unignored\n    }\n\n    if (matchedRule) {\n      ret.rule = matchedRule\n    }\n\n    return ret\n  }\n}\n\nconst throwError = (message, Ctor) => {\n  throw new Ctor(message)\n}\n\nconst checkPath = (path, originalPath, doThrow) => {\n  if (!isString(path)) {\n    return doThrow(\n      `path must be a string, but got \\`${originalPath}\\``,\n      TypeError\n    )\n  }\n\n  // We don't know if we should ignore EMPTY, so throw\n  if (!path) {\n    return doThrow(`path must not be empty`, TypeError)\n  }\n\n  // Check if it is a relative path\n  if (checkPath.isNotRelative(path)) {\n    const r = '`path.relative()`d'\n    return doThrow(\n      `path should be a ${r} string, but got \"${originalPath}\"`,\n      RangeError\n    )\n  }\n\n  return true\n}\n\n// > pathname should be a `path.relative()`d one\n//\n// The same thing `REGEX_TEST_INVALID_PATH` says, spelled out: a path is not\n//   relative if it begins with a separator, or with `./` or `../`, or is\n//   nothing but `.` or `..`. Every match is decided by the first three\n//   characters, and this runs on every path handed to the library -- where it\n//   was 55% of a cached lookup, more than the cache lookup itself.\nconst isNotRelative = path => {\n  const first = path.charCodeAt(0)\n\n  if (first === SLASH_CODE) {\n    return true\n  }\n\n  if (first !== DOT_CODE) {\n    return false\n  }\n\n  // '.'\n  if (path.length === 1) {\n    return true\n  }\n\n  const second = path.charCodeAt(1)\n\n  // './'\n  if (second === SLASH_CODE) {\n    return true\n  }\n\n  if (second !== DOT_CODE) {\n    return false\n  }\n\n  // '..' or '../'\n  return path.length === 2 || path.charCodeAt(2) === SLASH_CODE\n}\n\ncheckPath.isNotRelative = isNotRelative\n\n// On windows, the following function will be replaced\n/* istanbul ignore next */\ncheckPath.convert = p => p\n\n\nclass Ignore {\n  constructor ({\n    ignorecase = true,\n    ignoreCase = ignorecase,\n    allowRelativePaths = false\n  } = {}) {\n    define(this, KEY_IGNORE, true)\n\n    this._rules = new RuleManager(ignoreCase)\n    this._strictPathCheck = !allowRelativePaths\n    this._initCache()\n  }\n\n  _initCache () {\n    // A cache for the result of `.ignores()`\n    this._ignoreCache = Object.create(null)\n\n    // A cache for the result of `.test()`\n    this._testCache = Object.create(null)\n  }\n\n  add (pattern) {\n    if (this._rules.add(pattern)) {\n      // Some rules have just added to the ignore,\n      //   making the behavior changed,\n      //   so we need to re-initialize the result cache\n      this._initCache()\n    }\n\n    return this\n  }\n\n  // legacy\n  addPattern (pattern) {\n    return this.add(pattern)\n  }\n\n  // @returns {TestResult}\n  _test (originalPath, cache, checkUnignored) {\n    const path = originalPath\n      // Supports nullable path\n      && checkPath.convert(originalPath)\n\n    checkPath(\n      path,\n      originalPath,\n      this._strictPathCheck\n        ? throwError\n        : RETURN_FALSE\n    )\n\n    return this._t(path, cache, checkUnignored)\n  }\n\n  checkIgnore (path) {\n    // If the path doest not end with a slash, `.ignores()` is much equivalent\n    //   to `git check-ignore`\n    if (path.charCodeAt(path.length - 1) !== SLASH_CODE) {\n      return this.test(path)\n    }\n\n    // Like `git check-ignore`: a directory excluded by itself or by an\n    //   ancestor settles it, and only then is the literal 'abc/' matched\n    //   against the rules (see `checkSourceOf`).\n    const dir = this._t(path, this._testCache, true)\n\n    if (dir.ignored) {\n      return dir\n    }\n\n    const literal = this._rules.testLiteral(path)\n\n    return literal.ignored || literal.unignored\n      ? literal\n      : dir\n  }\n\n  _t (\n    // The path to be tested\n    path,\n\n    // The cache for the result of a certain checking\n    cache,\n\n    // Whether should check if the path is unignored\n    checkUnignored\n  ) {\n    if (path in cache) {\n      return cache[path]\n    }\n\n    const parentPath = parentOf(path)\n\n    // If the path contains a parent directory, check the parent first\n    const parent = parentPath\n      ? this._t(parentPath, cache, checkUnignored)\n      : UNDEFINED\n\n    return cache[path] = parent && parent.ignored\n      // > It is not possible to re-include a file if a parent directory of\n      // >   that file is excluded.\n      ? parent\n      : this._rules.test(path, checkUnignored, MODE_IGNORE)\n  }\n\n  ignores (path) {\n    return this._test(path, this._ignoreCache, false).ignored\n  }\n\n  createFilter () {\n    return path => !this.ignores(path)\n  }\n\n  filter (paths) {\n    return makeArray(paths).filter(this.createFilter())\n  }\n\n  // @returns {TestResult}\n  test (path) {\n    return this._test(path, this._testCache, true)\n  }\n}\n\nconst factory = options => new Ignore(options)\n\nconst isPathValid = path =>\n  checkPath(path && checkPath.convert(path), path, RETURN_FALSE)\n\n/* istanbul ignore next */\nconst setupWindows = () => {\n  /* eslint no-control-regex: \"off\" */\n  const makePosix = str => /^\\\\\\\\\\?\\\\/.test(str)\n  || /[\"<>|\\u0000-\\u001F]+/u.test(str)\n    ? str\n    : str.replace(/\\\\/g, '/')\n\n  checkPath.convert = makePosix\n\n  // 'C:\\\\foo'     <- 'C:\\\\foo' has been converted to 'C:/'\n  // 'd:\\\\foo'\n  const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\\//i\n  checkPath.isNotRelative = path =>\n    REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path)\n    || isNotRelative(path)\n}\n\n\n// Windows\n// --------------------------------------------------------------\n/* istanbul ignore next */\nif (\n  // Detect `process` so that it can run in browsers.\n  typeof process !== 'undefined'\n  && process.platform === 'win32'\n) {\n  setupWindows()\n}\n\n// COMMONJS_EXPORTS ////////////////////////////////////////////////////////////\n\nmodule.exports = factory\n\n// Although it is an anti-pattern,\n//   it is still widely misused by a lot of libraries in github\n// Ref: https://github.com/search?q=ignore.default%28%29&type=code\nfactory.default = factory\n\nmodule.exports.isPathValid = isPathValid\n\n// For testing purposes\ndefine(module.exports, Symbol.for('setupWindows'), setupWindows)\n\n\n//# sourceURL=file://cloudcmd//Users/coderaiser/cloudcmd/node_modules/putout/node_modules/ignore/index.js\n}");
+eval("{/* provided dependency */ var process = __webpack_require__(/*! process/browser */ \"./node_modules/process/browser.js\");\n// A simple implementation of make-array\nfunction makeArray (subject) {\n  return Array.isArray(subject)\n    ? subject\n    : [subject]\n}\n\nconst UNDEFINED = undefined\nconst EMPTY = ''\nconst SPACE = ' '\nconst ESCAPE = '\\\\'\n\n// The characters that carry a meaning of their own inside a regular\n//   expression, so a literal one has to be escaped before it is emitted.\nconst REGEX_LITERAL_SPECIAL = /[.*+?()[\\]{}^$|\\\\/]/\nconst BOM = '\\uFEFF'\nconst REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\\\]|^)\\\\$/\n// A run of two or more asterisks is a globstar (#175)\nconst REGEX_ANCHORED_GLOBSTAR = /^\\/\\*{2,}$/\nconst REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\\\!/\nconst REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\\\#/\nconst REGEX_SPLITALL_CRLF = /\\r?\\n/g\n\n// Invalid:\n// - /foo,\n// - ./foo,\n// - ../foo,\n// - .\n// - ..\n// Valid:\n// - .foo\nconst DOUBLE_SLASH = '//'\nconst SLASH_CODE = 47\nconst DOT_CODE = 46\n\n\nconst SLASH = '/'\n\n// Do not use ternary expression here, since \"istanbul ignore next\" is buggy\nlet TMP_KEY_IGNORE = 'node-ignore'\n/* istanbul ignore else */\nif (typeof Symbol !== 'undefined') {\n  TMP_KEY_IGNORE = Symbol.for('node-ignore')\n}\nconst KEY_IGNORE = TMP_KEY_IGNORE\n\nconst define = (object, key, value) => {\n  Object.defineProperty(object, key, {value})\n  return value\n}\n\nconst RETURN_FALSE = () => false\n\n// > The range notation, e.g. [a-zA-Z],\n// > can be used to match one of the characters in a range.\n//\n// gitignore(5) defers to fnmatch(3) for this, and git implements it in\n//   `wildmatch.c`.  A bracket expression has a sub-grammar of its own, which\n//   is neither the surrounding pattern grammar nor the JavaScript one:\n//\n//   - a `]` right after `[` or `[!` is a literal member, not the terminator\n//   - `[:alpha:]` names one of twelve POSIX classes\n//   - `\\` escapes the next member, `]` included\n//   - `*`, `?` and `.` are plain literal members\n//   - an unterminated expression makes the whole pattern match nothing\n//\n// which means the expression can not be located -- let alone translated -- by\n//   a regular expression.  It is scanned out of the pattern before the\n//   replacers below run, and put back once they are done, so that neither the\n//   metacharacter escaper nor the `?` / `*` replacers ever see its body.\n\n// git classifies with its own ASCII-only ctype macros (`wildmatch.c`), never\n//   with the C library ones, so these must not be mapped onto `\\d` / `\\w` /\n//   `\\s`, which are wider.  `/` is left out of every expansion, because a\n//   bracket expression never matches a path separator.\nconst POSIX_CLASSES = {\n  alnum: '0-9A-Za-z',\n  alpha: 'A-Za-z',\n  blank: ' \\\\t',\n  cntrl: '\\\\x00-\\\\x1f\\\\x7f',\n  digit: '0-9',\n  graph: '!-.0-~',\n  lower: 'a-z',\n  print: ' -.0-~',\n  punct: '!-.:-@\\\\[-`{-~',\n  // git's `sane-ctype.h` classifies \\v and \\f as control, not space,\n  //   unlike C's `isspace`\n  space: ' \\\\t\\\\n\\\\r',\n  upper: 'A-Z',\n  xdigit: '0-9A-Fa-f'\n}\n\nconst CLASS_MEMBERS_TO_ESCAPE = '\\\\]^-['\n\nconst escapeMember = char => CLASS_MEMBERS_TO_ESCAPE.indexOf(char) < 0\n  ? char\n  : ESCAPE + char\n\n// > if (matched == negated || ((flags & WM_PATHNAME) && text_ch == '/'))\n// >   return WM_ABORT_TO_STARSTAR;                     (git, `wildmatch.c`)\n// A bracket expression never matches a path separator, whatever its members\n//   say, so a negated class gets `/` as one more excluded character, while a\n//   plain one -- where a literal member or a range could still let `/` in --\n//   is guarded with a lookahead, `/` being impossible to subtract from a\n//   JavaScript character class.\nconst NON_SLASH = '(?!\\\\/)'\n\nconst classSource = (negated, body) => {\n  if (negated) {\n    return `[^\\\\/${body}]`\n  }\n\n  const source = `[${body}]`\n\n  return new RegExp(source).test('/')\n    ? NON_SLASH + source\n    : source\n}\n\n// Scan the bracket expression that starts at `pattern[start] === '['`,\n//   mirroring the member loop of git's `wildmatch.c`.\n// @returns {{end: number, source: string} | null} `null` if the expression is\n//   never terminated, which makes the whole pattern match nothing.\nconst scanBracket = (pattern, start) => {\n  const {length} = pattern\n  let index = start + 1\n  let negated = EMPTY\n\n  const lead = pattern[index]\n  if (lead === '!' || lead === '^') {\n    negated = '^'\n    index ++\n  }\n\n  let body = EMPTY\n\n  // The member a `-` could start a range from, or EMPTY when the previous\n  //   member can not open one (start of the body, or a range / POSIX class\n  //   that has just closed)\n  let prev = EMPTY\n\n  // git scans the members with a do-while, so the first one is consumed\n  //   unconditionally.  That is the whole reason a leading `]` is a member\n  //   and not the terminator.\n  for (;;) {\n    const char = pattern[index]\n\n    if (char === UNDEFINED) {\n      return null\n    }\n\n    if (char === ESCAPE) {\n      const escaped = pattern[index + 1]\n      if (escaped === UNDEFINED) {\n        return null\n      }\n      body += escapeMember(escaped)\n      prev = escaped\n      index ++\n    } else if (\n      char === '-'\n      && prev\n      && index + 1 < length\n      && pattern[index + 1] !== ']'\n    ) {\n      index ++\n      let to = pattern[index]\n      if (to === ESCAPE) {\n        // A pattern can not end on a lone backslash -- `checkPattern` has\n        //   already thrown it away -- so there is an upper bound to read.\n        to = pattern[index += 1]\n      }\n      // An out-of-order range matches nothing in git but is a syntax error in\n      //   JavaScript, so it is dropped.  Its lower bound stays: git tests it\n      //   as a plain member before it ever looks at the `-`, so `[c-a]` does\n      //   match `c`.\n      if (prev <= to) {\n        body += `-${escapeMember(to)}`\n      }\n      prev = EMPTY\n    } else if (char === '[' && pattern[index + 1] === ':') {\n      const nameStart = index + 2\n      let end = nameStart\n      while (end < length && pattern[end] !== ']') {\n        end ++\n      }\n\n      if (end === length) {\n        return null\n      }\n\n      if (end > nameStart && pattern[end - 1] === ':') {\n        const name = pattern.slice(nameStart, end - 1)\n\n        // An unknown class name makes the whole pattern match nothing\n        if (!Object.prototype.hasOwnProperty.call(POSIX_CLASSES, name)) {\n          return null\n        }\n\n        body += POSIX_CLASSES[name]\n        prev = EMPTY\n        index = end\n      } else {\n        // No `:]` to close it, so the `[` is a plain member and scanning\n        //   resumes right after it.\n        body += escapeMember('[')\n        prev = '['\n        index = nameStart - 2\n      }\n    } else {\n      body += escapeMember(char)\n      prev = char\n    }\n\n    index ++\n\n    if (pattern[index] === ']') {\n      return {\n        end: index,\n        source: classSource(negated, body)\n      }\n    }\n  }\n}\n\n// An empty JavaScript class can never match, which is how a pattern that git\n//   gives up on (`WM_ABORT_ALL`) is expressed here.\nconst NEVER_MATCH = '[]'\n\n// A NUL can appear in neither a `.gitignore` line nor a path, which makes it\n//   the one safe placeholder character.  A literal one in the pattern is\n//   held aside all the same, so a collision is impossible by construction.\nconst PLACEHOLDER = '\\u0000'\nconst REGEX_RESTORE_PLACEHOLDER = new RegExp(\n  `${PLACEHOLDER}(\\\\d+)${PLACEHOLDER}`, 'g'\n)\n\n// The one wildcard the chain does not expand for itself is a trailing `*`. How\n//   it expands depends on the mode (`regex` vs `checkRegex`), so `_make` is\n//   left to do it, and until then the pending wildcard travels as this marker.\n//   That is what keeps it apart from a user-escaped literal `\\*`: the unescape\n//   steps collapse the escaped one to the exact `\\*` a wildcard would leave\n//   behind, so by the time `_make` runs the two are otherwise the same string\n//   and a literal star gets wrongly rewritten into a wildcard. The marker is a\n//   private-use character, and `extractBrackets` keeps one that came out of the\n//   pattern apart from it, so the only marker `_make` ever turns back into a\n//   real wildcard is the one this chain put there itself.\nconst TRAILING_WILDCARD = '\\uE000'\n\n// A trailing \"/**\" is deferred the same way, because `checkRegex` has to tell\n//   it apart from a trailing \"/*\" (see `checkSourceOf`). For `.ignores()` it\n//   still never matches the folder itself (#21).\nconst TRAILING_DOUBLESTAR = '\\uE001'\n\n// The three characters above mean something to the chain that builds the\n//   source rather than to the path, so one that came out of the pattern is\n//   held aside like a bracket expression instead of going straight out. Being\n//   held is what makes it safe: the restore runs after the step that anchors\n//   the source, so the character comes back in the middle of the source and\n//   not at its end, which is the one place `_make` and `checkSourceOf` look\n//   for a marker. Without it a pattern's own character lands where a pending\n//   marker sits, and `_make` turns it into a real trailing wildcard.\n//\n// It is held as a one-member class rather than bare, in both of the branches\n//   a reserved character can reach, so that the property can be\n//   read off this function alone -- a reserved character never goes out on\n//   its own -- rather than depending on where in the chain the restore\n//   happens to run. In the expression built here `[x]` matches exactly what\n//   `x` matches, none of the three being special to a regular expression or\n//   inside a class, so no test can tell the two apart: the class is insurance,\n//   and the paragraph above is the reason it is not needed.\nconst isReserved = char =>\n  char === PLACEHOLDER\n  || char === TRAILING_WILDCARD\n  || char === TRAILING_DOUBLESTAR\n\n// Replace every bracket expression with a placeholder the replacers below\n//   leave alone, and translate it separately.\nconst extractBrackets = pattern => {\n  const sources = []\n  const hold = source =>\n    `${PLACEHOLDER}${sources.push(source) - 1}${PLACEHOLDER}`\n\n  const {length} = pattern\n  let out = EMPTY\n  let index = 0\n\n  while (index < length) {\n    const char = pattern[index]\n\n    if (char === ESCAPE) {\n      // > Put a backslash (\"\\\") in front of ... a character to make it literal.\n      //                                            (gitignore(5) -> fnmatch(3))\n      // A backslash quotes the next character, whatever it is, so `\\d` is a\n      //   literal `d`, not the regex digit class, and `\\?` is a literal `?`,\n      //   not a wildcard. Held aside as its literal here, the escape never\n      //   reaches the replacers below, which would otherwise let `\\d`, `\\b`,\n      //   `\\1`, `\\/` keep their regular-expression meaning, and would turn a\n      //   `\\?` into `[^\\/]`.\n      //\n      // Three escapes are still left for the chain: `\\*` (a literal star,\n      //   told apart from a wildcard by `TRAILING_WILDCARD` and the wildcard\n      //   replacers), `\\[` (a literal bracket, the one `[` the bracket\n      //   replacer still expects), and `\\ ` (a quoted space, which one pass\n      //   below rewrites in bulk -- holding each one aside instead costs more\n      //   on a pattern built out of them). A lone trailing backslash can reach\n      //   here after line-ending cleanup.\n      //\n      // A quoted backslash is not among them. The chain doubles every\n      //   backslash, then takes the doubling back out again, and a quoted one\n      //   standing next to a character the chain also escapes left the two\n      //   counts sharing a run, so one of the escapes was lost. Held here as\n      //   the literal it means, it never joins that run.\n      const escaped = pattern[index + 1]\n\n      if (\n        escaped === UNDEFINED\n        || escaped === SLASH && index + 2 === length\n      ) {\n        // Git removes a final directory slash before matching. An escape\n        //   without a character after that removal makes the pattern invalid.\n        out += hold(NEVER_MATCH)\n      } else if (\n        escaped === '*'\n        || escaped === '['\n        || escaped === SPACE\n      ) {\n        out += pattern.slice(index, index + 2)\n      } else {\n        out += hold(\n          REGEX_LITERAL_SPECIAL.test(escaped)\n            ? ESCAPE + escaped\n            : isReserved(escaped)\n              ? `[${escaped}]`\n              : escaped\n        )\n      }\n\n      index += 2\n    } else if (isReserved(char)) {\n      out += hold(`[${char}]`)\n      index ++\n    } else if (char === '[') {\n      const scanned = scanBracket(pattern, index)\n\n      if (scanned === null) {\n        // git gives up on the whole pattern (`WM_ABORT_ALL`), so whatever\n        //   follows can not make it match either.\n        out += hold(NEVER_MATCH)\n        index = length\n      } else {\n        out += hold(scanned.source)\n        index = scanned.end + 1\n      }\n    } else {\n      out += char\n      index ++\n    }\n  }\n\n  return {\n    source: out,\n    sources\n  }\n}\n\n// A step of the chain below is normally a `[matcher, replacer]` pair handed\n//   to `String.replace`. `DIRECT` marks the ones that are plain string work\n//   instead, and take `(source, pattern)`.\n//\n// Anchoring the two ends is exactly that -- a test of one character and a\n//   concatenation -- and putting it through the regular expression engine\n//   cost a third of this chain for nothing: 167ns where 10ns does the same\n//   job. The two are still steps in the same list, in the same places,\n//   because their position in the order is part of what they mean.\nconst DIRECT = null\n\n// A separator at the beginning or in the middle of a pattern, as opposed to\n//   one at the very end.\nconst REGEX_INNER_SLASH = /\\/(?!$)/\n\n// > If the pattern ends with a slash,\n// > it is removed for the purpose of the following description,\n// > but it would only find a match with a directory.\n// > In other words, foo/ will match a directory foo and paths underneath it,\n// > but will not match a regular file or a symbolic link foo\n// >  (this is consistent with the way how pathspec works in general in Git).\n// '`foo/`' will not match regular file '`foo`' or symbolic link '`foo`'\n// -> ignore-rules will not deal with it, because it costs extra `fs.stat` call\n//      you could use option `mark: true` with `glob`\n\n// '`foo/`' should not continue with the '`..`'\n// The chain that turns one gitignore pattern into a regular expression\n//   source, in order. A step is either\n//\n//   [matcher, replacer]            handed to `String.replace`\n//   [matcher, replacer, required]  the same, but skipped outright unless\n//                                    `required` appears in the string, which\n//                                    the matcher cannot match without\n//   [DIRECT, transform]            plain string work, taking (source, pattern)\n//\n// The `required` character is only ever a shortcut: finding it does not mean\n//   the matcher will match, and not finding it means it cannot. It is there\n//   because scanning for one character costs a fraction of running a matcher\n//   that then finds nothing -- for the wildcard step, whose `[^\\\\]+`\n//   backtracks its way through the whole string before giving up, 11ns\n//   against 400ns.\nconst REPLACERS = [\n\n  // Replace (\\ ) with ' '\n  // Only a space: an escaped tab or other whitespace is already a literal by\n  //   the time it reaches here, and a bare tab must be left as one, not turned\n  //   into a space.\n  // (\\ ) -> ' '\n  // (\\\\ ) -> '\\\\ '\n  // (\\\\\\ ) -> '\\\\ '\n  [\n    // A run of backslashes is taken whole, from its first one, so no match\n    //   ever starts again inside it -- `(\\\\+?) ` did, which made a long run\n    //   quadratic.\n    /(\\\\+)( ?)/g,\n    (_, run, space) => space\n      ? run.slice(0, run.length - run.length % 2) + SPACE\n      : run,\n    ESCAPE + SPACE\n  ],\n\n  // git's wildmatch() reads a run of two or more asterisks as one globstar\n  //   whenever the run fills a path segment: it starts the pattern or follows\n  //   a `/`, and it ends the pattern or comes before a `/`. A run of two is\n  //   already `**`; a longer one is folded into `**` here, so the steps\n  //   below only ever have to know `**`.\n  // `***/foo` -> `**/foo`, `a/***/b` -> `a/**/b`, `a/***` -> `a/**`\n  // git also takes a run beside a literal prefix (`a***/b`) or beside an\n  //   escaped slash (`***\\/b`) as a globstar, and this does not; the README\n  //   lists both, under \"A run of asterisks\".\n  [\n    /(^|\\/)\\*{3,}(?=\\/|$)/g,\n    (_, start) => `${start}**`,\n    '*'\n  ],\n\n  // Escape metacharacters\n  // which is written down by users but means special for regular expressions.\n\n  // > There are 12 characters with special meanings:\n  // > - the backslash \\,\n  // > - the caret ^,\n  // > - the dollar sign $,\n  // > - the period or dot .,\n  // > - the vertical bar or pipe symbol |,\n  // > - the question mark ?,\n  // > - the asterisk or star *,\n  // > - the plus sign +,\n  // > - the opening parenthesis (,\n  // > - the closing parenthesis ),\n  // > - and the opening square bracket [,\n  // > - the opening curly brace {,\n  // > These special characters are often called \"metacharacters\".\n  [\n    /[\\\\$.|*+(){^]/g,\n    match => `\\\\${match}`\n  ],\n\n  [\n    // > a question mark (?) matches a single character\n    /(?!\\\\)\\?/g,\n    () => '[^/]',\n    '?'\n  ],\n\n  // leading slash\n  [\n\n    // > A leading slash matches the beginning of the pathname.\n    // > For example, \"/*.c\" matches \"cat-file.c\" but not \"mozilla-sha1/sha1.c\".\n    // A leading slash matches the beginning of the pathname\n    /^\\//,\n    () => '^',\n    SLASH\n  ],\n\n  // replace special metacharacter slash after the leading slash\n  [\n    /\\//g,\n    () => '\\\\/',\n    SLASH\n  ],\n\n  [\n    // > A leading \"**\" followed by a slash means match in all directories.\n    // > For example, \"**/foo\" matches file or directory \"foo\" anywhere,\n    // > the same as pattern \"foo\".\n    // > \"**/foo/bar\" matches file or directory \"bar\" anywhere that is directly\n    // >   under directory \"foo\".\n    // Notice that the '*'s have been replaced as '\\\\*'\n    /^\\^*(?:\\\\\\*\\\\\\*\\\\\\/)+/,\n\n    // '**/foo' <-> 'foo'\n    () => '^(?:.*\\\\/)?',\n    '*'\n  ],\n\n  // starting\n  [\n    // there will be no leading '/'\n    //   (which has been replaced by section \"leading slash\")\n    // If starts with '**', adding a '^' to the regular expression also works\n    DIRECT,\n    (source, pattern) => {\n      // Nothing to anchor to, or already anchored\n      if (!source || source[0] === '^') {\n        return source\n      }\n\n      // If has a slash `/` at the beginning or middle\n      const anchor = !REGEX_INNER_SLASH.test(pattern)\n        // > Prior to 2.22.1\n        // > If the pattern does not contain a slash /,\n        // >   Git treats it as a shell glob pattern\n        // Actually, if there is only a trailing slash,\n        //   git also treats it as a shell glob pattern\n\n        // After 2.22.1 (compatible but clearer)\n        // > If there is a separator at the beginning or middle (or both)\n        // > of the pattern, then the pattern is relative to the directory\n        // > level of the particular .gitignore file itself.\n        // > Otherwise the pattern may also match at any level below\n        // > the .gitignore level.\n        ? '(?:^|\\\\/)'\n\n        // > Otherwise, Git treats the pattern as a shell glob suitable for\n        // >   consumption by fnmatch(3)\n        : '^'\n\n      return anchor + source\n    }\n  ],\n\n  // two globstars\n  [\n    // Use lookahead assertions so that we could match more than one `'/**'`\n    /\\\\\\/\\\\\\*\\\\\\*(?=\\\\\\/|$)/g,\n\n    // Zero, one or several directories\n    // should not use '*', or it will be replaced by the next replacer\n\n    // Check if it is not the last `'/**'`\n    (_, index, str) => index + 6 < str.length\n\n      // case: /**/ at the end of the pattern, i.e. a trailing `'/**/'`\n      // > A trailing `\"/**/\"` (a trailing `\"/**\"` restricted to directories)\n      // >   matches everything inside, but it should not match the current\n      // >   folder itself, so it requires at least one directory segment.\n      // 'a/**/' matches 'a/b/', 'a/x/y/' but not 'a/'\n      ? str.slice(index + 6) === '\\\\/'\n        ? '(?:\\\\/[^\\\\/]+)+'\n\n        // case: /**/\n        // > A slash followed by two consecutive asterisks then a slash matches\n        // >   zero or more directories.\n        // > For example, \"a/**/b\" matches \"a/b\", \"a/x/b\", \"a/x/y/b\" and so on.\n        // '/**/'\n        : '(?:\\\\/[^\\\\/]+)*'\n\n      // case: /**\n      // > A trailing `\"/**\"` matches everything inside.\n\n      // #21: everything inside but it should not include the current folder,\n      //   resolved by `_make`\n      : `\\\\/${TRAILING_DOUBLESTAR}`,\n    '*'\n  ],\n\n  // normal intermediate wildcards\n  [\n    // Never replace escaped '*'\n    // ignore rule '\\*' will match the path '*'\n\n    // 'abc.*/' -> go\n    // 'abc.*'  -> skip this rule,\n    //    coz trailing single wildcard will be handed by [trailing wildcard]\n    /(^|[^\\\\]+)(\\\\\\*)+(?=.+)/g,\n\n    // '*.js' matches '.js'\n    // '*.js' doesn't match 'abc'\n    (_, p1, p2) => {\n      // 1.\n      // > An asterisk \"*\" matches anything except a slash.\n      // 2.\n      // > Other consecutive asterisks are considered regular asterisks\n      // > and will match according to the previous rules.\n      const unescaped = p2.replace(/\\\\\\*/g, '[^\\\\/]*')\n      return p1 + unescaped\n    },\n    '*'\n  ],\n\n  // trailing wildcard, held apart from a literal star\n  [\n    // The step above leaves a trailing `*` alone, so a single `\\*` is all that\n    //   can be left at the end here, and what stands in front of it says which\n    //   kind it is. A wildcard arrives as the escaper wrote it, `\\*` with\n    //   nothing before it; a literal arrives as the user's own escape, which\n    //   the escaper doubled, and then the star's own -- `\\\\` and then `\\*`.\n    //   There is no third case: every backslash still reaching the chain is\n    //   one `\\*`, `\\[` or `\\ ` carries itself, and each is followed by its\n    //   own character, so a longer run can never form. This runs while the\n    //   two are still distinct, before the unescape steps below collapse the\n    //   literal onto the very `\\*` a wildcard leaves behind.\n    /(^|[^\\\\])((?:\\\\\\\\)*)\\\\\\*$/,\n\n    (match, p1, p2) =>\n      p2 === EMPTY\n        // A real wildcard: carry it to `_make` as the marker, so the unescape\n        //   steps and the trailing-wildcard rewrite can never mistake it for a\n        //   literal `\\*` (nor the reverse).\n        ? p1 + TRAILING_WILDCARD\n        // A literal star: leave it exactly as it stands for the unescape steps.\n        : match,\n    '*'\n  ],\n\n  [\n    // unescape, revert step 3 except for back slash\n    // For example, if a user escape a '\\\\*',\n    // after step 3, the result will be '\\\\\\\\\\\\*'\n    /\\\\\\\\\\\\(?=[$.|*+(){^])/g,\n    () => ESCAPE,\n    ESCAPE + ESCAPE\n  ],\n\n  [\n    // '\\\\\\\\' -> '\\\\'\n    /\\\\\\\\/g,\n    () => ESCAPE,\n    ESCAPE + ESCAPE\n  ],\n\n  [\n    // Every real bracket expression -- POSIX classes included -- has already\n    //   been held aside by `extractBrackets`, so the only `[` left in the\n    //   pattern is an escaped, literal one.\n\n    // A backslash could only stand at the end of the range if it quoted the\n    //   `]`, and `\\]` is held aside long before this.\n    /\\\\\\[([^\\]/]*?)($|\\])/g,\n\n    // '\\\\[bar]' -> '\\\\\\\\[bar]'\n    (match, range, close) => `\\\\[${range}${close}`,\n    '['\n  ],\n\n  // ending\n  [\n    // 'js' will not match 'js.'\n    // 'ab' will not match 'abc'\n    DIRECT,\n\n    // WTF!\n    // https://git-scm.com/docs/gitignore\n    // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)\n    // which re-fixes #24, #38\n\n    // > If there is a separator at the end of the pattern then the pattern\n    // > will only match directories, otherwise the pattern can match both\n    // > files and directories.\n\n    // 'js*' will not match 'a.js'\n    // 'js/' will not match 'a.js'\n    // 'js' will match 'a.js' and 'a.js/'\n    source => {\n      const last = source[source.length - 1]\n\n      // The pattern is empty, or ends in a pending marker `_make` owns --\n      //   the trailing wildcard, or a trailing \"/**\". A trailing `*` that is\n      //   not the marker is a literal star, which anchors like any other\n      //   final character.\n      if (!last || last === TRAILING_WILDCARD || last === TRAILING_DOUBLESTAR) {\n        return source\n      }\n\n      return last === SLASH\n        // foo/ will not match 'foo'\n        ? `${source}$`\n        // foo matches 'foo' and 'foo/'\n        : `${source}(?=$|\\\\/$)`\n    }\n  ]\n]\n\nconst REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\\\\/)?\\uE000$/\nconst MODE_IGNORE = 'regex'\nconst MODE_CHECK_IGNORE = 'checkRegex'\nconst UNDERSCORE = '_'\n\nconst replaceTrailingWildcard = (_, p1) => {\n  const prefix = p1\n    // '\\^':\n    // '/*' does not match EMPTY\n    // '/*' does not match everything\n\n    // '\\\\\\/':\n    // 'abc/*' does not match 'abc/'\n    ? `${p1}[^/]+`\n\n    // 'a*' matches 'a'\n    // 'a*' matches 'aa'\n    : '[^/]*'\n\n  return `${prefix}(?=$|\\\\/$)`\n}\n\nconst REGEX_REPLACE_TRAILING_DOUBLESTAR = /\\uE001$/\n\n// 'abc/**' matches everything under 'abc', but not 'abc/' itself (#21)\nconst replaceTrailingDoublestar = () => '.+(?=$|\\\\/$)'\n\nconst WILDCARD = '[^\\\\/]*'\n\n// The fixed piece between the wildcard at `at` and the next wildcard of the\n//   run: the tokens that separate them, joined as they appear in the source.\n//   A run never holds two wildcards in a row, so there is always at least one\n//   token.\nconst separatorAfter = (run, at) => {\n  let separator = EMPTY\n\n  for (let index = at + 1; index < run.length && !run[index].wildcard; index ++) {\n    separator += run[index].single\n  }\n\n  return separator\n}\n\n// Where a run of non-slash wildcards is split by fixed pieces --\n//   `[^/]*ab[^/]*cd...` -- the engine has many equivalent ways to lay the\n//   input across the wildcards, and on input that does not match it works\n//   through all of them, so the time grows with the number of wildcards\n//   rather than the length of the path. Every wildcard but the last in such a\n//   run can be pinned to stop where the piece after it begins, which leaves\n//   one way to lay out the input and no rewinding, without changing which\n//   paths match: the fixed pieces still bound the count, and the last\n//   wildcard still absorbs the rest.\n//\n// A wildcard is pinned to the whole piece, never to the piece's first\n//   character. The pin leaves no way back, so a wildcard that stopped at that\n//   first character would hand over wherever the character happens to turn\n//   up, including the places the rest of the piece cannot follow -- which is\n//   how `f*o/*/*` came to miss `foo/b/c`, the first `o` of `foo` not being\n//   the one the `o/` after it needs. Every token of a piece matches exactly\n//   one character, so the first place the whole piece fits is the leftmost\n//   place it can sit, and whatever is left over goes to the wildcards that\n//   follow.\n//\n// The source is read one token at a time -- a wildcard, a single-character\n//   piece (a literal, an escape, a class), or a parenthesised group or anchor\n//   that ends the run -- so only a genuine wildcard is touched.\nconst pinWildcards = source => {\n  if (source.indexOf(WILDCARD) < 0) {\n    return source\n  }\n\n  const tokens = []\n  const {length} = source\n  let index = 0\n\n  while (index < length) {\n    const char = source[index]\n\n    if (source.startsWith(WILDCARD, index)) {\n      tokens.push({wildcard: true})\n      index += WILDCARD.length\n    } else if (char === '[') {\n      let end = index + 1\n\n      if (source[end] === '^') {\n        end ++\n      }\n\n      if (source[end] === ']') {\n        end ++\n      }\n\n      while (end < length && source[end] !== ']') {\n        end += source[end] === ESCAPE\n          ? 2\n          : 1\n      }\n\n      end ++\n      tokens.push({single: source.slice(index, end)})\n      index = end\n    } else if (char === ESCAPE) {\n      tokens.push({single: source.slice(index, index + 2)})\n      index += 2\n    } else if (char === '(') {\n      let depth = 0\n      let end = index\n\n      do {\n        if (source[end] === ESCAPE) {\n          end ++\n        } else if (source[end] === '(') {\n          depth ++\n        } else if (source[end] === ')') {\n          depth --\n        }\n\n        end ++\n      } while (end < length && depth > 0)\n\n      if ('*+?'.indexOf(source[end]) >= 0) {\n        end ++\n      }\n\n      tokens.push({boundary: source.slice(index, end)})\n      index = end\n    } else if (char === '^' || char === '$') {\n      tokens.push({boundary: char})\n      index ++\n    } else {\n      tokens.push({single: char})\n      index ++\n    }\n  }\n\n  let out = EMPTY\n  let run = []\n\n  const flush = () => {\n    let lastWildcard\n\n    run.forEach((token, at) => {\n      if (token.wildcard) {\n        lastWildcard = at\n      }\n    })\n\n    run.forEach((token, at) => {\n      if (!token.wildcard) {\n        out += token.single\n        return\n      }\n\n      // Every wildcard but the last is pinned to the whole piece that\n      //   follows it, for the reason set out above this function. The last\n      //   one stays as it is and takes up the rest.\n      out += at === lastWildcard\n        ? WILDCARD\n        : `(?:(?!${separatorAfter(run, at)})[^\\\\/])*`\n    })\n\n    run = []\n  }\n\n  tokens.forEach(token => {\n    if (token.boundary === undefined) {\n      run.push(token)\n      return\n    }\n\n    flush()\n    out += token.boundary\n  })\n\n  flush()\n\n  return out\n}\n\n// @param {pattern}\nconst makeRegexPrefix = pattern => {\n  // `/**` matches every path, as `**` does. The translation below only finds\n  //   a globstar beside a slash it keeps, and the leading one is turned into\n  //   an anchor, so `/**` would come out as `/*` and match one level only.\n  //   Here rather than in `createRule`, so that `checkSourceOf`, which\n  //   compiles `/**/` again without its trailing slash, gets it too.\n  if (REGEX_ANCHORED_GLOBSTAR.test(pattern)) {\n    pattern = '**'\n  }\n\n  const {source, sources} = extractBrackets(pattern)\n\n  const replaced = REPLACERS.reduce(\n    // A pass whose matcher finds nothing hands back the very string it was\n    //   given, so asking first costs a search and saves a rewrite. Ten of the\n    //   fifteen passes never fire for a typical .gitignore line, and between\n    //   them they were 45% of this chain.\n    (prev, [matcher, replacer, required]) => {\n      if (matcher === DIRECT) {\n        return replacer(prev, pattern)\n      }\n\n      if (required !== UNDEFINED && prev.indexOf(required) < 0) {\n        return prev\n      }\n\n      // A pass whose matcher finds nothing hands back the very string it was\n      //   given, so asking first costs a search and saves a rewrite.\n      return matcher.test(prev)\n        ? prev.replace(matcher, replacer.bind(pattern))\n        : prev\n    },\n    source\n  )\n\n  // Most patterns hold no bracket expression at all, and then there is\n  //   nothing to put back.\n  return sources.length\n    ? replaced.replace(\n      REGEX_RESTORE_PLACEHOLDER,\n      (match, index) => sources[index]\n    )\n    : replaced\n}\n\n// `checkRegex` tests a path with a trailing slash, 'abc/', the way\n//   `git check-ignore` matches that literal string once the directory itself\n//   is known not to be excluded (see `checkIgnore`): a trailing '/' of the\n//   pattern is dropped, a basename pattern sees an empty basename, and only a\n//   pattern whose last segment is a pending wildcard can match what is left\n//   after the final slash -- 'abc/*' and 'abc/**' match 'abc/', and 'abc/**'\n//   also matches 'abc/d/' (#77, #169).\nconst checkSourceOf = (body, prefix) => {\n  if (body[body.length - 1] === SLASH) {\n    prefix = makeRegexPrefix(body.slice(0, - 1))\n  }\n\n  const head = prefix.slice(0, - 1)\n  const last = prefix[prefix.length - 1]\n\n  return last === TRAILING_WILDCARD\n    ? `${head}$`\n    : last === TRAILING_DOUBLESTAR\n      ? `${head}.*$`\n      : NEVER_MATCH\n}\n\n// A trailing slash does not stop a pattern being basename-only: it restricts\n//   the match to a directory, it does not let the pattern reach across one.\n//   Everything else a pattern can hold -- a wildcard, a character class, an\n//   escape -- stays inside a single path segment too, so a pattern with no\n//   separator in it can only ever describe the last one.\nconst matchesBasename = body => {\n  const index = body.indexOf(SLASH)\n\n  return index < 0 || index === body.length - 1\n}\n\n// The last segment of a path, keeping a trailing slash, because a pattern that\n//   ends in one matches only a directory.\n// 'a/b/c.js' -> 'c.js';  'a/b/' -> 'b/';  'c.js' -> 'c.js' (no copy made)\nconst basenameOf = path => {\n  const end = path.length - 1\n\n  const index = path.lastIndexOf(\n    SLASH,\n    path[end] === SLASH\n      ? end - 1\n      : end\n  )\n\n  return index < 0\n    ? path\n    : path.slice(index + 1)\n}\n\n// The parent directory of a path, with its trailing separator, or EMPTY when\n//   the path has none.\n// 'a/b/c' -> 'a/b/';  'a/b/' -> 'a/';  'a' -> EMPTY;  'a/' -> EMPTY\n//\n// A path holding an empty segment has to be taken apart, because its\n//   ancestors are not prefixes of it: the parent of 'a//b' is 'a/', not\n//   'a//', and the parent of '/a/' is nothing at all. Both shapes reach here\n//   -- 'a//b' is accepted outright, and `checkIgnore` does not put the path\n//   it is given through the relative-path check.\n//\n// Every other path is a prefix of itself, and cutting one costs a fraction of\n//   splitting it into an array and joining that back at every level: 73ns\n//   against 207ns.\nconst parentOf = path => {\n  if (\n    path.charCodeAt(0) === SLASH_CODE\n    || path.indexOf(DOUBLE_SLASH) >= 0\n  ) {\n    const slices = path.split(SLASH).filter(Boolean)\n\n    slices.pop()\n\n    return slices.length\n      ? slices.join(SLASH) + SLASH\n      : EMPTY\n  }\n\n  const end = path.length - 1\n\n  // Look back from before a trailing separator, since that one belongs to the\n  //   path itself.\n  //\n  // A negative place to start would be a trap here: `lastIndexOf` clamps one\n  //   to 0 and searches there rather than reporting no match, so '/' would\n  //   come back as its own parent and the walk would never end. It cannot\n  //   happen -- that is the only path short enough to produce one, and the\n  //   test above has already sent it the other way.\n  const cut = path.lastIndexOf(\n    SLASH,\n    path.charCodeAt(end) === SLASH_CODE\n      ? end - 1\n      : end\n  )\n\n  return cut < 0\n    ? EMPTY\n    : path.slice(0, cut + 1)\n}\n\nconst isString = subject => typeof subject === 'string'\n\n// Blank lines and comments are told by `createRule`, once the pattern is\n//   normalized.\nconst checkPattern = pattern => pattern\n  && isString(pattern)\n  && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern)\n\nconst splitPattern = pattern => pattern\n.split(REGEX_SPLITALL_CRLF)\n.filter(Boolean)\n\nclass IgnoreRule {\n  constructor (\n    pattern,\n    mark,\n    body,\n    ignoreCase,\n    negative,\n    prefix\n  ) {\n    this.pattern = pattern\n    this.mark = mark\n    this.negative = negative\n\n    define(this, 'body', body)\n    define(this, 'ignoreCase', ignoreCase)\n    define(this, 'regexPrefix', prefix)\n  }\n\n  // Worked out on first use and kept behind an own property, the way `regex`\n  //   caches itself in `_regex`. Deciding it in the constructor instead would\n  //   add a fourth `defineProperty` to every rule ever built, which cost 4% of\n  //   every compile -- including the compiles of rules that are never matched\n  //   against anything.\n  get _basenameOnly () {\n    return define(this, '_basenameOnly', matchesBasename(this.body))\n  }\n\n  get regex () {\n    const key = UNDERSCORE + MODE_IGNORE\n\n    if (this[key]) {\n      return this[key]\n    }\n\n    return this._make(MODE_IGNORE, key)\n  }\n\n  get checkRegex () {\n    const key = UNDERSCORE + MODE_CHECK_IGNORE\n\n    if (this[key]) {\n      return this[key]\n    }\n\n    return this._make(MODE_CHECK_IGNORE, key)\n  }\n\n  _make (mode, key) {\n    const str = pinWildcards(\n      mode === MODE_IGNORE\n        ? this.regexPrefix\n        .replace(REGEX_REPLACE_TRAILING_WILDCARD, replaceTrailingWildcard)\n        .replace(REGEX_REPLACE_TRAILING_DOUBLESTAR, replaceTrailingDoublestar)\n        : checkSourceOf(this.body, this.regexPrefix)\n    )\n\n    const regex = this.ignoreCase\n      ? new RegExp(str, 'i')\n      : new RegExp(str)\n\n    return define(this, key, regex)\n  }\n}\n\nconst isLineEnd = char => char === '\\r' || char === '\\n'\n\n// Drop a line terminator, which can remain when patterns are passed as an\n//   array, and then the trailing spaces. Git trims spaces only, and a space\n//   escaped by an odd run of backslashes stays, unescaped, as the last one.\n// Scanned from the end: a regular expression can only try each start in\n//   turn, which is quadratic over a long run of spaces or backslashes.\n// 'a  ' -> 'a';  'a\\ ' -> 'a ';  'a\\\\ ' -> 'a\\\\';  'a\\t' -> 'a\\t'\nconst trimEnd = body => {\n  let end = body.length\n\n  while (end && isLineEnd(body[end - 1])) {\n    end --\n  }\n\n  const lineEnd = end\n\n  while (end && body[end - 1] === SPACE) {\n    end --\n  }\n\n  if (end === lineEnd) {\n    return body.slice(0, end)\n  }\n\n  let backslashes = 0\n\n  while (backslashes < end && body[end - backslashes - 1] === ESCAPE) {\n    backslashes ++\n  }\n\n  return backslashes % 2\n    ? body.slice(0, end - 1) + SPACE\n    : body.slice(0, end)\n}\n\nconst createRule = ({\n  pattern,\n  mark\n}, ignoreCase) => {\n  // Git drops a BOM before it reads the first line, so before anything else.\n  let body = pattern[0] === BOM\n    ? pattern.slice(1)\n    : pattern\n\n  // > A line starting with # serves as a comment.\n  if (body[0] === '#') {\n    return\n  }\n\n  let negative = false\n\n  // > An optional prefix \"!\" which negates the pattern;\n  if (body[0] === '!') {\n    negative = true\n    body = body.slice(1)\n  }\n\n  // Normalize the body before checking which slashes anchor the pattern.\n  //   Otherwise `bar/ ` is mistaken for a pattern containing an inner slash.\n  //   Only a body ending in a space or a line terminator has anything to trim.\n  const last = body[body.length - 1]\n\n  if (last === SPACE || last === '\\r' || last === '\\n') {\n    body = trimEnd(body)\n  }\n\n  // > A blank line matches no files, so it can serve as a separator for\n  // >   readability.\n  // Nor does a lone \"!\", or anything else left empty here: an empty pattern\n  //   would compile to a regex matching every path.\n  if (!body) {\n    return\n  }\n\n  body = body\n  // > Put a backslash (\"\\\") in front of the first \"!\" for patterns that\n  // >   begin with a literal \"!\", for example, `\"\\!important!.txt\"`.\n  .replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, '!')\n  // > Put a backslash (\"\\\") in front of the first hash for patterns that\n  // >   begin with a hash.\n  .replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, '#')\n\n  const regexPrefix = makeRegexPrefix(body)\n\n  return new IgnoreRule(\n    pattern,\n    mark,\n    body,\n    ignoreCase,\n    negative,\n    regexPrefix\n  )\n}\n\nclass RuleManager {\n  constructor (ignoreCase) {\n    this._ignoreCase = ignoreCase\n    this._rules = []\n\n    // How many of the rules git would tag `EXC_FLAG_NODIR`.\n    //\n    // The scan uses it to decide, once for the whole set, whether handing\n    //   those rules the basename is worth what it costs the others. The\n    //   shortcut saves a full-path scan on every rule it applies to and costs\n    //   a check on every rule it does not, so a set where almost nothing is\n    //   basename-only comes out behind -- a 955 pattern set with 44 of them\n    //   measured 19% slower with the shortcut always on.\n    //\n    // Deciding this by measurement rather than by meaning is safe: a\n    //   basename-only pattern gives the very same answer against the whole\n    //   path, it just takes longer to say so. The choice can only change how\n    //   fast the scan runs, never what it returns.\n    this._basenameCount = 0\n  }\n\n  _add (pattern) {\n    // #32\n    if (pattern && pattern[KEY_IGNORE]) {\n      this._rules = this._rules.concat(pattern._rules._rules)\n      this._basenameCount += pattern._rules._basenameCount\n      this._added = true\n      return\n    }\n\n    if (isString(pattern)) {\n      pattern = {\n        pattern\n      }\n    }\n\n    const rule = checkPattern(pattern.pattern)\n      && createRule(pattern, this._ignoreCase)\n\n    if (rule) {\n      this._added = true\n      this._rules.push(rule)\n\n      // Deliberately not `rule._basenameOnly`: reading that would materialise\n      //   the rule's own copy, and the whole point of leaving it lazy is that\n      //   a rule which is compiled and never matched never pays for it.\n      if (matchesBasename(rule.body)) {\n        this._basenameCount ++\n      }\n    }\n  }\n\n  // @param {Array<string> | string | Ignore} pattern\n  add (pattern) {\n    this._added = false\n\n    makeArray(\n      isString(pattern)\n        ? splitPattern(pattern)\n        : pattern\n    ).forEach(this._add, this)\n\n    if (this._added) {\n      this._literalRules = UNDEFINED\n    }\n\n    return this._added\n  }\n\n  // Match the literal 'abc/' for `checkIgnore`, last rule wins. Only a rule\n  //   ending in a wildcard can match it (see `checkSourceOf`), so the rest\n  //   are left out once, rather than tested or compiled for every path.\n  testLiteral (path) {\n    const rules = this._literalRules || (\n      this._literalRules = this._rules.filter(\n        ({body}) => body[body.length - (\n          body[body.length - 1] === SLASH ? 2 : 1\n        )] === '*'\n      )\n    )\n\n    let ignored = false\n    let unignored = false\n    let matchedRule\n\n    for (let index = rules.length - 1; index >= 0; index --) {\n      const rule = rules[index]\n\n      if (rule.checkRegex.test(path)) {\n        ignored = !rule.negative\n        unignored = rule.negative\n        matchedRule = rule.negative\n          ? UNDEFINED\n          : rule\n        break\n      }\n    }\n\n    const ret = {\n      ignored,\n      unignored\n    }\n\n    if (matchedRule) {\n      ret.rule = matchedRule\n    }\n\n    return ret\n  }\n\n  // Test one single path without recursively checking parent directories\n  //\n  // - mode `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`\n\n  // @returns {TestResult}\n  test (path, mode) {\n    // Most of a .gitignore is patterns with no slash in them, and running\n    //   those against the whole path makes the regular expression engine walk\n    //   every directory name on the way to the only segment that could match.\n    //   Handing them the basename instead is what git does, and it is where\n    //   the time in a directory walk goes: the rule scan was two thirds of it.\n    const rules = this._rules\n    const {length} = rules\n\n    const shortcut = this._basenameCount * 2 >= length\n\n    const basename = shortcut\n      ? basenameOf(path)\n      : path\n\n    // The last rule to match decides, as in git, and it is the rule\n    //   `git check-ignore -v` reports, so the scan runs from the end and stops\n    //   at the first match.\n    // A plain loop rather than `forEach`, so that `path`, `basename` and\n    //   `shortcut` are locals. As a callback they became closure variables,\n    //   and reaching for one of those once per rule cost 10% of a scan over a\n    //   large rule set -- more than the shortcut they were there to serve.\n    for (let index = length - 1; index >= 0; index --) {\n      const rule = rules[index]\n\n      if (rule[mode].test(\n        shortcut && rule._basenameOnly\n          ? basename\n          : path\n      )) {\n        const {negative} = rule\n\n        const ret = {\n          ignored: !negative,\n          unignored: negative\n        }\n\n        if (!negative) {\n          ret.rule = rule\n        }\n\n        return ret\n      }\n    }\n\n    return {\n      ignored: false,\n      unignored: false\n    }\n  }\n}\n\nconst throwError = (message, Ctor) => {\n  throw new Ctor(message)\n}\n\nconst checkPath = (path, originalPath, doThrow) => {\n  if (!isString(path)) {\n    return doThrow(\n      `path must be a string, but got \\`${originalPath}\\``,\n      TypeError\n    )\n  }\n\n  // We don't know if we should ignore EMPTY, so throw\n  if (!path) {\n    return doThrow(`path must not be empty`, TypeError)\n  }\n\n  // Check if it is a relative path\n  if (checkPath.isNotRelative(path)) {\n    const r = '`path.relative()`d'\n    return doThrow(\n      `path should be a ${r} string, but got \"${originalPath}\"`,\n      RangeError\n    )\n  }\n\n  return true\n}\n\n// > pathname should be a `path.relative()`d one\n//\n// The same thing `REGEX_TEST_INVALID_PATH` says, spelled out: a path is not\n//   relative if it begins with a separator, or with `./` or `../`, or is\n//   nothing but `.` or `..`. Every match is decided by the first three\n//   characters, and this runs on every path handed to the library -- where it\n//   was 55% of a cached lookup, more than the cache lookup itself.\nconst isNotRelative = path => {\n  const first = path.charCodeAt(0)\n\n  if (first === SLASH_CODE) {\n    return true\n  }\n\n  if (first !== DOT_CODE) {\n    return false\n  }\n\n  // '.'\n  if (path.length === 1) {\n    return true\n  }\n\n  const second = path.charCodeAt(1)\n\n  // './'\n  if (second === SLASH_CODE) {\n    return true\n  }\n\n  if (second !== DOT_CODE) {\n    return false\n  }\n\n  // '..' or '../'\n  return path.length === 2 || path.charCodeAt(2) === SLASH_CODE\n}\n\ncheckPath.isNotRelative = isNotRelative\n\n// On windows, the following function will be replaced\n/* istanbul ignore next */\ncheckPath.convert = p => p\n\n\nclass Ignore {\n  constructor ({\n    ignorecase = true,\n    ignoreCase = ignorecase,\n    allowRelativePaths = false\n  } = {}) {\n    define(this, KEY_IGNORE, true)\n\n    this._rules = new RuleManager(ignoreCase)\n    this._strictPathCheck = !allowRelativePaths\n    this._initCache()\n  }\n\n  _initCache () {\n    // A cache for the result of `.ignores()`\n    this._ignoreCache = Object.create(null)\n\n    // A cache for the result of `.test()`\n    this._testCache = Object.create(null)\n  }\n\n  add (pattern) {\n    if (this._rules.add(pattern)) {\n      // Some rules have just added to the ignore,\n      //   making the behavior changed,\n      //   so we need to re-initialize the result cache\n      this._initCache()\n    }\n\n    return this\n  }\n\n  // legacy\n  addPattern (pattern) {\n    return this.add(pattern)\n  }\n\n  // @returns {TestResult}\n  _test (originalPath, cache) {\n    const path = originalPath\n      // Supports nullable path\n      && checkPath.convert(originalPath)\n\n    checkPath(\n      path,\n      originalPath,\n      this._strictPathCheck\n        ? throwError\n        : RETURN_FALSE\n    )\n\n    return this._t(path, cache)\n  }\n\n  checkIgnore (path) {\n    // If the path doest not end with a slash, `.ignores()` is much equivalent\n    //   to `git check-ignore`\n    if (path.charCodeAt(path.length - 1) !== SLASH_CODE) {\n      return this.test(path)\n    }\n\n    // Like `git check-ignore`: a directory excluded by itself or by an\n    //   ancestor settles it, and only then is the literal 'abc/' matched\n    //   against the rules (see `checkSourceOf`).\n    const dir = this._t(path, this._testCache)\n\n    if (dir.ignored) {\n      return dir\n    }\n\n    const literal = this._rules.testLiteral(path)\n\n    return literal.ignored || literal.unignored\n      ? literal\n      : dir\n  }\n\n  _t (\n    // The path to be tested\n    path,\n\n    // The cache for the result of a certain checking\n    cache\n  ) {\n    if (path in cache) {\n      return cache[path]\n    }\n\n    const parentPath = parentOf(path)\n\n    // If the path contains a parent directory, check the parent first\n    const parent = parentPath\n      ? this._t(parentPath, cache)\n      : UNDEFINED\n\n    return cache[path] = parent && parent.ignored\n      // > It is not possible to re-include a file if a parent directory of\n      // >   that file is excluded.\n      ? parent\n      : this._rules.test(path, MODE_IGNORE)\n  }\n\n  ignores (path) {\n    return this._test(path, this._ignoreCache).ignored\n  }\n\n  createFilter () {\n    return path => !this.ignores(path)\n  }\n\n  filter (paths) {\n    return makeArray(paths).filter(this.createFilter())\n  }\n\n  // @returns {TestResult}\n  test (path) {\n    return this._test(path, this._testCache)\n  }\n}\n\nconst factory = options => new Ignore(options)\n\nconst isPathValid = path =>\n  checkPath(path && checkPath.convert(path), path, RETURN_FALSE)\n\n/* istanbul ignore next */\nconst setupWindows = () => {\n  /* eslint no-control-regex: \"off\" */\n  const makePosix = str => /^\\\\\\\\\\?\\\\/.test(str)\n  || /[\"<>|\\u0000-\\u001F]+/u.test(str)\n    ? str\n    : str.replace(/\\\\/g, '/')\n\n  checkPath.convert = makePosix\n\n  // 'C:\\\\foo'     <- 'C:\\\\foo' has been converted to 'C:/'\n  // 'd:\\\\foo'\n  const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\\//i\n  checkPath.isNotRelative = path =>\n    REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path)\n    || isNotRelative(path)\n}\n\n\n// Windows\n// --------------------------------------------------------------\n/* istanbul ignore next */\nif (\n  // Detect `process` so that it can run in browsers.\n  typeof process !== 'undefined'\n  && process.platform === 'win32'\n) {\n  setupWindows()\n}\n\n// COMMONJS_EXPORTS ////////////////////////////////////////////////////////////\n\nmodule.exports = factory\n\n// Although it is an anti-pattern,\n//   it is still widely misused by a lot of libraries in github\n// Ref: https://github.com/search?q=ignore.default%28%29&type=code\nfactory.default = factory\n\nmodule.exports.isPathValid = isPathValid\n\n// For testing purposes\ndefine(module.exports, Symbol.for('setupWindows'), setupWindows)\n\n\n//# sourceURL=file://cloudcmd//Users/coderaiser/cloudcmd/node_modules/putout/node_modules/ignore/index.js\n}");
 
 },
 "./node_modules/regexp-tree/dist/compat-transpiler/index.js"
@@ -1774,7 +1774,7 @@ eval("{__webpack_require__.r(__webpack_exports__);\n__webpack_require__.d(__webp
   \*****************************************************************/
 (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 "use strict";
-eval("{__webpack_require__.r(__webpack_exports__);\n__webpack_require__.d(__webpack_exports__, {\n  buildPlugin: () => (buildPlugin)\n});\n/* import */ var _includer_index_js__rspack_import_0 = __webpack_require__(/*! ./includer/index.js */ \"./node_modules/@putout/engine-runner/lib/builder/includer/index.js\");\n/* import */ var _replacer_index_js__rspack_import_1 = __webpack_require__(/*! ./replacer/index.js */ \"./node_modules/@putout/engine-runner/lib/builder/replacer/index.js\");\n/* import */ var _declarator_index_js__rspack_import_2 = __webpack_require__(/*! ./declarator/index.js */ \"./node_modules/@putout/engine-runner/lib/builder/declarator/index.js\");\n/* import */ var _scanner_index_js__rspack_import_3 = __webpack_require__(/*! ./scanner/index.js */ \"./node_modules/@putout/engine-runner/lib/builder/scanner/index.js\");\n\n\n\n\n\nconst {entries} = Object;\n\nfunction buildPlugin(item, {progress, runners}) {\n    const {plugin} = item;\n    \n    if (plugin.traverse)\n        return item;\n    \n    if (plugin.replace)\n        return (0,_includer_index_js__rspack_import_0.include)((0,_replacer_index_js__rspack_import_1.replace)(item));\n    \n    if (plugin.declare)\n        return (0,_declarator_index_js__rspack_import_2.declare)(item);\n    \n    if (plugin.include)\n        return (0,_includer_index_js__rspack_import_0.include)(item);\n    \n    if (plugin.scan)\n        return (0,_scanner_index_js__rspack_import_3.scan)(item, {\n            progress,\n        });\n    \n    for (const [name, build] of entries(runners)) {\n        if (plugin[name])\n            return build(item);\n    }\n}\n\n\n//# sourceURL=file://cloudcmd//Users/coderaiser/cloudcmd/node_modules/@putout/engine-runner/lib/builder/index.js\n}");
+eval("{__webpack_require__.r(__webpack_exports__);\n__webpack_require__.d(__webpack_exports__, {\n  buildPlugin: () => (buildPlugin)\n});\n/* import */ var _includer_index_js__rspack_import_0 = __webpack_require__(/*! ./includer/index.js */ \"./node_modules/@putout/engine-runner/lib/builder/includer/index.js\");\n/* import */ var _replacer_index_js__rspack_import_1 = __webpack_require__(/*! ./replacer/index.js */ \"./node_modules/@putout/engine-runner/lib/builder/replacer/index.js\");\n/* import */ var _declarator_index_js__rspack_import_2 = __webpack_require__(/*! ./declarator/index.js */ \"./node_modules/@putout/engine-runner/lib/builder/declarator/index.js\");\n/* import */ var _scanner_index_js__rspack_import_3 = __webpack_require__(/*! ./scanner/index.js */ \"./node_modules/@putout/engine-runner/lib/builder/scanner/index.js\");\n\n\n\n\n\nconst {entries} = Object;\n\nfunction buildPlugin(item, {progress, runners}) {\n    const parsedItem = parseItem(item, runners);\n    const {plugin} = parsedItem;\n    \n    if (plugin.traverse)\n        return parsedItem;\n    \n    if (plugin.replace)\n        return (0,_includer_index_js__rspack_import_0.include)((0,_replacer_index_js__rspack_import_1.replace)(parsedItem));\n    \n    if (plugin.declare)\n        return (0,_declarator_index_js__rspack_import_2.declare)(parsedItem);\n    \n    if (plugin.include)\n        return (0,_includer_index_js__rspack_import_0.include)(parsedItem);\n    \n    if (plugin.scan)\n        return (0,_scanner_index_js__rspack_import_3.scan)(parsedItem, {\n            progress,\n        });\n}\n\nfunction parseItem(item, runners = {}) {\n    const {plugin} = item;\n    \n    for (const [name, build] of entries(runners)) {\n        if (plugin[name])\n            return build(item);\n    }\n    \n    return item;\n}\n\n\n//# sourceURL=file://cloudcmd//Users/coderaiser/cloudcmd/node_modules/@putout/engine-runner/lib/builder/index.js\n}");
 
 },
 "./node_modules/@putout/engine-runner/lib/builder/replacer/index.js"
@@ -7849,7 +7849,7 @@ eval("{__webpack_require__.r(__webpack_exports__);\n__webpack_require__.d(__webp
   \***************************************************************/
 (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 "use strict";
-eval("{__webpack_require__.r(__webpack_exports__);\n__webpack_require__.d(__webpack_exports__, {\n  findAndReplace: () => (findAndReplace)\n});\n/* import */ var escape_string_regexp__rspack_import_0 = __webpack_require__(/*! escape-string-regexp */ \"./node_modules/mdast-util-find-and-replace/node_modules/escape-string-regexp/index.js\");\n/* import */ var unist_util_visit_parents__rspack_import_2 = __webpack_require__(/*! unist-util-visit-parents */ \"./node_modules/unist-util-visit-parents/lib/index.js\");\n/* import */ var unist_util_is__rspack_import_1 = __webpack_require__(/*! unist-util-is */ \"./node_modules/unist-util-is/lib/index.js\");\n/**\n * @import {Nodes, Parents, PhrasingContent, Root, Text} from 'mdast'\n * @import {BuildVisitor, Test, VisitorResult} from 'unist-util-visit-parents'\n */\n\n/**\n * @typedef RegExpMatchObject\n *   Info on the match.\n * @property {number} index\n *   The index of the search at which the result was found.\n * @property {string} input\n *   A copy of the search string in the text node.\n * @property {[...Array<Parents>, Text]} stack\n *   All ancestors of the text node, where the last node is the text itself.\n *\n * @typedef {RegExp | string} Find\n *   Pattern to find.\n *\n *   Strings are escaped and then turned into global expressions.\n *\n * @typedef {Array<FindAndReplaceTuple>} FindAndReplaceList\n *   Several find and replaces, in array form.\n *\n * @typedef {[Find, Replace?]} FindAndReplaceTuple\n *   Find and replace in tuple form.\n *\n * @typedef {ReplaceFunction | string | null | undefined} Replace\n *   Thing to replace with.\n *\n * @callback ReplaceFunction\n *   Callback called when a search matches.\n * @param {...any} parameters\n *   The parameters are the result of corresponding search expression:\n *\n *   * `value` (`string`) — whole match\n *   * `...capture` (`Array<string>`) — matches from regex capture groups\n *   * `match` (`RegExpMatchObject`) — info on the match\n * @returns {Array<PhrasingContent> | PhrasingContent | string | false | null | undefined}\n *   Thing to replace with.\n *\n *   * when `null`, `undefined`, `''`, remove the match\n *   * …or when `false`, do not replace at all\n *   * …or when `string`, replace with a text node of that value\n *   * …or when `Node` or `Array<Node>`, replace with those nodes\n *\n * @typedef {[RegExp, ReplaceFunction]} Pair\n *   Normalized find and replace.\n *\n * @typedef {Array<Pair>} Pairs\n *   All find and replaced.\n *\n * @typedef Options\n *   Configuration.\n * @property {Test | null | undefined} [ignore]\n *   Test for which nodes to ignore (optional).\n */\n\n\n\n\n\n/**\n * Find patterns in a tree and replace them.\n *\n * The algorithm searches the tree in *preorder* for complete values in `Text`\n * nodes.\n * Partial matches are not supported.\n *\n * @param {Nodes} tree\n *   Tree to change.\n * @param {FindAndReplaceList | FindAndReplaceTuple} list\n *   Patterns to find.\n * @param {Options | null | undefined} [options]\n *   Configuration (when `find` is not `Find`).\n * @returns {undefined}\n *   Nothing.\n */\nfunction findAndReplace(tree, list, options) {\n  const settings = options || {}\n  const ignored = (0,unist_util_is__rspack_import_1.convert)(settings.ignore || [])\n  const pairs = toPairs(list)\n  let pairIndex = -1\n\n  while (++pairIndex < pairs.length) {\n    (0,unist_util_visit_parents__rspack_import_2.visitParents)(tree, 'text', visitor)\n  }\n\n  /**\n   * Visit a text node, and handle it if it is not in an ignored parent.\n   *\n   * @type {BuildVisitor<Root, 'text'>}\n   */\n  function visitor(node, parents) {\n    let index = -1\n    /** @type {Parents | undefined} */\n    let grandparent\n\n    while (++index < parents.length) {\n      const parent = parents[index]\n      /** @type {Array<Nodes> | undefined} */\n      const siblings = grandparent ? grandparent.children : undefined\n\n      if (\n        ignored(\n          parent,\n          siblings ? siblings.indexOf(parent) : undefined,\n          grandparent\n        )\n      ) {\n        return\n      }\n\n      grandparent = parent\n    }\n\n    if (grandparent) {\n      return handler(node, parents)\n    }\n  }\n\n  /**\n   * Handle a text node which is not in an ignored parent.\n   *\n   * @param {Text} node\n   *   Text node to search in.\n   * @param {Array<Parents>} parents\n   *   Ancestors of `node`.\n   * @returns {VisitorResult}\n   *   Where to continue visiting.\n   */\n  function handler(node, parents) {\n    const parent = parents[parents.length - 1]\n    const find = pairs[pairIndex][0]\n    const replace = pairs[pairIndex][1]\n    let start = 0\n    /** @type {Array<Nodes>} */\n    const siblings = parent.children\n    const index = siblings.indexOf(node)\n    let change = false\n    /** @type {Array<PhrasingContent>} */\n    let nodes = []\n\n    find.lastIndex = 0\n\n    let match = find.exec(node.value)\n\n    while (match) {\n      const position = match.index\n      /** @type {RegExpMatchObject} */\n      const matchObject = {\n        index: match.index,\n        input: match.input,\n        stack: [...parents, node]\n      }\n      let value = replace(...match, matchObject)\n\n      if (typeof value === 'string') {\n        value = value.length > 0 ? {type: 'text', value} : undefined\n      }\n\n      // It wasn’t a match after all.\n      if (value === false) {\n        // False acts as if there was no match.\n        // So we need to reset `lastIndex`, which currently being at the end of\n        // the current match, to the beginning.\n        find.lastIndex = position + 1\n      } else {\n        if (start !== position) {\n          add({type: 'text', value: node.value.slice(start, position)})\n        }\n\n        if (Array.isArray(value)) {\n          for (const child of value) add(child)\n        } else if (value) {\n          add(value)\n        }\n\n        start = position + match[0].length\n        change = true\n      }\n\n      if (!find.global) {\n        break\n      }\n\n      match = find.exec(node.value)\n    }\n\n    if (change) {\n      if (start < node.value.length) {\n        add({type: 'text', value: node.value.slice(start)})\n      }\n\n      parent.children.splice(index, 1, ...nodes)\n    } else {\n      nodes = [node]\n    }\n\n    return index + nodes.length\n\n    /**\n     * Add a node.\n     *\n     * @param {PhrasingContent} child\n     *   Node to add.\n     * @returns {undefined}\n     *   Nothing.\n     */\n    function add(child) {\n      const previous = nodes[nodes.length - 1]\n\n      if (previous && previous.type === 'text' && child.type === 'text') {\n        previous.value += child.value\n      } else {\n        nodes.push(child)\n      }\n    }\n  }\n}\n\n/**\n * Turn a tuple or a list of tuples into pairs.\n *\n * @param {FindAndReplaceList | FindAndReplaceTuple} tupleOrList\n *   Schema.\n * @returns {Pairs}\n *   Clean pairs.\n */\nfunction toPairs(tupleOrList) {\n  if (!Array.isArray(tupleOrList)) {\n    throw new TypeError('Expected find and replace tuple or list of tuples')\n  }\n\n  /** @type {Pairs} */\n  const result = []\n\n  /** @type {FindAndReplaceList} */\n  // @ts-expect-error: correct.\n  const list =\n    !tupleOrList[0] || Array.isArray(tupleOrList[0])\n      ? tupleOrList\n      : [tupleOrList]\n\n  let index = -1\n\n  while (++index < list.length) {\n    const tuple = list[index]\n    result.push([toExpression(tuple[0]), toFunction(tuple[1])])\n  }\n\n  return result\n}\n\n/**\n * Turn a find into an expression.\n *\n * @param {Find} find\n *   Pattern to find.\n * @returns {RegExp}\n *   Global expression.\n */\nfunction toExpression(find) {\n  return typeof find === 'string' ? new RegExp((0,escape_string_regexp__rspack_import_0[\"default\"])(find), 'g') : find\n}\n\n/**\n * Turn a replace into a function.\n *\n * @param {Replace} replace\n *   Thing to replace with.\n * @returns {ReplaceFunction}\n *   Function that returns that thing.\n */\nfunction toFunction(replace) {\n  return typeof replace === 'function'\n    ? replace\n    : function () {\n        return replace\n      }\n}\n\n\n//# sourceURL=file://cloudcmd//Users/coderaiser/cloudcmd/node_modules/mdast-util-find-and-replace/lib/index.js\n}");
+eval("{__webpack_require__.r(__webpack_exports__);\n__webpack_require__.d(__webpack_exports__, {\n  findAndReplace: () => (findAndReplace)\n});\n/* import */ var escape_string_regexp__rspack_import_0 = __webpack_require__(/*! escape-string-regexp */ \"./node_modules/mdast-util-find-and-replace/node_modules/escape-string-regexp/index.js\");\n/* import */ var unist_util_visit_parents__rspack_import_2 = __webpack_require__(/*! unist-util-visit-parents */ \"./node_modules/unist-util-visit-parents/lib/index.js\");\n/* import */ var unist_util_is__rspack_import_1 = __webpack_require__(/*! unist-util-is */ \"./node_modules/unist-util-is/lib/index.js\");\n/**\n * @import {Nodes, Parents, PhrasingContent, Root, Text} from 'mdast'\n * @import {BuildVisitor, Test, VisitorResult} from 'unist-util-visit-parents'\n */\n\n/**\n * @typedef RegExpMatchObject\n *   Info on the match.\n * @property {number} index\n *   The index of the search at which the result was found.\n * @property {string} input\n *   A copy of the search string in the text node.\n * @property {[...Array<Parents>, Text]} stack\n *   All ancestors of the text node, where the last node is the text itself.\n *\n * @typedef {RegExp | string} Find\n *   Pattern to find.\n *\n *   Strings are escaped and then turned into global expressions.\n *\n * @typedef {Array<FindAndReplaceTuple>} FindAndReplaceList\n *   Several find and replaces, in array form.\n *\n * @typedef {[Find, Replace?]} FindAndReplaceTuple\n *   Find and replace in tuple form.\n *\n * @typedef {ReplaceFunction | string | null | undefined} Replace\n *   Thing to replace with.\n *\n * @callback ReplaceFunction\n *   Callback called when a search matches.\n * @param {...any} parameters\n *   The parameters are the result of corresponding search expression:\n *\n *   * `value` (`string`) — whole match\n *   * `...capture` (`Array<string>`) — matches from regex capture groups\n *   * `match` (`RegExpMatchObject`) — info on the match\n * @returns {Array<PhrasingContent> | PhrasingContent | string | false | null | undefined}\n *   Thing to replace with.\n *\n *   * when `null`, `undefined`, `''`, remove the match\n *   * …or when `false`, do not replace at all\n *   * …or when `string`, replace with a text node of that value\n *   * …or when `Node` or `Array<Node>`, replace with those nodes\n *\n * @typedef {[RegExp, ReplaceFunction]} Pair\n *   Normalized find and replace.\n *\n * @typedef {Array<Pair>} Pairs\n *   All find and replaced.\n *\n * @typedef Options\n *   Configuration.\n * @property {Test | null | undefined} [ignore]\n *   Test for which nodes to ignore (optional).\n */\n\n\n\n\n\n/**\n * Find patterns in a tree and replace them.\n *\n * The algorithm searches the tree in *preorder* for complete values in `Text`\n * nodes.\n * Partial matches are not supported.\n *\n * @param {Nodes} tree\n *   Tree to change.\n * @param {FindAndReplaceList | FindAndReplaceTuple} list\n *   Patterns to find.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {undefined}\n *   Nothing.\n */\nfunction findAndReplace(tree, list, options) {\n  const settings = options || {}\n  const ignored = (0,unist_util_is__rspack_import_1.convert)(settings.ignore || [])\n  const pairs = toPairs(list)\n  let pairIndex = -1\n\n  while (++pairIndex < pairs.length) {\n    (0,unist_util_visit_parents__rspack_import_2.visitParents)(tree, visitor)\n  }\n\n  /**\n   * Handle text nodes and skip ignored nodes.\n   *\n   * @type {BuildVisitor<Root>}\n   */\n  function visitor(node, parents, index) {\n    if (node.type === 'text' && typeof index === 'number') {\n      return handler(node, parents, index)\n    }\n\n    if (ignored(node, index, parents[parents.length - 1])) return unist_util_visit_parents__rspack_import_2.SKIP\n  }\n\n  /**\n   * Handle a text node which is not in an ignored parent.\n   *\n   * @param {Text} node\n   *   Text node to search in.\n   * @param {Array<Parents>} parents\n   *   Ancestors of `node`.\n   * @param {number} index\n   *   Index of `node` in its parent.\n   * @returns {VisitorResult}\n   *   Where to continue visiting.\n   */\n  function handler(node, parents, index) {\n    const parent = parents[parents.length - 1]\n    const find = pairs[pairIndex][0]\n    const replace = pairs[pairIndex][1]\n    let start = 0\n    let change = false\n    /** @type {Array<PhrasingContent>} */\n    let nodes = []\n\n    find.lastIndex = 0\n\n    let match = find.exec(node.value)\n\n    while (match) {\n      const position = match.index\n      /** @type {RegExpMatchObject} */\n      const matchObject = {\n        index: match.index,\n        input: match.input,\n        stack: [...parents, node]\n      }\n      let value = replace(...match, matchObject)\n\n      if (typeof value === 'string') {\n        value = value.length > 0 ? {type: 'text', value} : undefined\n      }\n\n      // It wasn’t a match after all.\n      if (value === false) {\n        // False acts as if there was no match.\n        // So we need to reset `lastIndex`, which currently being at the end of\n        // the current match, to the beginning.\n        find.lastIndex = position + 1\n      } else {\n        if (start !== position) {\n          add({type: 'text', value: node.value.slice(start, position)})\n        }\n\n        if (Array.isArray(value)) {\n          for (const child of value) add(child)\n        } else if (value) {\n          add(value)\n        }\n\n        start = position + match[0].length\n        change = true\n      }\n\n      if (!find.global) {\n        break\n      }\n\n      match = find.exec(node.value)\n    }\n\n    if (change) {\n      if (start < node.value.length) {\n        add({type: 'text', value: node.value.slice(start)})\n      }\n\n      parent.children.splice(index, 1, ...nodes)\n    } else {\n      nodes = [node]\n    }\n\n    return index + nodes.length\n\n    /**\n     * Add a node.\n     *\n     * @param {PhrasingContent} child\n     *   Node to add.\n     * @returns {undefined}\n     *   Nothing.\n     */\n    function add(child) {\n      const previous = nodes[nodes.length - 1]\n\n      if (previous && previous.type === 'text' && child.type === 'text') {\n        previous.value += child.value\n      } else {\n        nodes.push(child)\n      }\n    }\n  }\n}\n\n/**\n * Turn a tuple or a list of tuples into pairs.\n *\n * @param {FindAndReplaceList | FindAndReplaceTuple} tupleOrList\n *   Schema.\n * @returns {Pairs}\n *   Clean pairs.\n */\nfunction toPairs(tupleOrList) {\n  if (!Array.isArray(tupleOrList)) {\n    throw new TypeError('Expected find and replace tuple or list of tuples')\n  }\n\n  /** @type {Pairs} */\n  const result = []\n\n  const list =\n    !tupleOrList[0] || Array.isArray(tupleOrList[0])\n      ? /** @type {FindAndReplaceList} */ (tupleOrList)\n      : [/** @type {FindAndReplaceTuple} */ (tupleOrList)]\n\n  let index = -1\n\n  while (++index < list.length) {\n    const tuple = list[index]\n    result.push([toExpression(tuple[0]), toFunction(tuple[1])])\n  }\n\n  return result\n}\n\n/**\n * Turn a find into an expression.\n *\n * @param {Find} find\n *   Pattern to find.\n * @returns {RegExp}\n *   Global expression.\n */\nfunction toExpression(find) {\n  return typeof find === 'string' ? new RegExp((0,escape_string_regexp__rspack_import_0[\"default\"])(find), 'g') : find\n}\n\n/**\n * Turn a replace into a function.\n *\n * @param {Replace} replace\n *   Thing to replace with.\n * @returns {ReplaceFunction}\n *   Function that returns that thing.\n */\nfunction toFunction(replace) {\n  return typeof replace === 'function'\n    ? replace\n    : function () {\n        return replace\n      }\n}\n\n\n//# sourceURL=file://cloudcmd//Users/coderaiser/cloudcmd/node_modules/mdast-util-find-and-replace/lib/index.js\n}");
 
 },
 "./node_modules/mdast-util-find-and-replace/node_modules/escape-string-regexp/index.js"
@@ -9532,7 +9532,7 @@ eval("{__webpack_require__.r(__webpack_exports__);\n__webpack_require__.d(__webp
   \************************************************************/
 (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 "use strict";
-eval("{__webpack_require__.r(__webpack_exports__);\n__webpack_require__.d(__webpack_exports__, {\n  color: () => (color)\n});\n/**\n * @param {string} d\n * @returns {string}\n */\nfunction color(d) {\n  return d\n}\n\n\n//# sourceURL=file://cloudcmd//Users/coderaiser/cloudcmd/node_modules/unist-util-visit-parents/lib/color.js\n}");
+eval("{__webpack_require__.r(__webpack_exports__);\n__webpack_require__.d(__webpack_exports__, {\n  color: () => (color)\n});\n/**\n * Color a string.\n *\n * @param {string} d\n *   Value.\n * @returns {string}\n *   Colored value.\n */\nfunction color(d) {\n  return d\n}\n\n\n//# sourceURL=file://cloudcmd//Users/coderaiser/cloudcmd/node_modules/unist-util-visit-parents/lib/color.js\n}");
 
 },
 "./node_modules/unist-util-visit-parents/lib/index.js"
@@ -9541,7 +9541,7 @@ eval("{__webpack_require__.r(__webpack_exports__);\n__webpack_require__.d(__webp
   \************************************************************/
 (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 "use strict";
-eval("{__webpack_require__.r(__webpack_exports__);\n__webpack_require__.d(__webpack_exports__, {\n  CONTINUE: () => (CONTINUE),\n  EXIT: () => (EXIT),\n  SKIP: () => (SKIP),\n  visitParents: () => (visitParents)\n});\n/* import */ var unist_util_is__rspack_import_0 = __webpack_require__(/*! unist-util-is */ \"./node_modules/unist-util-is/lib/index.js\");\n/* import */ var unist_util_visit_parents_do_not_use_color__rspack_import_1 = __webpack_require__(/*! unist-util-visit-parents/do-not-use-color */ \"./node_modules/unist-util-visit-parents/lib/color.js\");\n/**\n * @import {Node as UnistNode, Parent as UnistParent} from 'unist'\n */\n\n/**\n * @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test\n *   Test from `unist-util-is`.\n *\n *   Note: we have remove and add `undefined`, because otherwise when generating\n *   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,\n *   which doesn’t work when publishing on npm.\n */\n\n/**\n * @typedef {(\n *   Fn extends (value: any) => value is infer Thing\n *   ? Thing\n *   : Fallback\n * )} Predicate\n *   Get the value of a type guard `Fn`.\n * @template Fn\n *   Value; typically function that is a type guard (such as `(x): x is Y`).\n * @template Fallback\n *   Value to yield if `Fn` is not a type guard.\n */\n\n/**\n * @typedef {(\n *   Check extends null | undefined // No test.\n *   ? Value\n *   : Value extends {type: Check} // String (type) test.\n *   ? Value\n *   : Value extends Check // Partial test.\n *   ? Value\n *   : Check extends Function // Function test.\n *   ? Predicate<Check, Value> extends Value\n *     ? Predicate<Check, Value>\n *     : never\n *   : never // Some other test?\n * )} MatchesOne\n *   Check whether a node matches a primitive check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test, but not arrays.\n */\n\n/**\n * @typedef {(\n *   Check extends ReadonlyArray<infer T>\n *   ? MatchesOne<Value, T>\n *   : Check extends Array<infer T>\n *   ? MatchesOne<Value, T>\n *   : MatchesOne<Value, Check>\n * )} Matches\n *   Check whether a node matches a check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test.\n */\n\n/**\n * @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint\n *   Number; capped reasonably.\n */\n\n/**\n * @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment\n *   Increment a number in the type system.\n * @template {Uint} [I=0]\n *   Index.\n */\n\n/**\n * @typedef {(\n *   Node extends UnistParent\n *   ? Node extends {children: Array<infer Children>}\n *     ? Child extends Children ? Node : never\n *     : never\n *   : never\n * )} InternalParent\n *   Collect nodes that can be parents of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {InternalParent<InclusiveDescendant<Tree>, Child>} Parent\n *   Collect nodes in `Tree` that can be parents of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Depth extends Max\n *   ? never\n *   :\n *     | InternalParent<Node, Child>\n *     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>\n * )} InternalAncestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {InternalAncestor<InclusiveDescendant<Tree>, Child>} Ancestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Tree extends UnistParent\n *     ? Depth extends Max\n *       ? Tree\n *       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>\n *     : Tree\n * )} InclusiveDescendant\n *   Collect all (inclusive) descendants of `Tree`.\n *\n *   > 👉 **Note**: for performance reasons, this seems to be the fastest way to\n *   > recurse without actually running into an infinite loop, which the\n *   > previous version did.\n *   >\n *   > Practically, a max of `2` is typically enough assuming a `Root` is\n *   > passed, but it doesn’t improve performance.\n *   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.\n *   > Using up to `10` doesn’t hurt or help either.\n * @template {UnistNode} Tree\n *   Tree type.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {'skip' | boolean} Action\n *   Union of the action types.\n *\n * @typedef {number} Index\n *   Move to the sibling at `index` next (after node itself is completely\n *   traversed).\n *\n *   Useful if mutating the tree, such as removing the node the visitor is\n *   currently on, or any of its previous siblings.\n *   Results less than 0 or greater than or equal to `children.length` stop\n *   traversing the parent.\n *\n * @typedef {[(Action | null | undefined | void)?, (Index | null | undefined)?]} ActionTuple\n *   List with one or two values, the first an action, the second an index.\n *\n * @typedef {Action | ActionTuple | Index | null | undefined | void} VisitorResult\n *   Any value that can be returned from a visitor.\n */\n\n/**\n * @callback Visitor\n *   Handle a node (matching `test`, if given).\n *\n *   Visitors are free to transform `node`.\n *   They can also transform the parent of node (the last of `ancestors`).\n *\n *   Replacing `node` itself, if `SKIP` is not returned, still causes its\n *   descendants to be walked (which is a bug).\n *\n *   When adding or removing previous siblings of `node` (or next siblings, in\n *   case of reverse), the `Visitor` should return a new `Index` to specify the\n *   sibling to traverse after `node` is traversed.\n *   Adding or removing next siblings of `node` (or previous siblings, in case\n *   of reverse) is handled as expected without needing to return a new `Index`.\n *\n *   Removing the children property of an ancestor still results in them being\n *   traversed.\n * @param {Visited} node\n *   Found node.\n * @param {Array<VisitedParents>} ancestors\n *   Ancestors of `node`.\n * @returns {VisitorResult}\n *   What to do next.\n *\n *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.\n *   An `Action` is treated as a tuple of `[Action]`.\n *\n *   Passing a tuple back only makes sense if the `Action` is `SKIP`.\n *   When the `Action` is `EXIT`, that action can be returned.\n *   When the `Action` is `CONTINUE`, `Index` can be returned.\n * @template {UnistNode} [Visited=UnistNode]\n *   Visited node type.\n * @template {UnistParent} [VisitedParents=UnistParent]\n *   Ancestor type.\n */\n\n/**\n * @typedef {Visitor<Matches<InclusiveDescendant<Tree>, Check>, Ancestor<Tree, Matches<InclusiveDescendant<Tree>, Check>>>} BuildVisitor\n *   Build a typed `Visitor` function from a tree and a test.\n *\n *   It will infer which values are passed as `node` and which as `parents`.\n * @template {UnistNode} [Tree=UnistNode]\n *   Tree type.\n * @template {Test} [Check=Test]\n *   Test type.\n */\n\n\n\n\n/** @type {Readonly<ActionTuple>} */\nconst empty = []\n\n/**\n * Continue traversing as normal.\n */\nconst CONTINUE = true\n\n/**\n * Stop traversing immediately.\n */\nconst EXIT = false\n\n/**\n * Do not traverse this node’s children.\n */\nconst SKIP = 'skip'\n\n/**\n * Visit nodes, with ancestral information.\n *\n * This algorithm performs *depth-first* *tree traversal* in *preorder*\n * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).\n *\n * You can choose for which nodes `visitor` is called by passing a `test`.\n * For complex tests, you should test yourself in `visitor`, as it will be\n * faster and will have improved type information.\n *\n * Walking the tree is an intensive task.\n * Make use of the return values of the visitor when possible.\n * Instead of walking a tree multiple times, walk it once, use `unist-util-is`\n * to check if a node matches, and then perform different operations.\n *\n * You can change the tree.\n * See `Visitor` for more info.\n *\n * @overload\n * @param {Tree} tree\n * @param {Check} check\n * @param {BuildVisitor<Tree, Check>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @overload\n * @param {Tree} tree\n * @param {BuildVisitor<Tree>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @param {UnistNode} tree\n *   Tree to traverse.\n * @param {Visitor | Test} test\n *   `unist-util-is`-compatible test\n * @param {Visitor | boolean | null | undefined} [visitor]\n *   Handle each node.\n * @param {boolean | null | undefined} [reverse]\n *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).\n * @returns {undefined}\n *   Nothing.\n *\n * @template {UnistNode} Tree\n *   Node type.\n * @template {Test} Check\n *   `unist-util-is`-compatible test.\n */\nfunction visitParents(tree, test, visitor, reverse) {\n  /** @type {Test} */\n  let check\n\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor\n    // @ts-expect-error no visitor given, so `visitor` is test.\n    visitor = test\n  } else {\n    // @ts-expect-error visitor given, so `test` isn’t a visitor.\n    check = test\n  }\n\n  const is = (0,unist_util_is__rspack_import_0.convert)(check)\n  const step = reverse ? -1 : 1\n\n  factory(tree, undefined, [])()\n\n  /**\n   * @param {UnistNode} node\n   * @param {number | undefined} index\n   * @param {Array<UnistParent>} parents\n   */\n  function factory(node, index, parents) {\n    const value = /** @type {Record<string, unknown>} */ (\n      node && typeof node === 'object' ? node : {}\n    )\n\n    if (typeof value.type === 'string') {\n      const name =\n        // `hast`\n        typeof value.tagName === 'string'\n          ? value.tagName\n          : // `xast`\n            typeof value.name === 'string'\n            ? value.name\n            : undefined\n\n      Object.defineProperty(visit, 'name', {\n        value:\n          'node (' + (0,unist_util_visit_parents_do_not_use_color__rspack_import_1.color)(node.type + (name ? '<' + name + '>' : '')) + ')'\n      })\n    }\n\n    return visit\n\n    function visit() {\n      /** @type {Readonly<ActionTuple>} */\n      let result = empty\n      /** @type {Readonly<ActionTuple>} */\n      let subresult\n      /** @type {number} */\n      let offset\n      /** @type {Array<UnistParent>} */\n      let grandparents\n\n      if (!test || is(node, index, parents[parents.length - 1] || undefined)) {\n        // @ts-expect-error: `visitor` is now a visitor.\n        result = toResult(visitor(node, parents))\n\n        if (result[0] === EXIT) {\n          return result\n        }\n      }\n\n      if ('children' in node && node.children) {\n        const nodeAsParent = /** @type {UnistParent} */ (node)\n\n        if (nodeAsParent.children && result[0] !== SKIP) {\n          offset = (reverse ? nodeAsParent.children.length : -1) + step\n          grandparents = parents.concat(nodeAsParent)\n\n          while (offset > -1 && offset < nodeAsParent.children.length) {\n            const child = nodeAsParent.children[offset]\n\n            subresult = factory(child, offset, grandparents)()\n\n            if (subresult[0] === EXIT) {\n              return subresult\n            }\n\n            offset =\n              typeof subresult[1] === 'number' ? subresult[1] : offset + step\n          }\n        }\n      }\n\n      return result\n    }\n  }\n}\n\n/**\n * Turn a return value into a clean result.\n *\n * @param {VisitorResult} value\n *   Valid return values from visitors.\n * @returns {Readonly<ActionTuple>}\n *   Clean result.\n */\nfunction toResult(value) {\n  if (Array.isArray(value)) {\n    return value\n  }\n\n  if (typeof value === 'number') {\n    return [CONTINUE, value]\n  }\n\n  return value === null || value === undefined ? empty : [value]\n}\n\n\n//# sourceURL=file://cloudcmd//Users/coderaiser/cloudcmd/node_modules/unist-util-visit-parents/lib/index.js\n}");
+eval("{__webpack_require__.r(__webpack_exports__);\n__webpack_require__.d(__webpack_exports__, {\n  CONTINUE: () => (CONTINUE),\n  EXIT: () => (EXIT),\n  SKIP: () => (SKIP),\n  visitParents: () => (visitParents)\n});\n/* import */ var unist_util_is__rspack_import_0 = __webpack_require__(/*! unist-util-is */ \"./node_modules/unist-util-is/lib/index.js\");\n/* import */ var unist_util_visit_parents_do_not_use_color__rspack_import_1 = __webpack_require__(/*! unist-util-visit-parents/do-not-use-color */ \"./node_modules/unist-util-visit-parents/lib/color.js\");\n/**\n * @import {Node as UnistNode, Parent as UnistParent} from 'unist'\n */\n\n/**\n * @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test\n *   Test from `unist-util-is`.\n *\n *   Note: we have remove and add `undefined`, because otherwise when generating\n *   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,\n *   which doesn’t work when publishing on npm.\n */\n\n/**\n * @typedef {(\n *   Fn extends (value: any) => value is infer Thing\n *   ? Thing\n *   : Fallback\n * )} Predicate\n *   Get the value of a type guard `Fn`.\n * @template Fn\n *   Value; typically function that is a type guard (such as `(x): x is Y`).\n * @template Fallback\n *   Value to yield if `Fn` is not a type guard.\n */\n\n/**\n * @typedef {(\n *   Check extends null | undefined // No test.\n *   ? Value\n *   : Value extends {type: Check} // String (type) test.\n *   ? Value\n *   : Value extends Check // Partial test.\n *   ? Value\n *   : Check extends Function // Function test.\n *   ? Predicate<Check, Value> extends Value\n *     ? Predicate<Check, Value>\n *     : never\n *   : never // Some other test?\n * )} MatchesOne\n *   Check whether a node matches a primitive check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test, but not arrays.\n */\n\n/**\n * @typedef {(\n *   Check extends ReadonlyArray<infer T>\n *   ? MatchesOne<Value, T>\n *   : Check extends Array<infer T>\n *   ? MatchesOne<Value, T>\n *   : MatchesOne<Value, Check>\n * )} Matches\n *   Check whether a node matches a check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test.\n */\n\n/**\n * @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint\n *   Number; capped reasonably.\n */\n\n/**\n * @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment\n *   Increment a number in the type system.\n * @template {Uint} [I=0]\n *   Index.\n */\n\n/**\n * @typedef {(\n *   Node extends UnistParent\n *   ? Node extends {children: Array<infer Children>}\n *     ? Child extends Children ? Node : never\n *     : never\n *   : never\n * )} InternalParent\n *   Collect nodes that can be parents of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {InternalParent<InclusiveDescendant<Tree>, Child>} Parent\n *   Collect nodes in `Tree` that can be parents of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Depth extends Max\n *   ? never\n *   :\n *     | InternalParent<Node, Child>\n *     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>\n * )} InternalAncestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {InternalAncestor<InclusiveDescendant<Tree>, Child>} Ancestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Tree extends UnistParent\n *     ? Depth extends Max\n *       ? Tree\n *       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>\n *     : Tree\n * )} InclusiveDescendant\n *   Collect all (inclusive) descendants of `Tree`.\n *\n *   > 👉 **Note**: for performance reasons, this seems to be the fastest way to\n *   > recurse without actually running into an infinite loop, which the\n *   > previous version did.\n *   >\n *   > Practically, a max of `2` is typically enough assuming a `Root` is\n *   > passed, but it doesn’t improve performance.\n *   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.\n *   > Using up to `10` doesn’t hurt or help either.\n * @template {UnistNode} Tree\n *   Tree type.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {'skip' | boolean} Action\n *   Union of the action types.\n *\n * @typedef {number} Index\n *   Move to the sibling at `index` next (after node itself is completely\n *   traversed).\n *\n *   Useful if mutating the tree, such as removing the node the visitor is\n *   currently on, or any of its previous siblings.\n *   Results less than 0 or greater than or equal to `children.length` stop\n *   traversing the parent.\n *\n * @typedef {[(Action | null | undefined | void)?, (Index | null | undefined)?]} ActionTuple\n *   List with one or two values, the first an action, the second an index.\n *\n * @typedef {Action | ActionTuple | Index | null | undefined | void} VisitorResult\n *   Any value that can be returned from an enter visitor.\n *\n *   Like `VisitorResultExit`,\n *   but `SKIP` can also be returned,\n *   to not walk the children of the node,\n *   and `ActionTuple` can be used to combine an action with an index.\n *\n * @typedef {Index | boolean | null | undefined | void} VisitorResultExit\n *   Any value that can be returned from an exit visitor.\n */\n\n/**\n * @callback Visitor\n *   Handle a node (matching `test`, if given) before its children.\n *\n *   Changes inside `node` are walked next.\n *   Replacing or removing it is easier in `exit`.\n *   When replacing or removing it here,\n *   return `SKIP` (as otherwise its old children are walked),\n *   or `[SKIP, index]` to continue with the node now at `index`.\n *   Changing next siblings (in walk order) is fine;\n *   changing previous siblings needs a new `Index`.\n *   Removing an ancestor or changing its previous siblings is not supported.\n * @param {Visited} node\n *   Found node.\n * @param {Array<VisitedParents>} ancestors\n *   Ancestors of `node`.\n * @param {number | undefined} index\n *   Index of `node` in its parent (the last of `ancestors`),\n *   or `undefined` for the tree itself.\n * @returns {VisitorResult}\n *   What to do next.\n *\n *   Like `VisitorExit`,\n *   but `SKIP` can also be returned,\n *   to not walk the children of `node`.\n *   Passing a tuple back (`ActionTuple`) only makes sense as `[SKIP, Index]`.\n * @template {UnistNode} [Visited=UnistNode]\n *   Visited node type.\n * @template {UnistParent} [VisitedParents=UnistParent]\n *   Ancestor type.\n */\n\n/**\n * @callback VisitorExit\n *   Handle a node (matching `test`, if given) after its children.\n *\n *   Changes inside `node` are not walked,\n *   which makes this a good place to change `node` based on its children,\n *   or to replace or remove it.\n *   When removing `node` or changing previous siblings (in walk order),\n *   return a new `Index`.\n *   Removing an ancestor or changing its previous siblings is not supported.\n * @param {Visited} node\n *   Found node.\n * @param {Array<VisitedParents>} ancestors\n *   Ancestors of `node`.\n * @param {number | undefined} index\n *   Index of `node` in its parent (the last of `ancestors`),\n *   or `undefined` for the tree itself.\n * @returns {VisitorResultExit}\n *   What to do next.\n *\n *   `CONTINUE` (`true`, nothing) continues as normal,\n *   `EXIT` (`false`) stops traversing,\n *   and `Index` continues at that sibling.\n * @template {UnistNode} [Visited=UnistNode]\n *   Visited node type.\n * @template {UnistParent} [VisitedParents=UnistParent]\n *   Ancestor type.\n */\n\n/**\n * @template {UnistNode} [Visited=UnistNode]\n *   Visited node type.\n * @template {UnistParent} [VisitedParents=UnistParent]\n *   Ancestor type.\n * @typedef Visitors\n *   Handle nodes when entering and exiting them.\n *   The `enter` visitor is optional while `exit` is required.\n *\n *   Pass an `enter` visitor directly to only handle nodes when entering them.\n *\n *   `enter` is called before children (if any) are walked and `exit` after that.\n *   `exit` is still called when `enter` returns `SKIP`.\n *   Both `enter` and `exit` are only called for nodes that match an optional `test`.\n * @property {Visitor<Visited, VisitedParents> | null | undefined} [enter]\n *   Handle a node before its children (optional).\n * @property {VisitorExit<Visited, VisitedParents>} exit\n *   Handle a node after its children.\n */\n\n/**\n * @typedef {Visitor<Matches<InclusiveDescendant<Tree>, Check>, Ancestor<Tree, Matches<InclusiveDescendant<Tree>, Check>>>} BuildVisitor\n *   Build a typed `Visitor` function from a tree and a test.\n *\n *   It will infer which values are passed as `node` and which as `parents`.\n * @template {UnistNode} [Tree=UnistNode]\n *   Tree type.\n * @template {Test} [Check=Test]\n *   Test type.\n */\n\n/**\n * @typedef {Visitors<Matches<InclusiveDescendant<Tree>, Check>, Ancestor<Tree, Matches<InclusiveDescendant<Tree>, Check>>>} BuildVisitors\n *   Build typed `Visitors` from a tree and a test.\n *\n *   It will infer which values are passed as `node` and which as `parents`.\n * @template {UnistNode} [Tree=UnistNode]\n *   Tree type.\n * @template {Test} [Check=Test]\n *   Test type.\n */\n\n\n\n\n/** @type {Readonly<ActionTuple>} */\nconst empty = []\n\n/**\n * Continue traversing as normal.\n */\nconst CONTINUE = true\n\n/**\n * Stop traversing immediately.\n */\nconst EXIT = false\n\n/**\n * Do not traverse this node’s children.\n * Only works when entering a node.\n */\nconst SKIP = 'skip'\n\n/**\n * Visit nodes, with ancestral information.\n *\n * This algorithm performs *depth-first* *tree traversal* in *preorder*\n * (**NLR**) or if `reverse` is given,\n * in *reverse preorder* (**NRL**).\n * An `exit` visitor is called in *postorder* (**LRN**)\n * or if `reverse` is given, in *reverse postorder* (**RLN**).\n *\n * You can choose which nodes are visited by passing a `test`.\n * For complex tests, you should test yourself in a visitor, as it will be\n * faster and will have improved type information.\n *\n * Walking the tree is an intensive task.\n * Make use of the return values of the visitor when possible.\n * Instead of walking a tree multiple times, walk it once, use `unist-util-is`\n * to check if a node matches, and then perform different operations.\n *\n * You can change the tree.\n * Changes inside a node made when entering it are walked,\n * changes made when exiting it are not.\n * See `Visitor` and `VisitorExit` for more info.\n *\n * @overload\n * @param {Tree} tree\n *   Tree to traverse.\n * @param {Check} check\n *   `unist-util-is`-compatible test.\n * @param {BuildVisitor<Tree, Check>} enter\n *   Handle each node when entering it.\n * @param {boolean | null | undefined} [reverse]\n *   Walk children from last to first;\n *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);\n *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).\n * @returns {undefined}\n *   Nothing.\n *\n * @overload\n * @param {Tree} tree\n *   Tree to traverse.\n * @param {Check} check\n *   `unist-util-is`-compatible test.\n * @param {BuildVisitors<Tree, Check>} visitors\n *   Handle each node when exiting it, and optionally when entering it.\n * @param {boolean | null | undefined} [reverse]\n *   Walk children from last to first;\n *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);\n *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).\n * @returns {undefined}\n *   Nothing.\n *\n * @overload\n * @param {Tree} tree\n *   Tree to traverse.\n * @param {BuildVisitor<Tree>} enter\n *   Handle each node when entering it.\n * @param {boolean | null | undefined} [reverse]\n *   Walk children from last to first;\n *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);\n *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).\n * @returns {undefined}\n *   Nothing.\n *\n * @overload\n * @param {Tree} tree\n *   Tree to traverse.\n * @param {BuildVisitors<Tree>} visitors\n *   Handle each node when exiting it, and optionally when entering it.\n * @param {boolean | null | undefined} [reverse]\n *   Walk children from last to first;\n *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);\n *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).\n * @returns {undefined}\n *   Nothing.\n *\n * @param {UnistNode} tree\n *   Tree to traverse.\n * @param {Visitor | Visitors | Test} testOrEnterOrVisitors\n *   `unist-util-is`-compatible test, `enter`, or `visitors`.\n * @param {Visitor | Visitors | boolean | null | undefined} [enterOrVisitorsOrReverse]\n *   `enter`, `visitors`, or `reverse` after a test.\n * @param {boolean | null | undefined} [reverse]\n *   Walk children from last to first;\n *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);\n *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).\n * @returns {undefined}\n *   Nothing.\n *\n * @template {UnistNode} Tree\n *   Node type.\n * @template {Test} Check\n *   `unist-util-is`-compatible test.\n */\nfunction visitParents(\n  tree,\n  testOrEnterOrVisitors,\n  enterOrVisitorsOrReverse,\n  reverse\n) {\n  if (!tree || typeof tree !== 'object') {\n    throw new Error('Unexpected value `' + tree + '` for `tree`, expected node')\n  }\n\n  let preorder = true\n  /** @type {Test} */\n  let check\n  /** @type {Visitors | Visitor} */\n  let visitors\n  /** @type {Visitor | null | undefined} */\n  let enter\n  /** @type {VisitorExit | null | undefined} */\n  let exit\n\n  // Third parameter is an enter visitor or a visitors object, so expect a `test` too.\n  if (\n    typeof enterOrVisitorsOrReverse === 'function' ||\n    (enterOrVisitorsOrReverse && typeof enterOrVisitorsOrReverse === 'object')\n  ) {\n    check = /** @type {Test} */ (testOrEnterOrVisitors)\n    visitors = enterOrVisitorsOrReverse\n    if (reverse) preorder = false\n  }\n  // Assume no test.\n  else {\n    visitors = /** @type {Visitors | Visitor} */ (testOrEnterOrVisitors)\n    if (enterOrVisitorsOrReverse) preorder = false\n  }\n\n  if (typeof visitors === 'function') {\n    enter = visitors\n  } else if (visitors && typeof visitors === 'object') {\n    if (visitors.enter === null || visitors.enter === undefined) {\n      // Empty.\n    } else if (typeof visitors.enter === 'function') {\n      enter = visitors.enter\n    } else {\n      throw new Error(\n        'Unexpected value `' +\n          visitors.enter +\n          '` for `visitors.enter`, expected optional visitor'\n      )\n    }\n\n    if (typeof visitors.exit === 'function') {\n      exit = visitors.exit\n    } else {\n      throw new Error(\n        'Unexpected value `' +\n          visitors.exit +\n          '` for `visitors.exit`, expected visitor (pass a visitor directly if you only want an enter visitor)'\n      )\n    }\n  } else {\n    throw new Error(\n      'Unexpected value `' +\n        visitors +\n        '` for `enter` or `visitors`, expected visitor or object with visitors'\n    )\n  }\n\n  const is = (0,unist_util_is__rspack_import_0.convert)(check)\n  const step = preorder ? 1 : -1\n\n  factory(tree, undefined, [])()\n\n  /**\n   * Create a function to visit a node.\n   *\n   * @param {UnistNode} node\n   *   Node to visit.\n   * @param {number | undefined} index\n   *   Index of `node` in its parent.\n   * @param {Array<UnistParent>} parents\n   *   Ancestors of `node`.\n   * @returns {() => Readonly<ActionTuple>}\n   *   Visit `node`.\n   */\n  function factory(node, index, parents) {\n    const value = /** @type {Record<string, unknown>} */ (\n      node && typeof node === 'object' ? node : {}\n    )\n\n    if (typeof value.type === 'string') {\n      const name =\n        // `hast`\n        typeof value.tagName === 'string'\n          ? value.tagName\n          : // `xast`\n            typeof value.name === 'string'\n            ? value.name\n            : undefined\n\n      Object.defineProperty(visit, 'name', {\n        value:\n          'node (' + (0,unist_util_visit_parents_do_not_use_color__rspack_import_1.color)(node.type + (name ? '<' + name + '>' : '')) + ')'\n      })\n    }\n\n    return visit\n\n    function visit() {\n      const matches =\n        !check || is(node, index, parents[parents.length - 1] || undefined)\n      /** @type {Readonly<ActionTuple>} */\n      let result = empty\n\n      if (enter && matches) {\n        result = toResult(enter(node, parents, index))\n\n        if (result[0] === EXIT) {\n          return result\n        }\n      }\n\n      if ('children' in node && node.children) {\n        const nodeAsParent = /** @type {UnistParent} */ (node)\n\n        if (nodeAsParent.children && result[0] !== SKIP) {\n          let offset = (preorder ? -1 : nodeAsParent.children.length) + step\n          const grandparents = [...parents, nodeAsParent]\n\n          while (offset > -1 && offset < nodeAsParent.children.length) {\n            const child = nodeAsParent.children[offset]\n\n            const subresult = factory(child, offset, grandparents)()\n\n            if (subresult[0] === EXIT) {\n              return subresult\n            }\n\n            offset =\n              typeof subresult[1] === 'number' ? subresult[1] : offset + step\n          }\n        }\n      }\n\n      if (exit && matches) {\n        const exitResult = toResult(exit(node, parents, index))\n\n        if (exitResult[0] === SKIP) {\n          throw new Error(\n            'Unexpected value `' +\n              exitResult[0] +\n              '` from `exit`, expected `CONTINUE`, `EXIT`, index, or nothing'\n          )\n        }\n\n        // Prefer a result from `exit` over `enter`.\n        if (exitResult[0] === EXIT || typeof exitResult[1] === 'number') {\n          return exitResult\n        }\n      }\n\n      return result\n    }\n  }\n}\n\n/**\n * Turn a return value into a clean result.\n *\n * @param {VisitorResult} value\n *   Valid return values from visitors.\n * @returns {Readonly<ActionTuple>}\n *   Clean result.\n */\nfunction toResult(value) {\n  if (Array.isArray(value)) {\n    return value\n  }\n\n  if (typeof value === 'number') {\n    return [CONTINUE, value]\n  }\n\n  return value === null || value === undefined ? empty : [value]\n}\n\n\n//# sourceURL=file://cloudcmd//Users/coderaiser/cloudcmd/node_modules/unist-util-visit-parents/lib/index.js\n}");
 
 },
 "./node_modules/unist-util-visit/lib/index.js"
@@ -9550,7 +9550,7 @@ eval("{__webpack_require__.r(__webpack_exports__);\n__webpack_require__.d(__webp
   \****************************************************/
 (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 "use strict";
-eval("{__webpack_require__.r(__webpack_exports__);\n__webpack_require__.d(__webpack_exports__, {\n  CONTINUE: () => (/* reexport safe */ unist_util_visit_parents__rspack_import_0.CONTINUE),\n  EXIT: () => (/* reexport safe */ unist_util_visit_parents__rspack_import_0.EXIT),\n  SKIP: () => (/* reexport safe */ unist_util_visit_parents__rspack_import_0.SKIP),\n  visit: () => (visit)\n});\n/* import */ var unist_util_visit_parents__rspack_import_0 = __webpack_require__(/*! unist-util-visit-parents */ \"./node_modules/unist-util-visit-parents/lib/index.js\");\n/**\n * @import {Node as UnistNode, Parent as UnistParent} from 'unist'\n * @import {VisitorResult} from 'unist-util-visit-parents'\n */\n\n/**\n * @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test\n *   Test from `unist-util-is`.\n *\n *   Note: we have remove and add `undefined`, because otherwise when generating\n *   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,\n *   which doesn’t work when publishing on npm.\n */\n\n// To do: use types from `unist-util-visit-parents` when it’s released.\n\n/**\n * @typedef {(\n *   Fn extends (value: any) => value is infer Thing\n *   ? Thing\n *   : Fallback\n * )} Predicate\n *   Get the value of a type guard `Fn`.\n * @template Fn\n *   Value; typically function that is a type guard (such as `(x): x is Y`).\n * @template Fallback\n *   Value to yield if `Fn` is not a type guard.\n */\n\n/**\n * @typedef {(\n *   Check extends null | undefined // No test.\n *   ? Value\n *   : Value extends {type: Check} // String (type) test.\n *   ? Value\n *   : Value extends Check // Partial test.\n *   ? Value\n *   : Check extends Function // Function test.\n *   ? Predicate<Check, Value> extends Value\n *     ? Predicate<Check, Value>\n *     : never\n *   : never // Some other test?\n * )} MatchesOne\n *   Check whether a node matches a primitive check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test, but not arrays.\n */\n\n/**\n * @typedef {(\n *   Check extends ReadonlyArray<any>\n *   ? MatchesOne<Value, Check[number]>\n *   : MatchesOne<Value, Check>\n * )} Matches\n *   Check whether a node matches a check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test.\n */\n\n/**\n * @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint\n *   Number; capped reasonably.\n */\n\n/**\n * @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment\n *   Increment a number in the type system.\n * @template {Uint} [I=0]\n *   Index.\n */\n\n/**\n * @typedef {(\n *   Node extends UnistParent\n *   ? Node extends {children: Array<infer Children>}\n *     ? Child extends Children ? Node : never\n *     : never\n *   : never\n * )} InternalParent\n *   Collect nodes that can be parents of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {InternalParent<InclusiveDescendant<Tree>, Child>} Parent\n *   Collect nodes in `Tree` that can be parents of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Depth extends Max\n *   ? never\n *   :\n *     | InternalParent<Node, Child>\n *     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>\n * )} InternalAncestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {(\n *   Tree extends UnistParent\n *     ? Depth extends Max\n *       ? Tree\n *       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>\n *     : Tree\n * )} InclusiveDescendant\n *   Collect all (inclusive) descendants of `Tree`.\n *\n *   > 👉 **Note**: for performance reasons, this seems to be the fastest way to\n *   > recurse without actually running into an infinite loop, which the\n *   > previous version did.\n *   >\n *   > Practically, a max of `2` is typically enough assuming a `Root` is\n *   > passed, but it doesn’t improve performance.\n *   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.\n *   > Using up to `10` doesn’t hurt or help either.\n * @template {UnistNode} Tree\n *   Tree type.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @callback Visitor\n *   Handle a node (matching `test`, if given).\n *\n *   Visitors are free to transform `node`.\n *   They can also transform `parent`.\n *\n *   Replacing `node` itself, if `SKIP` is not returned, still causes its\n *   descendants to be walked (which is a bug).\n *\n *   When adding or removing previous siblings of `node` (or next siblings, in\n *   case of reverse), the `Visitor` should return a new `Index` to specify the\n *   sibling to traverse after `node` is traversed.\n *   Adding or removing next siblings of `node` (or previous siblings, in case\n *   of reverse) is handled as expected without needing to return a new `Index`.\n *\n *   Removing the children property of `parent` still results in them being\n *   traversed.\n * @param {Visited} node\n *   Found node.\n * @param {Visited extends UnistNode ? number | undefined : never} index\n *   Index of `node` in `parent`.\n * @param {Ancestor extends UnistParent ? Ancestor | undefined : never} parent\n *   Parent of `node`.\n * @returns {VisitorResult}\n *   What to do next.\n *\n *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.\n *   An `Action` is treated as a tuple of `[Action]`.\n *\n *   Passing a tuple back only makes sense if the `Action` is `SKIP`.\n *   When the `Action` is `EXIT`, that action can be returned.\n *   When the `Action` is `CONTINUE`, `Index` can be returned.\n * @template {UnistNode} [Visited=UnistNode]\n *   Visited node type.\n * @template {UnistParent} [Ancestor=UnistParent]\n *   Ancestor type.\n */\n\n/**\n * @typedef {Visitor<Visited, Parent<Ancestor, Visited>>} BuildVisitorFromMatch\n *   Build a typed `Visitor` function from a node and all possible parents.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} Visited\n *   Node type.\n * @template {UnistParent} Ancestor\n *   Parent type.\n */\n\n/**\n * @typedef {(\n *   BuildVisitorFromMatch<\n *     Matches<Descendant, Check>,\n *     Extract<Descendant, UnistParent>\n *   >\n * )} BuildVisitorFromDescendants\n *   Build a typed `Visitor` function from a list of descendants and a test.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} Descendant\n *   Node type.\n * @template {Test} Check\n *   Test type.\n */\n\n/**\n * @typedef {(\n *   BuildVisitorFromDescendants<\n *     InclusiveDescendant<Tree>,\n *     Check\n *   >\n * )} BuildVisitor\n *   Build a typed `Visitor` function from a tree and a test.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} [Tree=UnistNode]\n *   Node type.\n * @template {Test} [Check=Test]\n *   Test type.\n */\n\n\n\n\n\n/**\n * Visit nodes.\n *\n * This algorithm performs *depth-first* *tree traversal* in *preorder*\n * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).\n *\n * You can choose for which nodes `visitor` is called by passing a `test`.\n * For complex tests, you should test yourself in `visitor`, as it will be\n * faster and will have improved type information.\n *\n * Walking the tree is an intensive task.\n * Make use of the return values of the visitor when possible.\n * Instead of walking a tree multiple times, walk it once, use `unist-util-is`\n * to check if a node matches, and then perform different operations.\n *\n * You can change the tree.\n * See `Visitor` for more info.\n *\n * @overload\n * @param {Tree} tree\n * @param {Check} check\n * @param {BuildVisitor<Tree, Check>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @overload\n * @param {Tree} tree\n * @param {BuildVisitor<Tree>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @param {UnistNode} tree\n *   Tree to traverse.\n * @param {Visitor | Test} testOrVisitor\n *   `unist-util-is`-compatible test (optional, omit to pass a visitor).\n * @param {Visitor | boolean | null | undefined} [visitorOrReverse]\n *   Handle each node (when test is omitted, pass `reverse`).\n * @param {boolean | null | undefined} [maybeReverse=false]\n *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).\n * @returns {undefined}\n *   Nothing.\n *\n * @template {UnistNode} Tree\n *   Node type.\n * @template {Test} Check\n *   `unist-util-is`-compatible test.\n */\nfunction visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {\n  /** @type {boolean | null | undefined} */\n  let reverse\n  /** @type {Test} */\n  let test\n  /** @type {Visitor} */\n  let visitor\n\n  if (\n    typeof testOrVisitor === 'function' &&\n    typeof visitorOrReverse !== 'function'\n  ) {\n    test = undefined\n    visitor = testOrVisitor\n    reverse = visitorOrReverse\n  } else {\n    // @ts-expect-error: assume the overload with test was given.\n    test = testOrVisitor\n    // @ts-expect-error: assume the overload with test was given.\n    visitor = visitorOrReverse\n    reverse = maybeReverse\n  }\n\n  (0,unist_util_visit_parents__rspack_import_0.visitParents)(tree, test, overload, reverse)\n\n  /**\n   * @param {UnistNode} node\n   * @param {Array<UnistParent>} parents\n   */\n  function overload(node, parents) {\n    const parent = parents[parents.length - 1]\n    const index = parent ? parent.children.indexOf(node) : undefined\n    return visitor(node, index, parent)\n  }\n}\n\n\n//# sourceURL=file://cloudcmd//Users/coderaiser/cloudcmd/node_modules/unist-util-visit/lib/index.js\n}");
+eval("{__webpack_require__.r(__webpack_exports__);\n__webpack_require__.d(__webpack_exports__, {\n  CONTINUE: () => (/* reexport safe */ unist_util_visit_parents__rspack_import_0.CONTINUE),\n  EXIT: () => (/* reexport safe */ unist_util_visit_parents__rspack_import_0.EXIT),\n  SKIP: () => (/* reexport safe */ unist_util_visit_parents__rspack_import_0.SKIP),\n  visit: () => (visit)\n});\n/* import */ var unist_util_visit_parents__rspack_import_0 = __webpack_require__(/*! unist-util-visit-parents */ \"./node_modules/unist-util-visit-parents/lib/index.js\");\n/**\n * @import {Node as UnistNode, Parent as UnistParent} from 'unist'\n * @import {\n *   InclusiveDescendant,\n *   Matches,\n *   Visitors as ParentsVisitors,\n *   VisitorResult,\n *   VisitorResultExit\n * } from 'unist-util-visit-parents'\n */\n\n/**\n * @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test\n *   Test from `unist-util-is`.\n *\n *   Note: we have remove and add `undefined`, because otherwise when generating\n *   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,\n *   which doesn’t work when publishing on npm.\n */\n\n/**\n * @typedef {(\n *   Node extends UnistParent\n *   ? Node extends {children: Array<infer Children>}\n *     ? Child extends Children ? Node : never\n *     : never\n *   : never\n * )} InternalParent\n *   Collect nodes that can be parents of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {InternalParent<InclusiveDescendant<Tree>, Child>} Parent\n *   Collect nodes in `Tree` that can be parents of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @callback Visitor\n *   Handle a node (matching `test`, if given) before its children.\n *\n *   Like `Visitor` in `unist-util-visit-parents`,\n *   but with `index` and `parent` instead of `parents`.\n * @param {Visited} node\n *   Found node.\n * @param {Visited extends UnistNode ? number | undefined : never} index\n *   Index of `node` in `parent`,\n *   or `undefined` for the tree itself.\n * @param {Ancestor extends UnistParent ? Ancestor | undefined : never} parent\n *   Parent of `node`,\n *   or `undefined` for the tree itself.\n * @returns {VisitorResult}\n *   What to do next.\n * @template {UnistNode} [Visited=UnistNode]\n *   Visited node type.\n * @template {UnistParent} [Ancestor=UnistParent]\n *   Ancestor type.\n */\n\n/**\n * @callback VisitorExit\n *   Handle a node (matching `test`, if given) after its children.\n *\n *   Like `VisitorExit` in `unist-util-visit-parents`,\n *   but with `index` and `parent` instead of `parents`.\n * @param {Visited} node\n *   Found node.\n * @param {Visited extends UnistNode ? number | undefined : never} index\n *   Index of `node` in `parent`,\n *   or `undefined` for the tree itself.\n * @param {Ancestor extends UnistParent ? Ancestor | undefined : never} parent\n *   Parent of `node`,\n *   or `undefined` for the tree itself.\n * @returns {VisitorResultExit}\n *   What to do next.\n * @template {UnistNode} [Visited=UnistNode]\n *   Visited node type.\n * @template {UnistParent} [Ancestor=UnistParent]\n *   Ancestor type.\n */\n\n/**\n * @template {UnistNode} [Visited=UnistNode]\n *   Visited node type.\n * @template {UnistParent} [Ancestor=UnistParent]\n *   Ancestor type.\n * @typedef Visitors\n *   Handle nodes when entering and exiting them.\n *\n *   Like `Visitors` in `unist-util-visit-parents`.\n * @property {Visitor<Visited, Ancestor> | null | undefined} [enter]\n *   Handle a node before its children (optional).\n * @property {VisitorExit<Visited, Ancestor>} exit\n *   Handle a node after its children.\n */\n\n/**\n * @typedef {Visitor<Visited, Parent<Ancestor, Visited>>} BuildVisitorFromMatch\n *   Build a typed `Visitor` function from a node and all possible parents.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} Visited\n *   Node type.\n * @template {UnistParent} Ancestor\n *   Parent type.\n */\n\n/**\n * @typedef {(\n *   BuildVisitorFromMatch<\n *     Matches<Descendant, Check>,\n *     Extract<Descendant, UnistParent>\n *   >\n * )} BuildVisitorFromDescendants\n *   Build a typed `Visitor` function from a list of descendants and a test.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} Descendant\n *   Node type.\n * @template {Test} Check\n *   Test type.\n */\n\n/**\n * @typedef {(\n *   BuildVisitorFromDescendants<\n *     InclusiveDescendant<Tree>,\n *     Check\n *   >\n * )} BuildVisitor\n *   Build a typed `Visitor` function from a tree and a test.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} [Tree=UnistNode]\n *   Node type.\n * @template {Test} [Check=Test]\n *   Test type.\n */\n\n/**\n * @typedef {(\n *   Visitors<\n *     Matches<InclusiveDescendant<Tree>, Check>,\n *     Parent<\n *       Extract<InclusiveDescendant<Tree>, UnistParent>,\n *       Matches<InclusiveDescendant<Tree>, Check>\n *     >\n *   >\n * )} BuildVisitors\n *   Build typed `Visitors` from a tree and a test.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} [Tree=UnistNode]\n *   Node type.\n * @template {Test} [Check=Test]\n *   Test type.\n */\n\n\n\n\n\n/**\n * Visit nodes.\n *\n * This algorithm performs *depth-first* *tree traversal* in *preorder*\n * (**NLR**) or if `reverse` is given,\n * in *reverse preorder* (**NRL**).\n * An `exit` visitor is called in *postorder* (**LRN**)\n * or if `reverse` is given, in *reverse postorder* (**RLN**).\n *\n * You can choose which nodes are visited by passing a `test`.\n * For complex tests, you should test yourself in a visitor, as it will be\n * faster and will have improved type information.\n *\n * Walking the tree is an intensive task.\n * Make use of the return values of the visitor when possible.\n * Instead of walking a tree multiple times, walk it once, use `unist-util-is`\n * to check if a node matches, and then perform different operations.\n *\n * You can change the tree.\n * Changes inside a node made when entering it are walked,\n * changes made when exiting it are not.\n * See `Visitor` and `VisitorExit` for more info.\n *\n * @overload\n * @param {Tree} tree\n *   Tree to traverse.\n * @param {Check} check\n *   `unist-util-is`-compatible test.\n * @param {BuildVisitor<Tree, Check> | BuildVisitors<Tree, Check>} visitors\n *   Handle each node when entering it,\n *   or `{enter, exit}` to also handle it when exiting it.\n * @param {boolean | null | undefined} [reverse]\n *   Walk children from last to first;\n *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);\n *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).\n * @returns {undefined}\n *   Nothing.\n *\n * @overload\n * @param {Tree} tree\n *   Tree to traverse.\n * @param {BuildVisitor<Tree> | BuildVisitors<Tree>} visitors\n *   Handle each node when entering it,\n *   or `{enter, exit}` to also handle it when exiting it.\n * @param {boolean | null | undefined} [reverse]\n *   Walk children from last to first;\n *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);\n *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).\n * @returns {undefined}\n *   Nothing.\n *\n * @param {UnistNode} tree\n *   Tree to traverse.\n * @param {Visitor | Visitors | Test} testOrEnterOrVisitors\n *   `unist-util-is`-compatible test, `enter`, or `visitors`.\n * @param {Visitor | Visitors | boolean | null | undefined} [enterOrVisitorsOrReverse]\n *   `enter`, `visitors`, or `reverse` after a test.\n * @param {boolean | null | undefined} [maybeReverse]\n *   Walk children from last to first;\n *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);\n *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).\n * @returns {undefined}\n *   Nothing.\n *\n * @template {UnistNode} Tree\n *   Node type.\n * @template {Test} Check\n *   `unist-util-is`-compatible test.\n */\nfunction visit(\n  tree,\n  testOrEnterOrVisitors,\n  enterOrVisitorsOrReverse,\n  maybeReverse\n) {\n  /** @type {Test} */\n  let check\n  /** @type {Visitor | Visitors} */\n  let visitors\n  /** @type {boolean | null | undefined} */\n  let reverse\n\n  // Third parameter is an enter visitor or a visitors object, so expect a `test` too.\n  if (\n    typeof enterOrVisitorsOrReverse === 'function' ||\n    (enterOrVisitorsOrReverse && typeof enterOrVisitorsOrReverse === 'object')\n  ) {\n    check = /** @type {Test} */ (testOrEnterOrVisitors)\n    visitors = enterOrVisitorsOrReverse\n    reverse = maybeReverse\n  }\n  // Assume no test.\n  else {\n    visitors = /** @type {Visitor | Visitors} */ (testOrEnterOrVisitors)\n    reverse = enterOrVisitorsOrReverse\n  }\n\n  if (typeof visitors === 'function') {\n    (0,unist_util_visit_parents__rspack_import_0.visitParents)(tree, check, wrap(visitors), reverse)\n  } else {\n    (0,unist_util_visit_parents__rspack_import_0.visitParents)(tree, check, wrapVisitors(visitors), reverse)\n  }\n}\n\n/**\n * Turn `visit` visitors into `visitParents` visitors.\n *\n * @param {Visitors} visitors\n *   Visitors for `visit`.\n * @returns {ParentsVisitors}\n *   Visitors for `visitParents`.\n */\nfunction wrapVisitors(visitors) {\n  // Pass anything else straight to `visitParents` to get its errors.\n  if (!visitors || typeof visitors !== 'object') return visitors\n\n  return {\n    enter:\n      typeof visitors.enter === 'function'\n        ? wrap(visitors.enter)\n        : visitors.enter,\n    exit:\n      typeof visitors.exit === 'function' ? wrap(visitors.exit) : visitors.exit\n  }\n}\n\n/**\n * Turn a `visit` visitor into a `visitParents` one.\n *\n * @template {VisitorResult} Result\n *   Result type.\n * @param {(node: UnistNode, index: number | undefined, parent: UnistParent | undefined) => Result} visitor\n *   Visitor for `visit`.\n * @returns {(node: UnistNode, parents: Array<UnistParent>, index: number | undefined) => Result}\n *   Visitor for `visitParents`.\n */\nfunction wrap(visitor) {\n  return overload\n\n  /**\n   * Call `visitor` with `index` and `parent` instead of `parents`.\n   *\n   * @param {UnistNode} node\n   *   Visited node.\n   * @param {Array<UnistParent>} parents\n   *   Ancestors of `node`.\n   * @param {number | undefined} index\n   *   Index of `node` in its parent.\n   * @returns {Result}\n   *   What to do next.\n   */\n  function overload(node, parents, index) {\n    return visitor(node, index, parents[parents.length - 1])\n  }\n}\n\n\n//# sourceURL=file://cloudcmd//Users/coderaiser/cloudcmd/node_modules/unist-util-visit/lib/index.js\n}");
 
 },
 "./node_modules/vfile-location/lib/index.js"

package/dist-dev/sw.js

@@ -23,7 +23,7 @@ eval("{// shim for using process in browser\nvar process = module.exports = {};\
   \*************************/
 (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 "use strict";
-eval("{__webpack_require__.r(__webpack_exports__);\n/* import */ var node_process__rspack_import_0 = __webpack_require__(/*! node:process */ \"./node_modules/process/browser.js\");\n/* import */ var try_to_catch__rspack_import_1 = __webpack_require__(/*! try-to-catch */ \"./node_modules/try-to-catch/lib/try-to-catch.js\");\n/* import */ var currify__rspack_import_2 = __webpack_require__(/*! currify */ \"./node_modules/currify/lib/currify.js\");\n\n\n\nconst isDev = \"development\" === 'development';\nconst isGet = a => a.method === 'GET';\nconst isBasic = a => a.type === 'basic';\nconst wait = currify__rspack_import_2((f, e) => e.waitUntil(f()));\nconst respondWith = currify__rspack_import_2((f, e) => {\n  const {\n    request\n  } = e;\n  const {\n    url\n  } = request;\n  const pathname = getPathName(url);\n  if (url.endsWith('/') || /\\^\\/fs/.test(pathname)) return;\n  if (!isGet(request)) return;\n  if (!isBasic(request)) return;\n  if (pathname.startsWith('/api')) return;\n  if (/^socket.io/.test(pathname)) return;\n  e.respondWith(f(e));\n});\nconst getPathName = url => new URL(url).pathname;\nconst date = \"Sat Oct 24 2026 01:38:32 GMT+0300 (Eastern European Summer Time)\";\nconst NAME = `cloudcmd: ${date}`;\nconst createRequest = a => new Request(a, {\n  credentials: 'same-origin'\n});\nconst getRequest = (a, request) => {\n  if (a !== '/') return request;\n  return createRequest('/');\n};\nglobalThis.addEventListener('install', wait(onInstall));\nglobalThis.addEventListener('fetch', respondWith(onFetch));\nglobalThis.addEventListener('activate', wait(onActivate));\nasync function onActivate() {\n  console.info(`cloudcmd: sw: activate: ${NAME}`);\n  await globalThis.clients.claim();\n  const keys = await caches.keys();\n  const deleteCache = caches.delete.bind(caches);\n  await Promise.all(keys.map(deleteCache));\n}\nasync function onInstall() {\n  console.info(`cloudcmd: sw: install: ${NAME}`);\n  await globalThis.skipWaiting();\n}\nasync function onFetch(event) {\n  const {\n    request\n  } = event;\n  const {\n    url\n  } = request;\n  const pathname = getPathName(url);\n  const newRequest = getRequest(pathname, event.request);\n  const cache = await caches.open(NAME);\n  const response = await cache.match(request);\n  if (!isDev && response) return response;\n  const [e, resp] = await (0,try_to_catch__rspack_import_1.tryToCatch)(fetch, newRequest, {\n    credentials: 'same-origin'\n  });\n  if (e) return new Response(e.message);\n  await addToCache(request, resp.clone());\n  return resp;\n}\nasync function addToCache(request, response) {\n  const cache = await caches.open(NAME);\n  return cache.put(request, response);\n}\n\n//# sourceURL=file://cloudcmd//Users/coderaiser/cloudcmd/client/sw/sw.js\n}");
+eval("{__webpack_require__.r(__webpack_exports__);\n/* import */ var node_process__rspack_import_0 = __webpack_require__(/*! node:process */ \"./node_modules/process/browser.js\");\n/* import */ var try_to_catch__rspack_import_1 = __webpack_require__(/*! try-to-catch */ \"./node_modules/try-to-catch/lib/try-to-catch.js\");\n/* import */ var currify__rspack_import_2 = __webpack_require__(/*! currify */ \"./node_modules/currify/lib/currify.js\");\n\n\n\nconst isDev = \"development\" === 'development';\nconst isGet = a => a.method === 'GET';\nconst isBasic = a => a.type === 'basic';\nconst wait = currify__rspack_import_2((f, e) => e.waitUntil(f()));\nconst respondWith = currify__rspack_import_2((f, e) => {\n  const {\n    request\n  } = e;\n  const {\n    url\n  } = request;\n  const pathname = getPathName(url);\n  if (url.endsWith('/') || /\\^\\/fs/.test(pathname)) return;\n  if (!isGet(request)) return;\n  if (!isBasic(request)) return;\n  if (pathname.startsWith('/api')) return;\n  if (/^socket.io/.test(pathname)) return;\n  e.respondWith(f(e));\n});\nconst getPathName = url => new URL(url).pathname;\nconst date = \"Sun Oct 25 2026 14:11:57 GMT+0200 (Eastern European Standard Time)\";\nconst NAME = `cloudcmd: ${date}`;\nconst createRequest = a => new Request(a, {\n  credentials: 'same-origin'\n});\nconst getRequest = (a, request) => {\n  if (a !== '/') return request;\n  return createRequest('/');\n};\nglobalThis.addEventListener('install', wait(onInstall));\nglobalThis.addEventListener('fetch', respondWith(onFetch));\nglobalThis.addEventListener('activate', wait(onActivate));\nasync function onActivate() {\n  console.info(`cloudcmd: sw: activate: ${NAME}`);\n  await globalThis.clients.claim();\n  const keys = await caches.keys();\n  const deleteCache = caches.delete.bind(caches);\n  await Promise.all(keys.map(deleteCache));\n}\nasync function onInstall() {\n  console.info(`cloudcmd: sw: install: ${NAME}`);\n  await globalThis.skipWaiting();\n}\nasync function onFetch(event) {\n  const {\n    request\n  } = event;\n  const {\n    url\n  } = request;\n  const pathname = getPathName(url);\n  const newRequest = getRequest(pathname, event.request);\n  const cache = await caches.open(NAME);\n  const response = await cache.match(request);\n  if (!isDev && response) return response;\n  const [e, resp] = await (0,try_to_catch__rspack_import_1.tryToCatch)(fetch, newRequest, {\n    credentials: 'same-origin'\n  });\n  if (e) return new Response(e.message);\n  await addToCache(request, resp.clone());\n  return resp;\n}\nasync function addToCache(request, response) {\n  const cache = await caches.open(NAME);\n  return cache.put(request, response);\n}\n\n//# sourceURL=file://cloudcmd//Users/coderaiser/cloudcmd/client/sw/sw.js\n}");
 
 },
 "./node_modules/try-to-catch/lib/try-to-catch.js"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudcmd",
-  "version": "19.21.3",
+  "version": "19.21.4",
   "type": "module",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "File manager for the web with console and editor",

package/server/cloudcmd.js

@@ -251,11 +251,13 @@ function cloudcmdMiddle({modules, config}) {
             dropboxToken,
         }),
         fileop(),
-        nomine(),
         setUrl,
         setSW,
         logout,
         authentication(config),
+        nomine({
+            root: root(),
+        }),
         config.middle,
         modules && modulas(modules),
         config('dropbox') && restbox({