apex-dev 1.0.0

package/.local/share/opencode/tool-output/tool_c93da840c0016GrdyAkOnHGezU

@@ -0,0 +1,2330 @@
+Found 2074 match(es) in 127 file(s)
+[Output truncated due to size limit]
+
+/home/runner/workspace/bun.lock
+  9: "boxen": "^5.1.2",
+  67: "boxen": ["boxen@5.1.2", "", { "dependencies": { "ansi-align": "^3.0.0", "camelcase": "^6.2.0", "chalk": "^4.1.0", "cli-boxes": "^2.2.1", "string-width": "^4.2.2", "type-fest": "^0.20.2", "widest-line": "^3.1.0", "wrap-ansi": "^7.0.0" } }, "sha512-9gYgQKXx+1nP8mP7CzFyaUARhg7D3n1dF/FnErWmu9l6JvGpNUN278h0aSb+QjoiKSWG+iZ3uHrcqk0qrY9RQQ=="],
+  81: "cli-boxes": ["cli-boxes@2.2.1", "", {}, "sha512-y4coMcylgSCdVinjiDBuR8PCC2bLjyGTwEmPb9NHR/QaNU6EUOXcTY/s6VjGMD6ENSEaeQYHCY0GNGS5jfMwPw=="],
+
+/home/runner/workspace/public/app.js
+  28: fileTree.innerHTML = renderTree(files, 0);
+  30: fileTree.innerHTML = '<div style="padding:16px;color:var(--text-tertiary)">No files loaded</div>';
+  34: function renderTree(items, depth) {
+  46: html += renderTree(item.children, depth + 1);
+  81: document.querySelector('.token-count').textContent = `~${count} tokens`;
+  92: const text = chatInput.value.trim();
+  93: if (!text || isProcessing) return;
+  99: appendMessage('user', text);
+  114: body: JSON.stringify({ message: text }),
+  194: function formatContent(text) {
+  196: text = text.replace(/```(\w+)?\n([\s\S]*?)```/g, (_, lang, code) => {
+  208: text = text.replace(/`([^`]+)`/g, '<code>$1</code>');
+  211: text = text.replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>');
+  214: text = text.split('\n\n').map(p => `<p>${p}</p>`).join('');
+  215: text = text.replace(/\n/g, '<br>');
+  217: return text;
+  220: function escapeHtml(text) {
+  222: div.textContent = text;
+  255: function sendQuickAction(text) {
+  256: chatInput.value = text;
+  270: const code = btn.closest('.code-block').querySelector('.code-body').textContent;
+  272: btn.textContent = 'Copied!';
+  273: setTimeout(() => btn.textContent = 'Copy', 2000);
+
+/home/runner/workspace/public/styles.css
+  14: --text-primary: #e4e4ed;
+  15: --text-secondary: #8888a0;
+  16: --text-tertiary: #5a5a72;
+  17: --text-inverse: #0a0a0f;
+  55: box-sizing: border-box;
+  66: color: var(--text-primary);
+  119: .logo-text {
+  127: -webkit-background-clip: text;
+  128: -webkit-text-fill-color: transparent;
+  140: color: var(--text-secondary);
+  164: color: var(--text-primary);
+  181: box-shadow: 0 0 6px rgba(34, 197, 94, 0.5);
+  189: color: var(--text-secondary);
+  200: box-shadow: 0 0 6px rgba(34, 197, 94, 0.5);
+  218: color: var(--text-secondary);
+  225: color: var(--text-primary);
+  262: text-transform: uppercase;
+  264: color: var(--text-tertiary);
+  301: color: var(--text-secondary);
+  306: color: var(--text-primary);
+  324: .tree-icon.md { color: var(--text-secondary); }
+  339: color: var(--text-secondary);
+  348: color: var(--text-primary);
+  368: text-overflow: ellipsis;
+  373: color: var(--text-tertiary);
+  409: text-align: center;
+  428: background: linear-gradient(135deg, var(--text-primary), var(--text-secondary));
+  429: -webkit-background-clip: text;
+  430: -webkit-text-fill-color: transparent;
+  435: color: var(--text-secondary);
+  456: color: var(--text-secondary);
+  461: text-align: left;
+  467: color: var(--text-primary);
+  468: box-shadow: var(--shadow-glow);
+  518: color: var(--text-tertiary);
+  525: color: var(--text-primary);
+  563: color: var(--text-tertiary);
+  573: color: var(--text-tertiary);
+  583: color: var(--text-primary);
+  591: color: var(--text-primary);
+  608: color: var(--text-secondary);
+  616: text-transform: uppercase;
+  630: color: var(--text-tertiary);
+  681: color: var(--text-tertiary);
+  688: color: var(--text-primary);
+  718: box-shadow: 0 0 0 1px var(--accent-glow), var(--shadow-glow);
+  726: color: var(--text-primary);
+  736: color: var(--text-tertiary);
+  756: box-shadow: var(--shadow-glow);
+  773: color: var(--text-tertiary);
+  788: color: var(--text-tertiary);
+  817: text-transform: uppercase;
+  819: color: var(--text-tertiary);
+  867: color: var(--text-primary);
+  873: color: var(--text-tertiary);
+  876: text-overflow: ellipsis;
+  919: color: var(--text-secondary);
+  962: color: var(--text-secondary);
+  968: color: var(--text-primary);
+
+/home/runner/workspace/public/index.html
+  29: <span class="logo-text">Apex <span class="logo-highlight">AI</span></span>
+  144: <button class="toolbar-btn" title="Add context">
+  152: <textarea
+  157: ></textarea>
+
+/home/runner/workspace/index.js
+  6: const boxen = require('boxen');
+  18: text:     chalk.hex('#e4e4ed'),
+  58: console.clear();
+  60: const model = t.dim('model: ') + t.text('Claude 4 Opus');
+  64: console.log();
+  65: console.log(indent(`${logo}  ${t.bar('│')}  ${model}  ${t.bar('│')}  ${branch}  ${t.bar('│')}  ${status}`));
+  66: console.log(indent(hr()));
+  67: console.log();
+  72: const title = t.text.bold('What can I help you build?');
+  75: console.log(indent(title));
+  76: console.log(indent(subtitle));
+  77: console.log();
+  87: console.log(indent(`  ${icon}  ${label}`));
+  89: console.log();
+  90: console.log(indent(hr()));
+  91: console.log();
+  95: function showUserMessage(text) {
+  97: console.log(indent(header));
+  98: console.log(indent(t.text(text), 6));
+  99: console.log();
+  104: console.log(indent(header));
+  107: function showAssistantMessage(text) {
+  108: const lines = text.split('\n');
+  122: formatted.push(renderCodeBlock(codeLines.join('\n'), codeLang));
+  128: formatted.push(t.text(processed));
+  132: console.log(indent(formatted.join('\n'), 4));
+  133: console.log();
+  137: function renderCodeBlock(code, lang) {
+  146: highlighted = t.text(code);
+  172: text: `${toolBadge(name)}  ${t.muted(detail)}`,
+  182: text: `${toolBadge(name)}  ${t.dim(detail)}  ${t.dim(`${randomInt(50, 500)}ms`)}`,
+  198: console.log(indent(`${prefix}${branch}${t.brand(f.name + '/')}`, 4));
+  203: console.log(indent(`${prefix}${branch}${color(f.name)}`, 4));
+  210: console.log(indent(t.dim('┌─ ') + t.text.bold(filename) + t.dim(' ─────────────────')));
+  213: console.log(indent(chalk.red('│ - ' + line)));
+  216: console.log(indent(chalk.green('│ + ' + line)));
+  219: console.log(indent(t.dim('└─────────────────────────────────────')));
+  220: console.log();
+  225: const box = boxen(
+  227: t.dim('Tokens   ') + t.text(tokens.toLocaleString()),
+  228: t.dim('Cost     ') + t.text('$' + cost.toFixed(3)),
+  229: t.dim('Duration ') + t.text(duration + 's'),
+  238: console.log(indent(box, 4));
+  239: console.log();
+  245: text: t.dim('Thinking...'),
+  273: console.log();
+  274: console.log('  ' + topLeft);
+  278: console.log();
+  279: console.log('  ' + bottom);
+  280: console.log(hint);
+  296: console.log();
+  303: console.log();
+  317: // Response text
+  335: console.log(indent(hr()));
+  363: console.log();
+  364: console.log(indent(t.dim('Goodbye! ') + t.brand('✦')));
+  365: console.log();
+  388: console.log();
+  389: console.log(indent(t.dim('Goodbye! ') + t.brand('✦')));
+  390: console.log();
+  407: console.log();
+  408: console.log(indent(t.dim.bold('PROJECT FILES')));
+  409: console.log();
+  411: console.log();
+  426: console.log();
+  427: console.log(indent(t.text.bold('Commands')));
+  428: console.log();
+  429: console.log(indent(`  ${t.brand('/help')}    ${t.muted('Show this menu')}`));
+  430: console.log(indent(`  ${t.brand('/files')}   ${t.muted('Show project file tree')}`));
+  431: console.log(indent(`  ${t.brand('/clear')}   ${t.muted('Clear the screen')}`));
+  432: console.log(indent(`  ${t.brand('/model')}   ${t.muted('Switch AI model')}`));
+  433: console.log(indent(`  ${t.brand('/cost')}    ${t.muted('Show session cost')}`));
+  434: console.log(indent(`  ${t.brand('/quit')}    ${t.muted('Exit the agent')}`));
+  435: console.log();
+  458: main().catch(console.error);
+
+/home/runner/workspace/package.json
+  15: "boxen": "^5.1.2",
+
+/home/runner/workspace/package-lock.json
+  14: "boxen": "^5.1.2",
+  373: "node_modules/boxen": {
+  375: "resolved": "https://registry.npmjs.org/boxen/-/boxen-5.1.2.tgz",
+  382: "cli-boxes": "^2.2.1",
+  485: "node_modules/cli-boxes": {
+  487: "resolved": "https://registry.npmjs.org/cli-boxes/-/cli-boxes-2.2.1.tgz",
+  1957: "boxen": {
+  1959: "resolved": "https://registry.npmjs.org/boxen/-/boxen-5.1.2.tgz",
+  1965: "cli-boxes": "^2.2.1",
+  2018: "cli-boxes": {
+  2020: "resolved": "https://registry.npmjs.org/cli-boxes/-/cli-boxes-2.2.1.tgz",
+
+/home/runner/workspace/node_modules/vary/README.md
+  77: res.setHeader('Content-Type', 'text/html')
+
+/home/runner/workspace/node_modules/@types/node/ts5.6/index.d.ts
+  45: /// <reference path="../console.d.ts" />
+
+/home/runner/workspace/node_modules/finalhandler/README.md
+  86: res.setHeader('Content-Type', 'text/html')
+  123: res.setHeader('Content-Type', 'text/html')
+  131: console.error(err.stack || err.toString())
+
+/home/runner/workspace/node_modules/type-is/README.md
+  28: var istext = typeis(req, ['text/*'])
+  29: res.end('you ' + (istext ? 'sent' : 'did not send') + ' me text')
+  127: typeis.match('text/html', 'text/html') // => true
+  128: typeis.match('*/html', 'text/html') // => true
+  129: typeis.match('text/*', 'text/html') // => true
+  130: typeis.match('*/*', 'text/html') // => true
+
+/home/runner/workspace/node_modules/type-is/HISTORY.md
+  19: - Add extension `.mvt` to `application/vnd.mapbox-vector-tile`
+  54: - Add `text/mdx` with extension `.mdx`
+  63: - Add `text/shex` with extension `.shex`
+  71: - Update extensions `.md` and `.markdown` to be `text/markdown`
+  73: - Update `text/hjson` to registered `application/hjson`
+
+/home/runner/workspace/node_modules/finalhandler/package.json
+  43: "test-ci": "nyc --reporter=lcovonly --reporter=text npm test",
+  44: "test-cov": "nyc --reporter=html --reporter=text npm test",
+
+/home/runner/workspace/node_modules/@types/node/ts5.6/buffer.buffer.d.ts
+  78: * console.log(buf);
+  84: * console.log(buf);
+  97: * console.log(buf.length);
+  115: * console.log(arrA.buffer === arrB.buffer); // true
+  118: * console.log(buf);
+  143: * console.log(buf1.toString());
+  145: * console.log(buf2.toString());
+  147: * console.log(buf1.toString('latin1'));
+  188: * console.log(totalLength);
+  193: * console.log(bufA);
+  195: * console.log(bufA.length);
+  212: * console.log(buf.length); // 2
+  213: * console.log(buf[0]); // 255
+  214: * console.log(buf[1]); // 255
+  230: * console.log(buf);
+  243: * console.log(buf);
+  255: * console.log(buf);
+  281: * console.log(buf);
+  286: * console.log(buf);
+  369: * console.log(copiedBuf.toString());
+  372: * console.log(buf.toString());
+  378: * console.log(notReallyCopiedBuf.toString());
+  380: * console.log(buf.toString());
+  415: * console.log(buf2.toString('ascii', 0, buf2.length));
+  420: * console.log(buf2.toString('ascii', 0, buf2.length));
+  432: * console.log(buf.subarray(-6, -1).toString());
+  436: * console.log(buf.subarray(-6, -2).toString());
+  440: * console.log(buf.subarray(-5, -2).toString());
+
+/home/runner/workspace/node_modules/type-is/package.json
+  39: "test-ci": "nyc --reporter=lcovonly --reporter=text npm test",
+  40: "test-cov": "nyc --reporter=html --reporter=text npm test"
+
+/home/runner/workspace/node_modules/finalhandler/index.js
+  271: res.setHeader('Content-Type', 'text/html; charset=utf-8')
+
+/home/runner/workspace/node_modules/type-is/index.js
+  107: *     // With Content-Type: text/html; charset=utf-8
+  109: *     this.is('text/html'); // => 'text/html'
+  110: *     this.is('text/*', 'application/json'); // => 'text/html'
+
+/home/runner/workspace/node_modules/@types/node/timers/promises.d.ts
+  24: * console.log(res);  // Prints 'result'
+  39: * console.log(res);  // Prints 'result'
+  58: *   console.log(now);
+  62: * console.log(Date.now());
+
+/home/runner/workspace/node_modules/@types/node/stream/web.d.ts
+  548: * https://nodejs.org/api/globals.html#class-textdecoderstream
+  557: * https://nodejs.org/api/globals.html#class-textencoderstream
+
+/home/runner/workspace/node_modules/statuses/package.json
+  44: "test-ci": "nyc --reporter=lcov --reporter=text npm test",
+  45: "test-cov": "nyc --reporter=html --reporter=text npm test",
+
+/home/runner/workspace/node_modules/@types/node/stream/consumers.d.ts
+  5: function text(stream: NodeJS.ReadableStream | Readable | AsyncIterable<any>): Promise<string>;
+
+/home/runner/workspace/node_modules/@types/node/readline/promises.d.ts
+  36: * console.log(`Oh, so your favorite food is ${answer}`);
+  45: *   console.log('The food question timed out');
+  49: * console.log(`Oh, so your favorite food is ${answer}`);
+  142: *   console.log(`Received: ${line}`);
+  146: * If `terminal` is `true` for this instance then the `output` stream will get
+  156: terminal?: boolean,
+
+/home/runner/workspace/node_modules/serve-static/package.json
+  40: "test-ci": "nyc --reporter=lcov --reporter=text npm test",
+  41: "test-cov": "nyc --reporter=html --reporter=text npm test",
+
+/home/runner/workspace/node_modules/serve-static/index.js
+  201: res.setHeader('Content-Type', 'text/html; charset=UTF-8')
+
+/home/runner/workspace/node_modules/@types/node/fs/promises.d.ts
+  260: *   console.log(chunk);
+  329: *   console.log(line);
+  516: *   console.log('can access');
+  518: *   console.error('cannot access');
+  545: *   console.log('source.txt was copied to destination.txt');
+  547: *   console.error('The file could not be copied');
+  553: *   console.log('source.txt was copied to destination.txt');
+  555: *   console.error('The file could not be copied');
+  625: *   console.log(`created ${createDir}`);
+  627: *   console.error(err.message);
+  677: *     console.log(file);
+  679: *   console.error(err);
+  939: *   console.error(err);
+  1003: *   console.error(err);
+  1075: *   console.log(contents);
+  1077: *   console.error(err.message);
+  1098: *   console.error(err);
+  1172: *     console.log(dirent.name);
+  1174: *   console.error(err);
+  1198: *       console.log(event);
+
+/home/runner/workspace/node_modules/send/README.md
+  228: custom function to render a listing of a directory.
+  259: // render an index for the directory
+  260: res.setHeader('Content-Type', 'text/plain; charset=UTF-8')
+
+/home/runner/workspace/node_modules/encodeurl/README.md
+  42: res.setHeader('Content-Type', 'text/html; charset=UTF-8')
+  72: res.setHeader('Content-Type', 'text/html; charset=UTF-8')
+
+/home/runner/workspace/node_modules/send/package.json
+  59: "test-ci": "nyc --reporter=lcovonly --reporter=text npm test",
+  60: "test-cov": "nyc --reporter=html --reporter=text npm test",
+
+/home/runner/workspace/node_modules/send/index.js
+  185: res.setHeader('Content-Type', 'text/html; charset=UTF-8')
+  387: res.setHeader('Content-Type', 'text/html; charset=UTF-8')
+
+/home/runner/workspace/node_modules/@types/node/dns/promises.d.ts
+  71: *   console.log('address: %j family: IPv%s', result.address, result.family);
+  78: *   console.log('addresses: %j', result);
+  101: *   console.log(result.hostname, result.service);
+  296: * Uses the DNS protocol to resolve text queries (`TXT` records) for the `hostname`. On success, the `Promise` is resolved with a two-dimensional array
+  297: * of the text records available for `hostname` (e.g.`[ ['v=spf1 ip4:0.0.0.0 ', '~all' ] ]`). Each sub-array contains TXT chunks of
+
+/home/runner/workspace/node_modules/range-parser/package.json
+  41: "test-cov": "nyc --reporter=html --reporter=text npm test",
+  42: "test-travis": "nyc --reporter=text npm test"
+
+/home/runner/workspace/node_modules/depd/index.js
+  297: var context = callSite.getThis()
+  298: var typeName = context && callSite.getTypeName()
+  307: typeName = context.name || typeName
+
+/home/runner/workspace/node_modules/router/README.md
+  30: res.setHeader('Content-Type', 'text/plain; charset=utf-8')
+  99: res.setHeader('Content-Type', 'text/plain; charset=utf-8')
+  179: res.setHeader('Content-Type', 'text/plain; charset=utf-8')
+  200: res.setHeader('Content-Type', 'text/plain; charset=utf-8')
+  225: This is most used when you want to define arbitrary rendering of errors.
+  268: res.setHeader('Content-Type', 'text/plain; charset=utf-8')
+  285: res.setHeader('Content-Type', 'text/plain; charset=utf-8')
+  289: res.setHeader('Content-Type', 'text/plain; charset=utf-8')
+  298: You can get the message by running this command in your terminal,
+  330: res.setHeader('Content-Type', 'text/plain; charset=utf-8')
+  344: res.setHeader('Content-Type', 'text/plain; charset=utf-8')
+
+/home/runner/workspace/node_modules/depd/package.json
+  42: "test-ci": "istanbul cover --print=none node_modules/mocha/bin/_mocha -- --reporter spec test/ && istanbul report lcovonly text-summary",
+  43: "test-cov": "istanbul cover --print=none node_modules/mocha/bin/_mocha -- --reporter dot test/ && istanbul report lcov text-summary"
+
+/home/runner/workspace/node_modules/router/package.json
+  40: "test-ci": "nyc --reporter=lcov --reporter=text npm test",
+  41: "test-cov": "nyc --reporter=text npm test",
+
+/home/runner/workspace/node_modules/@types/node/zlib.d.ts
+  32: *     console.error('An error occurred:', err);
+  51: *     console.error('An error occurred:', err);
+  64: *     console.error('An error occurred:', err);
+  67: *   console.log(buffer.toString('base64'));
+  73: *     console.error('An error occurred:', err);
+  76: *   console.log(buffer.toString());
+  85: *   .then((buf) => console.log(buf.toString()))
+  87: *     console.error('An error occurred:', err);
+
+/home/runner/workspace/node_modules/debug/README.md
+  18: `debug` exposes a function; simply pass this function the name of your module, and it will return a decorated version of `console.error` for you to pass debug statements to. This will allow you to toggle the debug output for different parts of your module as well as the module as a whole.
+  128: 31](https://hacks.mozilla.org/2014/05/editable-box-model-multiple-selection-sublime-text-keys-much-more-firefox-developer-tools-episode-31/))
+  199: For example, if you wanted to add support for rendering a Buffer as hex with
+  244: In Chromium-based web browsers (e.g. Brave, Chrome, and Electron), the JavaScript console will—by default—only show messages logged by `debug` if the "Verbose" log level is _enabled_.
+  262: // set this namespace to log via console.log
+  263: log.log = console.log.bind(console); // don't forget to bind to console!
+  267: // set all output to go via console.info
+  269: debug.log = console.info.bind(console);
+  270: error('now goes to stdout via console.info');
+  271: log('still goes to stdout, but via console.info now');
+  295: console.log(1, debug.enabled('test'));
+  298: console.log(2, debug.enabled('test'));
+  301: console.log(3, debug.enabled('test'));
+  319: $ DEBUG=foo node -e 'var dbg = require("debug"); dbg.enable("bar"); console.log(dbg.enabled("foo"))'
+
+/home/runner/workspace/node_modules/@types/node/worker_threads.d.ts
+  56: import { Context } from "node:vm";
+  78: * port1.on('message', (message) => console.log('received', message));
+  127: * port1.on('message', (message) => console.log(message));
+  149: * port1.on('message', (message) => console.log(message));
+  154: * // This does not copy data, but renders `uint8Array` unusable:
+  346: *     console.log('received:', value);
+  527: *     console.log(event.data);
+  589: * console.log(typedArray1);
+  590: * console.log(typedArray2);
+  631: * Transfer a `MessagePort` to a different `vm` Context. The original `port` object is rendered unusable, and the returned `MessagePort` instance
+  634: * The returned `MessagePort` is an object in the target context and
+  636: * target context
+  644: * @param contextifiedSandbox A `contextified` object as returned by the `vm.createContext()` method.
+  646: function moveMessagePortToContext(port: MessagePort, contextifiedSandbox: Context): MessagePort;
+  656: * console.log(receiveMessageOnPort(port2));
+  658: * console.log(receiveMessageOnPort(port2));
+  689: *   console.log(getEnvironmentData('Hello'));  // Prints 'World!'.
+  697: * The `worker.setEnvironmentData()` API sets the content of `worker.getEnvironmentData()` in the current thread and all new `Worker` instances spawned from the current context.
+
+/home/runner/workspace/node_modules/router/index.js
+  712: res.setHeader('Content-Type', 'text/plain')
+
+/home/runner/workspace/node_modules/@types/node/wasi.d.ts
+  4: * **Full support for secure file system sandboxing may or may not be implemented in**
+  32: * To run the above example, create a new WebAssembly text format file named `demo.wat`:
+  34: * ```text
+  45: *     ;; Note the trailing newline which is required for the text to appear
+  89: * sandbox directory structure. The string keys of `preopens` are treated as
+  90: * directories within the sandbox. The corresponding values in `preopens` are
+
+/home/runner/workspace/node_modules/debug/src/index.js
+  2: * Detect Electron renderer / nwjs process, which is node, but we should
+  6: if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {
+
+/home/runner/workspace/node_modules/debug/src/common.js
+  284: console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+
+/home/runner/workspace/node_modules/debug/src/browser.js
+  18: console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+  119: if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
+  135: (typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
+  185: * Invokes `console.debug()` when available.
+  186: * No-op when `console.debug` is not a "function".
+  187: * If `console.debug` is not available, falls back
+  188: * to `console.log`.
+  192: exports.log = console.debug || console.log || (() => {});
+  249: // TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
+  250: // The Browser also has localStorage in the global context.
+
+/home/runner/workspace/node_modules/@types/node/vm.d.ts
+  3: * Machine contexts.
+  11: * A common use case is to run the code in a different V8 Context. This means
+  14: * One can provide the context by `contextifying` an
+  15: * object. The invoked code treats any property in the context like a
+  17: * code are reflected in the context object.
+  24: * const context = { x: 2 };
+  25: * vm.createContext(context); // Contextify the object.
+  28: * // `x` and `y` are global variables in the context.
+  29: * // Initially, x has the value 2 because that is the value of context.x.
+  30: * vm.runInContext(code, context);
+  32: * console.log(context.x); // 42
+  33: * console.log(context.y); // 17
+  35: * console.log(x); // 1; y is not defined.
+  41: interface Context extends NodeJS.Dict<any> {}
+  95: interface RunningScriptInNewContextOptions extends RunningScriptOptions {
+  97: * Human-readable name of the newly created context.
+  99: contextName?: CreateContextOptions["name"];
+  101: * Origin corresponding to the newly created context for display purposes. The origin should be formatted like a URL,
+  105: contextOrigin?: CreateContextOptions["origin"];
+  106: contextCodeGeneration?: CreateContextOptions["codeGeneration"];
+  110: microtaskMode?: CreateContextOptions["microtaskMode"];
+  116: interface RunningCodeInNewContextOptions extends RunningScriptInNewContextOptions {
+  131: * The sandbox/context in which the said function should be compiled in.
+  133: parsingContext?: Context | undefined;
+  135: * An array containing a collection of context extensions (objects wrapping the current scope) to be applied while compiling
+  137: contextExtensions?: Object[] | undefined;
+  139: interface CreateContextOptions {
+  141: * Human-readable name of the newly created context.
+  142: * @default 'VM Context i' Where i is an ascending numerical index of the created context.
+  146: * Corresponds to the newly created context for display purposes.
+  192: * executed in specific contexts.
+  198: * Runs the compiled code contained by the `vm.Script` object within the given `contextifiedObject` and returns the result. Running code does not have access
+  203: * The globals are contained in the `context` object.
+  208: * const context = {
+  215: * vm.createContext(context);
+  217: *   script.runInContext(context);
+  220: * console.log(context);
+  228: * @param contextifiedObject A `contextified` object as returned by the `vm.createContext()` method.
+  231: runInContext(contextifiedObject: Context, options?: RunningScriptOptions): any;
+  233: * This method is a shortcut to `script.runInContext(vm.createContext(options), options)`.
+  236: * 1. Creates a new context.
+  237: * 2. If `contextObject` is an object, contextifies it with the new context.
+  238: *    If  `contextObject` is undefined, creates a new object and contextifies it.
+  239: *    If `contextObject` is `vm.constants.DONT_CONTEXTIFY`, don't contextify anything.
+  240: * 3. Runs the compiled code contained by the `vm.Script` object within the created context. The code
+  245: * the code multiple times in different contexts. The globals are set on and
+  246: * contained within each individual `context`.
+  253: * const contexts = [{}, {}, {}];
+  254: * contexts.forEach((context) => {
+  255: *   script.runInNewContext(context);
+  258: * console.log(contexts);
+  261: * // This would throw if the context is created from a contextified object.
+  262: * // vm.constants.DONT_CONTEXTIFY allows creating contexts with ordinary
+  265: * const frozenContext = freezeScript.runInNewContext(vm.constants.DONT_CONTEXTIFY);
+  268: * @param contextObject Either `vm.constants.DONT_CONTEXTIFY` or an object that will be contextified.
+  269: * If `undefined`, an empty contextified object will be created for backwards compatibility.
+  272: runInNewContext(
+  273: contextObject?: Context | typeof constants.DONT_CONTEXTIFY,
+  274: options?: RunningScriptInNewContextOptions,
+  277: * Runs the compiled code contained by the `vm.Script` within the context of the
+  291: *   script.runInThisContext();
+  294: * console.log(globalVar);
+  301: runInThisContext(options?: RunningScriptOptions): any;
+  329: * script.runInThisContext();
+  359: * console.log(script.sourceMapURL);
+  367: * If the given `contextObject` is an object, the `vm.createContext()` method will
+  368: * [prepare that object](https://nodejs.org/docs/latest-v22.x/api/vm.html#what-does-it-mean-to-contextify-an-object)
+  369: * and return a reference to it so that it can be used in calls to {@link runInContext} or
+  370: * [`script.runInContext()`](https://nodejs.org/docs/latest-v22.x/api/vm.html#scriptrunincontextcontextifiedobject-options).
+  371: * Inside such scripts, the global object will be wrapped by the `contextObject`, retaining all of its
+  381: * const context = { globalVar: 1 };
+  382: * vm.createContext(context);
+  384: * vm.runInContext('globalVar *= 2;', context);
+  386: * console.log(context);
+  389: * console.log(global.globalVar);
+  393: * If `contextObject` is omitted (or passed explicitly as `undefined`), a new,
+  394: * empty contextified object will be returned.
+  396: * When the global object in the newly created context is contextified, it has some quirks
+  397: * compared to ordinary global objects. For example, it cannot be frozen. To create a context
+  398: * without the contextifying quirks, pass `vm.constants.DONT_CONTEXTIFY` as the `contextObject`
+  401: * The `vm.createContext()` method is primarily useful for creating a single
+  402: * context that can be used to run multiple scripts. For instance, if emulating a
+  403: * web browser, the method can be used to create a single context representing a
+  405: * context.
+  407: * The provided `name` and `origin` of the context are made visible through the
+  410: * @param contextObject Either `vm.constants.DONT_CONTEXTIFY` or an object that will be contextified.
+  411: * If `undefined`, an empty contextified object will be created for backwards compatibility.
+  412: * @return contextified object.
+  414: function createContext(
+  415: contextObject?: Context | typeof constants.DONT_CONTEXTIFY,
+  416: options?: CreateContextOptions,
+  417: ): Context;
+  419: * Returns `true` if the given `object` object has been contextified using {@link createContext},
+  420: * or if it's the global object of a context created using `vm.constants.DONT_CONTEXTIFY`.
+  423: function isContext(sandbox: Context): boolean;
+  425: * The `vm.runInContext()` method compiles `code`, runs it within the context of
+  426: * the `contextifiedObject`, then returns the result. Running code does not have
+  427: * access to the local scope. The `contextifiedObject` object _must_ have been
+  428: * previously `contextified` using the {@link createContext} method.
+  432: * The following example compiles and executes different scripts using a single `contextified` object:
+  437: * const contextObject = { globalVar: 1 };
+  438: * vm.createContext(contextObject);
+  441: *   vm.runInContext('globalVar *= 2;', contextObject);
+  443: * console.log(contextObject);
+  448: * @param contextifiedObject The `contextified` object that will be used as the `global` when the `code` is compiled and run.
+  451: function runInContext(code: string, contextifiedObject: Context, options?: RunningCodeOptions | string): any;
+  454: * `(new vm.Script(code, options)).runInContext(vm.createContext(options), options)`.
+  459: * 1. Creates a new context.
+  460: * 2. If `contextObject` is an object, contextifies it with the new context.
+  461: *    If  `contextObject` is undefined, creates a new object and contextifies it.
+  462: *    If `contextObject` is `vm.constants.DONT_CONTEXTIFY`, don't contextify anything.
+  464: * 4. Runs the compield code within the created context. The code does not have access to the scope in
+  469: * variable and sets a new one. These globals are contained in the `contextObject`.
+  474: * const contextObject = {
+  479: * vm.runInNewContext('count += 1; name = "kitty"', contextObject);
+  480: * console.log(contextObject);
+  483: * // This would throw if the context is created from a contextified object.
+  484: * // vm.constants.DONT_CONTEXTIFY allows creating contexts with ordinary global objects that
+  486: * const frozenContext = vm.runInNewContext('Object.freeze(globalThis); globalThis;', vm.constants.DONT_CONTEXTIFY);
+  490: * @param contextObject Either `vm.constants.DONT_CONTEXTIFY` or an object that will be contextified.
+  491: * If `undefined`, an empty contextified object will be created for backwards compatibility.
+  494: function runInNewContext(
+  496: contextObject?: Context | typeof constants.DONT_CONTEXTIFY,
+  497: options?: RunningCodeInNewContextOptions | string,
+  500: * `vm.runInThisContext()` compiles `code`, runs it within the context of the
+  506: * The following example illustrates using both `vm.runInThisContext()` and
+  513: * const vmResult = vm.runInThisContext('localVar = "vm";');
+  514: * console.log(`vmResult: '${vmResult}', localVar: '${localVar}'`);
+  518: * console.log(`evalResult: '${evalResult}', localVar: '${localVar}'`);
+  522: * Because `vm.runInThisContext()` does not have access to the local scope, `localVar` is unchanged. In contrast,
+  524: * local scope, so the value `localVar` is changed. In this way `vm.runInThisContext()` is much like an [indirect `eval()` call](https://es5.github.io/#x10.4.2), e.g.`(0,eval)('code')`.
+  528: * When using either `script.runInThisContext()` or {@link runInThisContext}, the code is executed within the current V8 global
+  529: * context. The code passed to this VM context will have its own isolated scope.
+  532: * to the context must either import `node:http` on its own, or have a
+  544: *     response.writeHead(200, { 'Content-Type': 'text/plain' });
+  548: *   console.log('Server running at http://127.0.0.1:8124/');
+  551: * vm.runInThisContext(code)(require);
+  554: * The `require()` in the above case shares the state with the context it is
+  556: * altering objects in the context in unwanted ways.
+  561: function runInThisContext(code: string, options?: RunningCodeOptions | string): any;
+  563: * Compiles the given code into the provided context (if no context is
+  564: * supplied, the current context is used), and returns it wrapped inside a
+  580: * Measure the memory known to V8 and used by all contexts known to the
+  581: * current V8 isolate, or the main context.
+  587: * memory reachable by each V8 specific contexts in the current instance of
+  593: * // Measure the memory used by the main context.
+  603: *     console.log(result);
+  606: * const context = vm.createContext({ a: 1 });
+  609: *     // Reference the context here so that it won't be GC'ed
+  611: *     console.log(context.a);
+  628: *     console.log(result);
+  652: * ECMAScript modules in VM contexts. It is the counterpart of the `vm.Script` class that closely mirrors [Module Record](https://262.ecma-international.org/14.0/#sec-abstract-module-records) s as
+  656: * Unlike `vm.Script` however, every `vm.Module` object is bound to a context from
+  672: * const contextifiedObject = vm.createContext({
+  674: *   print: console.log,
+  680: * // parses the provided source text, throwing a `SyntaxError` if anything goes
+  681: * // wrong. By default, a Module is created in the top context. But here, we
+  682: * // specify `contextifiedObject` as the context this Module belongs to.
+  691: * `, { context: contextifiedObject });
+  720: *       // "contextifiedObject" when creating the context.
+  722: *     `, { context: referencingModule.context });
+  724: *     // Using `contextifiedObject` instead of `referencingModule.context`
+  767: context: Context;
+  819: * * It must belong to the same context as the parent `Module`.
+  848: * @default 'vm:module(i)' where i is a context-specific ascending index.
+  852: context?: Context | undefined;
+  865: * The `vm.SourceTextModule` class provides the [Source Text Module Record](https://tc39.es/ecma262/#sec-source-text-module-records) as
+  880: * @default 'vm:module(i)' where i is a context-specific ascending index.
+  884: * The contextified object as returned by the `vm.createContext()` method, to compile and evaluate this module in.
+  886: context?: Context | undefined;
+  953: * context to load the requested module.
+  960: * This constant, when used as the `contextObject` argument in vm APIs, instructs Node.js to create
+  961: * a context without wrapping its global object with another object in a Node.js-specific manner.
+  962: * As a result, the `globalThis` value inside the new context would behave more closely to an ordinary
+  965: * When `vm.constants.DONT_CONTEXTIFY` is used as the `contextObject` argument to {@link createContext},
+  966: * the returned object is a proxy-like object to the global object in the newly created context with
+  967: * fewer Node.js-specific quirks. It is reference equal to the `globalThis` value in the new context,
+  968: * can be modified from outside the context, and can be used to access built-ins in the new context directly.
+
+/home/runner/workspace/node_modules/qs/README.md
+  662: To completely skip rendering keys with `null` values, use the `skipNulls` flag:
+
+/home/runner/workspace/node_modules/@types/node/v8.d.ts
+  30: number_of_native_contexts: number;
+  31: number_of_detached_contexts: number;
+  60: * console.log(v8.cachedDataVersionTag()); // 3947234607
+  65: * console.log(v8.cachedDataVersionTag()); // 183726201
+  78: * `number_of_native_contexts` The value of native\_context is the number of the
+  79: * top-level contexts currently active. Increase of this number over time indicates
+  82: * `number_of_detached_contexts` The value of detached\_context is the number
+  83: * of contexts that were detached and not yet garbage collected. This number
+  106: *   number_of_native_contexts: 1,
+  107: *   number_of_detached_contexts: 0,
+  187: * This is similar to the [`queryObjects()` console API](https://developer.chrome.com/docs/devtools/console/utilities#queryObjects-function)
+  188: * provided by the Chromium DevTools console. It can be used to search for objects that have the matching constructor on its prototype chain
+  198: * Only objects created in the current execution context are included in the results.
+  203: * console.log(queryObjects(A)); // 0
+  205: * console.log(queryObjects(A)); // 1
+  207: * console.log(queryObjects(A, { format: 'summary' }));
+  211: * console.log(queryObjects(B)); // 1
+  213: * console.log(queryObjects(B, { format: 'summary' }));
+  219: * console.log(queryObjects(A));  // 3
+  221: * console.log(queryObjects(A, { format: 'summary' }));
+  245: * // Print heap snapshot to the console
+  282: *     console.log(`worker heapdump: ${filename}`);
+  284: *     console.log(`main thread heapdump: ${writeHeapSnapshot()}`);
+  345: * Pass the corresponding `ArrayBuffer` in the deserializing context to `deserializer.transferArrayBuffer()`.
+  395: * Pass the corresponding `ArrayBuffer` in the serializing context to `serializer.transferArrayBuffer()` (or return the `id` from `serializer._getSharedArrayBufferId()` in the case of
+  557: *   console.log(profiler.stop());
+  788: *   console.log(shelf.storage.get(name));
+
+/home/runner/workspace/node_modules/qs/CHANGELOG.md
+  234: - [Fix] parses comma delimited array while having percent-encoded comma treated as normal text (#336)
+  287: - [Fix] parses comma delimited array while having percent-encoded comma treated as normal text (#336)
+  314: - [meta] Clean up license text so it’s properly detected as BSD-3-Clause
+  343: - [Fix] parses comma delimited array while having percent-encoded comma treated as normal text (#336)
+  356: - [meta] Clean up license text so it’s properly detected as BSD-3-Clause
+  409: - [meta] Clean up license text so it’s properly detected as BSD-3-Clause
+  460: - [Docs] Clean up license text so it’s properly detected as BSD-3-Clause
+  522: - [meta] Clean up license text so it’s properly detected as BSD-3-Clause
+  561: - [meta] Clean up license text so it’s properly detected as BSD-3-Clause
+  622: - [meta] Clean up license text so it’s properly detected as BSD-3-Clause
+
+/home/runner/workspace/node_modules/cookie/README.md
+  199: res.setHeader('Content-Type', 'text/html; charset=UTF-8');
+
+/home/runner/workspace/node_modules/@types/node/util.d.ts
+  64: * to be displayed on a new line. It will also add new lines to text that is
+  68: * text will be reduced below 16 characters, no matter the `breakLength` size.
+  109: stylize(text: string, styleType: Style): string;
+  183: * // when printed to a terminal.
+  205: *   console.log('Call Sites:');
+  207: *     console.log(`CallSite ${index + 1}:`);
+  208: *     console.log(`Function Name: ${callSite.functionName}`);
+  209: *     console.log(`Script Name: ${callSite.scriptName}`);
+  210: *     console.log(`Line Number: ${callSite.lineNumber}`);
+  211: *     console.log(`Column Number: ${callSite.column}`);
+  277: *   console.error(name);  // ENOENT
+  292: *   console.error(name);  // ENOENT
+  306: *   console.error(name);  // no such file or directory
+  371: *   console.log('Dependent resource was aborted.');
+  421: * console.log(inspect(obj));
+  433: * console.log(util.inspect(util, { showHidden: true, depth: null }));
+  449: * console.log(util.inspect(o, { compact: true, depth: 5, breakLength: 80 }));
+  461: * console.log(util.inspect(o, { compact: false, depth: 5, breakLength: 80 }));
+  484: * // Setting `breakLength` to e.g. 150 will print the "Lorem ipsum" text in a
+  502: * console.log(inspect(weakSet, { showHidden: true }));
+  518: * console.log(inspect(o1, { sorted: true }));
+  520: * console.log(inspect(o1, { sorted: (a, b) => b.localeCompare(a) }));
+  545: * console.log(inspect(thousand, { numericSeparator: true }));
+  547: * console.log(inspect(million, { numericSeparator: true }));
+  549: * console.log(inspect(bigNumber, { numericSeparator: true }));
+  551: * console.log(inspect(bigDecimal, { numericSeparator: true }));
+  690: * console.log(stream instanceof EventEmitter); // true
+  691: * console.log(MyStream.super_ === EventEmitter); // true
+  694: *   console.log(`Received data: "${data}"`);
+  713: *   console.log(`Received data: "${data}"`);
+  728: * environment variable, then the returned function operates similar to `console.error()`. If not, then the returned function is a no-op.
+  740: * ```console
+  759: * ```console
+  1057: * console.log(util.stripVTControlCharacters('\u001B[4mvalue\u001B[0m'));
+  1079: *   console.log(ret);
+  1085: * ```text
+  1217: *   console.log(`This directory is owned by ${stats.uid}`);
+  1250: * // naiveBar().then(a => console.log(a));
+  1252: * naiveBar.call(foo).then((a) => console.log(a)); // '42'
+  1255: * bindBar().then((a) => console.log(a)); // '42'
+  1368: * This function returns a formatted text considering the `format` passed.
+  1373: * console.log(errorMessage);
+  1376: * `util.inspect.colors` also provides text formats such as `italic`, and `underline` and you can combine both:
+  1379: * console.log(
+  1388: * console.log(
+  1389: *   util.styleText(['red', 'green'], 'text'), // green
+  1394: * @param format A text format or an Array of text formats defined in `util.inspect.colors`.
+  1395: * @param text The text to to be formatted.
+  1404: text: string,
+  1412: * console.log(decoder.decode(u8arr)); // Hello
+  1441: * internally and emitted after the next call to `textDecoder.decode()`.
+  1443: * If `textDecoder.fatal` is `true`, decoding errors that occur will result in a `TypeError` being thrown.
+  1486: * @param [input='an empty string'] The text to encode.
+  1499: * @param src The text to encode.
+  1508: * https://nodejs.org/api/globals.html#textdecoder
+  1518: * https://nodejs.org/api/globals.html#textencoder
+  1550: * console.log(values, positionals);
+  1776: * const myMIME = new MIMEType('text/javascript');
+  1777: * console.log(myMIME.type);
+  1778: * // Prints: text
+  1780: * console.log(myMIME.type);
+  1782: * console.log(String(myMIME));
+  1793: * const myMIME = new MIMEType('text/ecmascript');
+  1794: * console.log(myMIME.subtype);
+  1797: * console.log(myMIME.subtype);
+  1799: * console.log(String(myMIME));
+  1800: * // Prints: text/javascript
+  1811: * const myMIME = new MIMEType('text/javascript;key=value');
+  1812: * console.log(myMIME.essence);
+  1813: * // Prints: text/javascript
+  1815: * console.log(myMIME.essence);
+  1817: * console.log(String(myMIME));
+  1866: * const { params } = new MIMEType('text/plain;foo=0;bar=1');
+  1868: *   console.log(name);
+  1883: * const { params } = new MIMEType('text/plain;foo=0;bar=1');
+  1886: * console.log(params.toString());
+  2014: * Returns `true` if the value is any boxed primitive object, e.g. created
+  2212: * console.log(util.types.isNativeError(new Error()));  // true
+  2213: * console.log(util.types.isNativeError(new TypeError()));  // true
+  2214: * console.log(util.types.isNativeError(new RangeError()));  // true
+  2221: * console.log(util.types.isNativeError(new MyError()));  // true
+  2229: * const context = vm.createContext({});
+  2230: * const myError = vm.runInContext('new Error()', context);
+  2231: * console.log(util.types.isNativeError(myError)); // true
+  2232: * console.log(myError instanceof Error); // false
+  2241: * console.log(util.types.isNativeError(myError)); // false
+  2242: * console.log(myError instanceof Error); // true
+
+/home/runner/workspace/node_modules/cookie/package.json
+  40: "test-ci": "nyc --reporter=lcov --reporter=text npm test",
+  41: "test-cov": "nyc --reporter=html --reporter=text npm test",
+
+/home/runner/workspace/node_modules/@types/node/url.d.ts
+  263: * console.log(url.domainToASCII('español.com'));
+  265: * console.log(url.domainToASCII('中文.com'));
+  267: * console.log(url.domainToASCII('xn--iñvalid.com'));
+  282: * console.log(url.domainToUnicode('xn--espaol-zwa.com'));
+  284: * console.log(url.domainToUnicode('xn--fiq228c.com'));
+  286: * console.log(url.domainToUnicode('xn--iñvalid.com'));
+  344: * console.log(urlToHttpOptions(myURL));
+  414: * console.log(otherBlob.size);
+  463: * console.log(myURL.hash);
+  467: * console.log(myURL.href);
+  481: * console.log(myURL.host);
+  485: * console.log(myURL.href);
+  498: * console.log(myURL.hostname);
+  503: * console.log(myURL.href);
+  508: * console.log(myURL.href);
+  520: * console.log(myURL.href);
+  524: * console.log(myURL.href);
+  541: * console.log(myURL.origin);
+  547: * console.log(idnURL.origin);
+  550: * console.log(idnURL.hostname);
+  560: * console.log(myURL.password);
+  564: * console.log(myURL.href);
+  578: * console.log(myURL.pathname);
+  582: * console.log(myURL.href);
+  611: * console.log(myURL.port);
+  617: * console.log(myURL.port);
+  619: * console.log(myURL.href);
+  623: * console.log(myURL.port);
+  625: * console.log(myURL.href);
+  630: * console.log(myURL.port);
+  635: * console.log(myURL.port);
+  640: * console.log(myURL.port);
+  646: * console.log(myURL.port);
+  658: * console.log(myURL.port);
+  668: * console.log(myURL.protocol);
+  672: * console.log(myURL.href);
+  684: * console.log(myURL.search);
+  688: * console.log(myURL.href);
+  711: * console.log(myURL.search);  // prints ?foo=~bar
+  716: * console.log(myURL.search);  // prints ?foo=%7Ebar
+  725: * console.log(myURL.username);
+  729: * console.log(myURL.href);
+  754: * console.log(JSON.stringify(myURLs));
+  775: * console.log(myURL.searchParams.get('abc'));
+  779: * console.log(myURL.href);
+  784: * console.log(myURL.href);
+  792: * console.log(myURL.href);
+  794: * console.log(newSearchParams.toString());
+  799: * console.log(myURL.href);
+  802: * console.log(myURL.href);
+  840: *   console.log(name, value, myURL.searchParams === searchParams);
+  880: *   console.log(name);
+  898: * console.log(params.toString());
+  903: * console.log(params.toString());
+  923: * console.log(params.toString());
+
+/home/runner/workspace/node_modules/@types/node/tty.d.ts
+  9: * When Node.js detects that it is being run with a text terminal ("TTY")
+  12: * whether Node.js is being run within a TTY context is to check that the value of
+  15: * ```console
+  47: * This flag is always `false` when a process starts, even if the terminal is
+  57: * terminal is disabled, including echoing input
+  138: * Use this to determine what colors the terminal supports. Due to the nature of
+  139: * colors in terminals it is possible to either have false positives or false
+  141: * may lie about what terminal is used.
+  143: * terminal. This can be useful to check how specific environment settings behave.
+  154: * @param [env=process.env] An object containing the environment variables to check. This enables simulating the usage of a specific terminal.
+  175: * @param [env=process.env] An object containing the environment variables to check. This enables simulating the usage of a specific terminal.
+
+/home/runner/workspace/node_modules/@types/node/trace_events.d.ts
+  15: * * `node.console`: Enables capture of `console.time()` and `console.count()` output.
+  32: * * `node.vm.script`: Enables capture of trace data for the `node:vm` module's `runInNewContext()`, `runInContext()`, and `runInThisContext()` methods.
+  81: *   console.info('Received SIGINT.');
+  128: * console.log(trace_events.getEnabledCategories());
+  133: * console.log(trace_events.getEnabledCategories());
+  178: * Given the file `test.js` below, the command `node --trace-event-categories node.perf test.js` will print `'node.async_hooks,node.perf'` to the console.
+  189: * console.log(trace_events.getEnabledCategories());
+
+/home/runner/workspace/node_modules/content-type/package.json
+  38: "test-ci": "nyc --reporter=lcovonly --reporter=text npm test",
+  39: "test-cov": "nyc --reporter=html --reporter=text npm test",
+
+/home/runner/workspace/node_modules/content-type/index.js
+  18: * quoted-string = DQUOTE *( qdtext / quoted-pair ) DQUOTE
+  19: * qdtext        = HTAB / SP / %x21 / %x23-5B / %x5D-7E / obs-text
+  20: * obs-text      = %x80-FF
+  21: * quoted-pair   = "\" ( HTAB / SP / VCHAR / obs-text )
+  30: * quoted-pair = "\" ( HTAB / SP / VCHAR / obs-text )
+  31: * obs-text    = %x80-FF
+
+/home/runner/workspace/node_modules/@types/node/tls.d.ts
+  188: interface TLSSocketOptions extends SecureContextOptions, CommonConnectionOptions {
+  470: * @param context Optionally provide a context.
+  473: exportKeyingMaterial(length: number, label: string, context: Buffer): Buffer;
+  507: * An optional TLS context object from tls.createSecureContext()
+  509: secureContext?: SecureContext | undefined;
+  531: * invoke cb(null, ctx), where ctx is a SecureContext instance.
+  532: * (tls.createSecureContext(...) can be used to get a proper
+  533: * SecureContext.) If SNICallback wasn't provided the default callback
+  536: SNICallback?: ((servername: string, cb: (err: Error | null, ctx?: SecureContext) => void) => void) | undefined;
+  545: interface TlsOptions extends SecureContextOptions, CommonConnectionOptions, net.ServerOpts {
+  594: interface ConnectionOptions extends SecureContextOptions, CommonConnectionOptions {
+  632: * The `server.addContext()` method adds a secure context that will be used if
+  635: * When there are multiple matching contexts, the most recently added one is
+  639: * @param context An object containing any of the possible properties from the {@link createSecureContext} `options` arguments (e.g. `key`, `cert`, `ca`, etc), or a TLS context object created
+  640: * with {@link createSecureContext} itself.
+  642: addContext(hostname: string, context: SecureContextOptions): void;
+  652: * The `server.setSecureContext()` method replaces the secure context of an
+  655: * @param options An object containing any of the possible properties from the {@link createSecureContext} `options` arguments (e.g. `key`, `cert`, `ca`, etc).
+  657: setSecureContext(options: SecureContextOptions): void;
+  797: cleartext: TLSSocket;
+  800: interface SecureContextOptions {
+  962: sessionIdContext?: string | undefined;
+  975: interface SecureContext {
+  976: context: any;
+  1027: *   console.log('server connected',
+  1034: *   console.log('server bound');
+  1074: *   console.log('client connected',
+  1081: *   console.log(data);
+  1084: *   console.log('server ends connection');
+  1099: * the encrypted data and the other of which reads and writes the cleartext data.
+  1101: * stream and the cleartext one is used as a replacement for the initial encrypted
+  1104: * `tls.createSecurePair()` returns a `tls.SecurePair` object with `cleartext` and `encrypted` stream properties.
+  1106: * Using `cleartext` has the same API as {@link TLSSocket}.
+  1122: * where `secureSocket` has the same API as `pair.cleartext`.
+  1125: * @param context A secure context object as returned by `tls.createSecureContext()`
+  1131: context?: SecureContext,
+  1138: * to `true`, other APIs that create secure contexts leave it unset.
+  1141: * from `process.argv` as the default value of the `sessionIdContext` option, other
+  1142: * APIs that create secure contexts have no default value.
+  1144: * The `tls.createSecureContext()` method creates a `SecureContext` object. It is
+  1145: * usable as an argument to several `tls` APIs, such as `server.addContext()`,
+  1146: * but has no public methods. The {@link Server} constructor and the {@link createServer} method do not support the `secureContext` option.
+  1160: function createSecureContext(options?: SecureContextOptions): SecureContext;
+  1164: * the `ciphers` option of `{@link createSecureContext}`.
+  1173: * console.log(tls.getCiphers()); // ['aes128-gcm-sha256', 'aes128-sha', ...]
+  1180: * The default value is `'auto'`. See `{@link createSecureContext()}` for further
+  1186: * The default value of the `maxVersion` option of `{@link createSecureContext()}`.
+  1196: * The default value of the `minVersion` option of `{@link createSecureContext()}`.
+  1207: * The default value of the `ciphers` option of `{@link createSecureContext()}`.
+
+/home/runner/workspace/node_modules/qs/test/parse.js
+  593: t.test('parses comma delimited array while having percent-encoded comma treated as normal text', function (st) {
+
+/home/runner/workspace/node_modules/content-disposition/README.md
+  119: - [RFC 2616: Hypertext Transfer Protocol -- HTTP/1.1][rfc-2616]
+  120: - [RFC 5987: Character Set and Language Encoding for Hypertext Transfer Protocol (HTTP) Header Field Parameters][rfc-5987]
+  121: - [RFC 6266: Use of the Content-Disposition Header Field in the Hypertext Transfer Protocol (HTTP)][rfc-6266]
+
+/home/runner/workspace/node_modules/@types/node/test.d.ts
+  107: * The `TestContext` object passed to the `fn` argument can be used to perform
+  138: * @param fn The function under test. The first argument to this function is a {@link TestContext} object.
+  169: * @param fn The suite function declaring nested tests and suites. The first argument to this function is a {@link SuiteContext} object.
+  297: * The type of a function passed to {@link test}. The first argument to this function is a {@link TestContext} object.
+  300: type TestFn = (t: TestContext, done: (result?: any) => void) => void | Promise<void>;
+  302: * The type of a suite test function. The argument to this function is a {@link SuiteContext} object.
+  304: type SuiteFn = (s: SuiteContext) => void | Promise<void>;
+  360: * If truthy, the test context will only run tests that have the `only` option set
+  558: * An instance of `TestContext` is passed to each test function in order to
+  559: * interact with the test runner. However, the `TestContext` constructor is not
+  563: class TestContext {
+  565: * An object containing assertion methods bound to the test context.
+  569: * TestContext `assert` object, then the context parameter in the test's function signature **must be explicitly typed**
+  572: * import { test, type TestContext } from 'node:test';
+  574: * // The test function's context parameter must have a type annotation.
+  575: * test('example', (t: TestContext) => {
+  586: readonly assert: TestContextAssert;
+  589: * @param fn The hook function. The first argument to this function is a `TestContext` object.
+  594: before(fn?: TestContextHookFn, options?: HookOptions): void;
+  597: * @param fn The hook function. The first argument to this function is a `TestContext` object.
+  602: beforeEach(fn?: TestContextHookFn, options?: HookOptions): void;
+  605: * @param fn The hook function. The first argument to this function is a `TestContext` object.
+  610: after(fn?: TestContextHookFn, options?: HookOptions): void;
+  613: * @param fn The hook function. The first argument to this function is a `TestContext` object.
+  618: afterEach(fn?: TestContextHookFn, options?: HookOptions): void;
+  653: * To make sure assertions are tracked, the assert functions on `context.assert` must be used,
+  686: * If `shouldRunOnlyTests` is truthy, the test context will only run tests that
+  693: *   // The test context can be set to run subtests with the 'only' option.
+  751: * @param fn The function under test. This first argument to this function is a {@link TestContext} object.
+  761: interface TestContextAssert extends
+  814: * An instance of `SuiteContext` is passed to each suite function in order to
+  815: * interact with the test runner. However, the `SuiteContext` constructor is not
+  819: class SuiteContext {
+  848: * If truthy, and the test context is configured to run `only` tests, then this test will be
+  891: *   before(() => console.log('about to run some test'));
+  907: *   after(() => console.log('finished running tests'));
+  923: *   beforeEach(() => console.log('about to run a test'));
+  940: *   afterEach(() => console.log('finished running a test'));
+  952: * The hook function. The first argument is the context in which the hook is called.
+  955: type HookFn = (c: TestContext | SuiteContext, done: (result?: any) => void) => any;
+  957: * The hook function. The first argument is a `TestContext` object.
+  960: type TestContextHookFn = (t: TestContext, done: (result?: any) => void) => any;
+  1000: mock: MockFunctionContext<F>;
+  1033: * Each test also provides its own `MockTracker` instance via the test context's `mock` property.
+  1071: * @return The mocked function. The mocked function contains a special `mock` property, which is an instance of {@link MockFunctionContext}, and can be used for inspecting and changing the
+  1113: * @return The mocked method. The mocked method contains a special `mock` property, which is an instance of {@link MockFunctionContext}, and can be used for inspecting and changing the
+  1203: module(specifier: string, options?: MockModuleOptions): MockModuleContext;
+  1211: * After each test completes, this function is called on the test context's `MockTracker`. If the global `MockTracker` is used extensively, calling this
+  1265: * The `MockFunctionContext` class is used to inspect or manipulate the behavior of
+  1269: class MockFunctionContext<F extends Function> {
+  1368: class MockModuleContext {
+  1451: * test('sets the time of a date object', (context) => {
+  1453: *   context.mock.timers.enable({ apis: ['Date'], now: 100 });
+  1456: *   context.mock.timers.setTime(1000);
+  1457: *   context.mock.timers.tick(200);
+  1469: * the test context's `MockTracker`.
+  1493: * test('mocks setTimeout to be executed synchronously without having to actually wait for it', (context) => {
+  1494: *   const fn = context.mock.fn();
+  1496: *   context.mock.timers.enable({ apis: ['setTimeout'] });
+  1503: *   context.mock.timers.tick(9999);
+  1515: * test('mocks setTimeout to be executed synchronously without having to actually wait for it', (context) => {
+  1516: *   const fn = context.mock.fn();
+  1517: *   context.mock.timers.enable({ apis: ['setTimeout'] });
+  1522: *   context.mock.timers.tick(twoSeconds);
+  1523: *   context.mock.timers.tick(twoSeconds);
+  1524: *   context.mock.timers.tick(twoSeconds);
+  1537: * test('mocks setTimeout to be executed synchronously without having to actually wait for it', (context) => {
+  1538: *   const fn = context.mock.fn();
+  1540: *   context.mock.timers.enable({ apis: ['setTimeout', 'Date'] });
+  1547: *   context.mock.timers.tick(9999);
+  1566: * test('runAll functions following the given order', (context) => {
+  1567: *   context.mock.timers.enable({ apis: ['setTimeout', 'Date'] });
+  1578: *   context.mock.timers.runAll();
+  1586: * triggering timers in the context of timer mocking.
+  1639: SuiteContext,
+  1642: TestContext,
+  1875: * Present if `context.todo` is called.
+  1879: * Present if `context.skip` is called.
+  1935: * Present if `context.todo` is called.
+  1939: * Present if `context.skip` is called.
+  1971: * Present if `context.todo` is called.
+  1975: * Present if `context.skip` is called.
+
+/home/runner/workspace/node_modules/content-disposition/package.json
+  40: "test-ci": "c8 --reporter=lcovonly --reporter=text npm test",
+  41: "test-cov": "c8 --reporter=html --reporter=text npm test"
+
+/home/runner/workspace/node_modules/@types/node/string_decoder.d.ts
+  17: * console.log(decoder.write(cent)); // Prints: ¢
+  20: * console.log(decoder.write(euro)); // Prints: €
+  37: * console.log(decoder.end(Buffer.from([0xAC]))); // Prints: €
+
+/home/runner/workspace/node_modules/content-disposition/index.js
+  72: * quoted-string = ( <"> *(qdtext | quoted-pair ) <"> )
+  73: * qdtext        = <any TEXT except <">>
+
+/home/runner/workspace/node_modules/proxy-addr/package.json
+  44: "test-ci": "nyc --reporter=lcov --reporter=text npm test",
+  45: "test-cov": "nyc --reporter=html --reporter=text npm test"
+
+/home/runner/workspace/node_modules/@types/node/stream.d.ts
+  197: *   console.log('Stream is readable (new data received in buffer)');
+  200: *     console.log(`Read ${chunk.length} bytes of data...`);
+  206: *   console.log('Reached end of stream.');
+  266: *   console.log('Got %d characters of string data:', chunk.length);
+  281: *   console.log(`Received ${chunk.length} bytes of data.`);
+  283: *   console.log('There will be no additional data for 1 second.');
+  285: *     console.log('Now data will start flowing again.');
+  306: *     console.log('Reached the end, but did not read anything.');
+  348: *   console.log('Stop writing to file.txt.');
+  350: *   console.log('Manually close the file stream.');
+  850: *   console.log('Write completed, do more writes now.');
+  1324: *   console.log(value); // hello
+  1325: *   console.log(done); // false
+  1365: *     console.error('Stream failed.', err);
+  1367: *     console.log('Stream is done reading.');
+  1457: *       console.error('Pipeline failed.', err);
+  1459: *       console.log('Pipeline succeeded.');
+  1492: *       console.log(err); // No such file
+
+/home/runner/workspace/node_modules/opencode-ai/postinstall.mjs
+  92: console.log(`opencode binary symlinked: ${targetPath} -> ${sourcePath}`)
+  105: console.log("Windows detected: binary setup not needed (using packaged .exe)")
+  121: console.error("Failed to setup opencode binary:", error.message)
+  129: console.error("Postinstall script error:", error.message)
+
+/home/runner/workspace/node_modules/body-parser/README.md
+  37: * [Text body parser](#bodyparsertextoptions)
+  170: ### bodyParser.text([options])
+  183: The `text` function takes an optional `options` object that may contain any of
+  188: Specify the default character set for the text content if the charset is not
+  209: be an extension name (like `txt`), a mime type (like `text/plain`), or a mime
+  210: type with a wildcard (like `*/*` or `text/*`). If a function, the `type`
+  212: truthy value. Defaults to `text/plain`.
+  424: res.setHeader('Content-Type', 'text/plain')
+  479: app.use(bodyParser.text({ type: 'text/html' }))
+
+/home/runner/workspace/node_modules/@types/node/sqlite.d.ts
+  38: * console.log(query.all());
+  331: * The source SQL text of the prepared statement with parameter
+  413: * The source SQL text of the prepared statement. This property is a
+
+/home/runner/workspace/node_modules/body-parser/package.json
+  49: "test-ci": "nyc --reporter=lcovonly --reporter=text npm test",
+  50: "test-cov": "nyc --reporter=html --reporter=text npm test"
+
+/home/runner/workspace/node_modules/@types/node/sea.d.ts
+  23: * echo 'console.log(`Hello, ${process.argv[2]}!`);' > hello.js
+  40: * ```text
+  80: *    ```text
+  103: * ```console
+  108: * ```console
+
+/home/runner/workspace/node_modules/opencode-ai/bin/opencode
+  13: console.error(result.error.message)
+  120: const text = ((result.stdout || "") + (result.stderr || "")).toLowerCase()
+  121: if (text.includes("musl")) return true
+  171: console.error(
+
+/home/runner/workspace/node_modules/@types/node/repl.d.ts
+  13: import { Context } from "node:vm";
+  32: * If `true`, specifies that the output should be treated as a TTY terminal, and have
+  37: terminal?: boolean | undefined;
+  50: * @default `true` Always `false` in case `terminal` is falsy.
+  57: * @default the REPL instance's `terminal` value
+  62: * `global` as the context as opposed to creating a new separate context for the REPL
+  105: context: Context,
+  117: type REPLCommandAction = (this: REPLServer, text: string) => void;
+  120: * Help text to be displayed when `.help` is entered.
+  144: * The `vm.Context` provided to the `eval` function to be used for JavaScript
+  147: readonly context: Context;
+  213: * function will use the JavaScript `global` as the context as opposed to creating a new
+  214: * separate context for the REPL instance.
+  267: *     console.log(`Hello, ${name}!`);
+  272: *   console.log('Goodbye!');
+  279: * ```console
+  343: addListener(event: "reset", listener: (context: Context) => void): this;
+  353: emit(event: "reset", context: Context): boolean;
+  363: on(event: "reset", listener: (context: Context) => void): this;
+  373: once(event: "reset", listener: (context: Context) => void): this;
+  383: prependListener(event: "reset", listener: (context: Context) => void): this;
+  393: prependOnceListener(event: "reset", listener: (context: Context) => void): this;
+
+/home/runner/workspace/node_modules/@types/node/readline.d.ts
+  27: * console.log(`Thank you for your valuable feedback: ${answer}`);
+  55: readonly terminal: boolean;
+  75: *   console.log(
+  93: * as well as the column where the terminal caret will be rendered.
+  109: terminal?: boolean,
+  162: *   console.log(`Oh, so your favorite food is ${answer}`);
+  173: *   console.log(`Oh, so your favorite food is ${answer}`);
+  177: *   console.log('The food question timed out');
+  214: * a `TTY` text terminal. See `TTY keybindings` for a list of key
+  334: terminal?: boolean | undefined;
+  337: * This option makes sense only if `terminal` is set to `true` by the user or by an internal `output` check,
+  345: * This option makes sense only if `terminal` is set to `true` by the user or by an internal `output` check,
+  406: *   console.log(`Received: ${line}`);
+  410: * If `terminal` is `true` for this instance then the `output` stream will get
+  424: terminal?: boolean,
+  435: * This is automatically called by any readline instance on its `input` if the `input` is a terminal. Closing the `readline` instance does not stop
+  462: *       console.log('world!');
+  465: *       console.log(`Say what? I might have heard '${line.trim()}'`);
+  470: *   console.log('Have a great day!');
+  497: *     console.log(`Line from file: ${line}`);
+  516: *   console.log(`Line from file: ${line}`);
+  540: *     console.log('File processed.');
+  542: *     console.error(err);
+
+/home/runner/workspace/node_modules/once/README.md
+  71: console.log(msg)
+
+/home/runner/workspace/node_modules/body-parser/lib/types/text.js
+  13: var debug = require('debug')('body-parser:text')
+  21: module.exports = text
+  24: * Create a middleware to parse text bodies.
+  30: function text (options) {
+  31: const normalizedOptions = normalizeOptions(options, 'text/plain')
+  33: return function textParser (req, res, next) {
+
+/home/runner/workspace/node_modules/parse5-htmlparser2-tree-adapter/lib/index.js
+  9: text: 3,
+  125: type: 'text',
+  231: exports.insertText = function(parentNode, text) {
+  234: if (lastChild && lastChild.type === 'text') {
+  235: lastChild.data += text;
+  237: appendChild(parentNode, createTextNode(text));
+  241: exports.insertTextBefore = function(parentNode, text, referenceNode) {
+  244: if (prevNode && prevNode.type === 'text') {
+  245: prevNode.data += text;
+  247: insertBefore(parentNode, createTextNode(text), referenceNode);
+  300: exports.getTextNodeContent = function(textNode) {
+  301: return textNode.data;
+  322: return node.type === 'text';
+
+/home/runner/workspace/node_modules/@types/node/process.d.ts
+  18: "console": typeof import("console");
+  19: "node:console": typeof import("node:console");
+  377: *   console.log(`Benchmark took ${diff[0] * NS_PER_SEC + diff[1]} nanoseconds`);
+  400: *   console.log(`Benchmark took ${end - start} nanoseconds`);
+  499: involuntaryContextSwitches: number;
+  512: voluntaryContextSwitches: number;
+  532: * Additional text to include with the error.
+  620: *   console.log(`${index}: ${val}`);
+  632: * ```text
+  645: * ```console
+  710: * console.log(`Starting directory: ${cwd()}`);
+  713: *   console.log(`New directory: ${cwd()}`);
+  715: *   console.error(`chdir: ${err}`);
+  730: * console.log(`Current directory: ${cwd()}`);
+  805: *   console.warn(warning.name);    // 'Warning'
+  806: *   console.warn(warning.message); // 'Something happened!'
+  807: *   console.warn(warning.code);    // 'MY_WARNING'
+  808: *   console.warn(warning.stack);   // Stack trace
+  809: *   console.warn(warning.detail);  // 'This is some additional information'
+  880: * console.log(env.foo);
+  891: * console.log(env.test);
+  894: * console.log(env.test);
+  905: * console.log(env.TEST);
+  915: * console.log(env.test);
+  1048: * console.log('Before:', getActiveResourcesInfo());
+  1050: * console.log('After:', getActiveResourcesInfo());
+  1072: *   console.log(`Current gid: ${process.getgid()}`);
+  1091: *   console.log(`Current gid: ${process.getgid()}`);
+  1094: *     console.log(`New gid: ${process.getgid()}`);
+  1096: *     console.log(`Failed to set gid: ${err}`);
+  1116: *   console.log(`Current uid: ${process.getuid()}`);
+  1135: *   console.log(`Current uid: ${process.getuid()}`);
+  1138: *     console.log(`New uid: ${process.getuid()}`);
+  1140: *     console.log(`Failed to set uid: ${err}`);
+  1159: *   console.log(`Current uid: ${process.geteuid()}`);
+  1178: *   console.log(`Current uid: ${process.geteuid()}`);
+  1181: *     console.log(`New uid: ${process.geteuid()}`);
+  1183: *     console.log(`Failed to set uid: ${err}`);
+  1203: *   console.log(`Current gid: ${process.getegid()}`);
+  1222: *   console.log(`Current gid: ${process.getegid()}`);
+  1225: *     console.log(`New gid: ${process.getegid()}`);
+  1227: *     console.log(`Failed to set gid: ${err}`);
+  1248: *   console.log(process.getgroups()); // [ 16, 21, 297 ]
+  1270: *     console.log(process.getgroups()); // new groups
+  1272: *     console.log(`Failed to set groups: ${err}`);
+  1331: * console.log(`Version: ${version}`);
+  1348: * console.log(versions);
+  1353: * ```console
+  1437: *   console.log('Got SIGHUP signal.');
+  1441: *   console.log('Exiting.');
+  1476: * console.log(`This process is pid ${pid}`);
+  1488: * console.log(`The parent process is pid ${ppid}`);
+  1518: * console.log(`This processor architecture is ${arch}`);
+  1540: * console.log(`This platform is ${platform}`);
+  1599: * console.log(cpuUsage(startUsage));
+  1616: * console.log('start');
+  1618: *   console.log('nextTick callback');
+  1620: * console.log('scheduled');
+  1856: * console.log(resourceUsage());
+  1874: *     voluntaryContextSwitches: 79,
+  1875: *     involuntaryContextSwitches: 1
+
+/home/runner/workspace/node_modules/body-parser/index.js
+  13: * @property {Function} text Text parser
+  47: Object.defineProperty(exports, 'text', {
+  50: get: () => require('./lib/types/text')
+
+/home/runner/workspace/node_modules/on-finished/HISTORY.md
+  9: * Prevent loss of async hooks context
+
+/home/runner/workspace/node_modules/on-finished/package.json
+  36: "test-ci": "nyc --reporter=lcovonly --reporter=text npm test",
+  37: "test-cov": "nyc --reporter=html --reporter=text npm test"
+
+/home/runner/workspace/node_modules/@types/node/perf_hooks.d.ts
+  16: *   console.log(items.getEntries()[0].duration);
+  388: *   console.log('hello world');
+  394: *   console.log(list.getEntries()[0].duration);
+  430: *   console.log(perfObserverList.getEntries());
+  473: *   console.log(perfObserverList.getEntriesByName('meow'));
+  485: *   console.log(perfObserverList.getEntriesByName('nope')); // []
+  487: *   console.log(perfObserverList.getEntriesByName('test', 'mark'));
+  499: *   console.log(perfObserverList.getEntriesByName('test', 'measure')); // []
+  524: *   console.log(perfObserverList.getEntriesByType('mark'));
+  853: * console.log(h.min);
+  854: * console.log(h.max);
+  855: * console.log(h.mean);
+  856: * console.log(h.stddev);
+  857: * console.log(h.percentiles);
+  858: * console.log(h.percentile(50));
+  859: * console.log(h.percentile(99));
+
+/home/runner/workspace/node_modules/accepts/README.md
+  14: - Allows types as an array or arguments list, ie `(['text/html', 'application/json'])`
+  15: as well as `('text/html', 'application/json')`.
+  72: Return the first accepted type (and it is returned as the same text as what
+  107: res.setHeader('Content-Type', 'text/html')
+  111: // the fallback is text/plain, so no need to specify it above
+  112: res.setHeader('Content-Type', 'text/plain')
+  125: curl -I -H'Accept: text/html' http://localhost:3000/
+
+/home/runner/workspace/node_modules/@types/node/net.d.ts
+  172: *   console.log('socket timeout');
+  596: *     console.error('Address in use, retrying...');
+  643: *   console.log('opened server on', server.address());
+  780: * console.log(blockList.check('123.123.123.123'));  // Prints: true
+  781: * console.log(blockList.check('10.0.0.3'));  // Prints: true
+  782: * console.log(blockList.check('222.111.111.222'));  // Prints: false
+  785: * console.log(blockList.check('::ffff:7b7b:7b7b', 'ipv6')); // Prints: true
+  786: * console.log(blockList.check('::ffff:123.123.123.123', 'ipv6')); // Prints: true
+  819: * context of TCP, when a FIN packed is received, a FIN packed is sent
+  837: *   console.log('client connected');
+  839: *     console.log('client disconnected');
+  848: *   console.log('server bound');
+  862: *   console.log('server bound');
+
+/home/runner/workspace/node_modules/accepts/package.json
+  38: "test-ci": "nyc --reporter=lcov --reporter=text npm test",
+  39: "test-cov": "nyc --reporter=html --reporter=text npm test"
+
+/home/runner/workspace/node_modules/@types/node/module.d.ts
+  200: * with `vm.runInContext()` or `vm.compileFunction()`.
+  216: * console.log(strippedCode);
+  226: * console.log(strippedCode);
+  239: * console.log(strippedCode);
+  312: interface ResolveHookContext {
+  356: context: ResolveHookContext,
+  359: context?: Partial<ResolveHookContext>,
+  362: interface LoadHookContext {
+  395: context: LoadHookContext,
+  398: context?: Partial<LoadHookContext>,
+
+/home/runner/workspace/node_modules/accepts/index.js
+  48: * such as "json" or an array `["json", "html", "text/plain"]`. When a list
+  53: *     // Accept: text/html
+  57: *     // Accept: text/*, application/json
+  60: *     this.types('text/html');
+  61: *     // => "text/html"
+  62: *     this.types('json', 'text');
+  67: *     // Accept: text/*, application/json
+  72: *     // Accept: text/*;q=.5, application/json
+
+/home/runner/workspace/node_modules/express/Readme.md
+  44: console.log('Server is running on http://localhost:3000')
+
+/home/runner/workspace/node_modules/express/package.json
+  95: "test-ci": "nyc --exclude examples --exclude test --exclude benchmarks --reporter=lcovonly --reporter=text npm test",
+  96: "test-cov": "nyc --exclude examples --exclude test --exclude benchmarks --reporter=html --reporter=text npm test",
+
+/home/runner/workspace/node_modules/mime-types/README.md
+  64: mime.lookup('.md') // 'text/markdown'
+  65: mime.lookup('file.html') // 'text/html'
+  81: mime.contentType('markdown') // 'text/x-markdown; charset=utf-8'
+  83: mime.contentType('text/html') // 'text/html; charset=utf-8'
+  84: mime.contentType('text/html; charset=iso-8859-1') // 'text/html; charset=iso-8859-1'
+  103: mime.charset('text/markdown') // 'UTF-8'
+
+/home/runner/workspace/node_modules/@types/node/inspector.d.ts
+  249: * Id of an execution context.
+  251: type ExecutionContextId = number;
+  255: interface ExecutionContextDescription {
+  257: * Unique id of the execution context. It can be used to specify in which execution context script evaluation should be performed.
+  259: id: ExecutionContextId;
+  261: * Execution context origin.
+  265: * Human readable name describing given context.
+  282: * Exception text, which should be used together with exception object when available.
+  284: text: string;
+  310: * Identifier of the context where exception happened.
+  312: executionContextId?: ExecutionContextId | undefined;
+  396: * Specifies in which execution context to perform evaluation. If the parameter is omitted the evaluation will be performed in the context of the inspected page.
+  398: contextId?: ExecutionContextId | undefined;
+  437: * Identifier of the object to call function on. Either objectId or executionContextId should be specified.
+  466: * Specifies execution context which global object will be used to call function on. Either executionContextId or objectId should be specified.
+  468: executionContextId?: ExecutionContextId | undefined;
+  523: * Specifies in which execution context to perform script run. If the parameter is omitted the evaluation will be performed in the context of the inspected page.
+  525: executionContextId?: ExecutionContextId | undefined;
+  533: * Specifies in which execution context to perform script run. If the parameter is omitted the evaluation will be performed in the context of the inspected page.
+  535: executionContextId?: ExecutionContextId | undefined;
+  569: * Specifies in which execution context to lookup global scope variables.
+  571: executionContextId?: ExecutionContextId | undefined;
+  646: interface ExecutionContextCreatedEventDataType {
+  648: * A newly created execution context.
+  650: context: ExecutionContextDescription;
+  652: interface ExecutionContextDestroyedEventDataType {
+  654: * Id of the destroyed context
+  656: executionContextId: ExecutionContextId;
+  685: * Identifier of the context where the call was made.
+  687: executionContextId: ExecutionContextId;
+  697: * Console context descriptor for calls on non-default console context (not console.*): 'anonymous#unique-logger-id' for call on unnamed context, 'name#unique-logger-id' for call on named context.
+  700: context?: string | undefined;
+  1031: interface SetBlackboxPatternsParameterType {
+  1033: * Array of regexps that will be used to check script url for blackbox state.
+  1037: interface SetBlackboxedRangesParameterType {
+  1166: * Specifies script creation context.
+  1168: executionContextId: Runtime.ExecutionContextId;
+  1176: executionContextAuxData?: {} | undefined;
+  1230: * Specifies script creation context.
+  1232: executionContextId: Runtime.ExecutionContextId;
+  1240: executionContextAuxData?: {} | undefined;
+  1320: * Message text.
+  1322: text: string;
+  1499: * Location of console.profile().
+  1503: * Profile title passed as an argument to console.profile().
+  1510: * Location of console.profileEnd().
+  1515: * Profile title passed as an argument to console.profile().
+  1708: * Resource type as it was perceived by the rendering engine.
+  1853: *              (error, { result }) => console.log(result));
+  1906: * Enables reporting of execution contexts creation by means of <code>executionContextCreated</code> event. When the reporting gets enabled the event will be sent immediately for each existing execution context.
+  1910: * Disables reporting of execution contexts creation.
+  1914: * Discards collected exceptions and console API calls.
+  1928: * Runs script with given id in a given context.
+  2074: * Replace previous blackbox patterns with passed ones. Forces backend to skip stepping/pausing in scripts with url matching one of the patterns. VM will try to leave blackboxed script by performing 'step in' several times, finally resorting to 'step out' if unsuccessful.
+  2077: post(method: 'Debugger.setBlackboxPatterns', params?: Debugger.SetBlackboxPatternsParameterType, callback?: (err: Error | null) => void): void;
+  2078: post(method: 'Debugger.setBlackboxPatterns', callback?: (err: Error | null) => void): void;
+  2080: * Makes backend skip steps in the script in blackboxed ranges. VM will try leave blacklisted scripts by performing 'step in' several times, finally resorting to 'step out' if unsuccessful. Positions array contains positions where blackbox state is changed. First interval isn't blackboxed. Array should be sorted.
+  2083: post(method: 'Debugger.setBlackboxedRanges', params?: Debugger.SetBlackboxedRangesParameterType, callback?: (err: Error | null) => void): void;
+  2084: post(method: 'Debugger.setBlackboxedRanges', callback?: (err: Error | null) => void): void;
+  2086: * Enables console domain, sends the messages collected so far to the client by means of the <code>messageAdded</code> notification.
+  2090: * Disables console domain, prevents further console messages from being reported to the client.
+  2139: * Enables console to refer to the node with given id via $x (see Command Line API for more details $x functions).
+  2211: * Issued when new execution context is created.
+  2213: addListener(event: 'Runtime.executionContextCreated', listener: (message: InspectorNotification<Runtime.ExecutionContextCreatedEventDataType>) => void): this;
+  2215: * Issued when execution context is destroyed.
+  2217: addListener(event: 'Runtime.executionContextDestroyed', listener: (message: InspectorNotification<Runtime.ExecutionContextDestroyedEventDataType>) => void): this;
+  2219: * Issued when all executionContexts were cleared in browser
+  2221: addListener(event: 'Runtime.executionContextsCleared', listener: () => void): this;
+  2231: * Issued when console API was called.
+  2233: addListener(event: 'Runtime.consoleAPICalled', listener: (message: InspectorNotification<Runtime.ConsoleAPICalledEventDataType>) => void): this;
+  2259: * Issued when new console message is added.
+  2263: * Sent when new profile recording is started using console.profile() call.
+  2265: addListener(event: 'Profiler.consoleProfileStarted', listener: (message: InspectorNotification<Profiler.ConsoleProfileStartedEventDataType>) => void): this;
+  2266: addListener(event: 'Profiler.consoleProfileFinished', listener: (message: InspectorNotification<Profiler.ConsoleProfileFinishedEventDataType>) => void): this;
+  2311: * This event is fired instead of `Runtime.executionContextDestroyed` when
+  2324: emit(event: 'Runtime.executionContextCreated', message: InspectorNotification<Runtime.ExecutionContextCreatedEventDataType>): boolean;
+  2325: emit(event: 'Runtime.executionContextDestroyed', message: InspectorNotification<Runtime.ExecutionContextDestroyedEventDataType>): boolean;
+  2326: emit(event: 'Runtime.executionContextsCleared'): boolean;
+  2329: emit(event: 'Runtime.consoleAPICalled', message: InspectorNotification<Runtime.ConsoleAPICalledEventDataType>): boolean;
+  2337: emit(event: 'Profiler.consoleProfileStarted', message: InspectorNotification<Profiler.ConsoleProfileStartedEventDataType>): boolean;
+  2338: emit(event: 'Profiler.consoleProfileFinished', message: InspectorNotification<Profiler.ConsoleProfileFinishedEventDataType>): boolean;
+  2361: * Issued when new execution context is created.
+  2363: on(event: 'Runtime.executionContextCreated', listener: (message: InspectorNotification<Runtime.ExecutionContextCreatedEventDataType>) => void): this;
+  2365: * Issued when execution context is destroyed.
+  2367: on(event: 'Runtime.executionContextDestroyed', listener: (message: InspectorNotification<Runtime.ExecutionContextDestroyedEventDataType>) => void): this;
+  2369: * Issued when all executionContexts were cleared in browser
+  2371: on(event: 'Runtime.executionContextsCleared', listener: () => void): this;
+  2381: * Issued when console API was called.
+  2383: on(event: 'Runtime.consoleAPICalled', listener: (message: InspectorNotification<Runtime.ConsoleAPICalledEventDataType>) => void): this;
+  2409: * Issued when new console message is added.
+  2413: * Sent when new profile recording is started using console.profile() call.
+  2415: on(event: 'Profiler.consoleProfileStarted', listener: (message: InspectorNotification<Profiler.ConsoleProfileStartedEventDataType>) => void): this;
+  2416: on(event: 'Profiler.consoleProfileFinished', listener: (message: InspectorNotification<Profiler.ConsoleProfileFinishedEventDataType>) => void): this;
+  2461: * This event is fired instead of `Runtime.executionContextDestroyed` when
+  2478: * Issued when new execution context is created.
+  2480: once(event: 'Runtime.executionContextCreated', listener: (message: InspectorNotification<Runtime.ExecutionContextCreatedEventDataType>) => void): this;
+  2482: * Issued when execution context is destroyed.
+  2484: once(event: 'Runtime.executionContextDestroyed', listener: (message: InspectorNotification<Runtime.ExecutionContextDestroyedEventDataType>) => void): this;
+  2486: * Issued when all executionContexts were cleared in browser
+  2488: once(event: 'Runtime.executionContextsCleared', listener: () => void): this;
+  2498: * Issued when console API was called.
+  2500: once(event: 'Runtime.consoleAPICalled', listener: (message: InspectorNotification<Runtime.ConsoleAPICalledEventDataType>) => void): this;
+  2526: * Issued when new console message is added.
+  2530: * Sent when new profile recording is started using console.profile() call.
+  2532: once(event: 'Profiler.consoleProfileStarted', listener: (message: InspectorNotification<Profiler.ConsoleProfileStartedEventDataType>) => void): this;
+  2533: once(event: 'Profiler.consoleProfileFinished', listener: (message: InspectorNotification<Profiler.ConsoleProfileFinishedEventDataType>) => void): this;
+  2578: * This event is fired instead of `Runtime.executionContextDestroyed` when
+  2595: * Issued when new execution context is created.
+  2597: prependListener(event: 'Runtime.executionContextCreated', listener: (message: InspectorNotification<Runtime.ExecutionContextCreatedEventDataType>) => void): this;
+  2599: * Issued when execution context is destroyed.
+  2601: prependListener(event: 'Runtime.executionContextDestroyed', listener: (message: InspectorNotification<Runtime.ExecutionContextDestroyedEventDataType>) => void): this;
+  2603: * Issued when all executionContexts were cleared in browser
+  2605: prependListener(event: 'Runtime.executionContextsCleared', listener: () => void): this;
+  2615: * Issued when console API was called.
+  2617: prependListener(event: 'Runtime.consoleAPICalled', listener: (message: InspectorNotification<Runtime.ConsoleAPICalledEventDataType>) => void): this;
+  2643: * Issued when new console message is added.
+  2647: * Sent when new profile recording is started using console.profile() call.
+  2649: prependListener(event: 'Profiler.consoleProfileStarted', listener: (message: InspectorNotification<Profiler.ConsoleProfileStartedEventDataType>) => void): this;
+  2650: prependListener(event: 'Profiler.consoleProfileFinished', listener: (message: InspectorNotification<Profiler.ConsoleProfileFinishedEventDataType>) => void): this;
+  2695: * This event is fired instead of `Runtime.executionContextDestroyed` when
+  2712: * Issued when new execution context is created.
+  2714: prependOnceListener(event: 'Runtime.executionContextCreated', listener: (message: InspectorNotification<Runtime.ExecutionContextCreatedEventDataType>) => void): this;
+  2716: * Issued when execution context is destroyed.
+  2718: prependOnceListener(event: 'Runtime.executionContextDestroyed', listener: (message: InspectorNotification<Runtime.ExecutionContextDestroyedEventDataType>) => void): this;
+  2720: * Issued when all executionContexts were cleared in browser
+  2722: prependOnceListener(event: 'Runtime.executionContextsCleared', listener: () => void): this;
+  2732: * Issued when console API was called.
+  2734: prependOnceListener(event: 'Runtime.consoleAPICalled', listener: (message: InspectorNotification<Runtime.ConsoleAPICalledEventDataType>) => void): this;
+  2760: * Issued when new console message is added.
+  2764: * Sent when new profile recording is started using console.profile() call.
+  2766: prependOnceListener(event: 'Profiler.consoleProfileStarted', listener: (message: InspectorNotification<Profiler.ConsoleProfileStartedEventDataType>) => void): this;
+  2767: prependOnceListener(event: 'Profiler.consoleProfileFinished', listener: (message: InspectorNotification<Profiler.ConsoleProfileFinishedEventDataType>) => void): this;
+  2812: * This event is fired instead of `Runtime.executionContextDestroyed` when
+  2849: * ```console
+  2874: // These methods are exposed by the V8 inspector console API (inspector/v8-console.h).
+  2875: // The method signatures differ from those of the Node.js console, and are deliberately
+  2902: * An object to send messages to the remote inspector console.
+  2905: const console: InspectorConsole;
+  2969: console,
+  3022: *   console.log(result);
+  3024: *   console.error(error);
+  3071: * Enables reporting of execution contexts creation by means of <code>executionContextCreated</code> event. When the reporting gets enabled the event will be sent immediately for each existing execution context.
+  3075: * Disables reporting of execution contexts creation.
+  3079: * Discards collected exceptions and console API calls.
+  3091: * Runs script with given id in a given context.
+  3207: * Replace previous blackbox patterns with passed ones. Forces backend to skip stepping/pausing in scripts with url matching one of the patterns. VM will try to leave blackboxed script by performing 'step in' several times, finally resorting to 'step out' if unsuccessful.
+  3210: post(method: 'Debugger.setBlackboxPatterns', params?: Debugger.SetBlackboxPatternsParameterType): Promise<void>;
+  3212: * Makes backend skip steps in the script in blackboxed ranges. VM will try leave blacklisted scripts by performing 'step in' several times, finally resorting to 'step out' if unsuccessful. Positions array contains positions where blackbox state is changed. First interval isn't blackboxed. Array should be sorted.
+  3215: post(method: 'Debugger.setBlackboxedRanges', params?: Debugger.SetBlackboxedRangesParameterType): Promise<void>;
+  3217: * Enables console domain, sends the messages collected so far to the client by means of the <code>messageAdded</code> notification.
+  3221: * Disables console domain, prevents further console messages from being reported to the client.
+  3260: * Enables console to refer to the node with given id via $x (see Command Line API for more details $x functions).
+  3324: * Issued when new execution context is created.
+  3326: addListener(event: 'Runtime.executionContextCreated', listener: (message: InspectorNotification<Runtime.ExecutionContextCreatedEventDataType>) => void): this;
+  3328: * Issued when execution context is destroyed.
+  3330: addListener(event: 'Runtime.executionContextDestroyed', listener: (message: InspectorNotification<Runtime.ExecutionContextDestroyedEventDataType>) => void): this;
+  3332: * Issued when all executionContexts were cleared in browser
+  3334: addListener(event: 'Runtime.executionContextsCleared', listener: () => void): this;
+  3344: * Issued when console API was called.
+  3346: addListener(event: 'Runtime.consoleAPICalled', listener: (message: InspectorNotification<Runtime.ConsoleAPICalledEventDataType>) => void): this;
+  3372: * Issued when new console message is added.
+  3376: * Sent when new profile recording is started using console.profile() call.
+  3378: addListener(event: 'Profiler.consoleProfileStarted', listener: (message: InspectorNotification<Profiler.ConsoleProfileStartedEventDataType>) => void): this;
+  3379: addListener(event: 'Profiler.consoleProfileFinished', listener: (message: InspectorNotification<Profiler.ConsoleProfileFinishedEventDataType>) => void): this;
+  3424: * This event is fired instead of `Runtime.executionContextDestroyed` when
+  3437: emit(event: 'Runtime.executionContextCreated', message: InspectorNotification<Runtime.ExecutionContextCreatedEventDataType>): boolean;
+  3438: emit(event: 'Runtime.executionContextDestroyed', message: InspectorNotification<Runtime.ExecutionContextDestroyedEventDataType>): boolean;
+  3439: emit(event: 'Runtime.executionContextsCleared'): boolean;
+  3442: emit(event: 'Runtime.consoleAPICalled', message: InspectorNotification<Runtime.ConsoleAPICalledEventDataType>): boolean;
+  3450: emit(event: 'Profiler.consoleProfileStarted', message: InspectorNotification<Profiler.ConsoleProfileStartedEventDataType>): boolean;
+  3451: emit(event: 'Profiler.consoleProfileFinished', message: InspectorNotification<Profiler.ConsoleProfileFinishedEventDataType>): boolean;
+  3474: * Issued when new execution context is created.
+  3476: on(event: 'Runtime.executionContextCreated', listener: (message: InspectorNotification<Runtime.ExecutionContextCreatedEventDataType>) => void): this;
+  3478: * Issued when execution context is destroyed.
+  3480: on(event: 'Runtime.executionContextDestroyed', listener: (message: InspectorNotification<Runtime.ExecutionContextDestroyedEventDataType>) => void): this;
+  3482: * Issued when all executionContexts were cleared in browser
+  3484: on(event: 'Runtime.executionContextsCleared', listener: () => void): this;
+  3494: * Issued when console API was called.
+  3496: on(event: 'Runtime.consoleAPICalled', listener: (message: InspectorNotification<Runtime.ConsoleAPICalledEventDataType>) => void): this;
+  3522: * Issued when new console message is added.
+  3526: * Sent when new profile recording is started using console.profile() call.
+  3528: on(event: 'Profiler.consoleProfileStarted', listener: (message: InspectorNotification<Profiler.ConsoleProfileStartedEventDataType>) => void): this;
+  3529: on(event: 'Profiler.consoleProfileFinished', listener: (message: InspectorNotification<Profiler.ConsoleProfileFinishedEventDataType>) => void): this;
+  3574: * This event is fired instead of `Runtime.executionContextDestroyed` when
+  3591: * Issued when new execution context is created.
+  3593: once(event: 'Runtime.executionContextCreated', listener: (message: InspectorNotification<Runtime.ExecutionContextCreatedEventDataType>) => void): this;
+  3595: * Issued when execution context is destroyed.
+  3597: once(event: 'Runtime.executionContextDestroyed', listener: (message: InspectorNotification<Runtime.ExecutionContextDestroyedEventDataType>) => void): this;
+  3599: * Issued when all executionContexts were cleared in browser
+  3601: once(event: 'Runtime.executionContextsCleared', listener: () => void): this;
+  3611: * Issued when console API was called.
+  3613: once(event: 'Runtime.consoleAPICalled', listener: (message: InspectorNotification<Runtime.ConsoleAPICalledEventDataType>) => void): this;
+  3639: * Issued when new console message is added.
+  3643: * Sent when new profile recording is started using console.profile() call.
+  3645: once(event: 'Profiler.consoleProfileStarted', listener: (message: InspectorNotification<Profiler.ConsoleProfileStartedEventDataType>) => void): this;
+  3646: once(event: 'Profiler.consoleProfileFinished', listener: (message: InspectorNotification<Profiler.ConsoleProfileFinishedEventDataType>) => void): this;
+  3691: * This event is fired instead of `Runtime.executionContextDestroyed` when
+  3708: * Issued when new execution context is created.
+  3710: prependListener(event: 'Runtime.executionContextCreated', listener: (message: InspectorNotification<Runtime.ExecutionContextCreatedEventDataType>) => void): this;
+  3712: * Issued when execution context is destroyed.
+  3714: prependListener(event: 'Runtime.executionContextDestroyed', listener: (message: InspectorNotification<Runtime.ExecutionContextDestroyedEventDataType>) => void): this;
+  3716: * Issued when all executionContexts were cleared in browser
+  3718: prependListener(event: 'Runtime.executionContextsCleared', listener: () => void): this;
+  3728: * Issued when console API was called.
+  3730: prependListener(event: 'Runtime.consoleAPICalled', listener: (message: InspectorNotification<Runtime.ConsoleAPICalledEventDataType>) => void): this;
+  3756: * Issued when new console message is added.
+  3760: * Sent when new profile recording is started using console.profile() call.
+  3762: prependListener(event: 'Profiler.consoleProfileStarted', listener: (message: InspectorNotification<Profiler.ConsoleProfileStartedEventDataType>) => void): this;
+  3763: prependListener(event: 'Profiler.consoleProfileFinished', listener: (message: InspectorNotification<Profiler.ConsoleProfileFinishedEventDataType>) => void): this;
+  3808: * This event is fired instead of `Runtime.executionContextDestroyed` when
+  3825: * Issued when new execution context is created.
+  3827: prependOnceListener(event: 'Runtime.executionContextCreated', listener: (message: InspectorNotification<Runtime.ExecutionContextCreatedEventDataType>) => void): this;
+  3829: * Issued when execution context is destroyed.
+  3831: prependOnceListener(event: 'Runtime.executionContextDestroyed', listener: (message: InspectorNotification<Runtime.ExecutionContextDestroyedEventDataType>) => void): this;
+  3833: * Issued when all executionContexts were cleared in browser
+  3835: prependOnceListener(event: 'Runtime.executionContextsCleared', listener: () => void): this;
+  3845: * Issued when console API was called.
+  3847: prependOnceListener(event: 'Runtime.consoleAPICalled', listener: (message: InspectorNotification<Runtime.ConsoleAPICalledEventDataType>) => void): this;
+  3873: * Issued when new console message is added.
+  3877: * Sent when new profile recording is started using console.profile() call.
+  3879: prependOnceListener(event: 'Profiler.consoleProfileStarted', listener: (message: InspectorNotification<Profiler.ConsoleProfileStartedEventDataType>) => void): this;
+  3880: prependOnceListener(event: 'Profiler.consoleProfileFinished', listener: (message: InspectorNotification<Profiler.ConsoleProfileFinishedEventDataType>) => void): this;
+  3925: * This event is fired instead of `Runtime.executionContextDestroyed` when
+  3944: console,
+
+/home/runner/workspace/node_modules/mime-types/HISTORY.md
+  26: * rtf -> text/rtf is now application/rtf
+  27: * xml -> text/xml is now application/xml
+  65: - Add extension `.mvt` to `application/vnd.mapbox-vector-tile`
+  128: - Add `text/mdx` with extension `.mdx`
+  168: - Add UTF-8 as default charset for `text/turtle`
+  176: - Add `text/shex` with extension `.shex`
+  181: - Update `text/hjson` to registered `application/hjson`
+  192: - Add `text/x-org`
+  205: - Update extensions `.md` and `.markdown` to be `text/markdown`
+  412: * Set charset=utf-8 for `text/javascript`
+  417: * Add `text/jsx` type
+
+/home/runner/workspace/node_modules/@types/node/index.d.ts
+  45: /// <reference path="console.d.ts" />
+
+/home/runner/workspace/node_modules/mime-types/package.json
+  46: "test-ci": "nyc --reporter=lcov --reporter=text npm test",
+  47: "test-cov": "nyc --reporter=html --reporter=text npm test"
+
+/home/runner/workspace/node_modules/express/lib/view.js
+  133: View.prototype.render = function render(options, callback) {
+  136: debug('render "%s"', this.path);
+  138: // render, normalizing sync callbacks
+  153: return process.nextTick(function renderTick() {
+
+/home/runner/workspace/node_modules/mime-types/mimeScore.js
+  21: // prefer application/xml over text/xml
+  22: // prefer application/rtf over text/rtf
+
+/home/runner/workspace/node_modules/@types/node/https.d.ts
+  14: > = tls.SecureContextOptions & tls.TlsOptions & http.ServerOptions<Request, Response>;
+  17: & tls.SecureContextOptions
+  303: * @param options Accepts `options` from `createServer`, `createSecureContext` and `createServer`.
+  321: * `pfx`, `rejectUnauthorized`, `secureOptions`, `secureProtocol`, `servername`, `sessionIdContext`, `highWaterMark`.
+  340: *   console.log('statusCode:', res.statusCode);
+  341: *   console.log('headers:', res.headers);
+  349: *   console.error(e);
+  447: *       console.log('Subject Common Name:', cert.subject.CN);
+  448: *       console.log('  Certificate SHA256 fingerprint:', cert.fingerprint256);
+  451: *       console.log('  Public key ping-sha256:', sha256(cert.pubkey));
+  462: *   console.log('All OK. Server matched our pinned cert or public key');
+  463: *   console.log('statusCode:', res.statusCode);
+  465: *   console.log('headers:', res.headers['public-key-pins']);
+  471: *   console.error(e.message);
+  478: * ```text
+  516: *   console.log('statusCode:', res.statusCode);
+  517: *   console.log('headers:', res.headers);
+  524: *   console.error(e);
+
+/home/runner/workspace/node_modules/express/lib/utils.js
+  54: * Normalize the given `type`, for example "html" becomes "text/html".
+  68: * Normalize `types`, for example "html" becomes "text/html".
+
+/home/runner/workspace/node_modules/mime-types/index.js
+  25: var TEXT_TYPE_REGEXP = /^text\//i
+  64: // default text/* to utf-8
+
+/home/runner/workspace/node_modules/express/lib/response.js
+  290: this.set('Content-Type', 'text/javascript');
+  535: *      'text/plain': function(){
+  539: *      'text/html': function(){
+  552: *      text: function(){
+  658: *    res.set({ Accept: 'text/plain', 'X-API-Key': 'tobi' });
+  845: // Support text/{plain,html} by default
+  847: text: function(){
+  890: * automatically, otherwise a response of _200_ and _text/html_ is given.
+  895: *  - `filename`  filename of the view being rendered
+  900: res.render = function render(view, options, callback) {
+  922: // render
+  923: app.render(view, opts, done);
+
+/home/runner/workspace/node_modules/@types/node/http2.d.ts
+  453: *     'content-type': 'text/plain; charset=utf-8',
+  496: *     'content-type': 'text/plain; charset=utf-8',
+  550: *       console.error(err);
+  556: *                          { 'content-type': 'text/plain; charset=utf-8' },
+  575: *                          { 'content-type': 'text/plain; charset=utf-8' },
+  603: *                          { 'content-type': 'text/plain; charset=utf-8' },
+  781: *     console.log(`Ping acknowledged in ${duration} milliseconds`);
+  782: *     console.log(`With payload '${payload.toString()}'`);
+  944: *   console.log(headers[HTTP2_HEADER_STATUS]);
+  1579: * console.log(request.headers);
+  1632: * console.log(request.rawHeaders);
+  1685: * Accept: text/plain
+  1696: * ```console
+  1978: * response.setHeader('Content-Type', 'text/html; charset=utf-8');
+  1995: * // Returns content-type = text/plain
+  1997: *   res.setHeader('Content-Type', 'text/html; charset=utf-8');
+  1999: *   res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
+  2093: *   'Content-Type': 'text/plain; charset=utf-8',
+  2112: * // Returns content-type = text/plain
+  2114: *   res.setHeader('Content-Type', 'text/html; charset=utf-8');
+  2116: *   res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
+  2421: * console.log(packed.toString('base64'));
+  2452: *     'content-type': 'text/html; charset=utf-8',
+  2492: *     'content-type': 'text/html; charset=utf-8',
+
+/home/runner/workspace/node_modules/express/lib/request.js
+  48: *     // => "text/plain"
+  51: *     // => "text/plain"
+  94: * such as "json", a comma-delimited list such as "json, html, text/plain",
+  95: * an argument list such as `"json", "html", "text/plain"`,
+  96: * or an array `["json", "html", "text/plain"]`. When a list
+  101: *     // Accept: text/html
+  105: *     // Accept: text/*, application/json
+  108: *     req.accepts('text/html');
+  109: *     // => "text/html"
+  110: *     req.accepts('json, text');
+  115: *     // Accept: text/*, application/json
+  120: *     // Accept: text/*;q=.5, application/json
+  236: *      // With Content-Type: text/html; charset=utf-8
+  238: *      req.is('text/html');
+  239: *      req.is('text/*');
+
+/home/runner/workspace/node_modules/merge-descriptors/readme.md
+  26: console.log(animal.name);
+
+/home/runner/workspace/node_modules/express/lib/express.js
+  80: exports.text = bodyParser.text
+
+/home/runner/workspace/node_modules/express/lib/application.js
+  265: * file extension. For example if you try to render
+  270: * For engines that do not provide `.__express` out of the box,
+  275: *     app.engine('html', require('ejs').renderFile);
+  277: * In this case EJS provides a `.renderFile()` method with
+  508: * rendered template string.
+  512: *    app.render('email', { name: 'Tobi' }, function(err, html){
+  522: app.render = function render(name, options, callback) {
+  536: var renderOptions = { ...this.locals, ...opts._locals, ...opts };
+  539: if (renderOptions.cache == null) {
+  540: renderOptions.cache = this.enabled('view cache');
+  544: if (renderOptions.cache) {
+  568: if (renderOptions.cache) {
+  573: // render
+  574: tryRender(view, renderOptions, done);
+  609: * Log error using console.error.
+  617: if (this.get('env') !== 'test') console.error(err.stack || err.toString());
+  621: * Try rendering a view.
+  627: view.render(options, callback);
+
+/home/runner/workspace/node_modules/@types/node/http.d.ts
+  14: *   "content-type": "text/plain",
+  35: *   'content-type', 'text/plain',
+  615: * // Returns content-type = text/plain
+  617: *   const headers = new Headers({ 'Content-Type': 'text/html' });
+  619: *   res.writeHead(200, { 'Content-Type': 'text/plain' });
+  710: * message.writeHead(200, { 'Content-Type': 'text/plain',
+  811: * const earlyHintsCallback = () => console.log('early hints message sent');
+  839: *     'Content-Type': 'text/plain',
+  861: * // Returns content-type = text/plain
+  863: *   res.setHeader('Content-Type', 'text/html');
+  865: *   res.writeHead(200, { 'Content-Type': 'text/plain' });
+  1209: *       console.error(
+  1246: * console.log(request.headers);
+  1273: * console.log(request.headersDistinct);
+  1298: * console.log(request.rawHeaders);
+  1341: * Accept: text/plain
+  1352: * ```console
+  1643: *   console.log(`STATUS: ${res.statusCode}`);
+  1644: *   console.log(`HEADERS: ${JSON.stringify(res.headers)}`);
+  1647: *     console.log(`BODY: ${chunk}`);
+  1650: *     console.log('No more data in response.');
+  1655: *   console.error(`problem with request: ${e.message}`);
+  1826: *     console.error(error.message);
+  1838: *       console.log(parsedData);
+  1840: *       console.error(e.message);
+  1844: *   console.error(`Got error: ${e.message}`);
+  1879: *   console.error(err instanceof TypeError); // --> true
+  1880: *   console.error(err.code); // --> 'ERR_INVALID_HTTP_TOKEN'
+  1881: *   console.error(err.message); // --> 'Header name must be a valid HTTP token [""]'
+  1907: *   console.error(err instanceof TypeError); // --> true
+  1908: *   console.error(err.code === 'ERR_HTTP_INVALID_HEADER_VALUE'); // --> true
+  1909: *   console.error(err.message); // --> 'Invalid value "undefined" for header "x-my-header"'
+  1915: *   console.error(err instanceof TypeError); // --> true
+  1916: *   console.error(err.code === 'ERR_INVALID_CHAR'); // --> true
+  1917: *   console.error(err.message); // --> 'Invalid character in header content ["x-my-header"]'
+
+/home/runner/workspace/node_modules/@types/node/globals.d.ts
+  157: var console: Console;
+  243: * `localStorage` data is not stored per user or per request when used in the context
+  314: * to infer a name from the function's context.
+
+/home/runner/workspace/node_modules/http-errors/README.md
+  17: ```console
+  61: - `message` - the message of the error, defaulting to node's text for that status code.
+
+/home/runner/workspace/node_modules/http-errors/package.json
+  40: "test-ci": "nyc --reporter=lcov --reporter=text npm test",
+  41: "test-cov": "nyc --reporter=html --reporter=text npm test",
+
+/home/runner/workspace/node_modules/@types/node/fs.d.ts
+  82: * ```console
+  106: * ```console
+  160: * ```console
+  174: * ```console
+  268: *     console.log(dirent.name);
+  270: *   console.error(err);
+  540: *   console.log('Rename complete!');
+  573: *   console.log('path/file.txt was truncated');
+  782: *   console.log('The permissions for file "my_file.txt" have been changed!');
+  871: * ```text
+  886: *     console.log(stats.isDirectory());
+  887: *     console.log(stats);
+  894: * ```console
+  1536: *   console.log('path/file.txt was deleted');
+  1845: *   console.log(directory);
+  1865: *   console.log(directory);
+  1875: *   console.log(directory);
+  2609: *   console.log(data);
+  2865: *   console.log('The file has been saved!');
+  2970: *   console.log('The "data to append" was appended to file!');
+  3055: *   console.log('The "data to append" was appended to file!');
+  3111: * watchFile('message.text', (curr, prev) => {
+  3112: *   console.log(`the current mtime is: ${curr.mtime}`);
+  3113: *   console.log(`the previous mtime was: ${prev.mtime}`);
+  3162: * watchFile('message.text', (curr, prev) => {
+  3163: *   console.log(`the current mtime is: ${curr.mtime}`);
+  3164: *   console.log(`the previous mtime was: ${prev.mtime}`);
+  3307: *   console.log(e ? 'it exists' : 'no passwd!');
+  3328: *     console.error('myfile already exists');
+  3352: *       console.error('myfile already exists');
+  3388: *     console.error('myfile does not exist');
+  3401: *       console.error('myfile does not exist');
+  3450: *   console.log('The path exists.');
+  3490: * Constant for fs.open(). Flag indicating that if path identifies a terminal device,
+  3491: * opening the path shall not cause that terminal to become the controlling terminal for the process
+  3587: *   console.log(`${file} ${err ? 'does not exist' : 'exists'}`);
+  3592: *   console.log(`${file} ${err ? 'is not readable' : 'is readable'}`);
+  3597: *   console.log(`${file} ${err ? 'is not writable' : 'is writable'}`);
+  3602: *   console.log(`${file} ${err ? 'is not' : 'is'} readable and writable`);
+  3618: *     console.error('myfile already exists');
+  3644: *       console.error('myfile already exists');
+  3668: *       console.error('myfile does not exist');
+  3697: *       console.error('myfile does not exist');
+  3758: *   console.log('can read/write');
+  3760: *   console.error('no access!');
+  3933: *   console.log('source.txt was copied to destination.txt');
+  3976: * console.log('source.txt was copied to destination.txt');
+
+/home/runner/workspace/node_modules/fresh/package.json
+  43: "test-ci": "nyc --reporter=lcov --reporter=text npm test",
+  44: "test-cov": "nyc --reporter=html --reporter=text npm test"
+
+/home/runner/workspace/node_modules/parse5-htmlparser2-tree-adapter/node_modules/parse5/lib/extensions/location-info/parser-mixin.js
+  65: _bootstrap(document, fragmentContext) {
+  66: orig._bootstrap.call(this, document, fragmentContext);
+  183: //NOTE: store last foster parenting location, so we will be able to find inserted text
+  202: const textNodeIdx =
+  207: const textNode = siblings[textNodeIdx];
+  210: const tnLoc = this.treeAdapter.getNodeSourceCodeLocation(textNode);
+  214: this.treeAdapter.updateNodeSourceCodeLocation(textNode, { endLine, endCol, endOffset });
+  216: this.treeAdapter.setNodeSourceCodeLocation(textNode, token.location);
+
+/home/runner/workspace/node_modules/@types/node/events.d.ts
+  31: *   console.log('an event occurred!');
+  158: * console.log(value);
+  168: *   console.error('error happened', err);
+  182: *   .then(([err]) => console.log('ok', err.message))
+  183: *   .catch((err) => console.error('error', err.message));
+  201: *     console.log('event emitted!');
+  204: *       console.error('Waiting for the event was canceled!');
+  206: *       console.error('There was an error', error.message);
+  240: *   console.log(event); // prints ['bar'] [42]
+  271: *     console.log(event); // prints ['bar'] [42]
+  295: *   console.log(event); // prints ['bar'] [42]
+  298: * console.log('done'); // prints 'done'
+  322: * console.log(listenerCount(myEmitter, 'event'));
+  345: *   const listener = () => console.log('Events are fun');
+  347: *   console.log(getEventListeners(ee, 'foo')); // [ [Function: listener] ]
+  351: *   const listener = () => console.log('Events are fun');
+  353: *   console.log(getEventListeners(et, 'foo')); // [ [Function: listener] ]
+  374: *   console.log(getMaxListeners(ee)); // 10
+  376: *   console.log(getMaxListeners(ee)); // 11
+  380: *   console.log(getMaxListeners(et)); // 10
+  382: *   console.log(getMaxListeners(et)); // 11
+  527: * of `events.EventEmitterAsyncResource` will run within its `async context`.
+  537: * // 'foo' listeners will run in the EventEmitters async context.
+  546: * // context, however, run in the same async context as the emit().
+  606: *   console.log('someone connected!');
+  618: * myEE.on('foo', () => console.log('a'));
+  619: * myEE.prependListener('foo', () => console.log('b'));
+  636: *   console.log('Ah, we have our first user!');
+  648: * myEE.once('foo', () => console.log('a'));
+  649: * myEE.prependOnceListener('foo', () => console.log('b'));
+  665: *   console.log('someone connected!');
+  687: *   console.log('A');
+  692: *   console.log('B');
+  728: *   console.log('pong');
+  780: *   console.log('someone connected!');
+  782: * console.log(util.inspect(server.listeners('connection')));
+  795: * emitter.once('log', () => console.log('log once'));
+  802: * // Logs "log once" to the console and does not unbind the `once` event
+  805: * // Logs "log once" to the console and removes the listener
+  808: * emitter.on('log', () => console.log('log persistently'));
+  831: *   console.log('Helloooo! first listener');
+  835: *   console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
+  840: *   console.log(`event with parameters ${parameters} in third listener`);
+  843: * console.log(myEmitter.listeners('event'));
+  877: *   console.log('someone connected!');
+  893: *   console.log('Ah, we have our first user!');
+  917: * console.log(myEE.eventNames());
+
+/home/runner/workspace/node_modules/@types/node/domain.d.ts
+  12: * will be notified, rather than losing the context of the error in the `process.on('uncaughtException')` handler, or causing the program to
+  45: * Any time execution is going to switch to the context of a different chain of
+  50: * If there are multiple, nested domains bound to the current execution context, `exit()` will exit any domains nested within this domain.
+  58: * Run the supplied function in the context of the domain, implicitly
+  60: * created in that context. Optionally, arguments can be passed to
+  70: *   console.error('Caught error!', er);
+
+/home/runner/workspace/node_modules/@napi-rs/keyring/README.md
+  17: console.log('My password is ', password)
+
+/home/runner/workspace/node_modules/@types/node/dns.d.ts
+  15: *   console.log('address: %j family: IPv%s', address, family);
+  31: *   console.log(`addresses: ${JSON.stringify(addresses)}`);
+  38: *       console.log(`reverse for ${a}: ${JSON.stringify(hostnames)}`);
+  148: *   console.log('address: %j family: IPv%s', address, family));
+  154: *   console.log('addresses: %j', addresses));
+  204: *   console.log(hostname, service);
+  613: * Uses the DNS protocol to resolve text queries (`TXT` records) for the `hostname`. The `records` argument passed to the `callback` function is a
+  614: * two-dimensional array of the text records available for `hostname` (e.g.`[ ['v=spf1 ip4:0.0.0.0 ', '~all' ] ]`). Each sub-array contains TXT chunks of
+
+/home/runner/workspace/node_modules/parse5-htmlparser2-tree-adapter/node_modules/parse5/lib/extensions/error-reporting/parser-mixin.js
+  31: _bootstrap(document, fragmentContext) {
+  32: orig._bootstrap.call(this, document, fragmentContext);
+
+/home/runner/workspace/node_modules/@types/node/diagnostics_channel.d.ts
+  125: ContextType extends object = StoreType extends object ? StoreType : object,
+  127: nameOrChannels: string | TracingChannelCollection<StoreType, ContextType>,
+  128: ): TracingChannel<StoreType, ContextType>;
+  138: class Channel<StoreType = unknown, ContextType = StoreType> {
+  162: * message handlers synchronously so they will execute within the same context.
+  219: * When `channel.runStores(context, ...)` is called, the given context data
+  222: * The `transform` function may be omitted to set the given context data as the
+  223: * context directly.
+  239: * @param store The store to which to bind the context data
+  240: * @param transform Transform context data before setting the store context
+  242: bindStore(store: AsyncLocalStorage<StoreType>, transform?: (context: ContextType) => StoreType): void;
+  269: * applied to transform the message data before it becomes the context value for
+  270: * the store. The prior storage context is accessible from within the transform
+  271: * function in cases where context linking is required.
+  273: * The context applied to the store should be accessible in any async code which
+  275: * there are some situations in which `context loss` may occur.
+  295: * @param context Message to send to subscribers and bind to stores
+  296: * @param fn Handler to run within the entered storage context
+  302: interface TracingChannelSubscribers<ContextType extends object> {
+  303: start: (message: ContextType) => void;
+  305: message: ContextType & {
+  311: message: ContextType & {
+  317: message: ContextType & {
+  323: message: ContextType & {
+  328: interface TracingChannelCollection<StoreType = unknown, ContextType = StoreType> {
+  329: start: Channel<StoreType, ContextType>;
+  330: end: Channel<StoreType, ContextType>;
+  331: asyncStart: Channel<StoreType, ContextType>;
+  332: asyncEnd: Channel<StoreType, ContextType>;
+  333: error: Channel<StoreType, ContextType>;
+  344: class TracingChannel<StoreType = unknown, ContextType extends object = {}> implements TracingChannelCollection {
+  345: start: Channel<StoreType, ContextType>;
+  346: end: Channel<StoreType, ContextType>;
+  347: asyncStart: Channel<StoreType, ContextType>;
+  348: asyncEnd: Channel<StoreType, ContextType>;
+  349: error: Channel<StoreType, ContextType>;
+  382: subscribe(subscribers: TracingChannelSubscribers<ContextType>): void;
+  416: unsubscribe(subscribers: TracingChannelSubscribers<ContextType>): void;
+  419: * This will run the given function using `channel.runStores(context, ...)` on the `start` channel which ensures all
+  420: * events should have any bound stores set to match this trace context.
+  439: * @param context Shared object to correlate events through
+  446: context?: ContextType,
+  454: * returned promise rejects. This will run the given function using `channel.runStores(context, ...)` on the `start` channel which ensures all
+  455: * events should have any bound stores set to match this trace context.
+  474: * @param context Shared object to correlate trace events through
+  481: context?: ContextType,
+  489: * promise rejects. This will run the given function using `channel.runStores(context, ...)` on the `start` channel which ensures all
+  490: * events should have any bound stores set to match this trace context.
+  508: * The callback will also be run with `channel.runStores(context, ...)` which
+  509: * enables context loss recovery in some cases.
+  522: * // and stores that store data value on the trace context object
+  538: * @param context Shared object to correlate trace events through
+  546: context?: ContextType,
+
+/home/runner/workspace/node_modules/@types/node/dgram.d.ts
+  10: *   console.error(`server error:\n${err.stack}`);
+  15: *   console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`);
+  20: *   console.log(`server listening ${address.address}:${address.port}`);
+  79: *   console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`);
+  159: *   console.error(`server error:\n${err.stack}`);
+  164: *   console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`);
+  169: *   console.log(`server listening ${address.address}:${address.port}`);
+  469: * "Time to Live", in this context it specifies the number of IP hops that a
+  498: * in this context it specifies the number of IP hops that a packet is allowed to
+
+/home/runner/workspace/node_modules/@sourcegraph/amp/README.md
+  3: [Amp](https://ampcode.com) is the frontier coding agent for your terminal and editor.
+
+/home/runner/workspace/node_modules/@types/node/crypto.d.ts
+  13: * console.log(hash);
+  40: * console.log(challenge.toString('utf8'));
+  53: * console.log(publicKey);
+  67: * console.log(Certificate.verifySpkac(Buffer.from(spkac)));
+  224: *     console.log(`${hash.digest('hex')} ${filename}`);
+  269: *     console.log(`${hmac.digest('hex')} ${filename}`);
+  308: *     console.log(data.toString('hex'));
+  341: * console.log(hash.digest('hex'));
+  369: * console.log(hash.copy().digest('hex'));
+  372: * console.log(hash.copy().digest('hex'));
+  375: * console.log(hash.copy().digest('hex'));
+  433: *     console.log(data.toString('hex'));
+  468: * console.log(hmac.digest('hex'));
+  587: * console.log(keyObject.symmetricKeySize);
+  727: * added to ciphertext messages unencrypted. It may sound contradictory that
+  804: *     cipher.on('end', () => console.log(encrypted));
+  806: *     cipher.write('some clear text data');
+  875: *     let encrypted = cipher.update('some clear text data', 'utf8', 'hex');
+  877: *     console.log(encrypted);
+  934: plaintextLength: number;
+  943: plaintextLength: number;
+  952: plaintextLength: number;
+  961: plaintextLength: number;
+  988: * added to ciphertext messages unencrypted. It may sound contradictory that
+  1053: * // The IV is usually passed along with the ciphertext.
+  1066: *   console.log(decrypted);
+  1067: *   // Prints: some clear text data
+  1094: * // The IV is usually passed along with the ciphertext.
+  1118: * // The IV is usually passed along with the ciphertext.
+  1128: * console.log(decrypted);
+  1129: * // Prints: some clear text data
+  1182: plaintextLength: number;
+  1191: plaintextLength: number;
+  1200: plaintextLength: number;
+  1209: plaintextLength: number;
+  1236: *   console.log(key.export().toString('hex'));  // 46e..........620
+  1261: * console.log(key.export().toString('hex'));  // e89..........41e
+  1377: * console.log(verify.verify(publicKey, signature, 'hex'));
+  1402: * console.log(verify.verify(publicKey, signature));
+  1746: * console.log(aliceSecret === bobSecret);
+  1781: *   console.log(derivedKey.toString('hex'));  // '3745e48...08d59ae'
+  1822: * console.log(key.toString('hex'));  // '3745e48...08d59ae'
+  1851: *   console.log(`${buf.length} bytes of random data: ${buf.toString('hex')}`);
+  1866: * console.log(
+  1909: *   console.log(`Random number chosen from (0, 1, 2): ${n}`);
+  1920: * console.log(`Random number chosen from (0, 1, 2): ${n}`);
+  1930: * console.log(`The dice rolled: ${n}`);
+  1949: * console.log(randomFillSync(buf).toString('hex'));
+  1952: * console.log(buf.toString('hex'));
+  1956: * console.log(buf.toString('hex'));
+  1966: * console.log(Buffer.from(randomFillSync(a).buffer,
+  1970: * console.log(Buffer.from(randomFillSync(b).buffer,
+  1974: * console.log(Buffer.from(randomFillSync(c)).toString('hex'));
+  1997: *   console.log(buf.toString('hex'));
+  2002: *   console.log(buf.toString('hex'));
+  2008: *   console.log(buf.toString('hex'));
+  2017: * contains finite numbers only, they are not drawn from a uniform random
+  2027: *   console.log(Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength)
+  2034: *   console.log(Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength)
+  2041: *   console.log(Buffer.from(buf).toString('hex'));
+  2106: *   console.log(derivedKey.toString('hex'));  // '3745e48...08d59ae'
+  2111: *   console.log(derivedKey.toString('hex'));  // '3745e48...aa39b34'
+  2152: * console.log(key1.toString('hex'));  // '3745e48...08d59ae'
+  2155: * console.log(key2.toString('hex'));  // '3745e48...aa39b34'
+  2228: * console.log(getCiphers()); // ['aes-128-cbc', 'aes-128-ccm', ...]
+  2240: * console.log(getCurves()); // ['Oakley-EC2N-3', 'Oakley-EC2N-4', ...]
+  2264: * console.log(getHashes()); // ['DSA', 'DSA-SHA', 'DSA-SHA1', ...]
+  2337: * console.log(uncompressedKey === ecdh.getPublicKey('hex'));
+  3374: * console.log(crypto.hash('sha1', string));
+  3380: * console.log(crypto.hash('sha1', Buffer.from(base64, 'base64'), 'buffer'));
+  3461: *   console.log(Buffer.from(derivedKey).toString('hex'));  // '24156e2...5391653'
+  3496: * console.log(Buffer.from(derivedKey).toString('hex'));  // '24156e2...5391653'
+  3584: * console.log(x509.subject);
+  3645: * A textual representation of the certificate's authority information access
+  4020: context?: BufferSource;
+  4192: * the returned promise will be resolved with an `<ArrayBuffer>` containing the plaintext result.
+
+/home/runner/workspace/node_modules/math-intrinsics/package.json
+  37: "postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\""
+
+/home/runner/workspace/node_modules/@types/node/console.d.ts
+  2: * The `node:console` module provides a simple debugging console that is similar to
+  3: * the JavaScript console mechanism provided by web browsers.
+  7: * * A `Console` class with methods such as `console.log()`, `console.error()`, and `console.warn()` that can be used to write to any Node.js stream.
+  8: * * A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstdout) and
+  9: * [`process.stderr`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.
+  11: * _**Warning**_: The global console object's methods are neither consistently
+  16: * Example using the global `console`:
+  19: * console.log('hello world');
+  21: * console.log('hello %s', 'world');
+  23: * console.error(new Error('Whoops, something bad happened'));
+  27: * //     at Script.runInThisContext (node:vm:132:18)
+  28: * //     at Object.runInThisContext (node:vm:309:38)
+  35: * console.warn(`Danger ${name}! Danger!`);
+  44: * const myConsole = new console.Console(out, err);
+  57: * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/console.js)
+  59: declare module "console" {
+  60: import console = require("node:console");
+  61: export = console;
+  63: declare module "node:console" {
+  68: Console: console.ConsoleConstructor;
+  70: * `console.assert()` writes a message if `value` is [falsy](https://developer.mozilla.org/en-US/docs/Glossary/Falsy) or omitted. It only
+  78: * console.assert(true, 'does nothing');
+  80: * console.assert(false, 'Whoops %s work', 'didn\'t');
+  83: * console.assert();
+  92: * When `stdout` is a TTY, calling `console.clear()` will attempt to clear the
+  95: * The specific operation of `console.clear()` can vary across operating systems
+  96: * and terminal types. For most Linux operating systems, `console.clear()` operates similarly to the `clear` shell command. On Windows, `console.clear()` will clear only the output in the
+  97: * current terminal viewport for the Node.js
+  104: * number of times `console.count()` has been called with the given `label`.
+  107: * > console.count()
+  110: * > console.count('default')
+  113: * > console.count('abc')
+  116: * > console.count('xyz')
+  119: * > console.count('abc')
+  122: * > console.count()
+  135: * > console.count('abc');
+  138: * > console.countReset('abc');
+  140: * > console.count('abc');
+  150: * The `console.debug()` function is an alias for {@link log}.
+  161: * This method calls `console.log()` passing it the arguments received.
+  174: * console.error('error #%d', code);
+  176: * console.error('error', code);
+  206: * The `console.info()` function is an alias for {@link log}.
+  218: * console.log('count: %d', count);
+  220: * console.log('count:', count);
+  234: * console.table(Symbol());
+  237: * console.table(undefined);
+  240: * console.table([{ a: 1, b: 'Y' }, { a: 'Z', b: 2 }]);
+  248: * console.table([{ a: 1, b: 'Y' }, { a: 'Z', b: 2 }], ['a']);
+  264: * time is 3869ms, `console.timeEnd()` displays "3.869s".
+  274: * console.time('bunch-of-stuff');
+  276: * console.timeEnd('bunch-of-stuff');
+  288: * console.time('process');
+  290: * console.timeLog('process', value);
+  293: * console.timeEnd('process');
+  304: * console.trace('Show me');
+  322: * The `console.warn()` function is an alias for {@link error}.
+  328: * This method does not display anything unless used in the inspector. The `console.profile()`
+  333: * console.profile('MyLabel');
+  335: * console.profileEnd('MyLabel');
+  351: * This method does not display anything unless used in the inspector. The `console.timeStamp()`
+  358: * The `console` module provides a simple debugging console that is similar to the
+  359: * JavaScript console mechanism provided by web browsers.
+  363: * * A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
+  364: * * A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstdout) and
+  365: * [`process.stderr`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.
+  367: * _**Warning**_: The global console object's methods are neither consistently
+  372: * Example using the global `console`:
+  375: * console.log('hello world');
+  377: * console.log('hello %s', 'world');
+  379: * console.error(new Error('Whoops, something bad happened'));
+  383: * //     at Script.runInThisContext (node:vm:132:18)
+  384: * //     at Object.runInThisContext (node:vm:309:38)
+  391: * console.warn(`Danger ${name}! Danger!`);
+  400: * const myConsole = new console.Console(out, err);
+  413: * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/console.js)
+  415: namespace console {
+  449: var console: Console;
+  451: export = globalThis.console;
+
+/home/runner/workspace/node_modules/@types/node/cluster.d.ts
+  19: *   console.log(`Primary ${process.pid} is running`);
+  27: *     console.log(`worker ${worker.process.pid} died`);
+  37: *   console.log(`Worker ${process.pid} started`);
+  43: * ```console
+  112: * Hide the forked processes console window that would normally be created on Windows systems.
+  290: *   console.log(`Primary ${process.pid} is running`);
+  298: *     console.log('worker is dead:', worker.isDead());
+  302: *     console.log('worker is dead:', worker.isDead());
+  328: *     console.log('Oh, it was just voluntary – no need to worry');
+  475: *   console.log('I am primary');
+  479: *   console.log(`I am worker #${cluster.worker.id}`);
+
+/home/runner/workspace/node_modules/@types/node/child_process.d.ts
+  11: *   console.log(`stdout: ${data}`);
+  15: *   console.error(`stderr: ${data}`);
+  19: *   console.log(`child process exited with code ${code}`);
+  117: *   console.log(`Received chunk ${data}`);
+  208: * console.log(`Spawned child pid: ${grep.pid}`);
+  256: *   console.log(
+  292: *       console.log(process.pid, 'is alive')
+  327: *   console.log('PARENT got message:', m);
+  338: *   console.log('CHILD got message:', m);
+  721: *   console.log(`stdout: ${data}`);
+  725: *   console.error(`stderr: ${data}`);
+  729: *   console.log(`child process exited with code ${code}`);
+  745: *   console.error(`ps stderr: ${data}`);
+  750: *     console.log(`ps process exited with code ${code}`);
+  756: *   console.log(data.toString());
+  760: *   console.error(`grep stderr: ${data}`);
+  765: *     console.log(`grep process exited with code ${code}`);
+  777: *   console.error('Failed to start subprocess.');
+  941: *     console.error(`exec error: ${error}`);
+  944: *   console.log(`stdout: ${stdout}`);
+  945: *   console.error(`stderr: ${stderr}`);
+  969: *   console.log('stdout:', stdout);
+  970: *   console.error('stderr:', stderr);
+  983: *   console.error(error); // an AbortError
+  1108: *   console.log(stdout);
+  1131: *   console.log(stdout);
+  1148: *   console.error(error); // an AbortError
+  1382: *     console.log(`Hello from ${process.argv[2]}!`);
+
+/home/runner/workspace/node_modules/@types/node/buffer.d.ts
+  105: * console.log(newBuf.toString('ascii'));
+  179: *   console.log(bytes); // Outputs: Uint8Array(5) [ 104, 101, 108, 108, 111 ]
+  198: text(): Promise<string>;
+  288: * console.log(Buffer.isEncoding('utf8'));
+  291: * console.log(Buffer.isEncoding('hex'));
+  294: * console.log(Buffer.isEncoding('utf/8'));
+  297: * console.log(Buffer.isEncoding(''));
+  319: * console.log(`${str}: ${str.length} characters, ` +
+  347: * console.log(arr.sort(Buffer.compare));
+  378: * console.log(`${len} bytes: ${buf.toString('utf8', 0, len)}`);
+  385: * console.log(`${length} bytes: ${buffer.toString('utf8', 8, 10)}`);
+  417: * console.log(buf1.toString('utf8'));
+  419: * console.log(buf1.toString('utf8', 0, 5));
+  424: * console.log(buf2.toString('hex'));
+  426: * console.log(buf2.toString('utf8', 0, 3));
+  428: * console.log(buf2.toString(undefined, 0, 3));
+  450: * console.log(json);
+  459: * console.log(copy);
+  478: * console.log(buf1.equals(buf2));
+  480: * console.log(buf1.equals(buf3));
+  502: * console.log(buf1.compare(buf1));
+  504: * console.log(buf1.compare(buf2));
+  506: * console.log(buf1.compare(buf3));
+  508: * console.log(buf2.compare(buf1));
+  510: * console.log(buf2.compare(buf3));
+  512: * console.log([buf1, buf2, buf3].sort(Buffer.compare));
+  525: * console.log(buf1.compare(buf2, 5, 9, 0, 4));
+  527: * console.log(buf1.compare(buf2, 0, 6, 4));
+  529: * console.log(buf1.compare(buf2, 5, 6, 5));
+  572: * console.log(buf2.toString('ascii', 0, 25));
+  591: * console.log(buf.toString());
+  614: * console.log(buf);
+  635: * console.log(buf);
+  656: * console.log(buf);
+  680: * console.log(buf);
+  709: * console.log(buf);
+  737: * console.log(buf);
+  763: * console.log(buf);
+  784: * console.log(buf);
+  804: * console.log(buf.readBigUInt64BE(0));
+  826: * console.log(buf.readBigUInt64LE(0));
+  867: * console.log(buf.readUIntLE(0, 6).toString(16));
+  891: * console.log(buf.readUIntBE(0, 6).toString(16));
+  893: * console.log(buf.readUIntBE(1, 6).toString(16));
+  915: * console.log(buf.readIntLE(0, 6).toString(16));
+  932: * console.log(buf.readIntBE(0, 6).toString(16));
+  934: * console.log(buf.readIntBE(1, 6).toString(16));
+  936: * console.log(buf.readIntBE(1, 0).toString(16));
+  954: * console.log(buf.readUInt8(0));
+  956: * console.log(buf.readUInt8(1));
+  958: * console.log(buf.readUInt8(2));
+  980: * console.log(buf.readUInt16LE(0).toString(16));
+  982: * console.log(buf.readUInt16LE(1).toString(16));
+  984: * console.log(buf.readUInt16LE(2).toString(16));
+  1006: * console.log(buf.readUInt16BE(0).toString(16));
+  1008: * console.log(buf.readUInt16BE(1).toString(16));
+  1030: * console.log(buf.readUInt32LE(0).toString(16));
+  1032: * console.log(buf.readUInt32LE(1).toString(16));
+  1054: * console.log(buf.readUInt32BE(0).toString(16));
+  1076: * console.log(buf.readInt8(0));
+  1078: * console.log(buf.readInt8(1));
+  1080: * console.log(buf.readInt8(2));
+  1097: * console.log(buf.readInt16LE(0));
+  1099: * console.log(buf.readInt16LE(1));
+  1116: * console.log(buf.readInt16BE(0));
+  1133: * console.log(buf.readInt32LE(0));
+  1135: * console.log(buf.readInt32LE(1));
+  1152: * console.log(buf.readInt32BE(0));
+  1167: * console.log(buf.readFloatLE(0));
+  1169: * console.log(buf.readFloatLE(1));
+  1184: * console.log(buf.readFloatBE(0));
+  1199: * console.log(buf.readDoubleLE(0));
+  1201: * console.log(buf.readDoubleLE(1));
+  1216: * console.log(buf.readDoubleBE(0));
+  1233: * console.log(buf1);
+  1238: * console.log(buf1);
+  1254: * buf.swap16(); // Convert to big-endian UTF-16 text.
+  1269: * console.log(buf1);
+  1274: * console.log(buf1);
+  1295: * console.log(buf1);
+  1300: * console.log(buf1);
+  1329: * console.log(buf);
+  1357: * console.log(buf);
+  1385: * console.log(buf);
+  1412: * console.log(buf);
+  1439: * console.log(buf);
+  1468: * console.log(buf);
+  1490: * console.log(buf);
+  1512: * console.log(buf);
+  1534: * console.log(buf);
+  1556: * console.log(buf);
+  1576: * console.log(buf);
+  1596: * console.log(buf);
+  1616: * console.log(buf);
+  1636: * console.log(buf);
+  1656: * console.log(b.toString());
+  1662: * console.log(c.fill(''));
+  1678: * console.log(Buffer.allocUnsafe(5).fill('\u0222'));
+  1690: * console.log(buf.fill('a'));
+  1692: * console.log(buf.fill('aazz', 'hex'));
+  1694: * console.log(buf.fill('zz', 'hex'));
+  1719: * console.log(buf.indexOf('this'));
+  1721: * console.log(buf.indexOf('is'));
+  1723: * console.log(buf.indexOf(Buffer.from('a buffer')));
+  1725: * console.log(buf.indexOf(97));
+  1727: * console.log(buf.indexOf(Buffer.from('a buffer example')));
+  1729: * console.log(buf.indexOf(Buffer.from('a buffer example').slice(0, 8)));
+  1734: * console.log(utf16Buffer.indexOf('\u03a3', 0, 'utf16le'));
+  1736: * console.log(utf16Buffer.indexOf('\u03a3', -4, 'utf16le'));
+  1754: * console.log(b.indexOf(99.9));
+  1755: * console.log(b.indexOf(256 + 99));
+  1759: * console.log(b.indexOf('b', undefined));
+  1760: * console.log(b.indexOf('b', {}));
+  1761: * console.log(b.indexOf('b', null));
+  1762: * console.log(b.indexOf('b', []));
+  1783: * console.log(buf.lastIndexOf('this'));
+  1785: * console.log(buf.lastIndexOf('buffer'));
+  1787: * console.log(buf.lastIndexOf(Buffer.from('buffer')));
+  1789: * console.log(buf.lastIndexOf(97));
+  1791: * console.log(buf.lastIndexOf(Buffer.from('yolo')));
+  1793: * console.log(buf.lastIndexOf('buffer', 5));
+  1795: * console.log(buf.lastIndexOf('buffer', 4));
+  1800: * console.log(utf16Buffer.lastIndexOf('\u03a3', undefined, 'utf16le'));
+  1802: * console.log(utf16Buffer.lastIndexOf('\u03a3', -5, 'utf16le'));
+  1820: * console.log(b.lastIndexOf(99.9));
+  1821: * console.log(b.lastIndexOf(256 + 99));
+  1825: * console.log(b.lastIndexOf('b', undefined));
+  1826: * console.log(b.lastIndexOf('b', {}));
+  1830: * console.log(b.lastIndexOf('b', null));
+  1831: * console.log(b.lastIndexOf('b', []));
+  1850: * console.log(buf.includes('this'));
+  1852: * console.log(buf.includes('is'));
+  1854: * console.log(buf.includes(Buffer.from('a buffer')));
+  1856: * console.log(buf.includes(97));
+  1858: * console.log(buf.includes(Buffer.from('a buffer example')));
+  1860: * console.log(buf.includes(Buffer.from('a buffer example').slice(0, 8)));
+  1862: * console.log(buf.includes('this', 4));
+
+/home/runner/workspace/node_modules/parse5-htmlparser2-tree-adapter/node_modules/parse5/lib/tokenizer/index.js
+  134: //this functions if they will be situated in another module due to context switch.
+
+/home/runner/workspace/node_modules/@types/node/buffer.buffer.d.ts
+  80: * console.log(buf);
+  86: * console.log(buf);
+  99: * console.log(buf.length);
+  117: * console.log(arrA.buffer === arrB.buffer); // true
+  120: * console.log(buf);
+  145: * console.log(buf1.toString());
+  147: * console.log(buf2.toString());
+  149: * console.log(buf1.toString('latin1'));
+  191: * console.log(totalLength);
+  196: * console.log(bufA);
+  198: * console.log(bufA.length);
+  215: * console.log(buf.length); // 2
+  216: * console.log(buf[0]); // 255
+  217: * console.log(buf[1]); // 255
+  233: * console.log(buf);
+  246: * console.log(buf);
+  258: * console.log(buf);
+  284: * console.log(buf);
+  289: * console.log(buf);
+  372: * console.log(copiedBuf.toString());
+  375: * console.log(buf.toString());
+  381: * console.log(notReallyCopiedBuf.toString());
+  383: * console.log(buf.toString());
+  418: * console.log(buf2.toString('ascii', 0, buf2.length));
+  423: * console.log(buf2.toString('ascii', 0, buf2.length));
+  435: * console.log(buf.subarray(-6, -1).toString());
+  439: * console.log(buf.subarray(-6, -2).toString());
+  443: * console.log(buf.subarray(-5, -2).toString());
+
+/home/runner/workspace/node_modules/@types/node/async_hooks.d.ts
+  5: * * [`AsyncLocalStorage`](https://nodejs.org/docs/latest-v22.x/api/async_context.html#class-asynclocalstorage) tracks async context
+  23: * console.log(executionAsyncId());  // 1 - bootstrap
+  26: *   console.log(executionAsyncId());  // 6 - open()
+  46: * Promise contexts may not get precise `executionAsyncIds` by default.
+  49: * @return The `asyncId` of the current execution context. Useful to track when something calls.
+  57: * Using `executionAsyncResource()` in the top-level execution context will
+  65: * console.log(executionAsyncId(), executionAsyncResource());  // 1 {}
+  67: *   console.log(executionAsyncId(), executionAsyncResource());  // 7 FSReqWrap
+  119: * Promise contexts may not get valid `triggerAsyncId`s by default. See
+  129: * @param triggerAsyncId The unique ID of the async resource in whose execution context this async resource was created
+  213: * The ID of the execution context that created this async event.
+  245: * // Run a function in the execution context of the resource. This will
+  246: * // * establish the context of the resource
+  250: * // * restore the original execution context
+  269: * @param triggerAsyncId The ID of the execution context that created
+  275: * Binds the given function to the current execution context.
+  277: * @param fn The function to bind to the