update @actions/tool-cache, install semver, nock

node_modules/propagate/.eslintignore

@@ -0,0 +1,2 @@
+/coverage
+/node_modules

node_modules/propagate/.eslintrc.yml

@@ -0,0 +1,35 @@
+env:
+  node: true
+
+parserOptions:
+  ecmaVersion: 9
+  # Override eslint-config-standard, which incorrectly sets this to "module",
+  # though that setting is only for ES6 modules, not CommonJS modules.
+  sourceType: 'script'
+
+extends:
+  - 'eslint:recommended'
+  - standard
+  - prettier
+
+rules:
+  # Override some recommended rules.
+  no-unused-vars: ['error', { 'args': 'none' }]
+  no-empty: ['error', { 'allowEmptyCatch': true }]
+
+  # Nock additions.
+  strict: ['error', 'safe']
+  no-loop-func: 'error'
+  no-var: 'error'
+  prefer-const: 'error'
+  object-shorthand: ['error', 'properties']
+  prefer-template: 'error'
+  arrow-body-style: ['error', 'as-needed']
+  prefer-destructuring:
+    [
+      'error',
+      {
+        'VariableDeclarator': { 'array': false, 'object': true },
+        'AssignmentExpression': { 'array': false, 'object': false },
+      },
+    ]

node_modules/propagate/.prettierignore

@@ -0,0 +1,4 @@
+package.json
+package-lock.json
+/.nyc_output
+/coverage

node_modules/propagate/.prettierrc.yml

@@ -0,0 +1,5 @@
+semi: false
+singleQuote: true
+trailingComma: es5
+bracketSpacing: true
+endOfLine: lf

node_modules/propagate/.travis.yml

