pokeedex 0.1.0

data/node_modules/playwright/lib/runner/projectUtils.js

@@ -0,0 +1,203 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildDependentProjects = buildDependentProjects;
+exports.buildProjectsClosure = buildProjectsClosure;
+exports.buildTeardownToSetupsMap = buildTeardownToSetupsMap;
+exports.collectFilesForProject = collectFilesForProject;
+exports.filterProjects = filterProjects;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _utils = require("playwright-core/lib/utils");
+var _utilsBundle = require("playwright-core/lib/utilsBundle");
+var _util = require("util");
+var _util2 = require("../util");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Copyright Microsoft Corporation. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const readFileAsync = (0, _util.promisify)(_fs.default.readFile);
+const readDirAsync = (0, _util.promisify)(_fs.default.readdir);
+function wildcardPatternToRegExp(pattern) {
+  return new RegExp('^' + pattern.split('*').map(_utils.escapeRegExp).join('.*') + '$', 'ig');
+}
+function filterProjects(projects, projectNames) {
+  if (!projectNames) return [...projects];
+  const projectNamesToFind = new Set();
+  const unmatchedProjectNames = new Map();
+  const patterns = new Set();
+  for (const name of projectNames) {
+    const lowerCaseName = name.toLocaleLowerCase();
+    if (lowerCaseName.includes('*')) {
+      patterns.add(wildcardPatternToRegExp(lowerCaseName));
+    } else {
+      projectNamesToFind.add(lowerCaseName);
+      unmatchedProjectNames.set(lowerCaseName, name);
+    }
+  }
+  const result = projects.filter(project => {
+    const lowerCaseName = project.project.name.toLocaleLowerCase();
+    if (projectNamesToFind.has(lowerCaseName)) {
+      unmatchedProjectNames.delete(lowerCaseName);
+      return true;
+    }
+    for (const regex of patterns) {
+      regex.lastIndex = 0;
+      if (regex.test(lowerCaseName)) return true;
+    }
+    return false;
+  });
+  if (unmatchedProjectNames.size) {
+    const unknownProjectNames = Array.from(unmatchedProjectNames.values()).map(n => `"${n}"`).join(', ');
+    throw new Error(`Project(s) ${unknownProjectNames} not found. Available projects: ${projects.map(p => `"${p.project.name}"`).join(', ')}`);
+  }
+  if (!result.length) {
+    const allProjects = projects.map(p => `"${p.project.name}"`).join(', ');
+    throw new Error(`No projects matched. Available projects: ${allProjects}`);
+  }
+  return result;
+}
+function buildTeardownToSetupsMap(projects) {
+  const result = new Map();
+  for (const project of projects) {
+    if (project.teardown) {
+      const setups = result.get(project.teardown) || [];
+      setups.push(project);
+      result.set(project.teardown, setups);
+    }
+  }
+  return result;
+}
+function buildProjectsClosure(projects, hasTests) {
+  const result = new Map();
+  const visit = (depth, project) => {
+    if (depth > 100) {
+      const error = new Error('Circular dependency detected between projects.');
+      error.stack = '';
+      throw error;
+    }
+    if (depth === 0 && hasTests && !hasTests(project)) return;
+    if (result.get(project) !== 'dependency') result.set(project, depth ? 'dependency' : 'top-level');
+    for (const dep of project.deps) visit(depth + 1, dep);
+    if (project.teardown) visit(depth + 1, project.teardown);
+  };
+  for (const p of projects) visit(0, p);
+  return result;
+}
+function buildDependentProjects(forProjects, projects) {
+  const reverseDeps = new Map(projects.map(p => [p, []]));
+  for (const project of projects) {
+    for (const dep of project.deps) reverseDeps.get(dep).push(project);
+  }
+  const result = new Set();
+  const visit = (depth, project) => {
+    if (depth > 100) {
+      const error = new Error('Circular dependency detected between projects.');
+      error.stack = '';
+      throw error;
+    }
+    result.add(project);
+    for (const reverseDep of reverseDeps.get(project)) visit(depth + 1, reverseDep);
+    if (project.teardown) visit(depth + 1, project.teardown);
+  };
+  for (const forProject of forProjects) visit(0, forProject);
+  return result;
+}
+async function collectFilesForProject(project, fsCache = new Map()) {
+  const extensions = new Set(['.js', '.ts', '.mjs', '.mts', '.cjs', '.cts', '.jsx', '.tsx', '.mjsx', '.mtsx', '.cjsx', '.ctsx']);
+  const testFileExtension = file => extensions.has(_path.default.extname(file));
+  const allFiles = await cachedCollectFiles(project.project.testDir, project.respectGitIgnore, fsCache);
+  const testMatch = (0, _util2.createFileMatcher)(project.project.testMatch);
+  const testIgnore = (0, _util2.createFileMatcher)(project.project.testIgnore);
+  const testFiles = allFiles.filter(file => {
+    if (!testFileExtension(file)) return false;
+    const isTest = !testIgnore(file) && testMatch(file);
+    if (!isTest) return false;
+    return true;
+  });
+  return testFiles;
+}
+async function cachedCollectFiles(testDir, respectGitIgnore, fsCache) {
+  const key = testDir + ':' + respectGitIgnore;
+  let result = fsCache.get(key);
+  if (!result) {
+    result = await collectFiles(testDir, respectGitIgnore);
+    fsCache.set(key, result);
+  }
+  return result;
+}
+async function collectFiles(testDir, respectGitIgnore) {
+  if (!_fs.default.existsSync(testDir)) return [];
+  if (!_fs.default.statSync(testDir).isDirectory()) return [];
+  const checkIgnores = (entryPath, rules, isDirectory, parentStatus) => {
+    let status = parentStatus;
+    for (const rule of rules) {
+      const ruleIncludes = rule.negate;
+      if (status === 'included' === ruleIncludes) continue;
+      const relative = _path.default.relative(rule.dir, entryPath);
+      if (rule.match('/' + relative) || rule.match(relative)) {
+        // Matches "/dir/file" or "dir/file"
+        status = ruleIncludes ? 'included' : 'ignored';
+      } else if (isDirectory && (rule.match('/' + relative + '/') || rule.match(relative + '/'))) {
+        // Matches "/dir/subdir/" or "dir/subdir/" for directories.
+        status = ruleIncludes ? 'included' : 'ignored';
+      } else if (isDirectory && ruleIncludes && (rule.match('/' + relative, true) || rule.match(relative, true))) {
+        // Matches "/dir/donotskip/" when "/dir" is excluded, but "!/dir/donotskip/file" is included.
+        status = 'ignored-but-recurse';
+      }
+    }
+    return status;
+  };
+  const files = [];
+  const visit = async (dir, rules, status) => {
+    const entries = await readDirAsync(dir, {
+      withFileTypes: true
+    });
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    if (respectGitIgnore) {
+      const gitignore = entries.find(e => e.isFile() && e.name === '.gitignore');
+      if (gitignore) {
+        const content = await readFileAsync(_path.default.join(dir, gitignore.name), 'utf8');
+        const newRules = content.split(/\r?\n/).map(s => {
+          s = s.trim();
+          if (!s) return;
+          // Use flipNegate, because we handle negation ourselves.
+          const rule = new _utilsBundle.minimatch.Minimatch(s, {
+            matchBase: true,
+            dot: true,
+            flipNegate: true
+          });
+          if (rule.comment) return;
+          rule.dir = dir;
+          return rule;
+        }).filter(rule => !!rule);
+        rules = [...rules, ...newRules];
+      }
+    }
+    for (const entry of entries) {
+      if (entry.name === '.' || entry.name === '..') continue;
+      if (entry.isFile() && entry.name === '.gitignore') continue;
+      if (entry.isDirectory() && entry.name === 'node_modules') continue;
+      const entryPath = _path.default.join(dir, entry.name);
+      const entryStatus = checkIgnores(entryPath, rules, entry.isDirectory(), status);
+      if (entry.isDirectory() && entryStatus !== 'ignored') await visit(entryPath, rules, entryStatus);else if (entry.isFile() && entryStatus === 'included') files.push(entryPath);
+    }
+  };
+  await visit(testDir, [], 'included');
+  return files;
+}

