postdoc 0.2.0.beta4 → 0.2.0

data/node_modules/puppeteer/lib/helper.js

@@ -1,248 +0,0 @@
-/**
- * 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 fs = require('fs');
-const path = require('path');
-
-const debugError = require('debug')(`puppeteer:error`);
-/** @type {?Map<string, boolean>} */
-let apiCoverage = null;
-let projectRoot = null;
-class Helper {
-  /**
-   * @param {Function|string} fun
-   * @param {!Array<*>} args
-   * @return {string}
-   */
-  static evaluationString(fun, ...args) {
-    if (Helper.isString(fun)) {
-      console.assert(args.length === 0, 'Cannot evaluate a string with arguments');
-      return /** @type {string} */ (fun);
-    }
-    return `(${fun})(${args.map(serializeArgument).join(',')})`;
-
-    /**
-     * @param {*} arg
-     * @return {string}
-     */
-    function serializeArgument(arg) {
-      if (Object.is(arg, undefined))
-        return 'undefined';
-      return JSON.stringify(arg);
-    }
-  }
-
-  /**
-   * @return {string}
-   */
-  static projectRoot() {
-    if (!projectRoot) {
-      // Project root will be different for node6-transpiled code.
-      projectRoot = fs.existsSync(path.join(__dirname, '..', 'package.json')) ? path.join(__dirname, '..') : path.join(__dirname, '..', '..');
-    }
-    return projectRoot;
-  }
-
-  /**
-   * @param {!Protocol.Runtime.ExceptionDetails} exceptionDetails
-   * @return {string}
-   */
-  static getExceptionMessage(exceptionDetails) {
-    if (exceptionDetails.exception)
-      return exceptionDetails.exception.description;
-    let message = exceptionDetails.text;
-    if (exceptionDetails.stackTrace) {
-      for (const callframe of exceptionDetails.stackTrace.callFrames) {
-        const location = callframe.url + ':' + callframe.lineNumber + ':' + callframe.columnNumber;
-        const functionName = callframe.functionName || '<anonymous>';
-        message += `\n    at ${functionName} (${location})`;
-      }
-    }
-    return message;
-  }
-
-  /**
-   * @param {!Protocol.Runtime.RemoteObject} remoteObject
-   * @return {*}
-   */
-  static valueFromRemoteObject(remoteObject) {
-    console.assert(!remoteObject.objectId, 'Cannot extract value when objectId is given');
-    if (remoteObject.unserializableValue) {
-      switch (remoteObject.unserializableValue) {
-        case '-0':
-          return -0;
-        case 'NaN':
-          return NaN;
-        case 'Infinity':
-          return Infinity;
-        case '-Infinity':
-          return -Infinity;
-        default:
-          throw new Error('Unsupported unserializable value: ' + remoteObject.unserializableValue);
-      }
-    }
-    return remoteObject.value;
-  }
-
-  /**
-   * @param {!Puppeteer.CDPSession} client
-   * @param {!Protocol.Runtime.RemoteObject} remoteObject
-   */
-  static async releaseObject(client, remoteObject) {
-    if (!remoteObject.objectId)
-      return;
-    await client.send('Runtime.releaseObject', {objectId: remoteObject.objectId}).catch(error => {
-      // Exceptions might happen in case of a page been navigated or closed.
-      // Swallow these since they are harmless and we don't leak anything in this case.
-      debugError(error);
-    });
-  }
-
-  /**
-   * @param {!Object} classType
-   * @param {string=} publicName
-   */
-  static tracePublicAPI(classType, publicName) {
-    let className = publicName || classType.prototype.constructor.name;
-    className = className.substring(0, 1).toLowerCase() + className.substring(1);
-    const debug = require('debug')(`puppeteer:${className}`);
-    if (!debug.enabled && !apiCoverage)
-      return;
-    for (const methodName of Reflect.ownKeys(classType.prototype)) {
-      const method = Reflect.get(classType.prototype, methodName);
-      if (methodName === 'constructor' || typeof methodName !== 'string' || methodName.startsWith('_') || typeof method !== 'function')
-        continue;
-      if (apiCoverage)
-        apiCoverage.set(`${className}.${methodName}`, false);
-      Reflect.set(classType.prototype, methodName, function(...args) {
-        const argsText = args.map(stringifyArgument).join(', ');
-        const callsite = `${className}.${methodName}(${argsText})`;
-        if (debug.enabled)
-          debug(callsite);
-        if (apiCoverage)
-          apiCoverage.set(`${className}.${methodName}`, true);
-        return method.call(this, ...args);
-      });
-    }
-
-    if (classType.Events) {
-      if (apiCoverage) {
-        for (const event of Object.values(classType.Events))
-          apiCoverage.set(`${className}.emit(${JSON.stringify(event)})`, false);
-      }
-      const method = Reflect.get(classType.prototype, 'emit');
-      Reflect.set(classType.prototype, 'emit', function(event, ...args) {
-        const argsText = [JSON.stringify(event)].concat(args.map(stringifyArgument)).join(', ');
-        if (debug.enabled && this.listenerCount(event))
-          debug(`${className}.emit(${argsText})`);
-        if (apiCoverage && this.listenerCount(event))
-          apiCoverage.set(`${className}.emit(${JSON.stringify(event)})`, true);
-        return method.call(this, event, ...args);
-      });
-    }
-
-    /**
-     * @param {!Object} arg
-     * @return {string}
-     */
-    function stringifyArgument(arg) {
-      if (Helper.isString(arg) || Helper.isNumber(arg) || !arg)
-        return JSON.stringify(arg);
-      if (typeof arg === 'function') {
-        let text = arg.toString().split('\n').map(line => line.trim()).join('');
-        if (text.length > 20)
-          text = text.substring(0, 20) + '…';
-        return `"${text}"`;
-      }
-      const state = {};
-      const keys = Object.keys(arg);
-      for (const key of keys) {
-        const value = arg[key];
-        if (Helper.isString(value) || Helper.isNumber(value))
-          state[key] = JSON.stringify(value);
-      }
-      const name = arg.constructor.name === 'Object' ? '' : arg.constructor.name;
-      return name + JSON.stringify(state);
-    }
-  }
-
-  /**
-   * @param {!NodeJS.EventEmitter} emitter
-   * @param {string} eventName
-   * @param {function(?)} handler
-   * @return {{emitter: !NodeJS.EventEmitter, eventName: string, handler: function(?)}}
-   */
-  static addEventListener(emitter, eventName, handler) {
-    emitter.on(eventName, handler);
-    return { emitter, eventName, handler };
-  }
-
-  /**
-   * @param {!Array<{emitter: !NodeJS.EventEmitter, eventName: string, handler: function(?)}>} listeners
-   */
-  static removeEventListeners(listeners) {
-    for (const listener of listeners)
-      listener.emitter.removeListener(listener.eventName, listener.handler);
-    listeners.splice(0, listeners.length);
-  }
-
-  /**
-   * @return {?Map<string, boolean>}
-   */
-  static publicAPICoverage() {
-    return apiCoverage;
-  }
-
-  static recordPublicAPICoverage() {
-    apiCoverage = new Map();
-  }
-
-  /**
-   * @param {!Object} obj
-   * @return {boolean}
-   */
-  static isString(obj) {
-    return typeof obj === 'string' || obj instanceof String;
-  }
-
-  /**
-   * @param {!Object} obj
-   * @return {boolean}
-   */
-  static isNumber(obj) {
-    return typeof obj === 'number' || obj instanceof Number;
-  }
-
-  static promisify(nodeFunction) {
-    function promisified(...args) {
-      return new Promise((resolve, reject) => {
-        function callback(err, ...result) {
-          if (err)
-            return reject(err);
-          if (result.length === 1)
-            return resolve(result[0]);
-          return resolve(result);
-        }
-        nodeFunction.call(null, ...args, callback);
-      });
-    }
-    return promisified;
-  }
-}
-
-module.exports = {
-  helper: Helper,
-  debugError
-};

