postdoc 0.1.2 → 0.2.0.beta4

data/node_modules/puppeteer/lib/Input.js

@@ -0,0 +1,309 @@
+/**
+ * Copyright 2017 Google Inc. 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 {helper} = require('./helper');
+const keyDefinitions = require('./USKeyboardLayout');
+
+/**
+ * @typedef {Object} KeyDescription
+ * @property {number} keyCode
+ * @property {string} key
+ * @property {string} text
+ * @property {string} code
+ * @property {number} location
+ */
+
+class Keyboard {
+  /**
+   * @param {!Puppeteer.CDPSession} client
+   */
+  constructor(client) {
+    this._client = client;
+    this._modifiers = 0;
+    this._pressedKeys = new Set();
+  }
+
+  /**
+   * @param {string} key
+   * @param {{text: string}=} options
+   */
+  async down(key, options = { text: undefined }) {
+    const description = this._keyDescriptionForString(key);
+
+    const autoRepeat = this._pressedKeys.has(description.code);
+    this._pressedKeys.add(description.code);
+    this._modifiers |= this._modifierBit(description.key);
+
+    const text = options.text === undefined ? description.text : options.text;
+    await this._client.send('Input.dispatchKeyEvent', {
+      type: text ? 'keyDown' : 'rawKeyDown',
+      modifiers: this._modifiers,
+      windowsVirtualKeyCode: description.keyCode,
+      code: description.code,
+      key: description.key,
+      text: text,
+      unmodifiedText: text,
+      autoRepeat,
+      location: description.location,
+      isKeypad: description.location === 3
+    });
+  }
+
+  /**
+   * @param {string} key
+   * @return {number}
+   */
+  _modifierBit(key) {
+    if (key === 'Alt')
+      return 1;
+    if (key === 'Control')
+      return 2;
+    if (key === 'Meta')
+      return 4;
+    if (key === 'Shift')
+      return 8;
+    return 0;
+  }
+
+  /**
+   * @param {string} keyString
+   * @return {KeyDescription}
+   */
+  _keyDescriptionForString(keyString) {
+    const shift = this._modifiers & 8;
+    const description = {
+      key: '',
+      keyCode: 0,
+      code: '',
+      text: '',
+      location: 0
+    };
+
+    const definition = keyDefinitions[keyString];
+    console.assert(definition, `Unknown key: "${keyString}"`);
+
+    if (definition.key)
+      description.key = definition.key;
+    if (shift && definition.shiftKey)
+      description.key = definition.shiftKey;
+
+    if (definition.keyCode)
+      description.keyCode = definition.keyCode;
+    if (shift && definition.shiftKeyCode)
+      description.keyCode = definition.shiftKeyCode;
+
+    if (definition.code)
+      description.code = definition.code;
+
+    if (definition.location)
+      description.location = definition.location;
+
+    if (description.key.length === 1)
+      description.text = description.key;
+
+    if (definition.text)
+      description.text = definition.text;
+    if (shift && definition.shiftText)
+      description.text = definition.shiftText;
+
+    // if any modifiers besides shift are pressed, no text should be sent
+    if (this._modifiers & ~8)
+      description.text = '';
+
+    return description;
+  }
+
+  /**
+   * @param {string} key
+   */
+  async up(key) {
+    const description = this._keyDescriptionForString(key);
+
+    this._modifiers &= ~this._modifierBit(description.key);
+    this._pressedKeys.delete(description.code);
+    await this._client.send('Input.dispatchKeyEvent', {
+      type: 'keyUp',
+      modifiers: this._modifiers,
+      key: description.key,
+      windowsVirtualKeyCode: description.keyCode,
+      code: description.code,
+      location: description.location
+    });
+  }
+
+  /**
+   * @param {string} char
+   */
+  async sendCharacter(char) {
+    await this._client.send('Input.dispatchKeyEvent', {
+      type: 'char',
+      modifiers: this._modifiers,
+      text: char,
+      key: char,
+      unmodifiedText: char
+    });
+  }
+
+  /**
+   * @param {string} text
+   * @param {{delay: (number|undefined)}=} options
+   */
+  async type(text, options) {
+    let delay = 0;
+    if (options && options.delay)
+      delay = options.delay;
+    for (const char of text) {
+      if (keyDefinitions[char])
+        await this.press(char, {delay});
+      else
+        await this.sendCharacter(char);
+      if (delay)
+        await new Promise(f => setTimeout(f, delay));
+    }
+  }
+
+  /**
+   * @param {string} key
+   * @param {!Object=} options
+   */
+  async press(key, options) {
+    await this.down(key, options);
+    if (options && options.delay)
+      await new Promise(f => setTimeout(f, options.delay));
+    await this.up(key);
+  }
+}
+
+class Mouse {
+  /**
+   * @param {Puppeteer.CDPSession} client
+   * @param {!Keyboard} keyboard
+   */
+  constructor(client, keyboard) {
+    this._client = client;
+    this._keyboard = keyboard;
+    this._x = 0;
+    this._y = 0;
+    this._button = 'none';
+  }
+
+  /**
+   * @param {number} x
+   * @param {number} y
+   * @param {Object=} options
+   * @return {!Promise}
+   */
+  async move(x, y, options = {}) {
+    const fromX = this._x, fromY = this._y;
+    this._x = x;
+    this._y = y;
+    const steps = options.steps || 1;
+    for (let i = 1; i <= steps; i++) {
+      await this._client.send('Input.dispatchMouseEvent', {
+        type: 'mouseMoved',
+        button: this._button,
+        x: fromX + (this._x - fromX) * (i / steps),
+        y: fromY + (this._y - fromY) * (i / steps),
+        modifiers: this._keyboard._modifiers
+      });
+    }
+  }
+
+  /**
+   * @param {number} x
+   * @param {number} y
+   * @param {!Object=} options
+   */
+  async click(x, y, options = {}) {
+    this.move(x, y);
+    this.down(options);
+    if (typeof options.delay === 'number')
+      await new Promise(f => setTimeout(f, options.delay));
+    await this.up(options);
+  }
+
+  /**
+   * @param {!Object=} options
+   */
+  async down(options = {}) {
+    this._button = (options.button || 'left');
+    await this._client.send('Input.dispatchMouseEvent', {
+      type: 'mousePressed',
+      button: this._button,
+      x: this._x,
+      y: this._y,
+      modifiers: this._keyboard._modifiers,
+      clickCount: (options.clickCount || 1)
+    });
+  }
+
+  /**
+   * @param {!Object=} options
+   */
+  async up(options = {}) {
+    this._button = 'none';
+    await this._client.send('Input.dispatchMouseEvent', {
+      type: 'mouseReleased',
+      button: (options.button || 'left'),
+      x: this._x,
+      y: this._y,
+      modifiers: this._keyboard._modifiers,
+      clickCount: (options.clickCount || 1)
+    });
+  }
+}
+
+class Touchscreen {
+  /**
+   * @param {Puppeteer.CDPSession} client
+   * @param {Keyboard} keyboard
+   */
+  constructor(client, keyboard) {
+    this._client = client;
+    this._keyboard = keyboard;
+  }
+
+  /**
+   * @param {number} x
+   * @param {number} y
+   */
+  async tap(x, y) {
+    // Touches appear to be lost during the first frame after navigation.
+    // This waits a frame before sending the tap.
+    // @see https://crbug.com/613219
+    await this._client.send('Runtime.evaluate', {
+      expression: 'new Promise(x => requestAnimationFrame(() => requestAnimationFrame(x)))',
+      awaitPromise: true
+    });
+
+    const touchPoints = [{x: Math.round(x), y: Math.round(y)}];
+    await this._client.send('Input.dispatchTouchEvent', {
+      type: 'touchStart',
+      touchPoints,
+      modifiers: this._keyboard._modifiers
+    });
+    await this._client.send('Input.dispatchTouchEvent', {
+      type: 'touchEnd',
+      touchPoints: [],
+      modifiers: this._keyboard._modifiers
+    });
+  }
+}
+
+module.exports = { Keyboard, Mouse, Touchscreen};
+helper.tracePublicAPI(Keyboard);
+helper.tracePublicAPI(Mouse);
+helper.tracePublicAPI(Touchscreen);