data/node_modules/playwright/lib/runner/reporters.js

@@ -0,0 +1,151 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createConsoleReporter = createConsoleReporter;
+exports.createReporterForTestServer = createReporterForTestServer;
+exports.createReporters = createReporters;
+var _path = _interopRequireDefault(require("path"));
+var _base = require("../reporters/base");
+var _dot = _interopRequireDefault(require("../reporters/dot"));
+var _empty = _interopRequireDefault(require("../reporters/empty"));
+var _github = _interopRequireDefault(require("../reporters/github"));
+var _html = _interopRequireDefault(require("../reporters/html"));
+var _json = _interopRequireDefault(require("../reporters/json"));
+var _junit = _interopRequireDefault(require("../reporters/junit"));
+var _line = _interopRequireDefault(require("../reporters/line"));
+var _list = _interopRequireDefault(require("../reporters/list"));
+var _markdown = _interopRequireDefault(require("../reporters/markdown"));
+var _loadUtils = require("./loadUtils");
+var _blob = require("../reporters/blob");
+var _reporterV = require("../reporters/reporterV2");
+var _utils = require("playwright-core/lib/utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Copyright Microsoft Corporation. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+async function createReporters(config, mode, isTestServer, descriptions) {
+  var _descriptions;
+  const defaultReporters = {
+    blob: _blob.BlobReporter,
+    dot: mode === 'list' ? ListModeReporter : _dot.default,
+    line: mode === 'list' ? ListModeReporter : _line.default,
+    list: mode === 'list' ? ListModeReporter : _list.default,
+    github: _github.default,
+    json: _json.default,
+    junit: _junit.default,
+    null: _empty.default,
+    html: _html.default,
+    markdown: _markdown.default
+  };
+  const reporters = [];
+  (_descriptions = descriptions) !== null && _descriptions !== void 0 ? _descriptions : descriptions = config.config.reporter;
+  if (config.configCLIOverrides.additionalReporters) descriptions = [...descriptions, ...config.configCLIOverrides.additionalReporters];
+  const runOptions = reporterOptions(config, mode, isTestServer);
+  for (const r of descriptions) {
+    const [name, arg] = r;
+    const options = {
+      ...runOptions,
+      ...arg
+    };
+    if (name in defaultReporters) {
+      reporters.push(new defaultReporters[name](options));
+    } else {
+      const reporterConstructor = await (0, _loadUtils.loadReporter)(config, name);
+      reporters.push((0, _reporterV.wrapReporterAsV2)(new reporterConstructor(options)));
+    }
+  }
+  if (process.env.PW_TEST_REPORTER) {
+    const reporterConstructor = await (0, _loadUtils.loadReporter)(config, process.env.PW_TEST_REPORTER);
+    reporters.push((0, _reporterV.wrapReporterAsV2)(new reporterConstructor(runOptions)));
+  }
+  const someReporterPrintsToStdio = reporters.some(r => r.printsToStdio());
+  if (reporters.length && !someReporterPrintsToStdio) {
+    // Add a line/dot/list-mode reporter for convenience.
+    // Important to put it first, just in case some other reporter stalls onEnd.
+    if (mode === 'list') reporters.unshift(new ListModeReporter());else if (mode !== 'merge') reporters.unshift(!process.env.CI ? new _line.default({
+      omitFailures: true
+    }) : new _dot.default());
+  }
+  return reporters;
+}
+async function createReporterForTestServer(file, messageSink) {
+  const reporterConstructor = await (0, _loadUtils.loadReporter)(null, file);
+  return (0, _reporterV.wrapReporterAsV2)(new reporterConstructor({
+    _send: messageSink
+  }));
+}
+function createConsoleReporter() {
+  return (0, _reporterV.wrapReporterAsV2)({
+    onError(error) {
+      process.stdout.write((0, _base.formatError)(error, _base.colors.enabled).message + '\n');
+    }
+  });
+}
+function reporterOptions(config, mode, isTestServer) {
+  return {
+    configDir: config.configDir,
+    _mode: mode,
+    _isTestServer: isTestServer,
+    _commandHash: computeCommandHash(config)
+  };
+}
+function computeCommandHash(config) {
+  const parts = [];
+  // Include project names for readability.
+  if (config.cliProjectFilter) parts.push(...config.cliProjectFilter);
+  const command = {};
+  if (config.cliArgs.length) command.cliArgs = config.cliArgs;
+  if (config.cliGrep) command.cliGrep = config.cliGrep;
+  if (config.cliGrepInvert) command.cliGrepInvert = config.cliGrepInvert;
+  if (config.cliOnlyChanged) command.cliOnlyChanged = config.cliOnlyChanged;
+  if (Object.keys(command).length) parts.push((0, _utils.calculateSha1)(JSON.stringify(command)).substring(0, 7));
+  return parts.join('-');
+}
+class ListModeReporter extends _empty.default {
+  constructor(...args) {
+    super(...args);
+    this.config = void 0;
+  }
+  onConfigure(config) {
+    this.config = config;
+  }
+  onBegin(suite) {
+    // eslint-disable-next-line no-console
+    console.log(`Listing tests:`);
+    const tests = suite.allTests();
+    const files = new Set();
+    for (const test of tests) {
+      // root, project, file, ...describes, test
+      const [, projectName,, ...titles] = test.titlePath();
+      const location = `${_path.default.relative(this.config.rootDir, test.location.file)}:${test.location.line}:${test.location.column}`;
+      const projectTitle = projectName ? `[${projectName}] › ` : '';
+      // eslint-disable-next-line no-console
+      console.log(`  ${projectTitle}${location} › ${titles.join(' › ')}`);
+      files.add(test.location.file);
+    }
+    // eslint-disable-next-line no-console
+    console.log(`Total: ${tests.length} ${tests.length === 1 ? 'test' : 'tests'} in ${files.size} ${files.size === 1 ? 'file' : 'files'}`);
+  }
+  onError(error) {
+    // eslint-disable-next-line no-console
+    console.error('\n' + (0, _base.formatError)(error, false).message);
+  }
+  printsToStdio() {
+    return true;
+  }
+}