@@ -0,0 +1,27 @@
+language: node_js
+cache: npm
+
+# Trigger a push build on master and greenkeeper branches + PRs build on every branches
+# Avoid double build on PRs (See https://github.com/travis-ci/travis-ci/issues/1147)
+branches:
+  only:
+    - master
+    - /^greenkeeper.*$/
+    - beta # semantic-release preview releases
+    - next # semantic-release @next releases
+    - /^\d+\.x$/ # semantic-release maintenance releases
+
+stages:
+  - test
+  - name: release
+    if: branch =~ /^(\d+\.x|master|next|beta)$/ AND type IN (push)
+
+jobs:
+  include:
+    - stage: test
+      node_js: 10
+    - node_js: 8
+    - stage: release
+      node_js: lts/*
+      env: semantic-release
+      script: npx semantic-release

node_modules/propagate/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2015-2019 Pedro Teixeira and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

node_modules/propagate/README.md

@@ -0,0 +1,72 @@
+# propagate
+
+[![npm](https://img.shields.io/npm/v/nock.svg?style=flat-square)][npmjs]
+[![Build Status](https://img.shields.io/travis/nock/propagate/master.svg?style=flat-square)][build]
+[![Coverage](https://img.shields.io/coveralls/github/nock/propagate.svg?style=flat-square)][coverage]
+
+[npmjs]: https://www.npmjs.com/package/propagate
+[build]: https://travis-ci.org/nock/propagate
+[coverage]: https://coveralls.io/github/nock/propagate
+
+Propagate events from one event emitter into another.
+
+## Install
+
+```bash
+$ npm install propagate
+```
+
+## Propagate
+
+```javascript
+var ee1 = new EventEmitter()
+var ee2 = new EventEmitter()
+propagate(ee1, ee2)
+
+ee2.on('event', function(a, b) {
+  console.log('got propagated event', a, b)
+})
+
+ee1.emit('event', 'a', 'b')
+```
+
+## Unpropagate
+
+You can unpropagate by ending the propagation like this:
+
+```javascript
+var ee1 = new EventEmitter()
+var ee2 = new EventEmitter()
+var p = propagate(ee1, ee2)
+
+// ...
+
+p.end()
+```
+
+## Only propagate certain events:
+
+```javascript
+var ee1 = new EventEmitter()
+var ee2 = new EventEmitter()
+var p = propagate(['event1', 'event2'], ee1, ee2)
+```
+
+## Propagate certain events as other events:
+
+```javascript
+var ee1 = new EventEmitter()
+var ee2 = new EventEmitter()
+var p = propagate(
+  {
+    event1: 'other-event1',
+    event2: 'other-event2',
+  },
+  ee1,
+  ee2
+)
+```
+
+# License
+
+MIT

node_modules/propagate/index.js

@@ -0,0 +1,85 @@
+'use strict'
+
+function propagate(events, source, dest) {
+  if (arguments.length < 3) {
+    dest = source
+    source = events
+    events = undefined
+  }
+
+  // events should be an array or object
+  const eventsIsObject = typeof events === 'object'
+  if (events && !eventsIsObject) events = [events]
+
+  if (eventsIsObject) {
+    return explicitPropagate(events, source, dest)
+  }
+
+  const shouldPropagate = eventName =>
+    events === undefined || events.includes(eventName)
+
+  const oldEmit = source.emit
+
+  // Returns true if the event had listeners, false otherwise.
+  // https://nodejs.org/api/events.html#events_emitter_emit_eventname_args
+  source.emit = (eventName, ...args) => {
+    const oldEmitHadListeners = oldEmit.call(source, eventName, ...args)
+
+    let destEmitHadListeners = false
+    if (shouldPropagate(eventName)) {
+      destEmitHadListeners = dest.emit(eventName, ...args)
+    }
+
+    return oldEmitHadListeners || destEmitHadListeners
+  }
+
+  function end() {
+    source.emit = oldEmit
+  }
+
+  return {
+    end,
+  }
+}
+
+module.exports = propagate
+
+function explicitPropagate(events, source, dest) {
+  let eventsIn
+  let eventsOut
+  if (Array.isArray(events)) {
+    eventsIn = events
+    eventsOut = events
+  } else {
+    eventsIn = Object.keys(events)
+    eventsOut = eventsIn.map(function(key) {
+      return events[key]
+    })
+  }
+
+  const listeners = eventsOut.map(function(event) {
+    return function() {
+      const args = Array.prototype.slice.call(arguments)
+      args.unshift(event)
+      dest.emit.apply(dest, args)
+    }
+  })
+
+  listeners.forEach(register)
+
+  return {
+    end,
+  }
+
+  function register(listener, i) {
+    source.on(eventsIn[i], listener)
+  }
+
+  function unregister(listener, i) {
+    source.removeListener(eventsIn[i], listener)
+  }
+
+  function end() {
+    listeners.forEach(unregister)
+  }
+}

node_modules/propagate/package.json

@@ -0,0 +1,86 @@
+{
+  "_from": "propagate@^2.0.0",
+  "_id": "propagate@2.0.1",
+  "_inBundle": false,
+  "_integrity": "sha512-vGrhOavPSTz4QVNuBNdcNXePNdNMaO1xj9yBeH1ScQPjk/rhg9sSlCXPhMkFuaNNW/syTvYqsnbIJxMBfRbbag==",
+  "_location": "/propagate",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "propagate@^2.0.0",
+    "name": "propagate",
+    "escapedName": "propagate",
+    "rawSpec": "^2.0.0",
+    "saveSpec": null,
+    "fetchSpec": "^2.0.0"
+  },
+  "_requiredBy": [
+    "/nock"
+  ],
+  "_resolved": "https://registry.npmjs.org/propagate/-/propagate-2.0.1.tgz",
+  "_shasum": "40cdedab18085c792334e64f0ac17256d38f9a45",
+  "_spec": "propagate@^2.0.0",
+  "_where": "/Users/alexkappa/Code/ts/github.com/github/codeql-action/node_modules/nock",
+  "author": {
+    "name": "Pedro Teixeira",
+    "email": "pedro.teixeira@gmail.com"
+  },
+  "bugs": {
+    "url": "http://github.com/nock/propagate/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Pedro Teixeira"
+    }
+  ],
+  "dependencies": {},
+  "deprecated": false,
+  "description": "Propagate events from one event emitter into another",
+  "devDependencies": {
+    "eslint": "^5.16.0",
+    "eslint-config-prettier": "^4.1.0",
+    "eslint-config-standard": "^12.0.0",
+    "eslint-plugin-import": "^2.16.0",
+    "eslint-plugin-node": "^8.0.1",
+    "eslint-plugin-promise": "^4.1.1",
+    "eslint-plugin-standard": "^4.0.0",
+    "prettier": "^1.16.4",
+    "semantic-release": "16.0.0-beta.18",
+    "tap": "^12.6.1"
+  },
+  "engines": {
+    "node": ">= 8"
+  },
+  "homepage": "http://github.com/nock/propagate#readme",
+  "keywords": [
+    "event",
+    "events",
+    "emitter",
+    "eventemitter",
+    "propagation"
+  ],
+  "license": "MIT",
+  "name": "propagate",
+  "nyc": {
+    "exclude": [
+      "tests/"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nock/propagate.git"
+  },
+  "scripts": {
+    "coverage": "tap --coverage-report=html && open coverage/lcov-report/index.html",
+    "lint": "eslint \"**/*.js\"",
+    "posttest": "npm run -s prettier:check",
+    "pretest": "npm run lint",
+    "prettier": "prettier --write \"**/*.@(js|md|yml|json)\"",
+    "prettier:check": "prettier --check \"**/*.@(js|md|yml|json)\"",
+    "test": "npm run -s unit",
+    "unit": "tap tests/index.js"
+  },
+  "version": "2.0.1"
+}

node_modules/propagate/tests/index.js

