minigame

node_modules/selenium-webdriver/io/exec.js

@@ -0,0 +1,166 @@
+// Licensed to the Software Freedom Conservancy (SFC) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The SFC licenses this file
+// to you 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.
+
+'use strict'
+
+const childProcess = require('child_process')
+
+/**
+ * Options for configuring an executed command.
+ *
+ * @record
+ */
+class Options {
+  constructor() {
+    /**
+     * Command line arguments for the child process, if any.
+     * @type (!Array<string>|undefined)
+     */
+    this.args
+
+    /**
+     * Environment variables for the spawned process. If unspecified, the
+     * child will inherit this process' environment.
+     *
+     * @type {(!Object<string, string>|undefined)}
+     */
+    this.env
+
+    /**
+     * IO conifguration for the spawned server child process. If unspecified,
+     * the child process' IO output will be ignored.
+     *
+     * @type {(string|!Array<string|number|!stream.Stream|null|undefined>|
+     *           undefined)}
+     * @see <https://nodejs.org/dist/latest-v8.x/docs/api/child_process.html#child_process_options_stdio>
+     */
+    this.stdio
+  }
+}
+
+/**
+ * Describes a command's termination conditions.
+ */
+class Result {
+  /**
+   * @param {?number} code The exit code, or {@code null} if the command did not
+   *     exit normally.
+   * @param {?string} signal The signal used to kill the command, or
+   *     {@code null}.
+   */
+  constructor(code, signal) {
+    /** @type {?number} */
+    this.code = code
+
+    /** @type {?string} */
+    this.signal = signal
+  }
+
+  /** @override */
+  toString() {
+    return `Result(code=${this.code}, signal=${this.signal})`
+  }
+}
+
+const COMMAND_RESULT =
+  /** !WeakMap<!Command, !Promise<!Result>> */ new WeakMap()
+const KILL_HOOK = /** !WeakMap<!Command, function(string)> */ new WeakMap()
+
+/**
+ * Represents a command running in a sub-process.
+ */
+class Command {
+  /**
+   * @param {!Promise<!Result>} result The command result.
+   * @param {function(string)} onKill The function to call when {@link #kill()}
+   *     is called.
+   */
+  constructor(result, onKill) {
+    COMMAND_RESULT.set(this, result)
+    KILL_HOOK.set(this, onKill)
+  }
+
+  /**
+   * @return {!Promise<!Result>} A promise for the result of this
+   *     command.
+   */
+  result() {
+    return /** @type {!Promise<!Result>} */ (COMMAND_RESULT.get(this))
+  }
+
+  /**
+   * Sends a signal to the underlying process.
+   * @param {string=} opt_signal The signal to send; defaults to `SIGTERM`.
+   */
+  kill(opt_signal) {
+    KILL_HOOK.get(this)(opt_signal || 'SIGTERM')
+  }
+}
+
+// PUBLIC API
+
+/**
+ * Spawns a child process. The returned {@link Command} may be used to wait
+ * for the process result or to send signals to the process.
+ *
+ * @param {string} command The executable to spawn.
+ * @param {Options=} opt_options The command options.
+ * @return {!Command} The launched command.
+ */
+function exec(command, opt_options) {
+  const options = opt_options || {}
+
+  let proc = childProcess.spawn(command, options.args || [], {
+    env: options.env || process.env,
+    stdio: options.stdio || 'ignore',
+  })
+
+  // This process should not wait on the spawned child, however, we do
+  // want to ensure the child is killed when this process exits.
+  proc.unref()
+  process.once('exit', onProcessExit)
+
+  const result = new Promise((resolve) => {
+    proc.once('exit', (code, signal) => {
+      proc = null
+      process.removeListener('exit', onProcessExit)
+      resolve(new Result(code, signal))
+    })
+  })
+  return new Command(result, killCommand)
+
+  function onProcessExit() {
+    killCommand('SIGTERM')
+  }
+
+  function killCommand(signal) {
+    process.removeListener('exit', onProcessExit)
+    if (proc) {
+      proc.kill(signal)
+      proc = null
+    }
+  }
+}
+
+// Exported to improve generated API documentation.
+
+module.exports = {
+  Command,
+  Options,
+  Result,
+  exec,
+}