data/node_modules/playwright/lib/runner/runner.js

@@ -0,0 +1,179 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Runner = void 0;
+exports.readLastRunInfo = readLastRunInfo;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _utils = require("playwright-core/lib/utils");
+var _webServerPlugin = require("../plugins/webServerPlugin");
+var _projectUtils = require("./projectUtils");
+var _reporters = require("./reporters");
+var _tasks = require("./tasks");
+var _reporterV = require("../reporters/reporterV2");
+var _compilationCache = require("../transform/compilationCache");
+var _internalReporter = require("../reporters/internalReporter");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Copyright 2019 Google Inc. All rights reserved.
+ * Modifications copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class Runner {
+  constructor(config) {
+    this._config = void 0;
+    this._config = config;
+  }
+  async listTestFiles(projectNames) {
+    const projects = (0, _projectUtils.filterProjects)(this._config.projects, projectNames);
+    const report = {
+      projects: []
+    };
+    for (const project of projects) {
+      report.projects.push({
+        name: project.project.name,
+        testDir: project.project.testDir,
+        use: {
+          testIdAttribute: project.project.use.testIdAttribute
+        },
+        files: await (0, _projectUtils.collectFilesForProject)(project)
+      });
+    }
+    return report;
+  }
+  async runAllTests() {
+    const config = this._config;
+    const listOnly = config.cliListOnly;
+    const deadline = config.config.globalTimeout ? (0, _utils.monotonicTime)() + config.config.globalTimeout : 0;
+
+    // Legacy webServer support.
+    (0, _webServerPlugin.webServerPluginsForConfig)(config).forEach(p => config.plugins.push({
+      factory: p
+    }));
+    const reporters = await (0, _reporters.createReporters)(config, listOnly ? 'list' : 'test', false);
+    const reporter = new _internalReporter.InternalReporter(reporters);
+    const taskRunner = listOnly ? (0, _tasks.createTaskRunnerForList)(config, reporter, 'in-process', {
+      failOnLoadErrors: true
+    }) : (0, _tasks.createTaskRunner)(config, reporter);
+    const testRun = new _tasks.TestRun(config);
+    reporter.onConfigure(config.config);
+    const taskStatus = await taskRunner.run(testRun, deadline);
+    let status = testRun.failureTracker.result();
+    if (status === 'passed' && taskStatus !== 'passed') status = taskStatus;
+    const modifiedResult = await reporter.onEnd({
+      status
+    });
+    if (modifiedResult && modifiedResult.status) status = modifiedResult.status;
+    if (!listOnly) await writeLastRunInfo(testRun, status);
+    await reporter.onExit();
+
+    // Calling process.exit() might truncate large stdout/stderr output.
+    // See https://github.com/nodejs/node/issues/6456.
+    // See https://github.com/nodejs/node/issues/12921
+    await new Promise(resolve => process.stdout.write('', () => resolve()));
+    await new Promise(resolve => process.stderr.write('', () => resolve()));
+    return status;
+  }
+  async loadAllTests(mode = 'in-process') {
+    const config = this._config;
+    const errors = [];
+    const reporter = new _internalReporter.InternalReporter([(0, _reporterV.wrapReporterAsV2)({
+      onError(error) {
+        errors.push(error);
+      }
+    })]);
+    const taskRunner = (0, _tasks.createTaskRunnerForList)(config, reporter, mode, {
+      failOnLoadErrors: true
+    });
+    const testRun = new _tasks.TestRun(config);
+    reporter.onConfigure(config.config);
+    const taskStatus = await taskRunner.run(testRun, 0);
+    let status = testRun.failureTracker.result();
+    if (status === 'passed' && taskStatus !== 'passed') status = taskStatus;
+    const modifiedResult = await reporter.onEnd({
+      status
+    });
+    if (modifiedResult && modifiedResult.status) status = modifiedResult.status;
+    await reporter.onExit();
+    return {
+      status,
+      suite: testRun.rootSuite,
+      errors
+    };
+  }
+  async findRelatedTestFiles(mode, files) {
+    var _playwrightTest;
+    const result = await this.loadAllTests(mode);
+    if (result.status !== 'passed' || !result.suite) return {
+      errors: result.errors,
+      testFiles: []
+    };
+    const resolvedFiles = files.map(file => _path.default.resolve(process.cwd(), file));
+    const override = (_playwrightTest = this._config.config['@playwright/test']) === null || _playwrightTest === void 0 || (_playwrightTest = _playwrightTest['cli']) === null || _playwrightTest === void 0 ? void 0 : _playwrightTest['find-related-test-files'];
+    if (override) return await override(resolvedFiles, this._config);
+    return {
+      testFiles: (0, _compilationCache.affectedTestFiles)(resolvedFiles)
+    };
+  }
+  async runDevServer() {
+    const reporter = new _internalReporter.InternalReporter([(0, _reporters.createConsoleReporter)()]);
+    const taskRunner = (0, _tasks.createTaskRunnerForDevServer)(this._config, reporter, 'in-process', true);
+    const testRun = new _tasks.TestRun(this._config);
+    reporter.onConfigure(this._config.config);
+    const status = await taskRunner.run(testRun, 0);
+    await reporter.onEnd({
+      status
+    });
+    await reporter.onExit();
+    return {
+      status
+    };
+  }
+}
+exports.Runner = Runner;
+async function writeLastRunInfo(testRun, status) {
+  var _testRun$rootSuite;
+  const [project] = (0, _projectUtils.filterProjects)(testRun.config.projects, testRun.config.cliProjectFilter);
+  if (!project) return;
+  const outputDir = project.project.outputDir;
+  await _fs.default.promises.mkdir(outputDir, {
+    recursive: true
+  });
+  const lastRunReportFile = _path.default.join(outputDir, '.last-run.json');
+  const failedTests = (_testRun$rootSuite = testRun.rootSuite) === null || _testRun$rootSuite === void 0 ? void 0 : _testRun$rootSuite.allTests().filter(t => !t.ok()).map(t => t.id);
+  const lastRunReport = JSON.stringify({
+    status,
+    failedTests
+  }, undefined, 2);
+  await _fs.default.promises.writeFile(lastRunReportFile, lastRunReport);
+}
+async function readLastRunInfo(config) {
+  const [project] = (0, _projectUtils.filterProjects)(config.projects, config.cliProjectFilter);
+  if (!project) return {
+    status: 'passed',
+    failedTests: []
+  };
+  const outputDir = project.project.outputDir;
+  try {
+    const lastRunReportFile = _path.default.join(outputDir, '.last-run.json');
+    return JSON.parse(await _fs.default.promises.readFile(lastRunReportFile, 'utf8'));
+  } catch {}
+  return {
+    status: 'passed',
+    failedTests: []
+  };
+}