data/node_modules/puppeteer/lib/Launcher.js

@@ -0,0 +1,310 @@
+/**
+ * Copyright 2017 Google Inc. 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 os = require('os');
+const path = require('path');
+const removeFolder = require('rimraf');
+const childProcess = require('child_process');
+const BrowserFetcher = require('./BrowserFetcher');
+const {Connection} = require('./Connection');
+const Browser = require('./Browser');
+const readline = require('readline');
+const fs = require('fs');
+const {helper, debugError} = require('./helper');
+const ChromiumRevision = require(path.join(helper.projectRoot(), 'package.json')).puppeteer.chromium_revision;
+
+const mkdtempAsync = helper.promisify(fs.mkdtemp);
+const removeFolderAsync = helper.promisify(removeFolder);
+
+const CHROME_PROFILE_PATH = path.join(os.tmpdir(), 'puppeteer_dev_profile-');
+
+const DEFAULT_ARGS = [
+  '--disable-background-networking',
+  '--disable-background-timer-throttling',
+  '--disable-client-side-phishing-detection',
+  '--disable-default-apps',
+  '--disable-dev-shm-usage',
+  '--disable-extensions',
+  '--disable-hang-monitor',
+  '--disable-popup-blocking',
+  '--disable-prompt-on-repost',
+  '--disable-sync',
+  '--disable-translate',
+  '--metrics-recording-only',
+  '--no-first-run',
+  '--safebrowsing-disable-auto-update',
+];
+
+const AUTOMATION_ARGS = [
+  '--enable-automation',
+  '--password-store=basic',
+  '--use-mock-keychain',
+];
+
+class Launcher {
+  /**
+   * @param {!LaunchOptions=} options
+   * @return {!Promise<!Browser>}
+   */
+  static async launch(options) {
+    options = Object.assign({}, options || {});
+    console.assert(!options.ignoreDefaultArgs || !options.appMode, '`appMode` flag cannot be used together with `ignoreDefaultArgs`');
+    let temporaryUserDataDir = null;
+    const chromeArguments = [];
+    if (!options.ignoreDefaultArgs)
+      chromeArguments.push(...DEFAULT_ARGS);
+    if (options.appMode) {
+      options.headless = false;
+      options.pipe = true;
+    } else if (!options.ignoreDefaultArgs) {
+      chromeArguments.push(...AUTOMATION_ARGS);
+    }
+
+    if (!options.ignoreDefaultArgs || !chromeArguments.some(argument => argument.startsWith('--remote-debugging-')))
+      chromeArguments.push(options.pipe ? '--remote-debugging-pipe' : '--remote-debugging-port=0');
+
+    if (!options.args || !options.args.some(arg => arg.startsWith('--user-data-dir'))) {
+      if (!options.userDataDir)
+        temporaryUserDataDir = await mkdtempAsync(CHROME_PROFILE_PATH);
+
+      chromeArguments.push(`--user-data-dir=${options.userDataDir || temporaryUserDataDir}`);
+    }
+    if (options.devtools === true) {
+      chromeArguments.push('--auto-open-devtools-for-tabs');
+      options.headless = false;
+    }
+    if (typeof options.headless !== 'boolean' || options.headless) {
+      chromeArguments.push(
+          '--headless',
+          '--disable-gpu',
+          '--hide-scrollbars',
+          '--mute-audio'
+      );
+    }
+    let chromeExecutable = options.executablePath;
+    if (typeof chromeExecutable !== 'string') {
+      const browserFetcher = new BrowserFetcher();
+      const revisionInfo = browserFetcher.revisionInfo(ChromiumRevision);
+      console.assert(revisionInfo.local, `Chromium revision is not downloaded. Run "npm install" or "yarn install"`);
+      chromeExecutable = revisionInfo.executablePath;
+    }
+    if (Array.isArray(options.args))
+      chromeArguments.push(...options.args);
+
+
+    const usePipe = chromeArguments.includes('--remote-debugging-pipe');
+    const stdio = ['pipe', 'pipe', 'pipe'];
+    if (usePipe)
+      stdio.push('pipe', 'pipe');
+    const chromeProcess = childProcess.spawn(
+        chromeExecutable,
+        chromeArguments,
+        {
+          // On non-windows platforms, `detached: false` makes child process a leader of a new
+          // process group, making it possible to kill child process tree with `.kill(-pid)` command.
+          // @see https://nodejs.org/api/child_process.html#child_process_options_detached
+          detached: process.platform !== 'win32',
+          env: options.env || process.env,
+          stdio
+        }
+    );
+
+    if (options.dumpio) {
+      chromeProcess.stderr.pipe(process.stderr);
+      chromeProcess.stdout.pipe(process.stdout);
+    }
+
+    let chromeClosed = false;
+    const waitForChromeToClose = new Promise((fulfill, reject) => {
+      chromeProcess.once('close', () => {
+        chromeClosed = true;
+        // Cleanup as processes exit.
+        if (temporaryUserDataDir) {
+          removeFolderAsync(temporaryUserDataDir)
+              .then(() => fulfill())
+              .catch(err => console.error(err));
+        } else {
+          fulfill();
+        }
+      });
+    });
+
+    const listeners = [ helper.addEventListener(process, 'exit', killChrome) ];
+    if (options.handleSIGINT !== false)
+      listeners.push(helper.addEventListener(process, 'SIGINT', () => { killChrome(); process.exit(130); }));
+    if (options.handleSIGTERM !== false)
+      listeners.push(helper.addEventListener(process, 'SIGTERM', gracefullyCloseChrome));
+    if (options.handleSIGHUP !== false)
+      listeners.push(helper.addEventListener(process, 'SIGHUP', gracefullyCloseChrome));
+    /** @type {?Connection} */
+    let connection = null;
+    try {
+      const connectionDelay = options.slowMo || 0;
+      if (!usePipe) {
+        const timeout = helper.isNumber(options.timeout) ? options.timeout : 30000;
+        const browserWSEndpoint = await waitForWSEndpoint(chromeProcess, timeout);
+        connection = await Connection.createForWebSocket(browserWSEndpoint, connectionDelay);
+      } else {
+        connection = Connection.createForPipe(/** @type {!NodeJS.WritableStream} */(chromeProcess.stdio[3]), /** @type {!NodeJS.ReadableStream} */ (chromeProcess.stdio[4]), connectionDelay);
+      }
+      return Browser.create(connection, options, chromeProcess, gracefullyCloseChrome);
+    } catch (e) {
+      killChrome();
+      throw e;
+    }
+
+    /**
+     * @return {Promise}
+     */
+    function gracefullyCloseChrome() {
+      helper.removeEventListeners(listeners);
+      if (temporaryUserDataDir) {
+        killChrome();
+      } else if (connection) {
+        // Attempt to close chrome gracefully
+        connection.send('Browser.close').catch(error => {
+          debugError(error);
+          killChrome();
+        });
+      }
+      return waitForChromeToClose;
+    }
+
+    // This method has to be sync to be used as 'exit' event handler.
+    function killChrome() {
+      helper.removeEventListeners(listeners);
+      if (chromeProcess.pid && !chromeProcess.killed && !chromeClosed) {
+        // Force kill chrome.
+        try {
+          if (process.platform === 'win32')
+            childProcess.execSync(`taskkill /pid ${chromeProcess.pid} /T /F`);
+          else
+            process.kill(-chromeProcess.pid, 'SIGKILL');
+        } catch (e) {
+          // the process might have already stopped
+        }
+      }
+      // Attempt to remove temporary profile directory to avoid littering.
+      try {
+        removeFolder.sync(temporaryUserDataDir);
+      } catch (e) { }
+    }
+  }
+
+  /**
+   * @return {!Array<string>}
+   */
+  static defaultArgs() {
+    return DEFAULT_ARGS.concat(AUTOMATION_ARGS);
+  }
+
+  /**
+   * @return {string}
+   */
+  static executablePath() {
+    const browserFetcher = new BrowserFetcher();
+    const revisionInfo = browserFetcher.revisionInfo(ChromiumRevision);
+    return revisionInfo.executablePath;
+  }
+
+  /**
+   * @param {!Object=} options
+   * @return {!Promise<!Browser>}
+   */
+  static async connect(options = {}) {
+    const connectionDelay = options.slowMo || 0;
+    const connection = await Connection.createForWebSocket(options.browserWSEndpoint, connectionDelay);
+    return Browser.create(connection, options, null, () => connection.send('Browser.close').catch(debugError));
+  }
+}
+
+/**
+ * @param {!Puppeteer.ChildProcess} chromeProcess
+ * @param {number} timeout
+ * @return {!Promise<string>}
+ */
+function waitForWSEndpoint(chromeProcess, timeout) {
+  return new Promise((resolve, reject) => {
+    const rl = readline.createInterface({ input: chromeProcess.stderr });
+    let stderr = '';
+    const listeners = [
+      helper.addEventListener(rl, 'line', onLine),
+      helper.addEventListener(rl, 'close', () => onClose()),
+      helper.addEventListener(chromeProcess, 'exit', () => onClose()),
+      helper.addEventListener(chromeProcess, 'error', error => onClose(error))
+    ];
+    const timeoutId = timeout ? setTimeout(onTimeout, timeout) : 0;
+
+    /**
+     * @param {!Error=} error
+     */
+    function onClose(error) {
+      cleanup();
+      reject(new Error([
+        'Failed to launch chrome!' + (error ? ' ' + error.message : ''),
+        stderr,
+        '',
+        'TROUBLESHOOTING: https://github.com/GoogleChrome/puppeteer/blob/master/docs/troubleshooting.md',
+        '',
+      ].join('\n')));
+    }
+
+    function onTimeout() {
+      cleanup();
+      reject(new Error(`Timed out after ${timeout} ms while trying to connect to Chrome! The only Chrome revision guaranteed to work is r${ChromiumRevision}`));
+    }
+
+    /**
+     * @param {string} line
+     */
+    function onLine(line) {
+      stderr += line + '\n';
+      const match = line.match(/^DevTools listening on (ws:\/\/.*)$/);
+      if (!match)
+        return;
+      cleanup();
+      resolve(match[1]);
+    }
+
+    function cleanup() {
+      if (timeoutId)
+        clearTimeout(timeoutId);
+      helper.removeEventListeners(listeners);
+    }
+  });
+}
+
+/**
+ * @typedef {Object} LaunchOptions
+ * @property {boolean=} ignoreHTTPSErrors
+ * @property {boolean=} headless
+ * @property {string=} executablePath
+ * @property {number=} slowMo
+ * @property {!Array<string>=} args
+ * @property {boolean=} ignoreDefaultArgs
+ * @property {boolean=} handleSIGINT
+ * @property {boolean=} handleSIGTERM
+ * @property {boolean=} handleSIGHUP
+ * @property {number=} timeout
+ * @property {boolean=} dumpio
+ * @property {string=} userDataDir
+ * @property {!Object<string, string | undefined>=} env
+ * @property {boolean=} devtools
+ * @property {boolean=} pipe
+ * @property {boolean=} appMode
+ */
+
+
+module.exports = Launcher;