@@ -0,0 +1,168 @@
+'use strict'
+
+const { test } = require('tap')
+const { EventEmitter } = require('events')
+const propagate = require('..')
+
+test('propagates events', t => {
+  t.plan(16)
+  const ee1 = new EventEmitter()
+  const ee2 = new EventEmitter()
+  propagate(ee1, ee2)
+
+  ee2.on('event-1', (a, b, c) => {
+    t.equal(a, 'a')
+    t.equal(b, 'b')
+    t.equal(c, undefined)
+  })
+
+  ee2.on('event-2', (a, b, c) => {
+    t.equal(a, 'c')
+    t.equal(b, 'd')
+    t.equal(c, undefined)
+  })
+
+  t.true(ee1.emit('event-1', 'a', 'b'))
+  t.true(ee1.emit('event-1', 'a', 'b'))
+  t.true(ee1.emit('event-2', 'c', 'd'))
+  t.true(ee1.emit('event-2', 'c', 'd'))
+})
+
+test('propagates can end', t => {
+  t.plan(3)
+
+  const ee1 = new EventEmitter()
+  const ee2 = new EventEmitter()
+  const prop = propagate(ee1, ee2)
+
+  ee2.on('event', () => {
+    t.ok('true', 'propagated')
+  })
+
+  t.true(ee1.emit('event'))
+  prop.end()
+  t.false(ee1.emit('event'))
+})
+
+test('after propagation old one still emits', t => {
+  t.plan(4)
+
+  const ee1 = new EventEmitter()
+  const ee2 = new EventEmitter()
+  const prop = propagate(ee1, ee2)
+
+  ee1.on('event', () => {
+    t.ok('true', 'propagated')
+  })
+
+  t.true(ee1.emit('event'))
+  prop.end()
+  t.true(ee1.emit('event'))
+})
+
+test('emit on source before destination', t => {
+  t.plan(2)
+
+  const source = new EventEmitter()
+  const dest = new EventEmitter()
+
+  // Set up test case for "propagate all"
+  // `count` should have been incremented by handler on source when handler on dest is invoked
+  let count = 0
+  propagate(source, dest)
+  source.on('event', () => {
+    count++
+  })
+  dest.on('event', () => {
+    t.equal(count, 1, 'emit on source first')
+  })
+
+  // Emit the events for assertion
+  t.true(source.emit('event'))
+})
+
+test('is able to propagate only certain events', t => {
+  t.plan(6)
+  const ee1 = new EventEmitter()
+  const ee2 = new EventEmitter()
+  // propagate only event-1 and event-2, leaving out
+  const p = propagate(['event-1', 'event-2'], ee1, ee2)
+
+  ee2.on('event-1', () => {
+    t.ok(true, 'event 1 received')
+  })
+
+  ee2.on('event-2', (a, b, c) => {
+    t.ok(true, 'event 2 received')
+  })
+
+  ee2.on('event-3', (a, b, c) => {
+    t.fail('event 3 should not have been received')
+  })
+
+  t.true(ee1.emit('event-1'))
+  t.true(ee1.emit('event-2'))
+  t.false(ee1.emit('event-3'))
+
+  p.end()
+
+  t.false(ee1.emit('event-1'))
+})
+
+test('is able to propagate and map certain events', t => {
+  t.plan(6)
+  const ee1 = new EventEmitter()
+  const ee2 = new EventEmitter()
+  // propagate only event-1 and event-2, leaving out
+  const p = propagate(
+    {
+      'event-1': 'other-event-1',
+      'event-2': 'other-event-2',
+    },
+    ee1,
+    ee2
+  )
+
+  ee2.on('other-event-1', () => {
+    t.ok(true, 'event 1 received')
+  })
+
+  ee2.on('other-event-2', (a, b, c) => {
+    t.ok(true, 'event 2 received')
+  })
+
+  ee2.on('event-3', (a, b, c) => {
+    t.fail('event 3 should not have been received')
+  })
+
+  t.true(ee1.emit('event-1'))
+  t.true(ee1.emit('event-2'))
+  t.false(ee1.emit('event-3'))
+
+  p.end()
+
+  t.false(ee1.emit('event-1'))
+})
+
+test('is able to propagate a single event', t => {
+  t.plan(5)
+  const ee1 = new EventEmitter()
+  const ee2 = new EventEmitter()
+  const p = propagate('event-1', ee1, ee2)
+
+  ee2.on('event-1', () => {
+    t.ok(true, 'event 1 received')
+  })
+
+  ee2.on('event-2', (a, b, c) => {
+    t.fail('event 3 should not have been received')
+  })
+
+  t.true(ee1.emit('event-1'))
+  t.false(ee1.emit('event-2'))
+
+  p.end()
+
+  t.false(ee1.emit('event-1'))
+  t.false(ee1.emit('event-2'))
+})