node_modules/selenium-webdriver/io/index.js

@@ -0,0 +1,351 @@
+// Licensed to the Software Freedom Conservancy (SFC) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The SFC licenses this file
+// to you 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.
+
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+const tmp = require('tmp')
+
+/**
+ * @param {!Function} fn .
+ * @return {!Promise<T>} .
+ * @template T
+ */
+function checkedCall(fn) {
+  return new Promise((resolve, reject) => {
+    try {
+      fn((err, value) => {
+        if (err) {
+          reject(err)
+        } else {
+          resolve(value)
+        }
+      })
+    } catch (e) {
+      reject(e)
+    }
+  })
+}
+
+/**
+ * Recursively removes a directory and all of its contents. This is equivalent
+ * to {@code rm -rf} on a POSIX system.
+ * @param {string} dirPath Path to the directory to remove.
+ * @return {!Promise} A promise to be resolved when the operation has
+ *     completed.
+ */
+function rmDir(dirPath) {
+  return new Promise(function (fulfill, reject) {
+    fs.rm(dirPath, { recursive: true, maxRetries: 2 }, function (err) {
+      if (err && err.code === 'ENOENT') {
+        fulfill()
+      } else if (err) {
+        reject(err)
+      }
+      fulfill()
+    })
+  })
+}
+
+/**
+ * Copies one file to another.
+ * @param {string} src The source file.
+ * @param {string} dst The destination file.
+ * @return {!Promise<string>} A promise for the copied file's path.
+ */
+function copy(src, dst) {
+  return new Promise(function (fulfill, reject) {
+    const rs = fs.createReadStream(src)
+    rs.on('error', reject)
+
+    const ws = fs.createWriteStream(dst)
+    ws.on('error', reject)
+    ws.on('close', () => fulfill(dst))
+
+    rs.pipe(ws)
+  })
+}
+
+/**
+ * Recursively copies the contents of one directory to another.
+ * @param {string} src The source directory to copy.
+ * @param {string} dst The directory to copy into.
+ * @param {(RegExp|function(string): boolean)=} opt_exclude An exclusion filter
+ *     as either a regex or predicate function. All files matching this filter
+ *     will not be copied.
+ * @return {!Promise<string>} A promise for the destination
+ *     directory's path once all files have been copied.
+ */
+function copyDir(src, dst, opt_exclude) {
+  let predicate = opt_exclude
+  if (opt_exclude && typeof opt_exclude !== 'function') {
+    predicate = function (p) {
+      return !opt_exclude.test(p)
+    }
+  }
+
+  if (!fs.existsSync(dst)) {
+    fs.mkdirSync(dst)
+  }
+
+  let files = fs.readdirSync(src)
+  files = files.map(function (file) {
+    return path.join(src, file)
+  })
+
+  if (predicate) {
+    files = files.filter(/** @type {function(string): boolean} */ (predicate))
+  }
+
+  const results = []
+  files.forEach(function (file) {
+    const stats = fs.statSync(file)
+    const target = path.join(dst, path.basename(file))
+
+    if (stats.isDirectory()) {
+      if (!fs.existsSync(target)) {
+        fs.mkdirSync(target, stats.mode)
+      }
+      results.push(copyDir(file, target, predicate))
+    } else {
+      results.push(copy(file, target))
+    }
+  })
+
+  return Promise.all(results).then(() => dst)
+}
+
+/**
+ * Tests if a file path exists.
+ * @param {string} aPath The path to test.
+ * @return {!Promise<boolean>} A promise for whether the file exists.
+ */
+function exists(aPath) {
+  return new Promise(function (fulfill, reject) {
+    let type = typeof aPath
+    if (type !== 'string') {
+      reject(TypeError(`expected string path, but got ${type}`))
+    } else {
+      fulfill(fs.existsSync(aPath))
+    }
+  })
+}
+
+/**
+ * Calls `stat(2)`.
+ * @param {string} aPath The path to stat.
+ * @return {!Promise<!fs.Stats>} A promise for the file stats.
+ */
+function stat(aPath) {
+  return checkedCall((callback) => fs.stat(aPath, callback))
+}
+
+/**
+ * Deletes a name from the filesystem and possibly the file it refers to. Has
+ * no effect if the file does not exist.
+ * @param {string} aPath The path to remove.
+ * @return {!Promise} A promise for when the file has been removed.
+ */
+function unlink(aPath) {
+  return new Promise(function (fulfill, reject) {
+    const exists = fs.existsSync(aPath)
+    if (exists) {
+      fs.unlink(aPath, function (err) {
+        ;(err && reject(err)) || fulfill()
+      })
+    } else {
+      fulfill()
+    }
+  })
+}
+
+/**
+ * @return {!Promise<string>} A promise for the path to a temporary directory.
+ * @see https://www.npmjs.org/package/tmp
+ */
+function tmpDir() {
+  return checkedCall((callback) => tmp.dir({ unsafeCleanup: true }, callback))
+}
+
+/**
+ * @param {{postfix: string}=} opt_options Temporary file options.
+ * @return {!Promise<string>} A promise for the path to a temporary file.
+ * @see https://www.npmjs.org/package/tmp
+ */
+function tmpFile(opt_options) {
+  return checkedCall((callback) => {
+    /**  check fixed in v > 0.2.1 if
+     * (typeof options === 'function') {
+     *     return [{}, options];
+     * }
+     */
+    tmp.file(opt_options, callback)
+  })
+}
+
+/**
+ * Searches the {@code PATH} environment variable for the given file.
+ * @param {string} file The file to locate on the PATH.
+ * @param {boolean=} opt_checkCwd Whether to always start with the search with
+ *     the current working directory, regardless of whether it is explicitly
+ *     listed on the PATH.
+ * @return {?string} Path to the located file, or {@code null} if it could
+ *     not be found.
+ */
+function findInPath(file, opt_checkCwd) {
+  const dirs = []
+  if (opt_checkCwd) {
+    dirs.push(process.cwd())
+  }
+  dirs.push.apply(dirs, process.env['PATH'].split(path.delimiter))
+
+  let foundInDir = dirs.find((dir) => {
+    let tmp = path.join(dir, file)
+    try {
+      let stats = fs.statSync(tmp)
+      return stats.isFile() && !stats.isDirectory()
+    } catch (ex) {
+      return false
+    }
+  })
+
+  return foundInDir ? path.join(foundInDir, file) : null
+}
+
+/**
+ * Reads the contents of the given file.
+ *
+ * @param {string} aPath Path to the file to read.
+ * @return {!Promise<!Buffer>} A promise that will resolve with a buffer of the
+ *     file contents.
+ */
+function read(aPath) {
+  return checkedCall((callback) => fs.readFile(aPath, callback))
+}
+
+/**
+ * Writes to a file.
+ *
+ * @param {string} aPath Path to the file to write to.
+ * @param {(string|!Buffer)} data The data to write.
+ * @return {!Promise} A promise that will resolve when the operation has
+ *     completed.
+ */
+function write(aPath, data) {
+  return checkedCall((callback) => fs.writeFile(aPath, data, callback))
+}
+
+/**
+ * Creates a directory.
+ *
+ * @param {string} aPath The directory path.
+ * @return {!Promise<string>} A promise that will resolve with the path of the
+ *     created directory.
+ */
+function mkdir(aPath) {
+  return checkedCall((callback) => {
+    fs.mkdir(aPath, undefined, (err) => {
+      if (err && err.code !== 'EEXIST') {
+        callback(err)
+      } else {
+        callback(null, aPath)
+      }
+    })
+  })
+}
+
+/**
+ * Recursively creates a directory and any ancestors that do not yet exist.
+ *
+ * @param {string} dir The directory path to create.
+ * @return {!Promise<string>} A promise that will resolve with the path of the
+ *     created directory.
+ */
+function mkdirp(dir) {
+  return checkedCall((callback) => {
+    fs.mkdir(dir, undefined, (err) => {
+      if (!err) {
+        callback(null, dir)
+        return
+      }
+
+      switch (err.code) {
+        case 'EEXIST':
+          callback(null, dir)
+          return
+        case 'ENOENT':
+          return mkdirp(path.dirname(dir))
+            .then(() => mkdirp(dir))
+            .then(
+              () => callback(null, dir),
+              (err) => callback(err)
+            )
+        default:
+          callback(err)
+          return
+      }
+    })
+  })
+}
+
+/**
+ * Recursively walks a directory, returning a promise that will resolve with
+ * a list of all files/directories seen.
+ *
+ * @param {string} rootPath the directory to walk.
+ * @return {!Promise<!Array<{path: string, dir: boolean}>>} a promise that will
+ *     resolve with a list of entries seen. For each entry, the recorded path
+ *     will be relative to `rootPath`.
+ */
+function walkDir(rootPath) {
+  const seen = []
+  return (function walk(dir) {
+    return checkedCall((callback) => fs.readdir(dir, callback)).then((files) =>
+      Promise.all(
+        files.map((file) => {
+          file = path.join(dir, file)
+          return checkedCall((cb) => fs.stat(file, cb)).then((stats) => {
+            seen.push({
+              path: path.relative(rootPath, file),
+              dir: stats.isDirectory(),
+            })
+            return stats.isDirectory() && walk(file)
+          })
+        })
+      )
+    )
+  })(rootPath).then(() => seen)
+}
+
+// PUBLIC API
+module.exports = {
+  walkDir,
+  rmDir,
+  mkdirp,
+  mkdir,
+  write,
+  read,
+  findInPath,
+  tmpFile,
+  tmpDir,
+  unlink,
+  copy,
+  copyDir,
+  exists,
+  stat,
+}