data/node_modules/puppeteer/node6/lib/Browser.js

@@ -1,394 +0,0 @@
-/**
- * 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 Target = require('./Target');
-const EventEmitter = require('events');
-const TaskQueue = require('./TaskQueue');
-
-class Browser extends EventEmitter {
-  /**
-   * @param {!Puppeteer.Connection} connection
-   * @param {!BrowserOptions=} options
-   * @param {?Puppeteer.ChildProcess} process
-   * @param {(function():Promise)=} closeCallback
-   */
-  constructor(connection, options = {}, process, closeCallback) {
-    super();
-    this._ignoreHTTPSErrors = !!options.ignoreHTTPSErrors;
-    this._appMode = !!options.appMode;
-    this._process = process;
-    this._screenshotTaskQueue = new TaskQueue();
-    this._connection = connection;
-    this._closeCallback = closeCallback || new Function();
-    /** @type {Map<string, Target>} */
-    this._targets = new Map();
-    this._connection.setClosedCallback(() => {
-      this.emit(Browser.Events.Disconnected);
-    });
-    this._connection.on('Target.targetCreated', this._targetCreated.bind(this));
-    this._connection.on('Target.targetDestroyed', this._targetDestroyed.bind(this));
-    this._connection.on('Target.targetInfoChanged', this._targetInfoChanged.bind(this));
-  }
-
-  /**
-   * @return {?Puppeteer.ChildProcess}
-   */
-  process() {
-    return this._process;
-  }
-
-  /**
-   * @param {!Puppeteer.Connection} connection
-   * @param {!BrowserOptions=} options
-   * @param {?Puppeteer.ChildProcess} process
-   * @param {function()=} closeCallback
-   */
-  static /* async */ create(connection, options, process, closeCallback) {return (fn => {
-  const gen = fn.call(this);
-  return new Promise((resolve, reject) => {
-    function step(key, arg) {
-      let info, value;
-      try {
-        info = gen[key](arg);
-        value = info.value;
-      } catch (error) {
-        reject(error);
-        return;
-      }
-      if (info.done) {
-        resolve(value);
-      } else {
-        return Promise.resolve(value).then(
-            value => {
-              step('next', value);
-            },
-            err => {
-              step('throw', err);
-            });
-      }
-    }
-    return step('next');
-  });
-})(function*(){
-    const browser = new Browser(connection, options, process, closeCallback);
-    (yield connection.send('Target.setDiscoverTargets', {discover: true}));
-    return browser;
-  });}
-
-  /**
-   * @param {{targetInfo: !Puppeteer.TargetInfo}} event
-   */
-  /* async */ _targetCreated(event) {return (fn => {
-  const gen = fn.call(this);
-  return new Promise((resolve, reject) => {
-    function step(key, arg) {
-      let info, value;
-      try {
-        info = gen[key](arg);
-        value = info.value;
-      } catch (error) {
-        reject(error);
-        return;
-      }
-      if (info.done) {
-        resolve(value);
-      } else {
-        return Promise.resolve(value).then(
-            value => {
-              step('next', value);
-            },
-            err => {
-              step('throw', err);
-            });
-      }
-    }
-    return step('next');
-  });
-})(function*(){
-    const targetInfo = event.targetInfo;
-    const target = new Target(targetInfo, this, () => this._connection.createSession(targetInfo.targetId), this._ignoreHTTPSErrors, !this._appMode, this._screenshotTaskQueue);
-    console.assert(!this._targets.has(event.targetInfo.targetId), 'Target should not exist before targetCreated');
-    this._targets.set(event.targetInfo.targetId, target);
-
-    if ((yield target._initializedPromise))
-      this.emit(Browser.Events.TargetCreated, target);
-  });}
-
-  /**
-   * @param {{targetId: string}} event
-   */
-  /* async */ _targetDestroyed(event) {return (fn => {
-  const gen = fn.call(this);
-  return new Promise((resolve, reject) => {
-    function step(key, arg) {
-      let info, value;
-      try {
-        info = gen[key](arg);
-        value = info.value;
-      } catch (error) {
-        reject(error);
-        return;
-      }
-      if (info.done) {
-        resolve(value);
-      } else {
-        return Promise.resolve(value).then(
-            value => {
-              step('next', value);
-            },
-            err => {
-              step('throw', err);
-            });
-      }
-    }
-    return step('next');
-  });
-})(function*(){
-    const target = this._targets.get(event.targetId);
-    target._initializedCallback(false);
-    this._targets.delete(event.targetId);
-    target._closedCallback();
-    if ((yield target._initializedPromise))
-      this.emit(Browser.Events.TargetDestroyed, target);
-  });}
-
-  /**
-   * @param {{targetInfo: !Puppeteer.TargetInfo}} event
-   */
-  _targetInfoChanged(event) {
-    const target = this._targets.get(event.targetInfo.targetId);
-    console.assert(target, 'target should exist before targetInfoChanged');
-    const previousURL = target.url();
-    const wasInitialized = target._isInitialized;
-    target._targetInfoChanged(event.targetInfo);
-    if (wasInitialized && previousURL !== target.url())
-      this.emit(Browser.Events.TargetChanged, target);
-  }
-
-  /**
-   * @return {string}
-   */
-  wsEndpoint() {
-    return this._connection.url();
-  }
-
-  /**
-   * @return {!Promise<!Puppeteer.Page>}
-   */
-  /* async */ newPage() {return (fn => {
-  const gen = fn.call(this);
-  return new Promise((resolve, reject) => {
-    function step(key, arg) {
-      let info, value;
-      try {
-        info = gen[key](arg);
-        value = info.value;
-      } catch (error) {
-        reject(error);
-        return;
-      }
-      if (info.done) {
-        resolve(value);
-      } else {
-        return Promise.resolve(value).then(
-            value => {
-              step('next', value);
-            },
-            err => {
-              step('throw', err);
-            });
-      }
-    }
-    return step('next');
-  });
-})(function*(){
-    const {targetId} = (yield this._connection.send('Target.createTarget', {url: 'about:blank'}));
-    const target = (yield this._targets.get(targetId));
-    console.assert((yield target._initializedPromise), 'Failed to create target for page');
-    const page = (yield target.page());
-    return page;
-  });}
-
-  /**
-   * @return {!Array<!Target>}
-   */
-  targets() {
-    return Array.from(this._targets.values()).filter(target => target._isInitialized);
-  }
-
-  /**
-   * @return {!Promise<!Array<!Puppeteer.Page>>}
-   */
-  /* async */ pages() {return (fn => {
-  const gen = fn.call(this);
-  return new Promise((resolve, reject) => {
-    function step(key, arg) {
-      let info, value;
-      try {
-        info = gen[key](arg);
-        value = info.value;
-      } catch (error) {
-        reject(error);
-        return;
-      }
-      if (info.done) {
-        resolve(value);
-      } else {
-        return Promise.resolve(value).then(
-            value => {
-              step('next', value);
-            },
-            err => {
-              step('throw', err);
-            });
-      }
-    }
-    return step('next');
-  });
-})(function*(){
-    const pages = (yield Promise.all(this.targets().map(target => target.page())));
-    return pages.filter(page => !!page);
-  });}
-
-  /**
-   * @return {!Promise<string>}
-   */
-  /* async */ version() {return (fn => {
-  const gen = fn.call(this);
-  return new Promise((resolve, reject) => {
-    function step(key, arg) {
-      let info, value;
-      try {
-        info = gen[key](arg);
-        value = info.value;
-      } catch (error) {
-        reject(error);
-        return;
-      }
-      if (info.done) {
-        resolve(value);
-      } else {
-        return Promise.resolve(value).then(
-            value => {
-              step('next', value);
-            },
-            err => {
-              step('throw', err);
-            });
-      }
-    }
-    return step('next');
-  });
-})(function*(){
-    const version = (yield this._getVersion());
-    return version.product;
-  });}
-
-  /**
-   * @return {!Promise<string>}
-   */
-  /* async */ userAgent() {return (fn => {
-  const gen = fn.call(this);
-  return new Promise((resolve, reject) => {
-    function step(key, arg) {
-      let info, value;
-      try {
-        info = gen[key](arg);
-        value = info.value;
-      } catch (error) {
-        reject(error);
-        return;
-      }
-      if (info.done) {
-        resolve(value);
-      } else {
-        return Promise.resolve(value).then(
-            value => {
-              step('next', value);
-            },
-            err => {
-              step('throw', err);
-            });
-      }
-    }
-    return step('next');
-  });
-})(function*(){
-    const version = (yield this._getVersion());
-    return version.userAgent;
-  });}
-
-  /* async */ close() {return (fn => {
-  const gen = fn.call(this);
-  return new Promise((resolve, reject) => {
-    function step(key, arg) {
-      let info, value;
-      try {
-        info = gen[key](arg);
-        value = info.value;
-      } catch (error) {
-        reject(error);
-        return;
-      }
-      if (info.done) {
-        resolve(value);
-      } else {
-        return Promise.resolve(value).then(
-            value => {
-              step('next', value);
-            },
-            err => {
-              step('throw', err);
-            });
-      }
-    }
-    return step('next');
-  });
-})(function*(){
-    (yield this._closeCallback.call(null));
-    this.disconnect();
-  });}
-
-  disconnect() {
-    this._connection.dispose();
-  }
-
-  /**
-   * @return {!Promise<!Object>}
-   */
-  _getVersion() {
-    return this._connection.send('Browser.getVersion');
-  }
-}
-
-/** @enum {string} */
-Browser.Events = {
-  TargetCreated: 'targetcreated',
-  TargetDestroyed: 'targetdestroyed',
-  TargetChanged: 'targetchanged',
-  Disconnected: 'disconnected'
-};
-
-helper.tracePublicAPI(Browser);
-
-module.exports = Browser;
-
-/**
- * @typedef {Object} BrowserOptions
- * @property {boolean=} appMode
- * @property {boolean=} ignoreHTTPSErrors
- */