data/node_modules/puppeteer/lib/Multimap.js

@@ -0,0 +1,95 @@
+/**
+ * Copyright 2017 Google Inc. 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.
+ */
+
+class Multimap {
+  constructor() {
+    this._map = new Map();
+  }
+
+  set(key, value) {
+    let set = this._map.get(key);
+    if (!set) {
+      set = new Set();
+      this._map.set(key, set);
+    }
+    set.add(value);
+  }
+
+  get(key) {
+    let result = this._map.get(key);
+    if (!result)
+      result = new Set();
+    return result;
+  }
+
+  has(key) {
+    return this._map.has(key);
+  }
+
+  hasValue(key, value) {
+    const set = this._map.get(key);
+    if (!set)
+      return false;
+    return set.has(value);
+  }
+
+  /**
+   * @return {number}
+   */
+  get size() {
+    return this._map.size;
+  }
+
+  delete(key, value) {
+    const values = this.get(key);
+    const result = values.delete(value);
+    if (!values.size)
+      this._map.delete(key);
+    return result;
+  }
+
+  deleteAll(key) {
+    this._map.delete(key);
+  }
+
+  firstValue(key) {
+    const set = this._map.get(key);
+    if (!set)
+      return null;
+    return set.values().next().value;
+  }
+
+  firstKey() {
+    return this._map.keys().next().value;
+  }
+
+  valuesArray() {
+    const result = [];
+    for (const key of this._map.keys())
+      result.push(...Array.from(this._map.get(key).values()));
+    return result;
+  }
+
+  keysArray() {
+    return Array.from(this._map.keys());
+  }
+
+  clear() {
+    this._map.clear();
+  }
+}
+
+module.exports = Multimap;