data/node_modules/playwright/lib/runner/sigIntWatcher.js

@@ -0,0 +1,100 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SigIntWatcher = void 0;
+var _class2;
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class SigIntWatcher {
+  constructor() {
+    this._hadSignal = false;
+    this._sigintPromise = void 0;
+    this._sigintHandler = void 0;
+    let sigintCallback;
+    this._sigintPromise = new Promise(f => sigintCallback = f);
+    this._sigintHandler = () => {
+      FixedNodeSIGINTHandler.off(this._sigintHandler);
+      this._hadSignal = true;
+      sigintCallback();
+    };
+    FixedNodeSIGINTHandler.on(this._sigintHandler);
+  }
+  promise() {
+    return this._sigintPromise;
+  }
+  hadSignal() {
+    return this._hadSignal;
+  }
+  disarm() {
+    FixedNodeSIGINTHandler.off(this._sigintHandler);
+  }
+}
+
+// NPM/NPX will send us duplicate SIGINT signals, so we need to ignore them.
+exports.SigIntWatcher = SigIntWatcher;
+class FixedNodeSIGINTHandler {
+  static _install() {
+    if (!this._handlerInstalled) {
+      this._handlerInstalled = true;
+      process.on('SIGINT', this._dispatch);
+    }
+  }
+  static _uninstall() {
+    if (this._handlerInstalled) {
+      this._handlerInstalled = false;
+      process.off('SIGINT', this._dispatch);
+    }
+  }
+  static on(handler) {
+    this._handlers.push(handler);
+    if (this._handlers.length === 1) this._install();
+  }
+  static off(handler) {
+    this._handlers = this._handlers.filter(h => h !== handler);
+    if (!this._ignoreNextSIGINTs && !this._handlers.length) this._uninstall();
+  }
+}
+_class2 = FixedNodeSIGINTHandler;
+FixedNodeSIGINTHandler._handlers = [];
+FixedNodeSIGINTHandler._ignoreNextSIGINTs = false;
+FixedNodeSIGINTHandler._handlerInstalled = false;
+FixedNodeSIGINTHandler._dispatch = () => {
+  if (_class2._ignoreNextSIGINTs) return;
+  _class2._ignoreNextSIGINTs = true;
+  setTimeout(() => {
+    _class2._ignoreNextSIGINTs = false;
+    // We remove the handler so that second Ctrl+C immediately kills the process
+    // via the default sigint handler. This is handy in the case where our shutdown
+    // takes a lot of time or is buggy.
+    //
+    // When running through NPM we might get multiple SIGINT signals
+    // for a single Ctrl+C - this is an NPM bug present since NPM v6+.
+    // https://github.com/npm/cli/issues/1591
+    // https://github.com/npm/cli/issues/2124
+    // https://github.com/npm/cli/issues/5021
+    //
+    // Therefore, removing the handler too soon will just kill the process
+    // with default handler without printing the results.
+    // We work around this by giving NPM 1000ms to send us duplicate signals.
+    // The side effect is that slow shutdown or bug in our process will force
+    // the user to hit Ctrl+C again after at least a second.
+    if (!_class2._handlers.length) _class2._uninstall();
+  }, 1000);
+  for (const handler of _class2._handlers) handler();
+};