node_modules/selenium-webdriver/io/zip.js

@@ -0,0 +1,221 @@
+// Licensed to the Software Freedom Conservancy (SFC) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The SFC licenses this file
+// to you 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.
+
+'use strict'
+
+const jszip = require('jszip')
+const path = require('path')
+
+const io = require('./index')
+const { InvalidArgumentError } = require('../lib/error')
+
+/**
+ * Manages a zip archive.
+ */
+class Zip {
+  constructor() {
+    /** @private @const */
+    this.z_ = new jszip()
+
+    /** @private @const {!Set<!Promise<?>>} */
+    this.pendingAdds_ = new Set()
+  }
+
+  /**
+   * Adds a file to this zip.
+   *
+   * @param {string} filePath path to the file to add.
+   * @param {string=} zipPath path to the file in the zip archive, defaults
+   *     to the basename of `filePath`.
+   * @return {!Promise<?>} a promise that will resolve when added.
+   */
+  addFile(filePath, zipPath = path.basename(filePath)) {
+    let add = io
+      .read(filePath)
+      .then((buffer) =>
+        this.z_.file(
+          /** @type {string} */ (zipPath.replace(/\\/g, '/')),
+          buffer
+        )
+      )
+    this.pendingAdds_.add(add)
+    return add.then(
+      () => this.pendingAdds_.delete(add),
+      (e) => {
+        this.pendingAdds_.delete(add)
+        throw e
+      }
+    )
+  }
+
+  /**
+   * Recursively adds a directory and all of its contents to this archive.
+   *
+   * @param {string} dirPath path to the directory to add.
+   * @param {string=} zipPath path to the folder in the archive to add the
+   *     directory contents to. Defaults to the root folder.
+   * @return {!Promise<?>} returns a promise that will resolve when
+   * the operation is complete.
+   */
+  addDir(dirPath, zipPath = '') {
+    return io.walkDir(dirPath).then((entries) => {
+      let archive = this.z_
+      if (zipPath) {
+        archive = archive.folder(zipPath)
+      }
+
+      let files = []
+      entries.forEach((spec) => {
+        if (spec.dir) {
+          archive.folder(spec.path)
+        } else {
+          files.push(
+            this.addFile(
+              path.join(dirPath, spec.path),
+              path.join(zipPath, spec.path)
+            )
+          )
+        }
+      })
+
+      return Promise.all(files)
+    })
+  }
+
+  /**
+   * @param {string} path File path to test for within the archive.
+   * @return {boolean} Whether this zip archive contains an entry with the given
+   *     path.
+   */
+  has(path) {
+    return this.z_.file(path) !== null
+  }
+
+  /**
+   * Returns the contents of the file in this zip archive with the given `path`.
+   * The returned promise will be rejected with an {@link InvalidArgumentError}
+   * if either `path` does not exist within the archive, or if `path` refers
+   * to a directory.
+   *
+   * @param {string} path the path to the file whose contents to return.
+   * @return {!Promise<!Buffer>} a promise that will be resolved with the file's
+   *     contents as a buffer.
+   */
+  getFile(path) {
+    let file = this.z_.file(path)
+    if (!file) {
+      return Promise.reject(
+        new InvalidArgumentError(`No such file in zip archive: ${path}`)
+      )
+    }
+
+    if (file.dir) {
+      return Promise.reject(
+        new InvalidArgumentError(`The requested file is a directory: ${path}`)
+      )
+    }
+
+    return Promise.resolve(file.async('nodebuffer'))
+  }
+
+  /**
+   * Returns the compressed data for this archive in a buffer. _This method will
+   * not wait for any outstanding {@link #addFile add}
+   * {@link #addDir operations} before encoding the archive._
+   *
+   * @param {string} compression The desired compression.
+   *     Must be `STORE` (the default) or `DEFLATE`.
+   * @return {!Promise<!Buffer>} a promise that will resolve with this archive
+   *     as a buffer.
+   */
+  toBuffer(compression = 'STORE') {
+    if (compression !== 'STORE' && compression !== 'DEFLATE') {
+      return Promise.reject(
+        new InvalidArgumentError(
+          `compression must be one of {STORE, DEFLATE}, got ${compression}`
+        )
+      )
+    }
+    return Promise.resolve(
+      this.z_.generateAsync({ compression, type: 'nodebuffer' })
+    )
+  }
+}
+
+/**
+ * Asynchronously opens a zip archive.
+ *
+ * @param {string} path to the zip archive to load.
+ * @return {!Promise<!Zip>} a promise that will resolve with the opened
+ *     archive.
+ */
+function load(path) {
+  return io.read(path).then((data) => {
+    let zip = new Zip()
+    return zip.z_.loadAsync(data).then(() => zip)
+  })
+}
+
+/**
+ * Asynchronously unzips an archive file.
+ *
+ * @param {string} src path to the source file to unzip.
+ * @param {string} dst path to the destination directory.
+ * @return {!Promise<string>} a promise that will resolve with `dst` once the
+ *     archive has been unzipped.
+ */
+function unzip(src, dst) {
+  return load(src).then((zip) => {
+    const promisedDirs = new Map()
+    const promises = []
+
+    zip.z_.forEach((relPath, file) => {
+      let p
+      if (file.dir) {
+        p = createDir(relPath)
+      } else {
+        let dirname = path.dirname(relPath)
+        if (dirname === '.') {
+          p = writeFile(relPath, file)
+        } else {
+          p = createDir(dirname).then(() => writeFile(relPath, file))
+        }
+      }
+      promises.push(p)
+    })
+
+    return Promise.all(promises).then(() => dst)
+
+    function createDir(dir) {
+      let p = promisedDirs.get(dir)
+      if (!p) {
+        p = io.mkdirp(path.join(dst, dir))
+        promisedDirs.set(dir, p)
+      }
+      return p
+    }
+
+    function writeFile(relPath, file) {
+      return file
+        .async('nodebuffer')
+        .then((buffer) => io.write(path.join(dst, relPath), buffer))
+    }
+  })
+}
+
+// PUBLIC API
+module.exports = { Zip, load, unzip }