i-c-fn-head 0.0.5

package/dist/extension.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension.js","mappings":"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","sources":["webpack://i-c-fn-head/./node_modules/balanced-match/index.js","webpack://i-c-fn-head/./node_modules/brace-expansion/index.js","webpack://i-c-fn-head/./src/basic_funx.ts","webpack://i-c-fn-head/./src/colorful.ts","webpack://i-c-fn-head/./src/extension.ts","webpack://i-c-fn-head/./src/faav.ts","webpack://i-c-fn-head/./src/fancy_f12.ts","webpack://i-c-fn-head/./src/fn_body_n_head.ts","webpack://i-c-fn-head/./src/goto_impl.ts","webpack://i-c-fn-head/./src/init.ts","webpack://i-c-fn-head/./src/quick_pick.ts","webpack://i-c-fn-head/./src/show_doc_symbs.ts","webpack://i-c-fn-head/external commonjs \"vscode\"","webpack://i-c-fn-head/external node-commonjs \"fs\"","webpack://i-c-fn-head/./node_modules/minimatch/dist/commonjs/assert-valid-pattern.js","webpack://i-c-fn-head/./node_modules/minimatch/dist/commonjs/ast.js","webpack://i-c-fn-head/./node_modules/minimatch/dist/commonjs/brace-expressions.js","webpack://i-c-fn-head/./node_modules/minimatch/dist/commonjs/escape.js","webpack://i-c-fn-head/./node_modules/minimatch/dist/commonjs/index.js","webpack://i-c-fn-head/./node_modules/minimatch/dist/commonjs/unescape.js","webpack://i-c-fn-head/webpack/bootstrap","webpack://i-c-fn-head/webpack/startup"],"sourcesContent":["'use strict';\nmodule.exports = balanced;\nfunction balanced(a, b, str) {\n  if (a instanceof RegExp) a = maybeMatch(a, str);\n  if (b instanceof RegExp) b = maybeMatch(b, str);\n\n  var r = range(a, b, str);\n\n  return r && {\n    start: r[0],\n    end: r[1],\n    pre: str.slice(0, r[0]),\n    body: str.slice(r[0] + a.length, r[1]),\n    post: str.slice(r[1] + b.length)\n  };\n}\n\nfunction maybeMatch(reg, str) {\n  var m = str.match(reg);\n  return m ? m[0] : null;\n}\n\nbalanced.range = range;\nfunction range(a, b, str) {\n  var begs, beg, left, right, result;\n  var ai = str.indexOf(a);\n  var bi = str.indexOf(b, ai + 1);\n  var i = ai;\n\n  if (ai >= 0 && bi > 0) {\n    if(a===b) {\n      return [ai, bi];\n    }\n    begs = [];\n    left = str.length;\n\n    while (i >= 0 && !result) {\n      if (i == ai) {\n        begs.push(i);\n        ai = str.indexOf(a, i + 1);\n      } else if (begs.length == 1) {\n        result = [ begs.pop(), bi ];\n      } else {\n        beg = begs.pop();\n        if (beg < left) {\n          left = beg;\n          right = bi;\n        }\n\n        bi = str.indexOf(b, i + 1);\n      }\n\n      i = ai < bi && ai >= 0 ? ai : bi;\n    }\n\n    if (begs.length) {\n      result = [ left, right ];\n    }\n  }\n\n  return result;\n}\n","var balanced = require('balanced-match');\n\nmodule.exports = expandTop;\n\nvar escSlash = '\\0SLASH'+Math.random()+'\\0';\nvar escOpen = '\\0OPEN'+Math.random()+'\\0';\nvar escClose = '\\0CLOSE'+Math.random()+'\\0';\nvar escComma = '\\0COMMA'+Math.random()+'\\0';\nvar escPeriod = '\\0PERIOD'+Math.random()+'\\0';\n\nfunction numeric(str) {\n  return parseInt(str, 10) == str\n    ? parseInt(str, 10)\n    : str.charCodeAt(0);\n}\n\nfunction escapeBraces(str) {\n  return str.split('\\\\\\\\').join(escSlash)\n            .split('\\\\{').join(escOpen)\n            .split('\\\\}').join(escClose)\n            .split('\\\\,').join(escComma)\n            .split('\\\\.').join(escPeriod);\n}\n\nfunction unescapeBraces(str) {\n  return str.split(escSlash).join('\\\\')\n            .split(escOpen).join('{')\n            .split(escClose).join('}')\n            .split(escComma).join(',')\n            .split(escPeriod).join('.');\n}\n\n\n// Basically just str.split(\",\"), but handling cases\n// where we have nested braced sections, which should be\n// treated as individual members, like {a,{b,c},d}\nfunction parseCommaParts(str) {\n  if (!str)\n    return [''];\n\n  var parts = [];\n  var m = balanced('{', '}', str);\n\n  if (!m)\n    return str.split(',');\n\n  var pre = m.pre;\n  var body = m.body;\n  var post = m.post;\n  var p = pre.split(',');\n\n  p[p.length-1] += '{' + body + '}';\n  var postParts = parseCommaParts(post);\n  if (post.length) {\n    p[p.length-1] += postParts.shift();\n    p.push.apply(p, postParts);\n  }\n\n  parts.push.apply(parts, p);\n\n  return parts;\n}\n\nfunction expandTop(str) {\n  if (!str)\n    return [];\n\n  // I don't know why Bash 4.3 does this, but it does.\n  // Anything starting with {} will have the first two bytes preserved\n  // but *only* at the top level, so {},a}b will not expand to anything,\n  // but a{},b}c will be expanded to [a}c,abc].\n  // One could argue that this is a bug in Bash, but since the goal of\n  // this module is to match Bash's rules, we escape a leading {}\n  if (str.substr(0, 2) === '{}') {\n    str = '\\\\{\\\\}' + str.substr(2);\n  }\n\n  return expand(escapeBraces(str), true).map(unescapeBraces);\n}\n\nfunction embrace(str) {\n  return '{' + str + '}';\n}\nfunction isPadded(el) {\n  return /^-?0\\d/.test(el);\n}\n\nfunction lte(i, y) {\n  return i <= y;\n}\nfunction gte(i, y) {\n  return i >= y;\n}\n\nfunction expand(str, isTop) {\n  var expansions = [];\n\n  var m = balanced('{', '}', str);\n  if (!m) return [str];\n\n  // no need to expand pre, since it is guaranteed to be free of brace-sets\n  var pre = m.pre;\n  var post = m.post.length\n    ? expand(m.post, false)\n    : [''];\n\n  if (/\\$$/.test(m.pre)) {    \n    for (var k = 0; k < post.length; k++) {\n      var expansion = pre+ '{' + m.body + '}' + post[k];\n      expansions.push(expansion);\n    }\n  } else {\n    var isNumericSequence = /^-?\\d+\\.\\.-?\\d+(?:\\.\\.-?\\d+)?$/.test(m.body);\n    var isAlphaSequence = /^[a-zA-Z]\\.\\.[a-zA-Z](?:\\.\\.-?\\d+)?$/.test(m.body);\n    var isSequence = isNumericSequence || isAlphaSequence;\n    var isOptions = m.body.indexOf(',') >= 0;\n    if (!isSequence && !isOptions) {\n      // {a},b}\n      if (m.post.match(/,(?!,).*\\}/)) {\n        str = m.pre + '{' + m.body + escClose + m.post;\n        return expand(str);\n      }\n      return [str];\n    }\n\n    var n;\n    if (isSequence) {\n      n = m.body.split(/\\.\\./);\n    } else {\n      n = parseCommaParts(m.body);\n      if (n.length === 1) {\n        // x{{a,b}}y ==> x{a}y x{b}y\n        n = expand(n[0], false).map(embrace);\n        if (n.length === 1) {\n          return post.map(function(p) {\n            return m.pre + n[0] + p;\n          });\n        }\n      }\n    }\n\n    // at this point, n is the parts, and we know it's not a comma set\n    // with a single entry.\n    var N;\n\n    if (isSequence) {\n      var x = numeric(n[0]);\n      var y = numeric(n[1]);\n      var width = Math.max(n[0].length, n[1].length)\n      var incr = n.length == 3\n        ? Math.abs(numeric(n[2]))\n        : 1;\n      var test = lte;\n      var reverse = y < x;\n      if (reverse) {\n        incr *= -1;\n        test = gte;\n      }\n      var pad = n.some(isPadded);\n\n      N = [];\n\n      for (var i = x; test(i, y); i += incr) {\n        var c;\n        if (isAlphaSequence) {\n          c = String.fromCharCode(i);\n          if (c === '\\\\')\n            c = '';\n        } else {\n          c = String(i);\n          if (pad) {\n            var need = width - c.length;\n            if (need > 0) {\n              var z = new Array(need + 1).join('0');\n              if (i < 0)\n                c = '-' + z + c.slice(1);\n              else\n                c = z + c;\n            }\n          }\n        }\n        N.push(c);\n      }\n    } else {\n      N = [];\n\n      for (var j = 0; j < n.length; j++) {\n        N.push.apply(N, expand(n[j], false));\n      }\n    }\n\n    for (var j = 0; j < N.length; j++) {\n      for (var k = 0; k < post.length; k++) {\n        var expansion = pre + N[j] + post[k];\n        if (!isTop || isSequence || expansion)\n          expansions.push(expansion);\n      }\n    }\n  }\n\n  return expansions;\n}\n\n","import * as vscode from 'vscode';\nimport { uri_to_file_of_opts } from './init';\nclass set_cmd_type {\n    static v: string = \"rgx\";\n}\nexport function prnt(msg: string) {\n    console_msg.show(msg);\n}\nexport class console_msg {\n    static #outputChannel = vscode.window.createOutputChannel('i-c-fn-head');\n    static show(msg: string) {\n        this.#outputChannel.appendLine(msg);\n        this.#outputChannel.show();\n    }\n}\nexport function getCMD(set_placeholder0?: string | null, _txt?: string | undefined | null,  cmd_type?: string): RegExp[] | null {\n    const txt = _txt ? _txt : vscode.window.activeTextEditor?.document.getText();\n    set_cmd_type.v = cmd_type ? cmd_type : set_cmd_type.v;\n    cmd_rgx.set_collect_rgx_from_doc();\n    if (txt == undefined) { return null}\n    const ret = set_placeholder0 ? cmd_rgx._collect_rgx_from_doc(txt, set_placeholder0) : cmd_rgx._collect_rgx_from_doc(txt); \n    let phldr = set_placeholder0 ? set_placeholder0 : \"no phldr\";\n    prnt(\"calc num of cmds: \" + ret.length.toString());\n   // prnt (ewt)\n    return ret;\n}\nexport class cmd_rgx {\n    static collect_rgx_from_doc: RegExp = /\\/\\/\\s*rgx:\\s*(\\/.*:::[gmis]*)\\s*\\/\\//g;\n    static placeholder0: string = \"@663@\";\n    static placeholder0_max_len: number = 200;\n    static open_rgx: string = \"/\";\n    static close_rgx: string = \":::\";\n    static set_collect_rgx_from_doc(\n        open_rgx?: string,\n        close_rgx?: string,\n    ): RegExp {\n        this.open_rgx = open_rgx ?? this.open_rgx;\n        this.close_rgx = close_rgx ?? this.close_rgx;\n        let cmd_type = set_cmd_type.v ?? \"rgx\";\n        let construct_rgx: string = \"//\\\\s*\" + cmd_type + \":\\\\s*(\" + this.open_rgx + \".*\" + this.close_rgx + \"[gmis]*)\\\\s*//\";\n        this.collect_rgx_from_doc = new RegExp(construct_rgx, \"g\");\n        prnt(\"set_collect_rgx_from_doc: \"+this.collect_rgx_from_doc.source);\n        return this.collect_rgx_from_doc;\n    }\n    static _collect_rgx_from_doc(txt: string, set_placeholder0?: string): RegExp[] {\n        if (set_placeholder0) { return this._collect_rgx_from_doc0(txt, set_placeholder0) }\n        let m: RegExpExecArray | null;\n        let ret: RegExp[] = [];\n        while ((m = this.collect_rgx_from_doc.exec(txt)) != null) {\n            let try_it = this.strn_2_rgx(m[1]);\n            if (try_it == null) {\n                prnt(\"_collect_rgx_from_doc: try_it is null\");\n                break\n            }\n            prnt(\"_collect_rgx_from_doc:\" + m[1]);\n            ret.push(try_it);\n        }\n        return ret;\n    }\n    static _collect_rgx_from_doc0(txt: string, set_placeholder0: string): RegExp[] {\n        let m: RegExpExecArray | null;\n        let ret: RegExp[] = [];\n        while ((m = this.collect_rgx_from_doc.exec(txt)) != null) {\n            let _m = m[1].replaceAll(this.placeholder0, set_placeholder0);\n            let try_it = this.strn_2_rgx(_m);\n            prnt(\"1st class cmd_rgx\");\n            if (try_it == null) {\n                prnt(\"_collect_rgx_from_doc: try_it is null\");\n                break\n            }\n            prnt(\"_collect_rgx_from_doc:\" + m[1]);\n            ret.push(try_it);\n        }\n        return ret;\n    }\n    static strn_2_rgx(strn: string): RegExp | null {\n        let check_end_of_rgx = this.close_rgx + \"[gmis]*$\";\n        let flags = strn.match(new RegExp(check_end_of_rgx));\n        let _flags = flags != null ? flags[0].slice(this.close_rgx.length) : \"\";\n        let regex = strn.slice(1).replaceAll(this.close_rgx + _flags, \"\");\n        try {\n            let ret = new RegExp(regex, _flags);\n            prnt(\"strn to rgx: \" + ret.source + \" \" + ret.flags);\n            return ret;\n        } catch (error) {\n            const msg = error instanceof Error ? error.message : String(error);\n            vscode.window.showInformationMessage(msg);\n            return null;\n        }\n    }\n}\nexport async function exclude_paths(uris: vscode.Uri[]): Promise<vscode.Uri[] |  undefined> {\n    try {\n        let ret: vscode.Uri[] = [];    \n        const file_of_opts = await uri_to_file_of_opts();\n        const txt = (await vscode.workspace.openTextDocument(file_of_opts[0])).getText();\n        prnt(txt);\n        let exclude_paths0 = getCMD(\n            null,\n            txt,\n            \"exclude_path\"\n        );\n        if (exclude_paths0 == null) { return; }\n        for (let exc of exclude_paths0) {\n            ret = exclude_path(uris, exc);\n        }\n        return ret.length == 0? uris: ret;\n    } catch (err) {\n        prnt(String(err))\n        return\n    }\n}\nfunction exclude_path(uris: vscode.Uri[], rgx: RegExp): vscode.Uri[] {\n    let ret: vscode.Uri[] = [];\n    for (let uri of uris) {\n        prnt(rgx.source);\n        if (!uri.fsPath.match(rgx)) { ret.push (uri)}\n    }\n    return ret;\n}","import * as vscode from 'vscode';\nimport { minimatch } from 'minimatch';\n\ntype Configuration = {\n    paths?: string[];\n    rules?: Rule[];\n};\nexport function extra_activate(): string {\n    return activate_;\n}\nconst activate_: string = `\n  //  console.log('Extension \"color-my-text\" is activated.');\n\n    let allConfigData: ConfigData[] = [];\n\n    // todoEditors need (re)decoration; doneEditors are already up to date.\n    // Tracking both avoids re-decorating unchanged editors when unrelated ones become visible.\n    let todoEditors: vscode.TextEditor[] = [];\n    let doneEditors: vscode.TextEditor[] = [];\n\n    // Disposes old decoration types and rebuilds allConfigData from current settings.\n    function resetDecorations(): void {\n        todoEditors = vscode.window.visibleTextEditors.slice();\n        doneEditors = [];\n\n        allConfigData.forEach(configData => configData.ruleData.forEach(ruleData => ruleData.decorationType.dispose()));\n\n        const configurations = vscode.workspace.getConfiguration('i_c_fn_head').get<Configuration[]>('configurations');\n        allConfigData = toArray(configurations).map(configuration => ({\n            globs: toArray(configuration.paths),\n            ruleData: toArray(configuration.rules).map(buildRuleData),\n        }));\n    }\n\n    // Applies decorations to all queued editors. Runs on a 500ms timer to batch rapid edits.\n\n\n    vscode.workspace.onDidChangeConfiguration(\n        event => {\n            if (event.affectsConfiguration('i_c_fn_head.configurations')) {\n                resetDecorations();\n            }\n        },\n        null,\n        context.subscriptions);\n\n    vscode.window.onDidChangeVisibleTextEditors(\n        visibleEditors => {\n            // Queue newly visible editors; prune editors that were closed.\n            todoEditors = visibleEditors.filter(editor => !doneEditors.includes(editor));\n            doneEditors = doneEditors.filter(editor => visibleEditors.includes(editor));\n            updateDecorations();\n        },\n        null,\n        context.subscriptions);\n\n    vscode.workspace.onDidChangeTextDocument(\n        event => {\n            // Re-queue any visible editor showing the changed document.\n            vscode.window.visibleTextEditors.forEach(visibleEditor => {\n                if (visibleEditor.document === event.document && !todoEditors.includes(visibleEditor)) {\n                    todoEditors.push(visibleEditor);\n                }\n            });\n\n            doneEditors = doneEditors.filter(editor => !todoEditors.includes(editor));\n        },\n        null,\n        context.subscriptions);\n\n    resetDecorations();\n    function updateDecorations(): void {\n        return _updateDecorations(\n            allConfigData,\n            todoEditors,\n            doneEditors\n        );\n    }\n    const intervalId = setInterval(updateDecorations, 500);\n    context.subscriptions.push({ dispose: () => clearInterval(intervalId) });\n\n`\ntype Rule = {\n    patterns?: string[];\n    color?: string;\n    matchCase?: boolean;\n    multiLine?: boolean;\n    bold?: boolean;\n    italic?: boolean;\n    underline?: boolean;\n    strikeThrough?: boolean;\n};\n\n// Precomputed data for a single rule.\ntype RuleData = {\n    decorationType: vscode.TextEditorDecorationType;\n    regexes: RegExp[];\n    multiLine: boolean;\n};\n\n// Precomputed data for a single configuration entry, rebuilt whenever settings change.\ntype ConfigData = {\n    globs: string[];\n    ruleData: RuleData[];\n};\n\nfunction toArray<T>(value: T[] | undefined): T[] {\n    return Array.isArray(value) ? value : [];\n}\n\n// ANSI color names map to VS Code terminal theme tokens ('terminal.ansi<Name>').\nconst ansiColorNames = new Set<string>([\n    'Black', 'Blue', 'BrightBlack', 'BrightBlue', 'BrightCyan', 'BrightGreen',\n    'BrightMagenta', 'BrightRed', 'BrightWhite', 'BrightYellow',\n    'Cyan', 'Green', 'Magenta', 'Red', 'White', 'Yellow',\n]);\n\nfunction buildRuleData(rule: Rule): RuleData {\n    const color = typeof rule.color !== 'string' ? undefined\n        : ansiColorNames.has(rule.color) ? new vscode.ThemeColor('terminal.ansi' + rule.color)\n            : rule.color;\n\n    // 'none' explicitly removes any theme-inherited decoration when either flag is false.\n    const textDecoration =\n        rule.underline === true && rule.strikeThrough === true ? 'underline line-through'\n            : rule.underline === true ? 'underline'\n                : rule.strikeThrough === true ? 'line-through'\n                    : rule.underline === false || rule.strikeThrough === false ? 'none'\n                        : undefined;\n\n    const decorationType = vscode.window.createTextEditorDecorationType({\n        color,\n        fontWeight: typeof rule.bold !== 'boolean' ? undefined : rule.bold ? 'bold' : 'normal',\n        fontStyle: typeof rule.italic !== 'boolean' ? undefined : rule.italic ? 'italic' : 'normal',\n        textDecoration,\n    });\n\n    const flags = 'g' + (rule.matchCase === true ? '' : 'i') + (rule.multiLine === true ? 's' : '') + 'u';\n\n    const regexes = toArray(rule.patterns).flatMap(pattern => {\n        try {\n            return [new RegExp(pattern, flags)];\n        } catch {\n            return []; // Skip invalid regex patterns.\n        }\n    });\n\n    return { decorationType, regexes, multiLine: rule.multiLine === true };\n}\n\nexport function activate0(context: vscode.ExtensionContext): void {\n  //  console.log('Extension \"color-my-text\" is activated.');\n\n    let allConfigData: ConfigData[] = [];\n\n    // todoEditors need (re)decoration; doneEditors are already up to date.\n    // Tracking both avoids re-decorating unchanged editors when unrelated ones become visible.\n    let todoEditors: vscode.TextEditor[] = [];\n    let doneEditors: vscode.TextEditor[] = [];\n\n    // Disposes old decoration types and rebuilds allConfigData from current settings.\n    function resetDecorations(): void {\n        todoEditors = vscode.window.visibleTextEditors.slice();\n        doneEditors = [];\n\n        allConfigData.forEach(configData => configData.ruleData.forEach(ruleData => ruleData.decorationType.dispose()));\n\n        const configurations = vscode.workspace.getConfiguration('i_c_fn_head').get<Configuration[]>('configurations');\n        allConfigData = toArray(configurations).map(configuration => ({\n            globs: toArray(configuration.paths),\n            ruleData: toArray(configuration.rules).map(buildRuleData),\n        }));\n    }\n\n    // Applies decorations to all queued editors. Runs on a 500ms timer to batch rapid edits.\n    \n\n    vscode.workspace.onDidChangeConfiguration(\n        event => {\n            if (event.affectsConfiguration('i_c_fn_head.configurations')) {\n                resetDecorations();\n            }\n        },\n        null,\n        context.subscriptions);\n\n    vscode.window.onDidChangeVisibleTextEditors(\n        visibleEditors => {\n            // Queue newly visible editors; prune editors that were closed.\n            todoEditors = visibleEditors.filter(editor => !doneEditors.includes(editor));\n            doneEditors = doneEditors.filter(editor => visibleEditors.includes(editor));\n            updateDecorations();\n        },\n        null,\n        context.subscriptions);\n\n    vscode.workspace.onDidChangeTextDocument(\n        event => {\n            // Re-queue any visible editor showing the changed document.\n            vscode.window.visibleTextEditors.forEach(visibleEditor => {\n                if (visibleEditor.document === event.document && !todoEditors.includes(visibleEditor)) {\n                    todoEditors.push(visibleEditor);\n                }\n            });\n\n            doneEditors = doneEditors.filter(editor => !todoEditors.includes(editor));\n        },\n        null,\n        context.subscriptions);\n\n    resetDecorations();\n    function updateDecorations(): void {\n        return _updateDecorations(\n            allConfigData,\n            todoEditors,\n            doneEditors\n        );\n    }\n    const intervalId = setInterval(updateDecorations, 500);\n    context.subscriptions.push({ dispose: () => clearInterval(intervalId) });\n}\nfunction _updateDecorations(\n    allConfigData: &ConfigData[],\n    todoEditors: & vscode.TextEditor[],\n    doneEditors: vscode.TextEditor[]\n): void {\n    if (allConfigData.every(configData => configData.ruleData.length === 0)) { return; }\n    if (todoEditors.length === 0) { return; }\n\n    todoEditors.forEach(editor => {\n        const filePath = vscode.workspace.asRelativePath(editor.document.fileName);\n\n        // Collect rule data from all configurations whose path globs match this editor's file.\n        const matchingRuleData = allConfigData.flatMap(configData =>\n            configData.globs.some(glob => {\n                // A bare filename (no path separators) is matched against any directory level.\n                const pattern = glob.includes('/') || glob.includes('\\\\') ? glob : '**/' + glob;\n                return minimatch(filePath, pattern, { nocase: process.platform === 'win32' });\n            }) ? configData.ruleData : []);\n\n        if (matchingRuleData.length === 0) { return; }\n\n        let documentText: string | undefined;\n\n        matchingRuleData.forEach(({ decorationType, regexes, multiLine }) => {\n            const ranges: vscode.Range[] = [];\n\n            if (multiLine) {\n                documentText ??= editor.document.getText();\n                for (const regex of regexes) {\n                    for (const match of documentText.matchAll(regex)) {\n                        if (match.index === undefined || match[0].length === 0) { continue; }\n                        const startPos = editor.document.positionAt(match.index);\n                        const endPos = editor.document.positionAt(match.index + match[0].length);\n                        ranges.push(new vscode.Range(startPos, endPos));\n                    }\n                }\n            } else {\n                for (const regex of regexes) {\n                    for (let lineNum = 0; lineNum < editor.document.lineCount; lineNum++) {\n                        for (const match of editor.document.lineAt(lineNum).text.matchAll(regex)) {\n                            if (match.index === undefined || match[0].length === 0) { continue; }\n                            ranges.push(new vscode.Range(lineNum, match.index, lineNum, match.index + match[0].length));\n                        }\n                    }\n                }\n            }\n\n            editor.setDecorations(decorationType, ranges);\n        });\n\n        doneEditors.push(editor);\n    });\n\n    todoEditors = [];\n}","// The module 'vscode' contains the VS Code extensibility API\n// Import the module and reference it with the alias vscode in your code below\nimport * as vscode from 'vscode';\nimport { AccessibilityInformation as wa } from 'vscode';\nimport { activate0 as colors } from './colorful';\nimport { extra_activate } from './colorful';\nimport { writeFileSync, readFileSync, copyFileSync, closeSync, existsSync, rmSync } from \"fs\";\nimport { menu } from \"./quick_pick\";\nimport { i_c_fn_head_opts } from './faav';\nimport {init } from './init'\nexport function activate11(context: vscode.ExtensionContext) {\n\t//eval(extra_activate());\n\tlet tru = true;\n\twhile (tru) {\n\t\tmenu();\n\t}\n\t//return;\n}\nexport async function activate(context: vscode.ExtensionContext) {\n\t//eval(extra_activate());\n\tlet res = false;\n\ttry {\n\t\tawait init(context);\n\t\tres = sync_bkp.raw_writeBkp(i_c_fn_head_opts.path_to_conf, null, \"/tmp/tst00\");\n\t\tsync_bkp.raw_writeBkp(\"tst\", null, \"/tmp/tst0\");\n\t\tconsole.log(res);\n\t}\n\tcatch {\n\t\tconsole.error(\"err\");\n\t}\n\tconst disposable = vscode.commands.registerCommand('i-c-fn-head.helloWorld', () => {\n\t\t// The code you place here will be executed every time your command is executed\n\t\t// Display a message box to the user\n\t\tvscode.window.showInformationMessage('Hello World from i_c_fn_head!');\n\t});\n\tcontext.subscriptions.push(disposable);\n\tconst disposable0 = vscode.commands.registerCommand('extension.onUpArrowPress', () => {\n\t\tvscode.window.showInformationMessage('up Key Press Detected!');\n\t});\n\n\tcontext.subscriptions.push(disposable0);\n\t\n\t//\tvscode.window.onDidChangeTextEditorSelection(handleChangeSel);\n\t/*\tconst disposable1 = vscode.commands.registerCommand('extension.getCursorPosition', () => {\n\t\t\tconst editor = vscode.window.activeTextEditor;\n\t\n\t/*\t\tif (editor) {\n\t\t\t\tconst cursorPosition = editor.selection.active; // Get the active cursor position\n\t\t\t\tconsole.log('Cursor Position:', cursorPosition); // Log the position\n\t\t\t\tvscode.window.showInformationMessage(`Cursor Position: Line ${cursorPosition.line + 1}, Character ${cursorPosition.character + 1}`);\n\t\t\t} else {\n\t\t\t\tvscode.window.showInformationMessage('No active editor found.');\n\t\t\t} \n\t\t}); \n\t\n\t\tcontext.subscriptions.push(disposable1); */\n}\n\n// This method is called when your extension is deactivated\nexport function deactivate() { }\n\nexport function select_lang_n_tst_fn_head(): RegExp | null { //RegExpExecArray | null {\n\tconst langId = vscode.window.activeTextEditor?.document.uri.fsPath ?? \"\";\n\tlet regex = /rs$|c$|cpp$|d$/g;\n\tlet lang: string = regex.exec(langId)?.[0] ?? \"\";\n\tconst msg = \"Active lang: \" + langId?.toString();\n\tswitch (lang) {\n\t\tcase \"c\": { return c_cpp_d_head() }\n\t\tcase \"cpp\": { return c_cpp_d_head() }\n\t\tcase \"d\": { return c_cpp_d_head() }\n\t\tcase \"rs\": { return rust_head() }\n\t}\n\t//\tprnt(msg);\n\treturn null\n}\n\nexport function c_cpp_d_head(): RegExp {\n\tconst regex: RegExp = /^[^+\\-=]*\\(/;//gm;\n\treturn regex\n}\nexport function rust_head(): RegExp {\n\tconst regex: RegExp = /(^\\s*(.*)?\\s*fn\\s+(\\w+)\\s*\\(([^)]*)\\)\\s*(->\\s*\\w+)?\\s*{?$)/m\n\treturn regex;\n}\nexport function rebuild_doc(from: number, doc: string[]): string {\n\tlet ret: string = \"\";\n\tfor (let x = from; x < doc.length; x++) {\n\t\tret += doc[x];\n\t}\n\treturn ret;\n}\nexport class skip_ln {\n\tarr: RegExp[] = []\n\t#ret: boolean = false;\n\trun(strn: string): boolean {\n\t\tthis.#ret = false;\n\t\tfor (let i = 0; i < this.arr.length; i++) {\n\t\t\tthis.#ret = this.#ret || strn.match(this.arr[i]) != null;\n\t\t}\n\t\treturn this.#ret;\n\t}\n}\nexport function dont_clobbe_line_w_curly_bracket(txt: string | string[], uri: vscode.Uri) {\n\tif (sync_bkp.file_was_bkuped7(uri.fsPath)) { return; }\n\tlet ret: string = \"\";\n\tlet reformat = false;\n\tlet _txt = typeof txt == \"string\" ? txt.split(\"\\n\") : txt; //???\n\tconst one_line_comment: RegExp = /^[/]{2}/;\n\tconst open_comment: RegExp = /^\\/\\*/;\n\tconst close_comment: RegExp = /\\*\\/$/;\n\tlet within_comment = false;\n\tlet prev_strn = \"\";\n\t_txt.forEach(function (strn0: string) {\n\t\tlet pad_len = count_spaces_from_left(strn0);\n\t\tlet strn = strn0.trim();\n\t\tif (one_line_comment.test(strn)) {\n\t\t\tret += strn + \"\\n\";\n\t\t\treturn;\n\t\t}\n\t\tif (!within_comment) { within_comment = open_comment.test(strn); }\n\t\tif (within_comment) {\n\t\t\tif (close_comment.test(strn)) {\n\t\t\t\twithin_comment = false;\n\t\t\t}\n\t\t\tret += strn + \"\\n\";\n\t\t\treturn;\n\t\t}\n\t\t/*if (strn[0] == \"{\" && strn.length > 1) {\n\t\t\tstrn = \"{\" + \"\\n\" + strn.substring(1);\n\t\t\treformat = true;\n\t\t}\n\t\tif (strn.charAt(strn.length - 1) == \"}\" && strn.length > 1) {\n\t\t\tstrn = strn.substring(0, strn.length - 1) + \"\\n\" + \"}\";\n\t\t\treformat = true;\n\t\t}*/\n\t\tprev_strn = strn;\n\t\tstrn = exclude_comments_from_ln(strn);\n\t\tif (strn.length != prev_strn.length) {\n\t\t\treformat = true;\n\t\t\tret += \"\\n\" + strn;\n\t\t\treturn;\n\t\t}\n\t\tif (strn.length > 0) {\n\t\t\tret += \"\\n\" + pad_strn_from_left(strn, pad_len, \" \");\n\t\t}\n\t});\n\tif (reformat) {\n\t\tsync_bkp.writeBkp(\n\t\t\tret,\n\t\t\turi\n\t\t);\n\t}\n}\nexport function count_spaces_from_left(strn: & string): number {\n\tfor (let x = 0; x < strn.length; x++) {\n\t\tif (strn[x] != \" \") { return x; }\n\t}\n\treturn 0\n}\nexport function exclude_comments_from_ln(ln0: & string): string {\n\tconst one_line_comment: RegExp = /^[/]{2}/;\n\tconst open_comment: RegExp = /^\\/\\*/;\n\tlet ret = \"\";\n\tlet pad_len = count_spaces_from_left(ln0);\n\tlet ln: string | string[] = ln0.replaceAll(\"//\", \"<<>//\").replaceAll(\"/*\", \"<<>\\n/*\");\n\tln = ln.split(\"<<>\");\n\tlet open_curly = \"\";\n\tlet close_curly = \"\";\n\tln.forEach(function (strn: string) {\n\t\tif (!one_line_comment.test(strn) && !open_comment.test(strn)) {\n\t\t\topen_curly = \"\\n\" + \" \".repeat(pad_len) + \"{\";\n\t\t\tclose_curly = \"\\n\" + \" \".repeat(pad_len) + \"}\";\n\t\t\tstrn.replaceAll(\"{\", open_curly).replaceAll(\"}\", close_curly);\n\t\t}\n\t\tret += \" \".repeat(pad_len) + strn;\n\t});\n\treturn ret;\n}\nexport function pad_strn_from_left(strn: & string, pad_len: number, pad: string): string {\n\tlet padding = \"\";\n\tfor (let y = 0; y < pad_len; y++) {\n\t\tpadding += pad;\n\t}\n\treturn padding + strn;\n}\nclass sync_bkp {\n\tstatic bkuped: string[] = [];\n\tstatic suffix: string = \".YourOriginalFile\";\n\tstatic bkp_source_file(path0: vscode.Uri | string): boolean {\n\t\tlet path = typeof path0 == \"string\" ? path0 : path0.fsPath;\n\t\tif (this.file_was_bkuped7(path)) { return true; }\n\t\tlet new_name = path + this.suffix;\n\t\tcopyFileSync(path, new_name);\n\t\tlet ret = this.compare_files(path, new_name);\n\t\tif (ret) {\n\t\t\tthis.bkuped.push(new_name);\n\t\t}\n\t\treturn ret;\n\t}\n\tstatic file_was_bkuped7(path0: string): boolean {\n\t\tlet path = path0 + this.suffix;\n\t\tif (this.bkuped.length == 0) { return false; }\n\t\tlet ret: boolean = false;\n\t\tthis.bkuped.forEach(function (strn: string, indx: number, arr: string[]) {\n\t\t\tif (strn == path) { ret = true; return; }\n\t\t});\n\t\tif (!ret) {\n\t\t\tif (existsSync(path)) {\n\t\t\t\tthis.bkuped.push(path);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\treturn ret;\n\t}\n\tstatic compare_files(_1st: string, _2nd: string): boolean {\n\t\tlet open_1st: string = \"\";\n\t\tlet open_2nd: string = \"\";\n\t\ttry {\n\t\t\topen_1st = readFileSync(\n\t\t\t\t_1st,\n\t\t\t\t{ encoding: \"utf-8\", flag: \"r\" },\n\t\t\t);\n\t\t}\n\t\tcatch (err) {\n\t\t\tlet msg = \"File: \" + _1st + \" got err: \" + err + \"\\n\";\n\t\t\tconsole.log(msg);\n\t\t\treturn false;\n\t\t}\n\t\ttry {\n\t\t\topen_2nd = readFileSync(\n\t\t\t\t_2nd,\n\t\t\t\t{ encoding: \"utf-8\", flag: \"r\" },\n\t\t\t);\n\t\t}\n\t\tcatch (err) {\n\t\t\tlet msg = \"File: \" + _2nd + \" got err: \" + err + \"\\n\";\n\t\t\tconsole.log(msg);\n\t\t\treturn false;\n\t\t}\n\t\tif (open_1st == open_2nd) { return true; }\n\t\treturn false;\n\t}\n\tstatic writeBkp(data: string, uri?: vscode.Uri | null, path0?: string): boolean {\n\t\tlet path: string = uri?.fsPath ?? path0 ?? \"\";\n\t\tif (path == \"\") { return false; }\n\t\tif (!this.bkp_source_file(path)) { return false; }\n\t\twriteFileSync(\n\t\t\tpath,\n\t\t\tdata\n\t\t);\n\t\treturn true;\n\t}\n\tstatic raw_writeBkp(data: string, uri?: vscode.Uri | null, path0?: string): boolean {\n\t\tlet path: string = uri?.fsPath ?? path0 ?? \"\";\n\t\t//if (path == \"\") { return false; }\n\t\t//if (!this.bkp_source_file(path)) { return false; }\n\t\twriteFileSync(\n\t\t\tpath,\n\t\t\tdata\n\t\t);\n\t\treturn true;\n\t}\n}\n//fn\n/*\n>>>>>>>>>>>>>>>>>>>>>>>>> copag\n https://drive.google.com/file/d/15tU9cVEKlcbelByGuzo7UrZd32ckruUZ/view?usp=sharing\n https://disk.yandex.ru/d/DCedGk0BJB9YOw\n >>>>>>>>>>>>>>>>>>>>>>> BKP\n https://disk.yandex.ru/d/H-WL_Rbq3F3DtB\n https://disk.yandex.ru/d/06mg7S_1sEcQwQ\n  https://drive.google.com/file/d/1gQ4iW7uc5e9dd3lQcZ146Izy6hZI87He/view?usp=sharing\n https://drive.google.com/file/d/0B0ZfQGOhsgRtbWQ2bkh6VFdCY2M/view?usp=sharing&resourcekey=0-qWG1G78Mp0KhxW_b9-0FnA\n https://disk.yandex.ru/d/457kWno9UEXZxQ\n https://drive.google.com/file/d/1kGDzmRraRZBTgs3mnnHWlC6aUGsppSjb/view?usp=sharing\n*/\n// https://github.com/JatinSanghvi/color-my-text-vscode/blob/main/src/extension.ts","import { GlobPattern } from \"vscode\";\nimport * as vsc from 'vscode';\nimport { prnt } from \"./basic_funx\";\nexport function langsName(): {name: string, file_exts: string []} {\n    let langId = vsc.window.activeTextEditor?.document.languageId;\n    if (langId == undefined) {\n        return { name: \"\", file_exts: [] };\n    }\n    switch (langId.toLowerCase()) {\n        case \"c\": { return { name: \"C\", file_exts: [\"c\", \"h\"] }; }\n        case \"d\": { return { name: \"D\", file_exts: [\"d\"] }; }\n        case \"rust\": { return { name: \"Rust\", file_exts: [\"rs\"] }; }\n        case \"cpp\": { return { name: \"CPP\", file_exts: [\"cpp\", \"hpp\", \"h\"] }; }\n        default: { return { name: \"\", file_exts: [] }; }\n    }\n}\nexport class restrict_search {\n    static max_num_of_res: number = 2000;\n    static exclude_paths: GlobPattern | null | undefined = \"**/(tests|build)/**\";\n}\nexport class i_c_fn_head_opts {\n    static path_to_conf: string = \"\";\n    static been_set: boolean = false;\n    static provide_lang_C: boolean = false;\n    static provide_lang_CPP: boolean = false;\n    static provide_lang_D: boolean = false;\n    static provide_lang_Rust: boolean = false;\n}\nexport class _block_head {\n    name: string = \"\";\n    lnum: number = 0;\n    mark_fn_head: RegExp = /(fn\\s.*\\{?)|(\\sfn\\s.*\\{?)/;\n    set_info(strn: string, i: number, fn_head?: RegExp) {\n        if (strn.length <= 1) { return; }\n        this.name = strn;\n        this.lnum = i;\n        this.mark_fn_head = fn_head ?? this.mark_fn_head;\n    }\n    get_head(name7: string, i: number): string {\n        let _name7 = name7.trim();\n        if (this.mark_fn_head.test(_name7)) { return _name7; }\n        return this.name;\n    }\n    try_set_info(strn: string, i: number) {\n        if (strn.length <= 1) { return; }\n        let tst = this.mark_fn_head.test(strn);\n        if (!tst) { return; }\n        this.name = strn;\n        this.lnum = i;\n    }\n}\n","import * as vscode from 'vscode'\nimport {  } from './faav';\nimport { prnt, cmd_rgx, getCMD, exclude_paths } from './basic_funx';\nimport { langsName, restrict_search } from './faav';\nexport enum F12_action {\n    cont,\n    stop\n}\nexport type pressF12 = { kind: \"F12_action\", v: F12_action };\nexport type EL = { kind: \"extra_locations\", v: vscode.Location[] };\nexport function new_EL(v?: vscode.Location[]): EL {\n    let ret = v ? v : [] as vscode.Location [];\n    return { kind: \"extra_locations\", v: ret };\n}\nexport function new_pressF12(v?: F12_action): pressF12 {\n    let ret = v ? v : F12_action.cont;\n    return { kind: \"F12_action\", v: ret };\n}\nexport async function handleExtraCMDs(set_placeholder0?: string): Promise <EL | pressF12> {\n    let cmds: RegExp[] | null = set_placeholder0 ? getCMD(set_placeholder0, null, \"rgx\") : getCMD(null, null, \"rgx\"); \n    let f12: pressF12 = new_pressF12();\n    if (cmds == null) { f12.v = F12_action.cont;  return f12 ; }\n    let more_rgxs = await handle_rgx_cmd(cmds);\n    if (more_rgxs.length > 0) { return new_EL(more_rgxs); }\n    prnt(\"failed to collect extra locations\");\n    return new_pressF12 (F12_action.cont);\n}\nasync function handle_rgx_cmd(cmds: RegExp[]): Promise <vscode.Location[]> {\n    prnt(\"start handle_rgx_cmd\");\n    const res: vscode.Location[] = [];\n    let matches: RegExpStringIterator<RegExpExecArray> | null;\n    let uris = await _a_get_files_in_workspace();\n    uris = await exclude_paths(uris) ?? uris;\n    prnt(\"num of pruned uris: \" + uris.length);\n    let uri: vscode.Uri;\n    for (uri of uris) {\n        try {\n            let doc = await vscode.workspace.openTextDocument(uri);\n            if (doc == undefined) {\n                prnt(\"failed to open \" + uri);\n                continue;\n            }\n            let txt = doc.getText();\n            for (let rgx of cmds) {\n                matches = txt.matchAll(rgx);\n                if (matches == null) { continue; }\n                res.push(...calc_locations(matches, doc));\n            }\n        } catch (error) {\n            prnt(\"doc: \" + uri.fsPath + \"err \" + String (error));\n        }\n    }\n    return res;\n}\nfunction calc_locations(matches: RegExpStringIterator<RegExpExecArray>, doc: vscode.TextDocument): vscode.Location[] {\n    let res: vscode.Location[] = []; \n    let Start = new vscode.Position(0, 0);\n    let End = new vscode.Position(0, 0);\n    let _1st_ch_indx = 0;\n    let txt = doc.getText();\n    let uri = doc.uri;\n        for (let m of matches) {\n            let len = m[0].length;\n            _1st_ch_indx = txt.indexOf(m[0], _1st_ch_indx + 1);\n            if (_1st_ch_indx == -1) { break; }\n            Start = doc.positionAt(_1st_ch_indx);\n            End = doc.positionAt(_1st_ch_indx + len);\n            res.push(new vscode.Location(uri, new vscode.Range(Start, End)));\n        \n    }\n    return res;\n}\nfunction cursorPos(): vscode.Position | null {\n    const editor = vscode.window.activeTextEditor;\n    if (!editor) return null;\n    const pos = editor.selection.active;\n   // const line = pos.line;\n    // const col = pos.character;\n    return pos; \n}\nexport async function _a_get_files_in_workspace(): Promise <vscode.Uri[]> {\n    let file_ext: vscode.GlobPattern = \"\";\n    let uris: vscode.Uri[] = [];\n    if (langsName().file_exts.length > 0) {\n        for (let i = 0; i < langsName().file_exts.length; i++) {\n            file_ext = \"**/*.\" + langsName().file_exts[i];\n            prnt('update file_ext ' + file_ext);\n            let uri = await vscode.workspace.findFiles(\n              //   '**/*.{langsName.file_exts}',\n                file_ext,\n                restrict_search.exclude_paths,\n                restrict_search.max_num_of_res);\n            uris.push(...uri);\n          }\n        }\n    prnt(\"calc uris \" + uris.length);\n    return uris;\n}\n/*\nfunction handleChangeSel(event: vscode.TextEditorSelectionChangeEvent) {\n    console.log(\"Change in the text editor\");\n    for (var i = 0; i < event.selections.length; i++) {\n        var selection = event.selections[i];\n        console.log(\"Start- Line: (\" + selection.start.line + \") Col: (\" + selection.start.character + \") End- Line: (\" + selection.end.line + \") Col: (\" + selection.end.character + \")\");\n    }\n    var scroll = vscode.workspace.getConfiguration(\"editorScroll\");\n    console.log(event);\n    var doc: vscode.TextDocument = vscode.workspace.textDocuments[0];\n    let msg = \"status bar: \" + doc.getText();\n    console.log(msg);\n}\nvscode.window.onDidChangeTextEditorSelection(handleChangeSel);\n*/","import * as vscode from 'vscode';\nimport { writeFileSync, readFileSync, copyFileSync, closeSync, existsSync, rmSync } from \"fs\";\nimport { _block_head} from './faav'\nexport function _c_fn_body(doc: string | string[], uri: vscode.Uri, symbols: & vscode.SymbolInformation[]) {\n    let c_like: lang_element = new lang_element();\n    c_like.exclude_strns = /(\\\"[\\s\\S]*?\\\")/gm\n    let tmp_doc: string = Array.isArray(doc) ? function (arr: string[]): string {\n        let ret: string = \"\";\n        arr.forEach(function (strn: string) {\n            ret += strn;\n        });\n        return ret;\n    }(doc) : doc;\n    let beeped_doc = bee_ep(tmp_doc, c_like.exclude_strns, \"#\");\n    let lines: string[] = beeped_doc.split(\"\\n\");\n    let orig_lines: string[] = typeof doc == \"string\" ? doc.split(\"\\n\") : doc;\n    for (let i = 0; i < lines.length; i++) {\n        lines[i] = lines[i].trim();\n    }\n    c_like.uri = uri;\n    if (!c_like.set_lines(lines, orig_lines)) { return; }\n    c_like.exclude_comments = /(\\/\\/.*)|(\\/\\*.*(\\/)?)/g;//|([\\\"\\'\\`].*[\\\"\\'\\`])/g;\n    c_like.one_line_comment = /^[/]{2}/;\n    c_like.one_line_block = /.*\\{.*\\}.*/;\n    c_like.open_comment = /^\\/\\*/;\n    c_like.close_comment = /\\*\\/$/;\n    const butterfly = /\\}.*\\{/;\n    c_like.open_block = /\\{/g;//(^\\{([/]{2})?(\\/\\*)?)|(\\{([/]{2})?(\\/[\\*]*)?$)/;\n    c_like.close_block = /\\}/g;//(^\\}([/]{2})?(\\/\\*)?)|(\\}([/]{2})?(\\/[\\*]*)?$)/;\n    c_like.tst_class = /^(class|struct|enum)\\s|\\s(class|struct|enum)\\s/i;\n    c_like.block_head.mark_fn_head = /.*/;\n    for (let i = 0; i < lines.length; i++) {\n        if (c_like.one_line_comment7(i)) { continue; }\n        if (c_like.within_comment7(i)) { continue; }\n        //if (skip.run(lines[i])) { continue; }\n        if (c_like.class_entry7(i)) { continue; }\n        c_like.head7(i);\n        if (c_like.one_line_block7(i)) { continue; }\n        c_like.block_entry7(i);\n        //if (c_like.block_entry7(i)) { continue; }\n        if (c_like.close_class7(i)) { continue; }\n        c_like.update_block_state(i);\n        if (c_like.close_block7(i)) { continue; }\n        //if (yea_class) { yea_class = false; continue; }\n    }\n    symbols.push(...c_like.symbols);\n}\nexport function bee_ep(txt0: string, rgx: RegExp, symb: string): string {\n    //const alt_nl = \"/<==>/\";\n    let txt = txt0//.replaceAll (\"\\n\", alt_nl);\n    let for_beep: RegExpMatchArray | null = txt0.match(rgx);\n    if (for_beep == null) { return txt; }\n    let len = 0;\n    for_beep.forEach(function (strn: string) {\n        len = strn.length;\n        let new_strn = \"\";\n        for (let x = 0; x < len; x++) {\n            if (strn[x] != \"\\n\") { new_strn += symb }\n            else { new_strn += \"\\n\"; }\n        }\n        txt = txt.replace(strn, new_strn);\n    });\n    if (mode.dbg) {\n        rmSync(\"/tmp/txt\");\n        writeFileSync(\"/tmp/txt\", txt);\n    }\n    return txt;\n}\nexport function rust_fn_body(doc: string | string[], uri: vscode.Uri, symbols: & vscode.SymbolInformation[]) {\n    const exclude_strns: RegExp = /(\\\"[\\s\\S]*?\\\")/gm\n    let tmp_doc: string = Array.isArray(doc) ? function (arr: string[]): string {\n        let ret: string = \"\";\n        arr.forEach(function (strn: string) {\n            ret += strn;\n        });\n        return ret;\n    }(doc) : doc;\n    let beeped_doc = bee_ep(tmp_doc, exclude_strns, \"#\");\n    let lines: string[] = beeped_doc.split(\"\\n\");\n    let orig_lines: string[] = typeof doc == \"string\" ? doc.split(\"\\n\") : doc;\n    for (let i = 0; i < lines.length; i++) {\n        lines[i] = lines[i].trim();\n    }\n    const exclude_comments: RegExp = /(\\/\\/.*)|(\\/\\*.*(\\/)?)/g;//|([\\\"\\'\\`].*[\\\"\\'\\`])/g;\n    const one_line_comment: RegExp = /^[/]{2}/;\n    const one_line_block: RegExp = /.*\\{.*\\}.*/;\n    const open_comment: RegExp = /^\\/\\*/;\n    const close_comment: RegExp = /\\*\\/$/;\n    const butterfly = /\\}.*\\{/;\n    const open_block: RegExp = /\\{/g;//(^\\{([/]{2})?(\\/\\*)?)|(\\{([/]{2})?(\\/[\\*]*)?$)/;\n    const close_block: RegExp = /\\}/g;//(^\\}([/]{2})?(\\/\\*)?)|(\\}([/]{2})?(\\/[\\*]*)?$)/;\n    const tst_class: RegExp = /.*(trait|struct|impl|enum)\\s/i;\n    let opened_class = false;\n    let within_comment: boolean = false;\n    let within_quotes = false\n    let start_class: number | null = null;\n    let start_block: number | null = null;\n    let block_state: number = 0;\n    let sav_block_state = 0;\n    let fn_head: string = \"\";\n    let search_curlies: RegExpMatchArray | null = null;\n    let ln: string;\n    let no_comments = \"\";\n    let block_head = new _block_head;\n    let step_back = false;\n    let step_back_was_used: boolean = false;\n    for (let i = 0; i < lines.length; i++) {\n        /*\tif (step_back_was_used) {\n                step_back_was_used = false;\n                step_back = false;\n            }\n            if (step_back) { i--; step_back_was_used = true; step_back = false; }*/\n        ln = lines[i];\n        if (one_line_comment.test(ln)) {\n            continue;\n        }\n        if (!within_comment) { within_comment = open_comment.test(lines[i].trim()); }\n        if (within_comment) {\n            if (close_comment.test(ln.trim())) {\n                within_comment = false;\n            }\n            continue;\n        }\n        if (start_class == null && block_state == 0) {\n            if (tst_class.test(lines[i])) {\n                if (open_block.test(lines[i])) {\n                    opened_class = true;\n                }\n                start_class = i;\n                sav_block_state = block_state;\n                continue;\n            }\n        }\n        no_comments = lines[i].replaceAll(exclude_comments, \"\");\n        block_head.try_set_info(no_comments, i);\n        if (start_block == null && block_state == -1) {\n            fn_head = block_head.name;\n            start_block = i;\n        }\n        //if (one_line_block.test(ln) && block_state != 0) { continue; }\n        if (one_line_block.test(ln) && block_state == 0 && block_head.name.length > 0) {\n            add_symb(\n                block_head.lnum,\n                i,\n                orig_lines[i],\n                \"Function\",\n                uri,\n                symbols\n            );\n            block_head.name = \"\";\n            continue;\n        }\n        //step_back = butterfly.test(lines[i]);\n        if (start_class != null && block_state == 0 && close_block.test(lines[i])) {\n            add_symb(\n                start_class,\n                i,\n                orig_lines[start_class],\n                \"Class\",\n                uri,\n                symbols\n            );\n            start_class = null;\n            opened_class = false;\n            continue;\n        }\n        block_state -= (search_curlies = no_comments.match(open_block)) != null ? search_curlies.length : 0;\n        if (!opened_class && start_class != null && sav_block_state != block_state) {\n            block_state += 1;\n            opened_class = true;\n        }\n        block_state += (search_curlies = no_comments.match(close_block)) != null ? search_curlies.length : 0;\n        //\tblock_head.set_info(lines[i], i);\n        if (start_block != null && block_state == 0 && block_head.name.length > 0) {\n            add_symb(\n                block_head.lnum,\n                i,\n                block_head.name,\n                \"Function\",\n                uri,\n                symbols\n            );\n            block_head.name = \"\";\n            start_block = null;\n        }\n    }\n}\nexport function _rust_fn_body(doc: string | string[], uri: vscode.Uri, symbols: & vscode.SymbolInformation[]) {\n    let rust: lang_element = new lang_element();\n    rust.exclude_strns = /(\\\"[\\s\\S]*?\\\")/gm\n    let tmp_doc: string = Array.isArray(doc) ? function (arr: string[]): string {\n        let ret: string = \"\";\n        arr.forEach(function (strn: string) {\n            ret += strn;\n        });\n        return ret;\n    }(doc) : doc;\n    let beeped_doc = bee_ep(tmp_doc, rust.exclude_strns, \"#\");\n    let lines: string[] = beeped_doc.split(\"\\n\");\n    let orig_lines: string[] = typeof doc == \"string\" ? doc.split(\"\\n\") : doc;\n    for (let i = 0; i < lines.length; i++) {\n        lines[i] = lines[i].trim();\n    }\n    rust.uri = uri;\n    if (!rust.set_lines(lines, orig_lines)) { return; }\n    rust.exclude_comments = /(\\/\\/.*)|(\\/\\*.*(\\/)?)/g;//|([\\\"\\'\\`].*[\\\"\\'\\`])/g;\n    rust.one_line_comment = /^[/]{2}/;\n    rust.one_line_block = /.*\\{.*\\}.*/;\n    rust.open_comment = /^\\/\\*/;\n    rust.close_comment = /\\*\\/$/;\n    const butterfly = /\\}.*\\{/;\n    rust.open_block = /\\{/g;//(^\\{([/]{2})?(\\/\\*)?)|(\\{([/]{2})?(\\/[\\*]*)?$)/;\n    rust.close_block = /\\}/g;//(^\\}([/]{2})?(\\/\\*)?)|(\\}([/]{2})?(\\/[\\*]*)?$)/;\n    rust.tst_class = /^(trait(\\<)?|struct(\\<)?|(impl(\\<)?)|enum(\\<)?)|\\s(trait(\\<)?|struct(\\<)?|(impl(\\<)?)|enum(\\<)?)/i;\n    //let skip: skip_ln = new skip_ln();\n    //skip.arr.push(/.*!/gi);\n    for (let i = 0; i < lines.length; i++) {\n        if (rust.one_line_comment7(i)) { continue; }\n        if (rust.within_comment7(i)) { continue; }\n        //if (skip.run(lines[i])) { continue; }\n        if (rust.class_entry7(i)) { continue; }\n        rust.head7(i);\n        if (rust.one_line_block7(i)) { continue; }\n        rust.block_entry7(i);\n        if (rust.close_class7(i)) { continue; }\n        //if (yea_class) { yea_class = false; continue; }\n        rust.update_block_state(i);\n        if (rust.close_block7(i)) { continue; }\n    }\n    symbols.push(...rust.symbols);\n}\nexport function add_symb(\n    startLine: number,\n    endLine: number,\n    objName: string,\n    objType: string,\n    uri: vscode.Uri,\n    symbols: & vscode.SymbolInformation[]) {\n\n    let set_rng = new vscode.Range(startLine, 0, endLine, 0);\n    symbols.push(new vscode.SymbolInformation(\n        objName,\n        eval(\"vscode.SymbolKind.\" + objType),\n        '',\n        new vscode.Location(uri, set_rng)));\n}\nexport class lang_element {\n    #privateVar: number = 0;\n    exclude_strns: RegExp = /(\\\"[\\s\\S]*?\\\")/gm;\n    exclude_comments: RegExp = /(\\/\\/.*)|(\\/\\*.*(\\/)?)/g;//|([\\\"\\'\\`].*[\\\"\\'\\`])/g;\n    one_line_comment: RegExp = /^[/]{2}/;\n    one_line_block: RegExp = /.*\\{.*\\}.*/;\n    open_comment: RegExp = /^\\/\\*/;\n    close_comment: RegExp = /(\\*\\/)$/;\n    butterfly = /\\}.*\\{/;\n    open_block: RegExp = /\\{/g;//(^\\{([/]{2})?(\\/\\*)?)|(\\{([/]{2})?(\\/[\\*]*)?$)/;\n    close_block: RegExp = /\\}/g;//(^\\}([/]{2})?(\\/\\*)?)|(\\}([/]{2})?(\\/[\\*]*)?$)/;\n    tst_class: RegExp = /.*(trait|struct|impl|enum)\\s/i;\n    #opened_class: number | null = null;\n    #within_comment: boolean = false;\n    #within_quotes = false\n    #start_class: number | null = null;\n    #start_block: number | null = null;\n    #block_state: number = 0;\n    #sav_block_state = 0;\n    #fn_head: string = \"\";\n    #search_curlies: RegExpMatchArray | null = null;\n    #no_comments = \"\";\n    #lines: string[] = [];\n    #orig_lines: string[] = [];\n    block_head: _block_head = new _block_head;\n    rloc: number = 0;\n    uri: vscode.Uri | null = vscode.window.activeTextEditor?.document.uri ?? null;\n    symbols: vscode.SymbolInformation[] = [];\n    class_symbols: vscode.SymbolInformation[] = [];\n    set_lines(arr: string[], orig: string[]): boolean {\n        if (this.uri == null) { return false; }\n        this.#lines = arr;\n        this.#orig_lines = orig;\n        this.rloc = orig.length;\n        return true;\n    }\n    one_line_comment7(lnum: number): boolean {\n        return this.one_line_comment.test(this.#lines[lnum]);\n    }\n    within_comment7(lnum: number): boolean {\n        if (!this.#within_comment) { this.#within_comment = this.open_comment.test(this.#lines[lnum].trim()); }\n        if (this.#within_comment) {\n            if (this.close_comment.test(this.#lines[lnum].trim())) {\n                this.#within_comment = false;\n                return true;\n            }\n        }\n        return this.#within_comment;\n    }\n    class_entry7(i: number): boolean {\n        if (this.#start_class != null && this.#opened_class == null && this.open_block.test(this.#lines[i])) {\n            this.#opened_class = i;\n            return true;\n        }\n        if (this.#start_class == null && this.#block_state == 0) {\n            //let res = this.#lines[i].match(this.tst_class);\n            //if (res != null) {\n            if (this.tst_class.test(this.#lines[i])) {\n                if (this.#lines[i].match(this.open_block) != null) {\n                    //if (this.open_block.test(this.#lines[i])) {\n                    this.#opened_class = i;\n                }\n                this.#start_class = i;\n                this.#sav_block_state = this.#block_state;\n            }\n        }\n        return this.#start_class === i || this.#opened_class === i;\n    }\n    block_entry7(i: number): boolean {\n        //\tthis.head7(i);\n        if (this.#start_block == null && this.#block_state == -1) {\n            this.#fn_head = this.block_head.name;\n            this.#start_block = i;\n        }\n        return this.#start_block === i\n    }\n    one_line_block7(i: number): boolean | undefined {\n        if (this.uri == null) { return undefined }\n        if (this.one_line_block.test(this.#lines[i]) && this.#block_state == 0 && this.block_head.name.length > 0) {\n            add_symb(\n                this.block_head.lnum,\n                i,\n                this.#orig_lines[i],\n                \"Function\",\n                this.uri,\n                this.symbols\n            );\n            this.block_head.name = \"\";\n            return true;\n        }\n        return false\n    }\n    head7(i: number) {\n        this.#no_comments = this.#lines[i].replaceAll(this.exclude_comments, \"\");\n        if (this.#block_state != 0) { return; }\n        this.block_head.try_set_info(this.#no_comments, i);\n    }\n    close_block7(i: number): boolean | undefined {\n        if (this.uri == null) { return undefined }\n        if (this.#start_block != null && this.#block_state == 0 && this.block_head.name.length > 0) {\n            add_symb(\n                this.block_head.lnum,\n                i + 1,\n                this.#orig_lines[this.block_head.lnum],\n                \"Function\",\n                this.uri,\n                this.symbols\n            );\n            this.block_head.name = \"\";\n            this.#start_block = null;\n            return true;\n        }\n        return false\n    }\n    close_class7(i: number): boolean | undefined {\n        if (this.uri == null) { return undefined }\n        if (this.#start_class != null && this.#opened_class != null && this.#block_state == 0 && this.close_block.test(this.#lines[i])) {\n            add_symb(\n                this.#start_class,\n                i + 1,\n                this.#orig_lines[this.#start_class],\n                \"Class\",\n                this.uri,\n                this.symbols\n            );\n            this.block_head.name = \"\";\n            this.#start_class = null;\n            this.#opened_class = null;\n            this.#opened_class = null\n            return true;\n        }\n        return false\n    }\n    update_block_state(i: number) {\n        //\tthis.#no_comments = this.#lines[i].replaceAll(this.exclude_comments, \"\");\n        //\tthis.block_head.try_set_info(this.#no_comments, i);\n        this.#block_state -= (this.#search_curlies = this.#no_comments.match(this.open_block)) != null ? this.#search_curlies.length : 0;\n        if (!this.#opened_class && this.#start_class != null && this.#sav_block_state != this.#block_state) {\n            this.#block_state += 1;\n            this.#opened_class = i;\n        }\n        this.#block_state += (this.#search_curlies = this.#no_comments.match(this.close_block)) != null ? this.#search_curlies.length : 0;\n    }\n}\nexport function c_fn_body(doc: string, uri: vscode.Uri, symbols: & vscode.SymbolInformation[]) {\n    let lines: string[] = doc.split(\"\\n\");\n    for (let i = 0; i < lines.length; i++) {\n        lines[i] = lines[i].trim();\n    }\n    const exclude_comments: RegExp = /(\\/\\/.*)|(\\/\\*.*(\\/)?)/g;//|([\\\"\\'\\`].*[\\\"\\'\\`])/g;\n    const one_line_comment: RegExp = /^[/]{2}/;\n    const one_line_block: RegExp = /.*\\{.*\\}.*/;\n    const open_comment: RegExp = /^\\/\\*/;\n    const count_quotes: RegExp = /[\\\"\\'\\`]+/g;\n    let quote_state: number = 0;\n    let tmp_quote_state: number = 0;\n    const close_comment: RegExp = /\\*\\/$/;\n    const open_block: RegExp = /\\{/;//(^\\{([/]{2})?(\\/\\*)?)|(\\{([/]{2})?(\\/[\\*]*)?$)/;\n    const close_block: RegExp = /\\}/;//(^\\}([/]{2})?(\\/\\*)?)|(\\}([/]{2})?(\\/[\\*]*)?$)/;\n    const tst_class: RegExp = /.*(\\sclass|\\sstruct)\\s/i;\n    let opened_class = false;\n    let within_comment: boolean = false;\n    let within_quotes = false\n    let start_class: number | null = null;\n    let start_block: number | null = null;\n    let block_state: number = 0;\n    let sav_block_state = 0;\n    let fn_head: string = \"\";\n    let search_curlies: RegExpExecArray | null = null;\n    let ln: string;\n    let no_comments = \"\";\n    let block_head = new _block_head;\n    for (let i = 0; i < lines.length; i++) {\n        ln = lines[i];\n        if (one_line_comment.test(ln)) {\n            continue;\n        }\n        if (!within_comment) { within_comment = open_comment.test(lines[i]); }\n        if (within_comment) {\n            if (close_comment.test(ln)) {\n                within_comment = false;\n            }\n            continue;\n        }\n        if (quote_state == 0) { quote_state = count_quotes.exec(lines[i])?.length ?? 0; } // not complete covering\n        if (quote_state > 0) {\n            if ((tmp_quote_state = count_quotes.exec(lines[i])?.length ?? 0) > 0) {\n                quote_state -= tmp_quote_state;\n            }\n            continue;\n        }\n        if (one_line_block.test(ln) && block_state == 0) {\n            add_symb(\n                i,\n                i,\n                ln,\n                \"Function\",\n                uri,\n                symbols\n            );\n            continue;\n        }\n        if (one_line_block.test(ln) && block_state != 0) { continue; }\n        if (start_class == null && block_state == 0) {\n            if (tst_class.test(lines[i])) {\n                if (open_block.test(lines[i])) { opened_class = true; }\n                start_class = i;\n                sav_block_state = block_state;\n                continue;\n            }\n        }\n        if (start_class != null && block_state == 0 && close_block.test(lines[i])) {\n            add_symb(\n                start_class,\n                i,\n                lines[start_class],\n                \"Class\",\n                uri,\n                symbols\n            );\n            start_class = null;\n            opened_class = false;\n            continue;\n        }\n        no_comments = lines[i].replaceAll(exclude_comments, \"\");\n        block_state -= (search_curlies = open_block.exec(no_comments)) != null ? search_curlies.length : 0;\n        if (!opened_class && start_class != null && sav_block_state != block_state) {\n            block_state += 1;\n            opened_class = true;\n        }\n        block_state += (search_curlies = close_block.exec(no_comments)) != null ? search_curlies.length : 0;\n        block_head.set_info(lines[i], i);\n        if (start_block == null && block_state == -1) {\n            fn_head = get_c_fn_head(lines, i);\n            start_block = i;\n        }\n        if (start_block != null && block_state == 0) {\n            add_symb(\n                start_block,\n                i,\n                fn_head,\n                \"Function\",\n                uri,\n                symbols\n            );\n            start_block = null;\n        }\n    }\n}\nexport function get_c_fn_head(doc: string[], lnum: number): string {\n    for (let i = lnum; i > -1; i--) {\n        if (doc[i].includes(\"(\")) { return doc[i]; }\n    }\n    return doc[0];\n}\nexport class mode {\n    static dbg: boolean = false;\n}","import * as vscode from 'vscode';\nimport { langsName, restrict_search } from './faav'\nimport { handleExtraCMDs, pressF12, EL } from './fancy_f12';\nimport { prnt } from './basic_funx';\nexport class langDefinitionProvider implements vscode.DefinitionProvider {\n  async provideDefinition(\n    document: vscode.TextDocument,\n    position: vscode.Position,\n    token: vscode.CancellationToken\n  ): Promise<vscode.Location[]> {\n    const wordRange = document.getWordRangeAtPosition(position, /[\\w$@_]+/);\n    //if (!wordRange) return [];\n    let word = document.getText(wordRange);\n    const extra_locations = word != undefined && word != \"\" ? await handleExtraCMDs(word) : await handleExtraCMDs();\n    const results: vscode.Location[] = [];\n    prnt(extra_locations.kind);\n    if (extra_locations.kind == \"extra_locations\") {\n      results.push(...extra_locations.v);\n    }\n    let file_ext: vscode.GlobPattern = \"**/*.\" + langsName().file_exts[0];\n    let uris = await vscode.workspace.findFiles(\n      //\"**/*.d\",\n      file_ext,\n      restrict_search.exclude_paths, \n      restrict_search.max_num_of_res);\n    if (langsName().file_exts.length > 1) {\n      for (let i = 1; i < langsName().file_exts.length; i++) {\n        file_ext = \"**/*.\" + langsName().file_exts[i];\n        let uri = await vscode.workspace.findFiles(\n          //   '**/*.{langsName.file_exts}',\n            file_ext,\n            restrict_search.exclude_paths,\n            restrict_search.max_num_of_res);\n        uris.push(...uri);\n      }\n    }\n    for (const uri of uris) {\n      if (token.isCancellationRequested) break;\n      try {\n        const doc = await vscode.workspace.openTextDocument(uri);\n        const text = doc.getText();\n        let idx = text.indexOf(word);\n      //  vscode.window.showInformationMessage(idx.toString());\n        while (idx !== -1) {\n          if (token.isCancellationRequested) break;\n          // crude heuristic: treat occurrences followed by '(' or ':' or '=' as possible definitions\n          const after = text.substr(idx + word.length, 3);\n          const isDef = /[\\s\\(=:\\{]/.test(after);\n          if (isDef) {\n            const start = doc.positionAt(idx);\n            const end = doc.positionAt(idx + word.length);\n            results.push(new vscode.Location(uri, new vscode.Range(start, end)));\n          }\n          idx = text.indexOf(word, idx + 1);\n        }\n      } catch {\n        // ignore files that can't be opened\n      }\n    }\n    return results;\n  }\n}","import * as vscode from 'vscode';\nimport { i_c_fn_head_opts, langsName } from './faav';\nimport { langDefinitionProvider } from './goto_impl';\nimport { activate0 as colors } from './colorful';\nimport { ShowDocumentSymbols } from './show_doc_symbs'\nimport { getCMD, prnt } from './basic_funx';\nexport async function uri_to_file_of_opts(): Promise <vscode.Uri[]> {\n    return vscode.workspace.findFiles(\n        '**/i_c_fn_head.opts',\n        \"\", /* exclude none path */\n        1 /* only one result */\n    );\n}\nexport async function init(context: & vscode.ExtensionContext) {\n   // if (!i_c_fn_head_opts.been_set) { return; }\n    try {\n        const uri = await uri_to_file_of_opts();\n        const doc = await vscode.workspace.openTextDocument(uri[0]);\n        txt._0 = doc.getText();\n        set_lang(\"D\", context);\n        set_lang(\"Rust\", context);\n        set_lang(\"C\", context);\n        set_lang(\"CPP\", context);\n        i_c_fn_head_opts.been_set = true;\n        i_c_fn_head_opts.path_to_conf = uri[0].fsPath;\n        \n        //vscode.window.showInformationMessage(msg);\n      //  vscode.window.showInformationMessage(txt._0);\n    }\n    catch (err) {\n        prnt(\"Sorry, Dear Dev.. it was failed to init i_c_fn_head (\" + String(err) + \" )\");\n        return;\n     }\n    regDefProvider(context);\n    colors(context);\n}\nfunction run_opt(key: string): RegExp {\n    return new RegExp(`\\\\/\\\\/\\\\s*run\\\\s+${key}\\\\s*\\\\/\\\\/`);\n}\nfunction set_lang(name: string, context?: vscode.ExtensionContext) {\n    //vscode.window.showInformationMessage(txt._0);\n    if (run_opt(name).test(txt._0) && name == \"D\") {\n        i_c_fn_head_opts.provide_lang_D = true;\n        context?.subscriptions.push(\n            vscode.languages.registerDocumentSymbolProvider({ language: 'D' }, new ShowDocumentSymbols())\n        );\n    }\n    if (run_opt(name).test(txt._0) && name == \"CPP\") {\n        i_c_fn_head_opts.provide_lang_CPP = true;\n        context?.subscriptions.push(\n            vscode.languages.registerDocumentSymbolProvider({ language: 'cpp' }, new ShowDocumentSymbols())\n        );\n    }\n    if (run_opt(name).test(txt._0) && name == \"C\") {\n        i_c_fn_head_opts.provide_lang_C = true;\n        context?.subscriptions.push(\n            vscode.languages.registerDocumentSymbolProvider({ language: 'c' }, new ShowDocumentSymbols())\n        );\n    }\n    if (run_opt(name).test(txt._0) && name == \"Rust\") {\n        i_c_fn_head_opts.provide_lang_Rust = true;\n        context?.subscriptions.push(\n            vscode.languages.registerDocumentSymbolProvider({ language: 'rust' }, new ShowDocumentSymbols())\n        );\n    }\n}\nclass txt {\n    static _0: string = \"\";\n}\nexport function regDefProvider(context: & vscode.ExtensionContext) {\n     const selector: vscode.DocumentSelector = mkDocSel ();\n      context.subscriptions.push(\n        vscode.languages.registerDefinitionProvider(selector, new langDefinitionProvider())\n      );\n}\nfunction mkDocSel(): vscode.DocumentSelector {\n    let sel = [] as (vscode.DocumentFilter | string)[];\n    let sel_strn: string = \"\";\n    if (i_c_fn_head_opts.provide_lang_C) { sel.push({ scheme: 'file', language: 'c' }); }\n    if (i_c_fn_head_opts.provide_lang_Rust) { sel.push({ scheme: 'file', language: 'rust' }); }\n    if (i_c_fn_head_opts.provide_lang_CPP) { sel.push({ scheme: 'file', language: 'cpp' }); }\n    if (i_c_fn_head_opts.provide_lang_D) { sel.push({ scheme: 'file', language: 'D' }); }\n    return sel\n}\n","import * as vscode from 'vscode';\nexport function menu() {\n\n    async function showQuickPickExample() {\n        const items: vscode.QuickPickItem[] = [\n            { label: '$(file-text) Open file', description: 'Open a file from workspace', detail: 'Opens the file picker' },\n            { label: '$(gear) Settings', description: 'Open settings', detail: 'Show configuration' },\n            { label: '$(repo) Clone repo', description: 'Clone a repository', detail: 'Clone from URL' },\n        ];\n\n        // Single-select QuickPick (simple)\n        const single = await vscode.window.showQuickPick(items, {\n            placeHolder: 'Choose an action',\n            matchOnDescription: true,\n            matchOnDetail: true,\n            canPickMany: false,\n        });\n        if (single) {\n            vscode.window.showInformationMessage(`Selected: ${single.label}`);\n        }\n\n        // Multi-select QuickPick (programmatic QuickPick for more control)\n        const qp = vscode.window.createQuickPick<vscode.QuickPickItem>();\n        qp.items = items;\n        qp.canSelectMany = true;\n        qp.matchOnDescription = true;\n        qp.matchOnDetail = true;\n        qp.placeholder = 'Select one or more actions';\n        qp.ignoreFocusOut = true;\n\n        qp.onDidAccept(() => {\n            const selected = qp.selectedItems;\n            if (selected.length) {\n                vscode.window.showInformationMessage(`Selected: ${selected.map(s => s.label).join(', ')}`);\n            }\n            qp.hide();\n        });\n\n        qp.onDidHide(() => qp.dispose());\n        qp.show();\n    }\n\n}","import * as vscode from 'vscode';\nimport { _c_fn_body, _rust_fn_body, c_fn_body } from './fn_body_n_head';\nexport class ShowDocumentSymbols implements vscode.DocumentSymbolProvider {\n    provideDocumentSymbols(document: vscode.TextDocument, token: vscode.CancellationToken): vscode.ProviderResult<vscode.SymbolInformation[]> {\n        let symbols: vscode.SymbolInformation[] = [];\n        let text0 = document.getText();\n        const text = text0.split(\"\\n\");\n\n        // Regular expression patterns for different symbols\n        const functionPattern: RegExp[] = [\n            /(^(\\s*if))/g,\n        ];\n        const classPattern = /class\\s+([a-zA-Z_$][0-9a-zA-Z_$]*)/g;\n        const variablePattern = /const\\s+([a-zA-Z_$][0-9a-zA-Z_$]*)|let\\s+([a-zA-Z_$][0-9a-zA-Z_$]*)|var\\s+([a-zA-Z_$][0-9a-zA-Z_$]*)/g;\n        let wrong_ending = /;[\\s]*}?$/\n        const func_ret = /^return\\s/;\n        const while_op = /[\\s]*while[\\s]*\\(/;\n        const for_op = /\\s*for[\\s]*\\(?/;\n        const switch_op = /[\\s]*switch[\\s]*\\(?/;\n        const if_op = /^[\\s]*if[\\s]*\\(/;\n        const scope_op_in_D = /^scope\\s*\\(/;\n        const bad_symbs = /[=+\\-]/;\n        // Extract functions\n        let match: RegExpExecArray | null | undefined = null;\n        //console.log(\"start\");\n        //console.log(text);\n        let yes_D = vscode.window.activeTextEditor?.document.languageId.toLowerCase() === \"d\";\n        let functionName: string = \"\";\n        let _1st: boolean = true;\n        let line: number = 0;\n        let pos: vscode.Range | undefined = new vscode.Range(0, 0, 0, 100);\n        let point: vscode.Position = new vscode.Position(0, 0);\n        let set_rng: vscode.Range;\n        let default_range = new vscode.Range(0, 0, 0, 100);\n        /*\twhile ((match = select_lang_n_tst_fn_head (text0) ) !== null) {\n                const fnName = match[1];\n                const position = document.positionAt(match.index);\n                symbols.push(new vscode.SymbolInformation(fnName, vscode.SymbolKind.Function, '', new vscode.Location(document.uri, position)));\n            }*/\n        //dont_clobbe_line_w_curly_bracket(text0, document.uri);\n        //\tif (manage_output(text0, document.uri, symbols) != _manage_output.Rust) { return symbols; }\n        manage_output(text0, document.uri, symbols);\n        return symbols;\n    }\n}\nenum _manage_output {\n    C,\n    D,\n    Rust,\n    CPP\n}\nexport function manage_output(doc: string, uri: vscode.Uri, symbols: & vscode.SymbolInformation[]): _manage_output | RegExp | null {\n    const langId = vscode.window.activeTextEditor?.document.uri.fsPath ?? \"\";\n    let regex = /rs$|c$|cpp$|d$/g;\n    let lang: string = regex.exec(langId)?.[0] ?? \"\";\n    const msg = \"Active lang: \" + langId?.toString();\n    //vscode.window.showInformationMessage(msg);\n    switch (lang) {\n        case \"c\": { c_fn_body(doc, uri, symbols); return _manage_output.C }\n        case \"cpp\": { c_fn_body(doc, uri, symbols); return _manage_output.CPP }\n        case \"d\": { _c_fn_body(doc, uri, symbols); return _manage_output.D }\n        case \"rs\": { _rust_fn_body(doc, uri, symbols); return _manage_output.Rust }// { return rust_head() }\n    }\n    //\tprnt(msg);\n    return null\n}\n","module.exports = require(\"vscode\");","module.exports = require(\"fs\");","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.assertValidPattern = void 0;\nconst MAX_PATTERN_LENGTH = 1024 * 64;\nconst assertValidPattern = (pattern) => {\n    if (typeof pattern !== 'string') {\n        throw new TypeError('invalid pattern');\n    }\n    if (pattern.length > MAX_PATTERN_LENGTH) {\n        throw new TypeError('pattern is too long');\n    }\n};\nexports.assertValidPattern = assertValidPattern;\n//# sourceMappingURL=assert-valid-pattern.js.map","\"use strict\";\n// parse a single path portion\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.AST = void 0;\nconst brace_expressions_js_1 = require(\"./brace-expressions.js\");\nconst unescape_js_1 = require(\"./unescape.js\");\nconst types = new Set(['!', '?', '+', '*', '@']);\nconst isExtglobType = (c) => types.has(c);\n// Patterns that get prepended to bind to the start of either the\n// entire string, or just a single path portion, to prevent dots\n// and/or traversal patterns, when needed.\n// Exts don't need the ^ or / bit, because the root binds that already.\nconst startNoTraversal = '(?!(?:^|/)\\\\.\\\\.?(?:$|/))';\nconst startNoDot = '(?!\\\\.)';\n// characters that indicate a start of pattern needs the \"no dots\" bit,\n// because a dot *might* be matched. ( is not in the list, because in\n// the case of a child extglob, it will handle the prevention itself.\nconst addPatternStart = new Set(['[', '.']);\n// cases where traversal is A-OK, no dot prevention needed\nconst justDots = new Set(['..', '.']);\nconst reSpecials = new Set('().*{}+?[]^$\\\\!');\nconst regExpEscape = (s) => s.replace(/[-[\\]{}()*+?.,\\\\^$|#\\s]/g, '\\\\$&');\n// any single thing other than /\nconst qmark = '[^/]';\n// * => any number of characters\nconst star = qmark + '*?';\n// use + when we need to ensure that *something* matches, because the * is\n// the only thing in the path portion.\nconst starNoEmpty = qmark + '+?';\n// remove the \\ chars that we added if we end up doing a nonmagic compare\n// const deslash = (s: string) => s.replace(/\\\\(.)/g, '$1')\nclass AST {\n    type;\n    #root;\n    #hasMagic;\n    #uflag = false;\n    #parts = [];\n    #parent;\n    #parentIndex;\n    #negs;\n    #filledNegs = false;\n    #options;\n    #toString;\n    // set to true if it's an extglob with no children\n    // (which really means one child of '')\n    #emptyExt = false;\n    constructor(type, parent, options = {}) {\n        this.type = type;\n        // extglobs are inherently magical\n        if (type)\n            this.#hasMagic = true;\n        this.#parent = parent;\n        this.#root = this.#parent ? this.#parent.#root : this;\n        this.#options = this.#root === this ? options : this.#root.#options;\n        this.#negs = this.#root === this ? [] : this.#root.#negs;\n        if (type === '!' && !this.#root.#filledNegs)\n            this.#negs.push(this);\n        this.#parentIndex = this.#parent ? this.#parent.#parts.length : 0;\n    }\n    get hasMagic() {\n        /* c8 ignore start */\n        if (this.#hasMagic !== undefined)\n            return this.#hasMagic;\n        /* c8 ignore stop */\n        for (const p of this.#parts) {\n            if (typeof p === 'string')\n                continue;\n            if (p.type || p.hasMagic)\n                return (this.#hasMagic = true);\n        }\n        // note: will be undefined until we generate the regexp src and find out\n        return this.#hasMagic;\n    }\n    // reconstructs the pattern\n    toString() {\n        if (this.#toString !== undefined)\n            return this.#toString;\n        if (!this.type) {\n            return (this.#toString = this.#parts.map(p => String(p)).join(''));\n        }\n        else {\n            return (this.#toString =\n                this.type + '(' + this.#parts.map(p => String(p)).join('|') + ')');\n        }\n    }\n    #fillNegs() {\n        /* c8 ignore start */\n        if (this !== this.#root)\n            throw new Error('should only call on root');\n        if (this.#filledNegs)\n            return this;\n        /* c8 ignore stop */\n        // call toString() once to fill this out\n        this.toString();\n        this.#filledNegs = true;\n        let n;\n        while ((n = this.#negs.pop())) {\n            if (n.type !== '!')\n                continue;\n            // walk up the tree, appending everthing that comes AFTER parentIndex\n            let p = n;\n            let pp = p.#parent;\n            while (pp) {\n                for (let i = p.#parentIndex + 1; !pp.type && i < pp.#parts.length; i++) {\n                    for (const part of n.#parts) {\n                        /* c8 ignore start */\n                        if (typeof part === 'string') {\n                            throw new Error('string part in extglob AST??');\n                        }\n                        /* c8 ignore stop */\n                        part.copyIn(pp.#parts[i]);\n                    }\n                }\n                p = pp;\n                pp = p.#parent;\n            }\n        }\n        return this;\n    }\n    push(...parts) {\n        for (const p of parts) {\n            if (p === '')\n                continue;\n            /* c8 ignore start */\n            if (typeof p !== 'string' && !(p instanceof AST && p.#parent === this)) {\n                throw new Error('invalid part: ' + p);\n            }\n            /* c8 ignore stop */\n            this.#parts.push(p);\n        }\n    }\n    toJSON() {\n        const ret = this.type === null\n            ? this.#parts.slice().map(p => (typeof p === 'string' ? p : p.toJSON()))\n            : [this.type, ...this.#parts.map(p => p.toJSON())];\n        if (this.isStart() && !this.type)\n            ret.unshift([]);\n        if (this.isEnd() &&\n            (this === this.#root ||\n                (this.#root.#filledNegs && this.#parent?.type === '!'))) {\n            ret.push({});\n        }\n        return ret;\n    }\n    isStart() {\n        if (this.#root === this)\n            return true;\n        // if (this.type) return !!this.#parent?.isStart()\n        if (!this.#parent?.isStart())\n            return false;\n        if (this.#parentIndex === 0)\n            return true;\n        // if everything AHEAD of this is a negation, then it's still the \"start\"\n        const p = this.#parent;\n        for (let i = 0; i < this.#parentIndex; i++) {\n            const pp = p.#parts[i];\n            if (!(pp instanceof AST && pp.type === '!')) {\n                return false;\n            }\n        }\n        return true;\n    }\n    isEnd() {\n        if (this.#root === this)\n            return true;\n        if (this.#parent?.type === '!')\n            return true;\n        if (!this.#parent?.isEnd())\n            return false;\n        if (!this.type)\n            return this.#parent?.isEnd();\n        // if not root, it'll always have a parent\n        /* c8 ignore start */\n        const pl = this.#parent ? this.#parent.#parts.length : 0;\n        /* c8 ignore stop */\n        return this.#parentIndex === pl - 1;\n    }\n    copyIn(part) {\n        if (typeof part === 'string')\n            this.push(part);\n        else\n            this.push(part.clone(this));\n    }\n    clone(parent) {\n        const c = new AST(this.type, parent);\n        for (const p of this.#parts) {\n            c.copyIn(p);\n        }\n        return c;\n    }\n    static #parseAST(str, ast, pos, opt) {\n        let escaping = false;\n        let inBrace = false;\n        let braceStart = -1;\n        let braceNeg = false;\n        if (ast.type === null) {\n            // outside of a extglob, append until we find a start\n            let i = pos;\n            let acc = '';\n            while (i < str.length) {\n                const c = str.charAt(i++);\n                // still accumulate escapes at this point, but we do ignore\n                // starts that are escaped\n                if (escaping || c === '\\\\') {\n                    escaping = !escaping;\n                    acc += c;\n                    continue;\n                }\n                if (inBrace) {\n                    if (i === braceStart + 1) {\n                        if (c === '^' || c === '!') {\n                            braceNeg = true;\n                        }\n                    }\n                    else if (c === ']' && !(i === braceStart + 2 && braceNeg)) {\n                        inBrace = false;\n                    }\n                    acc += c;\n                    continue;\n                }\n                else if (c === '[') {\n                    inBrace = true;\n                    braceStart = i;\n                    braceNeg = false;\n                    acc += c;\n                    continue;\n                }\n                if (!opt.noext && isExtglobType(c) && str.charAt(i) === '(') {\n                    ast.push(acc);\n                    acc = '';\n                    const ext = new AST(c, ast);\n                    i = AST.#parseAST(str, ext, i, opt);\n                    ast.push(ext);\n                    continue;\n                }\n                acc += c;\n            }\n            ast.push(acc);\n            return i;\n        }\n        // some kind of extglob, pos is at the (\n        // find the next | or )\n        let i = pos + 1;\n        let part = new AST(null, ast);\n        const parts = [];\n        let acc = '';\n        while (i < str.length) {\n            const c = str.charAt(i++);\n            // still accumulate escapes at this point, but we do ignore\n            // starts that are escaped\n            if (escaping || c === '\\\\') {\n                escaping = !escaping;\n                acc += c;\n                continue;\n            }\n            if (inBrace) {\n                if (i === braceStart + 1) {\n                    if (c === '^' || c === '!') {\n                        braceNeg = true;\n                    }\n                }\n                else if (c === ']' && !(i === braceStart + 2 && braceNeg)) {\n                    inBrace = false;\n                }\n                acc += c;\n                continue;\n            }\n            else if (c === '[') {\n                inBrace = true;\n                braceStart = i;\n                braceNeg = false;\n                acc += c;\n                continue;\n            }\n            if (isExtglobType(c) && str.charAt(i) === '(') {\n                part.push(acc);\n                acc = '';\n                const ext = new AST(c, part);\n                part.push(ext);\n                i = AST.#parseAST(str, ext, i, opt);\n                continue;\n            }\n            if (c === '|') {\n                part.push(acc);\n                acc = '';\n                parts.push(part);\n                part = new AST(null, ast);\n                continue;\n            }\n            if (c === ')') {\n                if (acc === '' && ast.#parts.length === 0) {\n                    ast.#emptyExt = true;\n                }\n                part.push(acc);\n                acc = '';\n                ast.push(...parts, part);\n                return i;\n            }\n            acc += c;\n        }\n        // unfinished extglob\n        // if we got here, it was a malformed extglob! not an extglob, but\n        // maybe something else in there.\n        ast.type = null;\n        ast.#hasMagic = undefined;\n        ast.#parts = [str.substring(pos - 1)];\n        return i;\n    }\n    static fromGlob(pattern, options = {}) {\n        const ast = new AST(null, undefined, options);\n        AST.#parseAST(pattern, ast, 0, options);\n        return ast;\n    }\n    // returns the regular expression if there's magic, or the unescaped\n    // string if not.\n    toMMPattern() {\n        // should only be called on root\n        /* c8 ignore start */\n        if (this !== this.#root)\n            return this.#root.toMMPattern();\n        /* c8 ignore stop */\n        const glob = this.toString();\n        const [re, body, hasMagic, uflag] = this.toRegExpSource();\n        // if we're in nocase mode, and not nocaseMagicOnly, then we do\n        // still need a regular expression if we have to case-insensitively\n        // match capital/lowercase characters.\n        const anyMagic = hasMagic ||\n            this.#hasMagic ||\n            (this.#options.nocase &&\n                !this.#options.nocaseMagicOnly &&\n                glob.toUpperCase() !== glob.toLowerCase());\n        if (!anyMagic) {\n            return body;\n        }\n        const flags = (this.#options.nocase ? 'i' : '') + (uflag ? 'u' : '');\n        return Object.assign(new RegExp(`^${re}$`, flags), {\n            _src: re,\n            _glob: glob,\n        });\n    }\n    get options() {\n        return this.#options;\n    }\n    // returns the string match, the regexp source, whether there's magic\n    // in the regexp (so a regular expression is required) and whether or\n    // not the uflag is needed for the regular expression (for posix classes)\n    // TODO: instead of injecting the start/end at this point, just return\n    // the BODY of the regexp, along with the start/end portions suitable\n    // for binding the start/end in either a joined full-path makeRe context\n    // (where we bind to (^|/), or a standalone matchPart context (where\n    // we bind to ^, and not /).  Otherwise slashes get duped!\n    //\n    // In part-matching mode, the start is:\n    // - if not isStart: nothing\n    // - if traversal possible, but not allowed: ^(?!\\.\\.?$)\n    // - if dots allowed or not possible: ^\n    // - if dots possible and not allowed: ^(?!\\.)\n    // end is:\n    // - if not isEnd(): nothing\n    // - else: $\n    //\n    // In full-path matching mode, we put the slash at the START of the\n    // pattern, so start is:\n    // - if first pattern: same as part-matching mode\n    // - if not isStart(): nothing\n    // - if traversal possible, but not allowed: /(?!\\.\\.?(?:$|/))\n    // - if dots allowed or not possible: /\n    // - if dots possible and not allowed: /(?!\\.)\n    // end is:\n    // - if last pattern, same as part-matching mode\n    // - else nothing\n    //\n    // Always put the (?:$|/) on negated tails, though, because that has to be\n    // there to bind the end of the negated pattern portion, and it's easier to\n    // just stick it in now rather than try to inject it later in the middle of\n    // the pattern.\n    //\n    // We can just always return the same end, and leave it up to the caller\n    // to know whether it's going to be used joined or in parts.\n    // And, if the start is adjusted slightly, can do the same there:\n    // - if not isStart: nothing\n    // - if traversal possible, but not allowed: (?:/|^)(?!\\.\\.?$)\n    // - if dots allowed or not possible: (?:/|^)\n    // - if dots possible and not allowed: (?:/|^)(?!\\.)\n    //\n    // But it's better to have a simpler binding without a conditional, for\n    // performance, so probably better to return both start options.\n    //\n    // Then the caller just ignores the end if it's not the first pattern,\n    // and the start always gets applied.\n    //\n    // But that's always going to be $ if it's the ending pattern, or nothing,\n    // so the caller can just attach $ at the end of the pattern when building.\n    //\n    // So the todo is:\n    // - better detect what kind of start is needed\n    // - return both flavors of starting pattern\n    // - attach $ at the end of the pattern when creating the actual RegExp\n    //\n    // Ah, but wait, no, that all only applies to the root when the first pattern\n    // is not an extglob. If the first pattern IS an extglob, then we need all\n    // that dot prevention biz to live in the extglob portions, because eg\n    // +(*|.x*) can match .xy but not .yx.\n    //\n    // So, return the two flavors if it's #root and the first child is not an\n    // AST, otherwise leave it to the child AST to handle it, and there,\n    // use the (?:^|/) style of start binding.\n    //\n    // Even simplified further:\n    // - Since the start for a join is eg /(?!\\.) and the start for a part\n    // is ^(?!\\.), we can just prepend (?!\\.) to the pattern (either root\n    // or start or whatever) and prepend ^ or / at the Regexp construction.\n    toRegExpSource(allowDot) {\n        const dot = allowDot ?? !!this.#options.dot;\n        if (this.#root === this)\n            this.#fillNegs();\n        if (!this.type) {\n            const noEmpty = this.isStart() && this.isEnd();\n            const src = this.#parts\n                .map(p => {\n                const [re, _, hasMagic, uflag] = typeof p === 'string'\n                    ? AST.#parseGlob(p, this.#hasMagic, noEmpty)\n                    : p.toRegExpSource(allowDot);\n                this.#hasMagic = this.#hasMagic || hasMagic;\n                this.#uflag = this.#uflag || uflag;\n                return re;\n            })\n                .join('');\n            let start = '';\n            if (this.isStart()) {\n                if (typeof this.#parts[0] === 'string') {\n                    // this is the string that will match the start of the pattern,\n                    // so we need to protect against dots and such.\n                    // '.' and '..' cannot match unless the pattern is that exactly,\n                    // even if it starts with . or dot:true is set.\n                    const dotTravAllowed = this.#parts.length === 1 && justDots.has(this.#parts[0]);\n                    if (!dotTravAllowed) {\n                        const aps = addPatternStart;\n                        // check if we have a possibility of matching . or ..,\n                        // and prevent that.\n                        const needNoTrav = \n                        // dots are allowed, and the pattern starts with [ or .\n                        (dot && aps.has(src.charAt(0))) ||\n                            // the pattern starts with \\., and then [ or .\n                            (src.startsWith('\\\\.') && aps.has(src.charAt(2))) ||\n                            // the pattern starts with \\.\\., and then [ or .\n                            (src.startsWith('\\\\.\\\\.') && aps.has(src.charAt(4)));\n                        // no need to prevent dots if it can't match a dot, or if a\n                        // sub-pattern will be preventing it anyway.\n                        const needNoDot = !dot && !allowDot && aps.has(src.charAt(0));\n                        start = needNoTrav ? startNoTraversal : needNoDot ? startNoDot : '';\n                    }\n                }\n            }\n            // append the \"end of path portion\" pattern to negation tails\n            let end = '';\n            if (this.isEnd() &&\n                this.#root.#filledNegs &&\n                this.#parent?.type === '!') {\n                end = '(?:$|\\\\/)';\n            }\n            const final = start + src + end;\n            return [\n                final,\n                (0, unescape_js_1.unescape)(src),\n                (this.#hasMagic = !!this.#hasMagic),\n                this.#uflag,\n            ];\n        }\n        // We need to calculate the body *twice* if it's a repeat pattern\n        // at the start, once in nodot mode, then again in dot mode, so a\n        // pattern like *(?) can match 'x.y'\n        const repeated = this.type === '*' || this.type === '+';\n        // some kind of extglob\n        const start = this.type === '!' ? '(?:(?!(?:' : '(?:';\n        let body = this.#partsToRegExp(dot);\n        if (this.isStart() && this.isEnd() && !body && this.type !== '!') {\n            // invalid extglob, has to at least be *something* present, if it's\n            // the entire path portion.\n            const s = this.toString();\n            this.#parts = [s];\n            this.type = null;\n            this.#hasMagic = undefined;\n            return [s, (0, unescape_js_1.unescape)(this.toString()), false, false];\n        }\n        // XXX abstract out this map method\n        let bodyDotAllowed = !repeated || allowDot || dot || !startNoDot\n            ? ''\n            : this.#partsToRegExp(true);\n        if (bodyDotAllowed === body) {\n            bodyDotAllowed = '';\n        }\n        if (bodyDotAllowed) {\n            body = `(?:${body})(?:${bodyDotAllowed})*?`;\n        }\n        // an empty !() is exactly equivalent to a starNoEmpty\n        let final = '';\n        if (this.type === '!' && this.#emptyExt) {\n            final = (this.isStart() && !dot ? startNoDot : '') + starNoEmpty;\n        }\n        else {\n            const close = this.type === '!'\n                ? // !() must match something,but !(x) can match ''\n                    '))' +\n                        (this.isStart() && !dot && !allowDot ? startNoDot : '') +\n                        star +\n                        ')'\n                : this.type === '@'\n                    ? ')'\n                    : this.type === '?'\n                        ? ')?'\n                        : this.type === '+' && bodyDotAllowed\n                            ? ')'\n                            : this.type === '*' && bodyDotAllowed\n                                ? `)?`\n                                : `)${this.type}`;\n            final = start + body + close;\n        }\n        return [\n            final,\n            (0, unescape_js_1.unescape)(body),\n            (this.#hasMagic = !!this.#hasMagic),\n            this.#uflag,\n        ];\n    }\n    #partsToRegExp(dot) {\n        return this.#parts\n            .map(p => {\n            // extglob ASTs should only contain parent ASTs\n            /* c8 ignore start */\n            if (typeof p === 'string') {\n                throw new Error('string type in extglob ast??');\n            }\n            /* c8 ignore stop */\n            // can ignore hasMagic, because extglobs are already always magic\n            const [re, _, _hasMagic, uflag] = p.toRegExpSource(dot);\n            this.#uflag = this.#uflag || uflag;\n            return re;\n        })\n            .filter(p => !(this.isStart() && this.isEnd()) || !!p)\n            .join('|');\n    }\n    static #parseGlob(glob, hasMagic, noEmpty = false) {\n        let escaping = false;\n        let re = '';\n        let uflag = false;\n        for (let i = 0; i < glob.length; i++) {\n            const c = glob.charAt(i);\n            if (escaping) {\n                escaping = false;\n                re += (reSpecials.has(c) ? '\\\\' : '') + c;\n                continue;\n            }\n            if (c === '\\\\') {\n                if (i === glob.length - 1) {\n                    re += '\\\\\\\\';\n                }\n                else {\n                    escaping = true;\n                }\n                continue;\n            }\n            if (c === '[') {\n                const [src, needUflag, consumed, magic] = (0, brace_expressions_js_1.parseClass)(glob, i);\n                if (consumed) {\n                    re += src;\n                    uflag = uflag || needUflag;\n                    i += consumed - 1;\n                    hasMagic = hasMagic || magic;\n                    continue;\n                }\n            }\n            if (c === '*') {\n                if (noEmpty && glob === '*')\n                    re += starNoEmpty;\n                else\n                    re += star;\n                hasMagic = true;\n                continue;\n            }\n            if (c === '?') {\n                re += qmark;\n                hasMagic = true;\n                continue;\n            }\n            re += regExpEscape(c);\n        }\n        return [re, (0, unescape_js_1.unescape)(glob), !!hasMagic, uflag];\n    }\n}\nexports.AST = AST;\n//# sourceMappingURL=ast.js.map","\"use strict\";\n// translate the various posix character classes into unicode properties\n// this works across all unicode locales\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.parseClass = void 0;\n// { <posix class>: [<translation>, /u flag required, negated]\nconst posixClasses = {\n    '[:alnum:]': ['\\\\p{L}\\\\p{Nl}\\\\p{Nd}', true],\n    '[:alpha:]': ['\\\\p{L}\\\\p{Nl}', true],\n    '[:ascii:]': ['\\\\x' + '00-\\\\x' + '7f', false],\n    '[:blank:]': ['\\\\p{Zs}\\\\t', true],\n    '[:cntrl:]': ['\\\\p{Cc}', true],\n    '[:digit:]': ['\\\\p{Nd}', true],\n    '[:graph:]': ['\\\\p{Z}\\\\p{C}', true, true],\n    '[:lower:]': ['\\\\p{Ll}', true],\n    '[:print:]': ['\\\\p{C}', true],\n    '[:punct:]': ['\\\\p{P}', true],\n    '[:space:]': ['\\\\p{Z}\\\\t\\\\r\\\\n\\\\v\\\\f', true],\n    '[:upper:]': ['\\\\p{Lu}', true],\n    '[:word:]': ['\\\\p{L}\\\\p{Nl}\\\\p{Nd}\\\\p{Pc}', true],\n    '[:xdigit:]': ['A-Fa-f0-9', false],\n};\n// only need to escape a few things inside of brace expressions\n// escapes: [ \\ ] -\nconst braceEscape = (s) => s.replace(/[[\\]\\\\-]/g, '\\\\$&');\n// escape all regexp magic characters\nconst regexpEscape = (s) => s.replace(/[-[\\]{}()*+?.,\\\\^$|#\\s]/g, '\\\\$&');\n// everything has already been escaped, we just have to join\nconst rangesToString = (ranges) => ranges.join('');\n// takes a glob string at a posix brace expression, and returns\n// an equivalent regular expression source, and boolean indicating\n// whether the /u flag needs to be applied, and the number of chars\n// consumed to parse the character class.\n// This also removes out of order ranges, and returns ($.) if the\n// entire class just no good.\nconst parseClass = (glob, position) => {\n    const pos = position;\n    /* c8 ignore start */\n    if (glob.charAt(pos) !== '[') {\n        throw new Error('not in a brace expression');\n    }\n    /* c8 ignore stop */\n    const ranges = [];\n    const negs = [];\n    let i = pos + 1;\n    let sawStart = false;\n    let uflag = false;\n    let escaping = false;\n    let negate = false;\n    let endPos = pos;\n    let rangeStart = '';\n    WHILE: while (i < glob.length) {\n        const c = glob.charAt(i);\n        if ((c === '!' || c === '^') && i === pos + 1) {\n            negate = true;\n            i++;\n            continue;\n        }\n        if (c === ']' && sawStart && !escaping) {\n            endPos = i + 1;\n            break;\n        }\n        sawStart = true;\n        if (c === '\\\\') {\n            if (!escaping) {\n                escaping = true;\n                i++;\n                continue;\n            }\n            // escaped \\ char, fall through and treat like normal char\n        }\n        if (c === '[' && !escaping) {\n            // either a posix class, a collation equivalent, or just a [\n            for (const [cls, [unip, u, neg]] of Object.entries(posixClasses)) {\n                if (glob.startsWith(cls, i)) {\n                    // invalid, [a-[] is fine, but not [a-[:alpha]]\n                    if (rangeStart) {\n                        return ['$.', false, glob.length - pos, true];\n                    }\n                    i += cls.length;\n                    if (neg)\n                        negs.push(unip);\n                    else\n                        ranges.push(unip);\n                    uflag = uflag || u;\n                    continue WHILE;\n                }\n            }\n        }\n        // now it's just a normal character, effectively\n        escaping = false;\n        if (rangeStart) {\n            // throw this range away if it's not valid, but others\n            // can still match.\n            if (c > rangeStart) {\n                ranges.push(braceEscape(rangeStart) + '-' + braceEscape(c));\n            }\n            else if (c === rangeStart) {\n                ranges.push(braceEscape(c));\n            }\n            rangeStart = '';\n            i++;\n            continue;\n        }\n        // now might be the start of a range.\n        // can be either c-d or c-] or c<more...>] or c] at this point\n        if (glob.startsWith('-]', i + 1)) {\n            ranges.push(braceEscape(c + '-'));\n            i += 2;\n            continue;\n        }\n        if (glob.startsWith('-', i + 1)) {\n            rangeStart = c;\n            i += 2;\n            continue;\n        }\n        // not the start of a range, just a single character\n        ranges.push(braceEscape(c));\n        i++;\n    }\n    if (endPos < i) {\n        // didn't see the end of the class, not a valid class,\n        // but might still be valid as a literal match.\n        return ['', false, 0, false];\n    }\n    // if we got no ranges and no negates, then we have a range that\n    // cannot possibly match anything, and that poisons the whole glob\n    if (!ranges.length && !negs.length) {\n        return ['$.', false, glob.length - pos, true];\n    }\n    // if we got one positive range, and it's a single character, then that's\n    // not actually a magic pattern, it's just that one literal character.\n    // we should not treat that as \"magic\", we should just return the literal\n    // character. [_] is a perfectly valid way to escape glob magic chars.\n    if (negs.length === 0 &&\n        ranges.length === 1 &&\n        /^\\\\?.$/.test(ranges[0]) &&\n        !negate) {\n        const r = ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0];\n        return [regexpEscape(r), false, endPos - pos, false];\n    }\n    const sranges = '[' + (negate ? '^' : '') + rangesToString(ranges) + ']';\n    const snegs = '[' + (negate ? '' : '^') + rangesToString(negs) + ']';\n    const comb = ranges.length && negs.length\n        ? '(' + sranges + '|' + snegs + ')'\n        : ranges.length\n            ? sranges\n            : snegs;\n    return [comb, uflag, endPos - pos, true];\n};\nexports.parseClass = parseClass;\n//# sourceMappingURL=brace-expressions.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.escape = void 0;\n/**\n * Escape all magic characters in a glob pattern.\n *\n * If the {@link windowsPathsNoEscape | GlobOptions.windowsPathsNoEscape}\n * option is used, then characters are escaped by wrapping in `[]`, because\n * a magic character wrapped in a character class can only be satisfied by\n * that exact character.  In this mode, `\\` is _not_ escaped, because it is\n * not interpreted as a magic character, but instead as a path separator.\n */\nconst escape = (s, { windowsPathsNoEscape = false, } = {}) => {\n    // don't need to escape +@! because we escape the parens\n    // that make those magic, and escaping ! as [!] isn't valid,\n    // because [!]] is a valid glob class meaning not ']'.\n    return windowsPathsNoEscape\n        ? s.replace(/[?*()[\\]]/g, '[$&]')\n        : s.replace(/[?*()[\\]\\\\]/g, '\\\\$&');\n};\nexports.escape = escape;\n//# sourceMappingURL=escape.js.map","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.unescape = exports.escape = exports.AST = exports.Minimatch = exports.match = exports.makeRe = exports.braceExpand = exports.defaults = exports.filter = exports.GLOBSTAR = exports.sep = exports.minimatch = void 0;\nconst brace_expansion_1 = __importDefault(require(\"brace-expansion\"));\nconst assert_valid_pattern_js_1 = require(\"./assert-valid-pattern.js\");\nconst ast_js_1 = require(\"./ast.js\");\nconst escape_js_1 = require(\"./escape.js\");\nconst unescape_js_1 = require(\"./unescape.js\");\nconst minimatch = (p, pattern, options = {}) => {\n    (0, assert_valid_pattern_js_1.assertValidPattern)(pattern);\n    // shortcut: comments match nothing.\n    if (!options.nocomment && pattern.charAt(0) === '#') {\n        return false;\n    }\n    return new Minimatch(pattern, options).match(p);\n};\nexports.minimatch = minimatch;\n// Optimized checking for the most common glob patterns.\nconst starDotExtRE = /^\\*+([^+@!?\\*\\[\\(]*)$/;\nconst starDotExtTest = (ext) => (f) => !f.startsWith('.') && f.endsWith(ext);\nconst starDotExtTestDot = (ext) => (f) => f.endsWith(ext);\nconst starDotExtTestNocase = (ext) => {\n    ext = ext.toLowerCase();\n    return (f) => !f.startsWith('.') && f.toLowerCase().endsWith(ext);\n};\nconst starDotExtTestNocaseDot = (ext) => {\n    ext = ext.toLowerCase();\n    return (f) => f.toLowerCase().endsWith(ext);\n};\nconst starDotStarRE = /^\\*+\\.\\*+$/;\nconst starDotStarTest = (f) => !f.startsWith('.') && f.includes('.');\nconst starDotStarTestDot = (f) => f !== '.' && f !== '..' && f.includes('.');\nconst dotStarRE = /^\\.\\*+$/;\nconst dotStarTest = (f) => f !== '.' && f !== '..' && f.startsWith('.');\nconst starRE = /^\\*+$/;\nconst starTest = (f) => f.length !== 0 && !f.startsWith('.');\nconst starTestDot = (f) => f.length !== 0 && f !== '.' && f !== '..';\nconst qmarksRE = /^\\?+([^+@!?\\*\\[\\(]*)?$/;\nconst qmarksTestNocase = ([$0, ext = '']) => {\n    const noext = qmarksTestNoExt([$0]);\n    if (!ext)\n        return noext;\n    ext = ext.toLowerCase();\n    return (f) => noext(f) && f.toLowerCase().endsWith(ext);\n};\nconst qmarksTestNocaseDot = ([$0, ext = '']) => {\n    const noext = qmarksTestNoExtDot([$0]);\n    if (!ext)\n        return noext;\n    ext = ext.toLowerCase();\n    return (f) => noext(f) && f.toLowerCase().endsWith(ext);\n};\nconst qmarksTestDot = ([$0, ext = '']) => {\n    const noext = qmarksTestNoExtDot([$0]);\n    return !ext ? noext : (f) => noext(f) && f.endsWith(ext);\n};\nconst qmarksTest = ([$0, ext = '']) => {\n    const noext = qmarksTestNoExt([$0]);\n    return !ext ? noext : (f) => noext(f) && f.endsWith(ext);\n};\nconst qmarksTestNoExt = ([$0]) => {\n    const len = $0.length;\n    return (f) => f.length === len && !f.startsWith('.');\n};\nconst qmarksTestNoExtDot = ([$0]) => {\n    const len = $0.length;\n    return (f) => f.length === len && f !== '.' && f !== '..';\n};\n/* c8 ignore start */\nconst defaultPlatform = (typeof process === 'object' && process\n    ? (typeof process.env === 'object' &&\n        process.env &&\n        process.env.__MINIMATCH_TESTING_PLATFORM__) ||\n        process.platform\n    : 'posix');\nconst path = {\n    win32: { sep: '\\\\' },\n    posix: { sep: '/' },\n};\n/* c8 ignore stop */\nexports.sep = defaultPlatform === 'win32' ? path.win32.sep : path.posix.sep;\nexports.minimatch.sep = exports.sep;\nexports.GLOBSTAR = Symbol('globstar **');\nexports.minimatch.GLOBSTAR = exports.GLOBSTAR;\n// any single thing other than /\n// don't need to escape / when using new RegExp()\nconst qmark = '[^/]';\n// * => any number of characters\nconst star = qmark + '*?';\n// ** when dots are allowed.  Anything goes, except .. and .\n// not (^ or / followed by one or two dots followed by $ or /),\n// followed by anything, any number of times.\nconst twoStarDot = '(?:(?!(?:\\\\/|^)(?:\\\\.{1,2})($|\\\\/)).)*?';\n// not a ^ or / followed by a dot,\n// followed by anything, any number of times.\nconst twoStarNoDot = '(?:(?!(?:\\\\/|^)\\\\.).)*?';\nconst filter = (pattern, options = {}) => (p) => (0, exports.minimatch)(p, pattern, options);\nexports.filter = filter;\nexports.minimatch.filter = exports.filter;\nconst ext = (a, b = {}) => Object.assign({}, a, b);\nconst defaults = (def) => {\n    if (!def || typeof def !== 'object' || !Object.keys(def).length) {\n        return exports.minimatch;\n    }\n    const orig = exports.minimatch;\n    const m = (p, pattern, options = {}) => orig(p, pattern, ext(def, options));\n    return Object.assign(m, {\n        Minimatch: class Minimatch extends orig.Minimatch {\n            constructor(pattern, options = {}) {\n                super(pattern, ext(def, options));\n            }\n            static defaults(options) {\n                return orig.defaults(ext(def, options)).Minimatch;\n            }\n        },\n        AST: class AST extends orig.AST {\n            /* c8 ignore start */\n            constructor(type, parent, options = {}) {\n                super(type, parent, ext(def, options));\n            }\n            /* c8 ignore stop */\n            static fromGlob(pattern, options = {}) {\n                return orig.AST.fromGlob(pattern, ext(def, options));\n            }\n        },\n        unescape: (s, options = {}) => orig.unescape(s, ext(def, options)),\n        escape: (s, options = {}) => orig.escape(s, ext(def, options)),\n        filter: (pattern, options = {}) => orig.filter(pattern, ext(def, options)),\n        defaults: (options) => orig.defaults(ext(def, options)),\n        makeRe: (pattern, options = {}) => orig.makeRe(pattern, ext(def, options)),\n        braceExpand: (pattern, options = {}) => orig.braceExpand(pattern, ext(def, options)),\n        match: (list, pattern, options = {}) => orig.match(list, pattern, ext(def, options)),\n        sep: orig.sep,\n        GLOBSTAR: exports.GLOBSTAR,\n    });\n};\nexports.defaults = defaults;\nexports.minimatch.defaults = exports.defaults;\n// Brace expansion:\n// a{b,c}d -> abd acd\n// a{b,}c -> abc ac\n// a{0..3}d -> a0d a1d a2d a3d\n// a{b,c{d,e}f}g -> abg acdfg acefg\n// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg\n//\n// Invalid sets are not expanded.\n// a{2..}b -> a{2..}b\n// a{b}c -> a{b}c\nconst braceExpand = (pattern, options = {}) => {\n    (0, assert_valid_pattern_js_1.assertValidPattern)(pattern);\n    // Thanks to Yeting Li <https://github.com/yetingli> for\n    // improving this regexp to avoid a ReDOS vulnerability.\n    if (options.nobrace || !/\\{(?:(?!\\{).)*\\}/.test(pattern)) {\n        // shortcut. no need to expand.\n        return [pattern];\n    }\n    return (0, brace_expansion_1.default)(pattern);\n};\nexports.braceExpand = braceExpand;\nexports.minimatch.braceExpand = exports.braceExpand;\n// parse a component of the expanded set.\n// At this point, no pattern may contain \"/\" in it\n// so we're going to return a 2d array, where each entry is the full\n// pattern, split on '/', and then turned into a regular expression.\n// A regexp is made at the end which joins each array with an\n// escaped /, and another full one which joins each regexp with |.\n//\n// Following the lead of Bash 4.1, note that \"**\" only has special meaning\n// when it is the *only* thing in a path portion.  Otherwise, any series\n// of * is equivalent to a single *.  Globstar behavior is enabled by\n// default, and can be disabled by setting options.noglobstar.\nconst makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe();\nexports.makeRe = makeRe;\nexports.minimatch.makeRe = exports.makeRe;\nconst match = (list, pattern, options = {}) => {\n    const mm = new Minimatch(pattern, options);\n    list = list.filter(f => mm.match(f));\n    if (mm.options.nonull && !list.length) {\n        list.push(pattern);\n    }\n    return list;\n};\nexports.match = match;\nexports.minimatch.match = exports.match;\n// replace stuff like \\* with *\nconst globMagic = /[?*]|[+@!]\\(.*?\\)|\\[|\\]/;\nconst regExpEscape = (s) => s.replace(/[-[\\]{}()*+?.,\\\\^$|#\\s]/g, '\\\\$&');\nclass Minimatch {\n    options;\n    set;\n    pattern;\n    windowsPathsNoEscape;\n    nonegate;\n    negate;\n    comment;\n    empty;\n    preserveMultipleSlashes;\n    partial;\n    globSet;\n    globParts;\n    nocase;\n    isWindows;\n    platform;\n    windowsNoMagicRoot;\n    regexp;\n    constructor(pattern, options = {}) {\n        (0, assert_valid_pattern_js_1.assertValidPattern)(pattern);\n        options = options || {};\n        this.options = options;\n        this.pattern = pattern;\n        this.platform = options.platform || defaultPlatform;\n        this.isWindows = this.platform === 'win32';\n        this.windowsPathsNoEscape =\n            !!options.windowsPathsNoEscape || options.allowWindowsEscape === false;\n        if (this.windowsPathsNoEscape) {\n            this.pattern = this.pattern.replace(/\\\\/g, '/');\n        }\n        this.preserveMultipleSlashes = !!options.preserveMultipleSlashes;\n        this.regexp = null;\n        this.negate = false;\n        this.nonegate = !!options.nonegate;\n        this.comment = false;\n        this.empty = false;\n        this.partial = !!options.partial;\n        this.nocase = !!this.options.nocase;\n        this.windowsNoMagicRoot =\n            options.windowsNoMagicRoot !== undefined\n                ? options.windowsNoMagicRoot\n                : !!(this.isWindows && this.nocase);\n        this.globSet = [];\n        this.globParts = [];\n        this.set = [];\n        // make the set of regexps etc.\n        this.make();\n    }\n    hasMagic() {\n        if (this.options.magicalBraces && this.set.length > 1) {\n            return true;\n        }\n        for (const pattern of this.set) {\n            for (const part of pattern) {\n                if (typeof part !== 'string')\n                    return true;\n            }\n        }\n        return false;\n    }\n    debug(..._) { }\n    make() {\n        const pattern = this.pattern;\n        const options = this.options;\n        // empty patterns and comments match nothing.\n        if (!options.nocomment && pattern.charAt(0) === '#') {\n            this.comment = true;\n            return;\n        }\n        if (!pattern) {\n            this.empty = true;\n            return;\n        }\n        // step 1: figure out negation, etc.\n        this.parseNegate();\n        // step 2: expand braces\n        this.globSet = [...new Set(this.braceExpand())];\n        if (options.debug) {\n            this.debug = (...args) => console.error(...args);\n        }\n        this.debug(this.pattern, this.globSet);\n        // step 3: now we have a set, so turn each one into a series of\n        // path-portion matching patterns.\n        // These will be regexps, except in the case of \"**\", which is\n        // set to the GLOBSTAR object for globstar behavior,\n        // and will not contain any / characters\n        //\n        // First, we preprocess to make the glob pattern sets a bit simpler\n        // and deduped.  There are some perf-killing patterns that can cause\n        // problems with a glob walk, but we can simplify them down a bit.\n        const rawGlobParts = this.globSet.map(s => this.slashSplit(s));\n        this.globParts = this.preprocess(rawGlobParts);\n        this.debug(this.pattern, this.globParts);\n        // glob --> regexps\n        let set = this.globParts.map((s, _, __) => {\n            if (this.isWindows && this.windowsNoMagicRoot) {\n                // check if it's a drive or unc path.\n                const isUNC = s[0] === '' &&\n                    s[1] === '' &&\n                    (s[2] === '?' || !globMagic.test(s[2])) &&\n                    !globMagic.test(s[3]);\n                const isDrive = /^[a-z]:/i.test(s[0]);\n                if (isUNC) {\n                    return [...s.slice(0, 4), ...s.slice(4).map(ss => this.parse(ss))];\n                }\n                else if (isDrive) {\n                    return [s[0], ...s.slice(1).map(ss => this.parse(ss))];\n                }\n            }\n            return s.map(ss => this.parse(ss));\n        });\n        this.debug(this.pattern, set);\n        // filter out everything that didn't compile properly.\n        this.set = set.filter(s => s.indexOf(false) === -1);\n        // do not treat the ? in UNC paths as magic\n        if (this.isWindows) {\n            for (let i = 0; i < this.set.length; i++) {\n                const p = this.set[i];\n                if (p[0] === '' &&\n                    p[1] === '' &&\n                    this.globParts[i][2] === '?' &&\n                    typeof p[3] === 'string' &&\n                    /^[a-z]:$/i.test(p[3])) {\n                    p[2] = '?';\n                }\n            }\n        }\n        this.debug(this.pattern, this.set);\n    }\n    // various transforms to equivalent pattern sets that are\n    // faster to process in a filesystem walk.  The goal is to\n    // eliminate what we can, and push all ** patterns as far\n    // to the right as possible, even if it increases the number\n    // of patterns that we have to process.\n    preprocess(globParts) {\n        // if we're not in globstar mode, then turn all ** into *\n        if (this.options.noglobstar) {\n            for (let i = 0; i < globParts.length; i++) {\n                for (let j = 0; j < globParts[i].length; j++) {\n                    if (globParts[i][j] === '**') {\n                        globParts[i][j] = '*';\n                    }\n                }\n            }\n        }\n        const { optimizationLevel = 1 } = this.options;\n        if (optimizationLevel >= 2) {\n            // aggressive optimization for the purpose of fs walking\n            globParts = this.firstPhasePreProcess(globParts);\n            globParts = this.secondPhasePreProcess(globParts);\n        }\n        else if (optimizationLevel >= 1) {\n            // just basic optimizations to remove some .. parts\n            globParts = this.levelOneOptimize(globParts);\n        }\n        else {\n            // just collapse multiple ** portions into one\n            globParts = this.adjascentGlobstarOptimize(globParts);\n        }\n        return globParts;\n    }\n    // just get rid of adjascent ** portions\n    adjascentGlobstarOptimize(globParts) {\n        return globParts.map(parts => {\n            let gs = -1;\n            while (-1 !== (gs = parts.indexOf('**', gs + 1))) {\n                let i = gs;\n                while (parts[i + 1] === '**') {\n                    i++;\n                }\n                if (i !== gs) {\n                    parts.splice(gs, i - gs);\n                }\n            }\n            return parts;\n        });\n    }\n    // get rid of adjascent ** and resolve .. portions\n    levelOneOptimize(globParts) {\n        return globParts.map(parts => {\n            parts = parts.reduce((set, part) => {\n                const prev = set[set.length - 1];\n                if (part === '**' && prev === '**') {\n                    return set;\n                }\n                if (part === '..') {\n                    if (prev && prev !== '..' && prev !== '.' && prev !== '**') {\n                        set.pop();\n                        return set;\n                    }\n                }\n                set.push(part);\n                return set;\n            }, []);\n            return parts.length === 0 ? [''] : parts;\n        });\n    }\n    levelTwoFileOptimize(parts) {\n        if (!Array.isArray(parts)) {\n            parts = this.slashSplit(parts);\n        }\n        let didSomething = false;\n        do {\n            didSomething = false;\n            // <pre>/<e>/<rest> -> <pre>/<rest>\n            if (!this.preserveMultipleSlashes) {\n                for (let i = 1; i < parts.length - 1; i++) {\n                    const p = parts[i];\n                    // don't squeeze out UNC patterns\n                    if (i === 1 && p === '' && parts[0] === '')\n                        continue;\n                    if (p === '.' || p === '') {\n                        didSomething = true;\n                        parts.splice(i, 1);\n                        i--;\n                    }\n                }\n                if (parts[0] === '.' &&\n                    parts.length === 2 &&\n                    (parts[1] === '.' || parts[1] === '')) {\n                    didSomething = true;\n                    parts.pop();\n                }\n            }\n            // <pre>/<p>/../<rest> -> <pre>/<rest>\n            let dd = 0;\n            while (-1 !== (dd = parts.indexOf('..', dd + 1))) {\n                const p = parts[dd - 1];\n                if (p && p !== '.' && p !== '..' && p !== '**') {\n                    didSomething = true;\n                    parts.splice(dd - 1, 2);\n                    dd -= 2;\n                }\n            }\n        } while (didSomething);\n        return parts.length === 0 ? [''] : parts;\n    }\n    // First phase: single-pattern processing\n    // <pre> is 1 or more portions\n    // <rest> is 1 or more portions\n    // <p> is any portion other than ., .., '', or **\n    // <e> is . or ''\n    //\n    // **/.. is *brutal* for filesystem walking performance, because\n    // it effectively resets the recursive walk each time it occurs,\n    // and ** cannot be reduced out by a .. pattern part like a regexp\n    // or most strings (other than .., ., and '') can be.\n    //\n    // <pre>/**/../<p>/<p>/<rest> -> {<pre>/../<p>/<p>/<rest>,<pre>/**/<p>/<p>/<rest>}\n    // <pre>/<e>/<rest> -> <pre>/<rest>\n    // <pre>/<p>/../<rest> -> <pre>/<rest>\n    // **/**/<rest> -> **/<rest>\n    //\n    // **/*/<rest> -> */**/<rest> <== not valid because ** doesn't follow\n    // this WOULD be allowed if ** did follow symlinks, or * didn't\n    firstPhasePreProcess(globParts) {\n        let didSomething = false;\n        do {\n            didSomething = false;\n            // <pre>/**/../<p>/<p>/<rest> -> {<pre>/../<p>/<p>/<rest>,<pre>/**/<p>/<p>/<rest>}\n            for (let parts of globParts) {\n                let gs = -1;\n                while (-1 !== (gs = parts.indexOf('**', gs + 1))) {\n                    let gss = gs;\n                    while (parts[gss + 1] === '**') {\n                        // <pre>/**/**/<rest> -> <pre>/**/<rest>\n                        gss++;\n                    }\n                    // eg, if gs is 2 and gss is 4, that means we have 3 **\n                    // parts, and can remove 2 of them.\n                    if (gss > gs) {\n                        parts.splice(gs + 1, gss - gs);\n                    }\n                    let next = parts[gs + 1];\n                    const p = parts[gs + 2];\n                    const p2 = parts[gs + 3];\n                    if (next !== '..')\n                        continue;\n                    if (!p ||\n                        p === '.' ||\n                        p === '..' ||\n                        !p2 ||\n                        p2 === '.' ||\n                        p2 === '..') {\n                        continue;\n                    }\n                    didSomething = true;\n                    // edit parts in place, and push the new one\n                    parts.splice(gs, 1);\n                    const other = parts.slice(0);\n                    other[gs] = '**';\n                    globParts.push(other);\n                    gs--;\n                }\n                // <pre>/<e>/<rest> -> <pre>/<rest>\n                if (!this.preserveMultipleSlashes) {\n                    for (let i = 1; i < parts.length - 1; i++) {\n                        const p = parts[i];\n                        // don't squeeze out UNC patterns\n                        if (i === 1 && p === '' && parts[0] === '')\n                            continue;\n                        if (p === '.' || p === '') {\n                            didSomething = true;\n                            parts.splice(i, 1);\n                            i--;\n                        }\n                    }\n                    if (parts[0] === '.' &&\n                        parts.length === 2 &&\n                        (parts[1] === '.' || parts[1] === '')) {\n                        didSomething = true;\n                        parts.pop();\n                    }\n                }\n                // <pre>/<p>/../<rest> -> <pre>/<rest>\n                let dd = 0;\n                while (-1 !== (dd = parts.indexOf('..', dd + 1))) {\n                    const p = parts[dd - 1];\n                    if (p && p !== '.' && p !== '..' && p !== '**') {\n                        didSomething = true;\n                        const needDot = dd === 1 && parts[dd + 1] === '**';\n                        const splin = needDot ? ['.'] : [];\n                        parts.splice(dd - 1, 2, ...splin);\n                        if (parts.length === 0)\n                            parts.push('');\n                        dd -= 2;\n                    }\n                }\n            }\n        } while (didSomething);\n        return globParts;\n    }\n    // second phase: multi-pattern dedupes\n    // {<pre>/*/<rest>,<pre>/<p>/<rest>} -> <pre>/*/<rest>\n    // {<pre>/<rest>,<pre>/<rest>} -> <pre>/<rest>\n    // {<pre>/**/<rest>,<pre>/<rest>} -> <pre>/**/<rest>\n    //\n    // {<pre>/**/<rest>,<pre>/**/<p>/<rest>} -> <pre>/**/<rest>\n    // ^-- not valid because ** doens't follow symlinks\n    secondPhasePreProcess(globParts) {\n        for (let i = 0; i < globParts.length - 1; i++) {\n            for (let j = i + 1; j < globParts.length; j++) {\n                const matched = this.partsMatch(globParts[i], globParts[j], !this.preserveMultipleSlashes);\n                if (matched) {\n                    globParts[i] = [];\n                    globParts[j] = matched;\n                    break;\n                }\n            }\n        }\n        return globParts.filter(gs => gs.length);\n    }\n    partsMatch(a, b, emptyGSMatch = false) {\n        let ai = 0;\n        let bi = 0;\n        let result = [];\n        let which = '';\n        while (ai < a.length && bi < b.length) {\n            if (a[ai] === b[bi]) {\n                result.push(which === 'b' ? b[bi] : a[ai]);\n                ai++;\n                bi++;\n            }\n            else if (emptyGSMatch && a[ai] === '**' && b[bi] === a[ai + 1]) {\n                result.push(a[ai]);\n                ai++;\n            }\n            else if (emptyGSMatch && b[bi] === '**' && a[ai] === b[bi + 1]) {\n                result.push(b[bi]);\n                bi++;\n            }\n            else if (a[ai] === '*' &&\n                b[bi] &&\n                (this.options.dot || !b[bi].startsWith('.')) &&\n                b[bi] !== '**') {\n                if (which === 'b')\n                    return false;\n                which = 'a';\n                result.push(a[ai]);\n                ai++;\n                bi++;\n            }\n            else if (b[bi] === '*' &&\n                a[ai] &&\n                (this.options.dot || !a[ai].startsWith('.')) &&\n                a[ai] !== '**') {\n                if (which === 'a')\n                    return false;\n                which = 'b';\n                result.push(b[bi]);\n                ai++;\n                bi++;\n            }\n            else {\n                return false;\n            }\n        }\n        // if we fall out of the loop, it means they two are identical\n        // as long as their lengths match\n        return a.length === b.length && result;\n    }\n    parseNegate() {\n        if (this.nonegate)\n            return;\n        const pattern = this.pattern;\n        let negate = false;\n        let negateOffset = 0;\n        for (let i = 0; i < pattern.length && pattern.charAt(i) === '!'; i++) {\n            negate = !negate;\n            negateOffset++;\n        }\n        if (negateOffset)\n            this.pattern = pattern.slice(negateOffset);\n        this.negate = negate;\n    }\n    // set partial to true to test if, for example,\n    // \"/a/b\" matches the start of \"/*/b/*/d\"\n    // Partial means, if you run out of file before you run\n    // out of pattern, then that's fine, as long as all\n    // the parts match.\n    matchOne(file, pattern, partial = false) {\n        const options = this.options;\n        // UNC paths like //?/X:/... can match X:/... and vice versa\n        // Drive letters in absolute drive or unc paths are always compared\n        // case-insensitively.\n        if (this.isWindows) {\n            const fileDrive = typeof file[0] === 'string' && /^[a-z]:$/i.test(file[0]);\n            const fileUNC = !fileDrive &&\n                file[0] === '' &&\n                file[1] === '' &&\n                file[2] === '?' &&\n                /^[a-z]:$/i.test(file[3]);\n            const patternDrive = typeof pattern[0] === 'string' && /^[a-z]:$/i.test(pattern[0]);\n            const patternUNC = !patternDrive &&\n                pattern[0] === '' &&\n                pattern[1] === '' &&\n                pattern[2] === '?' &&\n                typeof pattern[3] === 'string' &&\n                /^[a-z]:$/i.test(pattern[3]);\n            const fdi = fileUNC ? 3 : fileDrive ? 0 : undefined;\n            const pdi = patternUNC ? 3 : patternDrive ? 0 : undefined;\n            if (typeof fdi === 'number' && typeof pdi === 'number') {\n                const [fd, pd] = [file[fdi], pattern[pdi]];\n                if (fd.toLowerCase() === pd.toLowerCase()) {\n                    pattern[pdi] = fd;\n                    if (pdi > fdi) {\n                        pattern = pattern.slice(pdi);\n                    }\n                    else if (fdi > pdi) {\n                        file = file.slice(fdi);\n                    }\n                }\n            }\n        }\n        // resolve and reduce . and .. portions in the file as well.\n        // dont' need to do the second phase, because it's only one string[]\n        const { optimizationLevel = 1 } = this.options;\n        if (optimizationLevel >= 2) {\n            file = this.levelTwoFileOptimize(file);\n        }\n        this.debug('matchOne', this, { file, pattern });\n        this.debug('matchOne', file.length, pattern.length);\n        for (var fi = 0, pi = 0, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {\n            this.debug('matchOne loop');\n            var p = pattern[pi];\n            var f = file[fi];\n            this.debug(pattern, p, f);\n            // should be impossible.\n            // some invalid regexp stuff in the set.\n            /* c8 ignore start */\n            if (p === false) {\n                return false;\n            }\n            /* c8 ignore stop */\n            if (p === exports.GLOBSTAR) {\n                this.debug('GLOBSTAR', [pattern, p, f]);\n                // \"**\"\n                // a/**/b/**/c would match the following:\n                // a/b/x/y/z/c\n                // a/x/y/z/b/c\n                // a/b/x/b/x/c\n                // a/b/c\n                // To do this, take the rest of the pattern after\n                // the **, and see if it would match the file remainder.\n                // If so, return success.\n                // If not, the ** \"swallows\" a segment, and try again.\n                // This is recursively awful.\n                //\n                // a/**/b/**/c matching a/b/x/y/z/c\n                // - a matches a\n                // - doublestar\n                //   - matchOne(b/x/y/z/c, b/**/c)\n                //     - b matches b\n                //     - doublestar\n                //       - matchOne(x/y/z/c, c) -> no\n                //       - matchOne(y/z/c, c) -> no\n                //       - matchOne(z/c, c) -> no\n                //       - matchOne(c, c) yes, hit\n                var fr = fi;\n                var pr = pi + 1;\n                if (pr === pl) {\n                    this.debug('** at the end');\n                    // a ** at the end will just swallow the rest.\n                    // We have found a match.\n                    // however, it will not swallow /.x, unless\n                    // options.dot is set.\n                    // . and .. are *never* matched by **, for explosively\n                    // exponential reasons.\n                    for (; fi < fl; fi++) {\n                        if (file[fi] === '.' ||\n                            file[fi] === '..' ||\n                            (!options.dot && file[fi].charAt(0) === '.'))\n                            return false;\n                    }\n                    return true;\n                }\n                // ok, let's see if we can swallow whatever we can.\n                while (fr < fl) {\n                    var swallowee = file[fr];\n                    this.debug('\\nglobstar while', file, fr, pattern, pr, swallowee);\n                    // XXX remove this slice.  Just pass the start index.\n                    if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {\n                        this.debug('globstar found match!', fr, fl, swallowee);\n                        // found a match.\n                        return true;\n                    }\n                    else {\n                        // can't swallow \".\" or \"..\" ever.\n                        // can only swallow \".foo\" when explicitly asked.\n                        if (swallowee === '.' ||\n                            swallowee === '..' ||\n                            (!options.dot && swallowee.charAt(0) === '.')) {\n                            this.debug('dot detected!', file, fr, pattern, pr);\n                            break;\n                        }\n                        // ** swallows a segment, and continue.\n                        this.debug('globstar swallow a segment, and continue');\n                        fr++;\n                    }\n                }\n                // no match was found.\n                // However, in partial mode, we can't say this is necessarily over.\n                /* c8 ignore start */\n                if (partial) {\n                    // ran out of file\n                    this.debug('\\n>>> no match, partial?', file, fr, pattern, pr);\n                    if (fr === fl) {\n                        return true;\n                    }\n                }\n                /* c8 ignore stop */\n                return false;\n            }\n            // something other than **\n            // non-magic patterns just have to match exactly\n            // patterns with magic have been turned into regexps.\n            let hit;\n            if (typeof p === 'string') {\n                hit = f === p;\n                this.debug('string match', p, f, hit);\n            }\n            else {\n                hit = p.test(f);\n                this.debug('pattern match', p, f, hit);\n            }\n            if (!hit)\n                return false;\n        }\n        // Note: ending in / means that we'll get a final \"\"\n        // at the end of the pattern.  This can only match a\n        // corresponding \"\" at the end of the file.\n        // If the file ends in /, then it can only match a\n        // a pattern that ends in /, unless the pattern just\n        // doesn't have any more for it. But, a/b/ should *not*\n        // match \"a/b/*\", even though \"\" matches against the\n        // [^/]*? pattern, except in partial mode, where it might\n        // simply not be reached yet.\n        // However, a/b/ should still satisfy a/*\n        // now either we fell off the end of the pattern, or we're done.\n        if (fi === fl && pi === pl) {\n            // ran out of pattern and filename at the same time.\n            // an exact hit!\n            return true;\n        }\n        else if (fi === fl) {\n            // ran out of file, but still had pattern left.\n            // this is ok if we're doing the match as part of\n            // a glob fs traversal.\n            return partial;\n        }\n        else if (pi === pl) {\n            // ran out of pattern, still have file left.\n            // this is only acceptable if we're on the very last\n            // empty segment of a file with a trailing slash.\n            // a/* should match a/b/\n            return fi === fl - 1 && file[fi] === '';\n            /* c8 ignore start */\n        }\n        else {\n            // should be unreachable.\n            throw new Error('wtf?');\n        }\n        /* c8 ignore stop */\n    }\n    braceExpand() {\n        return (0, exports.braceExpand)(this.pattern, this.options);\n    }\n    parse(pattern) {\n        (0, assert_valid_pattern_js_1.assertValidPattern)(pattern);\n        const options = this.options;\n        // shortcuts\n        if (pattern === '**')\n            return exports.GLOBSTAR;\n        if (pattern === '')\n            return '';\n        // far and away, the most common glob pattern parts are\n        // *, *.*, and *.<ext>  Add a fast check method for those.\n        let m;\n        let fastTest = null;\n        if ((m = pattern.match(starRE))) {\n            fastTest = options.dot ? starTestDot : starTest;\n        }\n        else if ((m = pattern.match(starDotExtRE))) {\n            fastTest = (options.nocase\n                ? options.dot\n                    ? starDotExtTestNocaseDot\n                    : starDotExtTestNocase\n                : options.dot\n                    ? starDotExtTestDot\n                    : starDotExtTest)(m[1]);\n        }\n        else if ((m = pattern.match(qmarksRE))) {\n            fastTest = (options.nocase\n                ? options.dot\n                    ? qmarksTestNocaseDot\n                    : qmarksTestNocase\n                : options.dot\n                    ? qmarksTestDot\n                    : qmarksTest)(m);\n        }\n        else if ((m = pattern.match(starDotStarRE))) {\n            fastTest = options.dot ? starDotStarTestDot : starDotStarTest;\n        }\n        else if ((m = pattern.match(dotStarRE))) {\n            fastTest = dotStarTest;\n        }\n        const re = ast_js_1.AST.fromGlob(pattern, this.options).toMMPattern();\n        if (fastTest && typeof re === 'object') {\n            // Avoids overriding in frozen environments\n            Reflect.defineProperty(re, 'test', { value: fastTest });\n        }\n        return re;\n    }\n    makeRe() {\n        if (this.regexp || this.regexp === false)\n            return this.regexp;\n        // at this point, this.set is a 2d array of partial\n        // pattern strings, or \"**\".\n        //\n        // It's better to use .match().  This function shouldn't\n        // be used, really, but it's pretty convenient sometimes,\n        // when you just want to work with a regex.\n        const set = this.set;\n        if (!set.length) {\n            this.regexp = false;\n            return this.regexp;\n        }\n        const options = this.options;\n        const twoStar = options.noglobstar\n            ? star\n            : options.dot\n                ? twoStarDot\n                : twoStarNoDot;\n        const flags = new Set(options.nocase ? ['i'] : []);\n        // regexpify non-globstar patterns\n        // if ** is only item, then we just do one twoStar\n        // if ** is first, and there are more, prepend (\\/|twoStar\\/)? to next\n        // if ** is last, append (\\/twoStar|) to previous\n        // if ** is in the middle, append (\\/|\\/twoStar\\/) to previous\n        // then filter out GLOBSTAR symbols\n        let re = set\n            .map(pattern => {\n            const pp = pattern.map(p => {\n                if (p instanceof RegExp) {\n                    for (const f of p.flags.split(''))\n                        flags.add(f);\n                }\n                return typeof p === 'string'\n                    ? regExpEscape(p)\n                    : p === exports.GLOBSTAR\n                        ? exports.GLOBSTAR\n                        : p._src;\n            });\n            pp.forEach((p, i) => {\n                const next = pp[i + 1];\n                const prev = pp[i - 1];\n                if (p !== exports.GLOBSTAR || prev === exports.GLOBSTAR) {\n                    return;\n                }\n                if (prev === undefined) {\n                    if (next !== undefined && next !== exports.GLOBSTAR) {\n                        pp[i + 1] = '(?:\\\\/|' + twoStar + '\\\\/)?' + next;\n                    }\n                    else {\n                        pp[i] = twoStar;\n                    }\n                }\n                else if (next === undefined) {\n                    pp[i - 1] = prev + '(?:\\\\/|' + twoStar + ')?';\n                }\n                else if (next !== exports.GLOBSTAR) {\n                    pp[i - 1] = prev + '(?:\\\\/|\\\\/' + twoStar + '\\\\/)' + next;\n                    pp[i + 1] = exports.GLOBSTAR;\n                }\n            });\n            return pp.filter(p => p !== exports.GLOBSTAR).join('/');\n        })\n            .join('|');\n        // need to wrap in parens if we had more than one thing with |,\n        // otherwise only the first will be anchored to ^ and the last to $\n        const [open, close] = set.length > 1 ? ['(?:', ')'] : ['', ''];\n        // must match entire pattern\n        // ending in a * or ** will make it less strict.\n        re = '^' + open + re + close + '$';\n        // can match anything, as long as it's not this.\n        if (this.negate)\n            re = '^(?!' + re + ').+$';\n        try {\n            this.regexp = new RegExp(re, [...flags].join(''));\n            /* c8 ignore start */\n        }\n        catch (ex) {\n            // should be impossible\n            this.regexp = false;\n        }\n        /* c8 ignore stop */\n        return this.regexp;\n    }\n    slashSplit(p) {\n        // if p starts with // on windows, we preserve that\n        // so that UNC paths aren't broken.  Otherwise, any number of\n        // / characters are coalesced into one, unless\n        // preserveMultipleSlashes is set to true.\n        if (this.preserveMultipleSlashes) {\n            return p.split('/');\n        }\n        else if (this.isWindows && /^\\/\\/[^\\/]+/.test(p)) {\n            // add an extra '' for the one we lose\n            return ['', ...p.split(/\\/+/)];\n        }\n        else {\n            return p.split(/\\/+/);\n        }\n    }\n    match(f, partial = this.partial) {\n        this.debug('match', f, this.pattern);\n        // short-circuit in the case of busted things.\n        // comments, etc.\n        if (this.comment) {\n            return false;\n        }\n        if (this.empty) {\n            return f === '';\n        }\n        if (f === '/' && partial) {\n            return true;\n        }\n        const options = this.options;\n        // windows: need to use /, not \\\n        if (this.isWindows) {\n            f = f.split('\\\\').join('/');\n        }\n        // treat the test path as a set of pathparts.\n        const ff = this.slashSplit(f);\n        this.debug(this.pattern, 'split', ff);\n        // just ONE of the pattern sets in this.set needs to match\n        // in order for it to be valid.  If negating, then just one\n        // match means that we have failed.\n        // Either way, return on the first hit.\n        const set = this.set;\n        this.debug(this.pattern, 'set', set);\n        // Find the basename of the path by looking for the last non-empty segment\n        let filename = ff[ff.length - 1];\n        if (!filename) {\n            for (let i = ff.length - 2; !filename && i >= 0; i--) {\n                filename = ff[i];\n            }\n        }\n        for (let i = 0; i < set.length; i++) {\n            const pattern = set[i];\n            let file = ff;\n            if (options.matchBase && pattern.length === 1) {\n                file = [filename];\n            }\n            const hit = this.matchOne(file, pattern, partial);\n            if (hit) {\n                if (options.flipNegate) {\n                    return true;\n                }\n                return !this.negate;\n            }\n        }\n        // didn't get any hits.  this is success if it's a negative\n        // pattern, failure otherwise.\n        if (options.flipNegate) {\n            return false;\n        }\n        return this.negate;\n    }\n    static defaults(def) {\n        return exports.minimatch.defaults(def).Minimatch;\n    }\n}\nexports.Minimatch = Minimatch;\n/* c8 ignore start */\nvar ast_js_2 = require(\"./ast.js\");\nObject.defineProperty(exports, \"AST\", { enumerable: true, get: function () { return ast_js_2.AST; } });\nvar escape_js_2 = require(\"./escape.js\");\nObject.defineProperty(exports, \"escape\", { enumerable: true, get: function () { return escape_js_2.escape; } });\nvar unescape_js_2 = require(\"./unescape.js\");\nObject.defineProperty(exports, \"unescape\", { enumerable: true, get: function () { return unescape_js_2.unescape; } });\n/* c8 ignore stop */\nexports.minimatch.AST = ast_js_1.AST;\nexports.minimatch.Minimatch = Minimatch;\nexports.minimatch.escape = escape_js_1.escape;\nexports.minimatch.unescape = unescape_js_1.unescape;\n//# sourceMappingURL=index.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.unescape = void 0;\n/**\n * Un-escape a string that has been escaped with {@link escape}.\n *\n * If the {@link windowsPathsNoEscape} option is used, then square-brace\n * escapes are removed, but not backslash escapes.  For example, it will turn\n * the string `'[*]'` into `*`, but it will not turn `'\\\\*'` into `'*'`,\n * becuase `\\` is a path separator in `windowsPathsNoEscape` mode.\n *\n * When `windowsPathsNoEscape` is not set, then both brace escapes and\n * backslash escapes are removed.\n *\n * Slashes (and backslashes in `windowsPathsNoEscape` mode) cannot be escaped\n * or unescaped.\n */\nconst unescape = (s, { windowsPathsNoEscape = false, } = {}) => {\n    return windowsPathsNoEscape\n        ? s.replace(/\\[([^\\/\\\\])\\]/g, '$1')\n        : s.replace(/((?!\\\\).|^)\\[([^\\/\\\\])\\]/g, '$1$2').replace(/\\\\([^\\/])/g, '$1');\n};\nexports.unescape = unescape;\n//# sourceMappingURL=unescape.js.map","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// startup\n// Load entry module and return exports\n// This entry module is referenced by other modules so it can't be inlined\nvar __webpack_exports__ = __webpack_require__(265);\n"],"names":["balanced","a","b","str","RegExp","maybeMatch","r","range","start","end","pre","slice","body","length","post","reg","m","match","begs","beg","left","right","result","ai","indexOf","bi","i","push","pop","module","exports","substr","expand","split","join","escSlash","escOpen","escClose","escComma","escPeriod","escapeBraces","map","unescapeBraces","Math","random","numeric","parseInt","charCodeAt","parseCommaParts","parts","p","postParts","shift","apply","embrace","isPadded","el","test","lte","y","gte","isTop","expansions","k","expansion","n","N","isNumericSequence","isAlphaSequence","isSequence","isOptions","x","width","max","incr","abs","pad","some","c","String","fromCharCode","need","z","Array","j","async","uris","ret","file_of_opts","uri_to_file_of_opts","txt","vscode","workspace","openTextDocument","getText","prnt","exclude_paths0","getCMD","exc","exclude_path","err","set_cmd_type","static","msg","console_msg","show","window","createOutputChannel","this","appendLine","set_placeholder0","_txt","cmd_type","activeTextEditor","document","v","cmd_rgx","set_collect_rgx_from_doc","undefined","_collect_rgx_from_doc","toString","open_rgx","close_rgx","construct_rgx","collect_rgx_from_doc","source","_collect_rgx_from_doc0","exec","try_it","strn_2_rgx","_m","replaceAll","placeholder0","strn","check_end_of_rgx","flags","_flags","regex","error","Error","message","showInformationMessage","rgx","uri","fsPath","activate_","context","allConfigData","todoEditors","doneEditors","resetDecorations","visibleTextEditors","forEach","configData","ruleData","decorationType","dispose","configurations","getConfiguration","get","toArray","configuration","globs","paths","rules","buildRuleData","updateDecorations","every","editor","filePath","asRelativePath","fileName","matchingRuleData","flatMap","glob","pattern","includes","minimatch","nocase","process","platform","documentText","regexes","multiLine","ranges","matchAll","index","startPos","positionAt","endPos","Range","lineNum","lineCount","lineAt","text","setDecorations","_updateDecorations","onDidChangeConfiguration","event","affectsConfiguration","subscriptions","onDidChangeVisibleTextEditors","visibleEditors","filter","onDidChangeTextDocument","visibleEditor","intervalId","setInterval","clearInterval","value","isArray","ansiColorNames","Set","rule","color","has","ThemeColor","textDecoration","underline","strikeThrough","createTextEditorDecorationType","fontWeight","bold","fontStyle","italic","matchCase","patterns","menu","res","init","sync_bkp","raw_writeBkp","i_c_fn_head_opts","path_to_conf","console","log","disposable","commands","registerCommand","disposable0","langId","lang","from","doc","file_was_bkuped7","reformat","one_line_comment","open_comment","close_comment","within_comment","prev_strn","strn0","pad_len","count_spaces_from_left","trim","exclude_comments_from_ln","pad_strn_from_left","writeBkp","c_cpp_d_head","rust_head","ln0","ln","open_curly","close_curly","repeat","padding","arr","run","bkp_source_file","path0","path","new_name","suffix","copyFileSync","compare_files","bkuped","indx","existsSync","_1st","_2nd","open_1st","open_2nd","readFileSync","encoding","flag","data","writeFileSync","vsc","languageId","name","file_exts","toLowerCase","lnum","mark_fn_head","set_info","fn_head","get_head","name7","_name7","try_set_info","cmds","f12","new_pressF12","F12_action","cont","more_rgxs","matches","_a_get_files_in_workspace","exclude_paths","calc_locations","handle_rgx_cmd","new_EL","kind","Start","Position","End","_1st_ch_indx","len","Location","file_ext","langsName","findFiles","restrict_search","max_num_of_res","_c_fn_body","symbols","c_like","lang_element","exclude_strns","lines","bee_ep","orig_lines","set_lines","exclude_comments","one_line_block","open_block","close_block","tst_class","block_head","one_line_comment7","within_comment7","class_entry7","head7","one_line_block7","block_entry7","close_class7","update_block_state","close_block7","txt0","symb","for_beep","new_strn","replace","mode","dbg","rmSync","rust_fn_body","opened_class","start_class","start_block","block_state","sav_block_state","search_curlies","no_comments","_block_head","add_symb","_rust_fn_body","rust","startLine","endLine","objName","objType","set_rng","SymbolInformation","eval","butterfly","rloc","class_symbols","orig","c_fn_body","count_quotes","quote_state","tmp_quote_state","get_c_fn_head","provideDefinition","position","token","wordRange","getWordRangeAtPosition","word","extra_locations","handleExtraCMDs","results","isCancellationRequested","idx","after","_0","set_lang","been_set","regDefProvider","run_opt","key","provide_lang_D","languages","registerDocumentSymbolProvider","language","ShowDocumentSymbols","provide_lang_CPP","provide_lang_C","provide_lang_Rust","selector","sel","scheme","mkDocSel","registerDefinitionProvider","langDefinitionProvider","_manage_output","manage_output","C","CPP","D","Rust","provideDocumentSymbols","text0","require","Object","defineProperty","assertValidPattern","TypeError","AST","brace_expressions_js_1","unescape_js_1","types","isExtglobType","startNoDot","addPatternStart","justDots","reSpecials","regExpEscape","s","qmark","star","starNoEmpty","type","constructor","parent","options","hasMagic","pp","part","copyIn","toJSON","isStart","unshift","isEnd","pl","clone","ast","pos","opt","escaping","inBrace","braceStart","braceNeg","acc","charAt","noext","ext","substring","fromGlob","toMMPattern","re","uflag","toRegExpSource","nocaseMagicOnly","toUpperCase","assign","_src","_glob","allowDot","dot","noEmpty","src","_","aps","needNoTrav","startsWith","needNoDot","unescape","repeated","bodyDotAllowed","final","_hasMagic","needUflag","consumed","magic","parseClass","posixClasses","braceEscape","rangesToString","negs","sawStart","negate","rangeStart","WHILE","cls","unip","u","neg","entries","sranges","snegs","escape","windowsPathsNoEscape","__importDefault","mod","__esModule","Minimatch","makeRe","braceExpand","defaults","GLOBSTAR","sep","brace_expansion_1","assert_valid_pattern_js_1","ast_js_1","escape_js_1","nocomment","starDotExtRE","starDotExtTest","f","endsWith","starDotExtTestDot","starDotExtTestNocase","starDotExtTestNocaseDot","starDotStarRE","starDotStarTest","starDotStarTestDot","dotStarRE","dotStarTest","starRE","starTest","starTestDot","qmarksRE","qmarksTestNocase","$0","qmarksTestNoExt","qmarksTestNocaseDot","qmarksTestNoExtDot","qmarksTestDot","qmarksTest","defaultPlatform","env","__MINIMATCH_TESTING_PLATFORM__","Symbol","def","keys","super","list","nobrace","default","mm","nonull","globMagic","set","nonegate","comment","empty","preserveMultipleSlashes","partial","globSet","globParts","isWindows","windowsNoMagicRoot","regexp","allowWindowsEscape","make","magicalBraces","debug","parseNegate","args","rawGlobParts","slashSplit","preprocess","__","isUNC","isDrive","ss","parse","noglobstar","optimizationLevel","firstPhasePreProcess","secondPhasePreProcess","levelOneOptimize","adjascentGlobstarOptimize","gs","splice","reduce","prev","levelTwoFileOptimize","didSomething","dd","gss","next","p2","other","splin","matched","partsMatch","emptyGSMatch","which","negateOffset","matchOne","file","fileDrive","fileUNC","patternDrive","fdi","pdi","fd","pd","fi","pi","fl","fr","pr","swallowee","hit","fastTest","Reflect","twoStar","add","open","close","ex","ff","filename","matchBase","flipNegate","ast_js_2","enumerable","escape_js_2","unescape_js_2","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","call","__webpack_exports__"],"sourceRoot":""}

package/empty

@@ -0,0 +1 @@
+

package/eslint.config.mjs

@@ -0,0 +1,27 @@
+import typescriptEslint from "typescript-eslint";
+
+export default [{
+    files: ["**/*.ts"],
+}, {
+    plugins: {
+        "@typescript-eslint": typescriptEslint.plugin,
+    },
+
+    languageOptions: {
+        parser: typescriptEslint.parser,
+        ecmaVersion: 2022,
+        sourceType: "module",
+    },
+
+    rules: {
+        "@typescript-eslint/naming-convention": ["warn", {
+            selector: "import",
+            format: ["camelCase", "PascalCase"],
+        }],
+
+        curly: "warn",
+        eqeqeq: "warn",
+        "no-throw-literal": "warn",
+        semi: "warn",
+    },
+}];