postdoc 0.2.0.beta4 → 0.2.0

data/node_modules/puppeteer/lib/Coverage.js

@@ -1,301 +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, debugError} = require('./helper');
-
-/**
- * @typedef {Object} CoverageEntry
- * @property {string} url
- * @property {string} text
- * @property {!Array<!{start: number, end: number}>} ranges
- */
-
-class Coverage {
-  /**
-   * @param {!Puppeteer.CDPSession} client
-   */
-  constructor(client) {
-    this._jsCoverage = new JSCoverage(client);
-    this._cssCoverage = new CSSCoverage(client);
-  }
-
-  /**
-   * @param {!Object} options
-   */
-  async startJSCoverage(options) {
-    return await this._jsCoverage.start(options);
-  }
-
-  /**
-   * @return {!Promise<!Array<!CoverageEntry>>}
-   */
-  async stopJSCoverage() {
-    return await this._jsCoverage.stop();
-  }
-
-  /**
-   * @param {!Object} options
-   */
-  async startCSSCoverage(options) {
-    return await this._cssCoverage.start(options);
-  }
-
-  /**
-   * @return {!Promise<!Array<!CoverageEntry>>}
-   */
-  async stopCSSCoverage() {
-    return await this._cssCoverage.stop();
-  }
-}
-
-module.exports = {Coverage};
-helper.tracePublicAPI(Coverage);
-
-class JSCoverage {
-  /**
-   * @param {!Puppeteer.CDPSession} client
-   */
-  constructor(client) {
-    this._client = client;
-    this._enabled = false;
-    this._scriptURLs = new Map();
-    this._scriptSources = new Map();
-    this._eventListeners = [];
-    this._resetOnNavigation = false;
-  }
-
-  /**
-   * @param {!Object} options
-   */
-  async start(options = {}) {
-    console.assert(!this._enabled, 'JSCoverage is already enabled');
-    this._resetOnNavigation = options.resetOnNavigation === undefined ? true : !!options.resetOnNavigation;
-    this._enabled = true;
-    this._scriptURLs.clear();
-    this._scriptSources.clear();
-    this._eventListeners = [
-      helper.addEventListener(this._client, 'Debugger.scriptParsed', this._onScriptParsed.bind(this)),
-      helper.addEventListener(this._client, 'Runtime.executionContextsCleared', this._onExecutionContextsCleared.bind(this)),
-    ];
-    await Promise.all([
-      this._client.send('Profiler.enable'),
-      this._client.send('Profiler.startPreciseCoverage', {callCount: false, detailed: true}),
-      this._client.send('Debugger.enable'),
-      this._client.send('Debugger.setSkipAllPauses', {skip: true})
-    ]);
-  }
-
-  _onExecutionContextsCleared() {
-    if (!this._resetOnNavigation)
-      return;
-    this._scriptURLs.clear();
-    this._scriptSources.clear();
-  }
-
-  /**
-   * @param {!Protocol.Debugger.scriptParsedPayload} event
-   */
-  async _onScriptParsed(event) {
-    // Ignore anonymous scripts
-    if (!event.url)
-      return;
-    try {
-      const response = await this._client.send('Debugger.getScriptSource', {scriptId: event.scriptId});
-      this._scriptURLs.set(event.scriptId, event.url);
-      this._scriptSources.set(event.scriptId, response.scriptSource);
-    } catch (e) {
-      // This might happen if the page has already navigated away.
-      debugError(e);
-    }
-  }
-
-  /**
-   * @return {!Promise<!Array<!CoverageEntry>>}
-   */
-  async stop() {
-    console.assert(this._enabled, 'JSCoverage is not enabled');
-    this._enabled = false;
-    const [profileResponse] = await Promise.all([
-      this._client.send('Profiler.takePreciseCoverage'),
-      this._client.send('Profiler.stopPreciseCoverage'),
-      this._client.send('Profiler.disable'),
-      this._client.send('Debugger.disable'),
-    ]);
-    helper.removeEventListeners(this._eventListeners);
-
-    const coverage = [];
-    for (const entry of profileResponse.result) {
-      const url = this._scriptURLs.get(entry.scriptId);
-      const text = this._scriptSources.get(entry.scriptId);
-      if (text === undefined || url === undefined)
-        continue;
-      const flattenRanges = [];
-      for (const func of entry.functions)
-        flattenRanges.push(...func.ranges);
-      const ranges = convertToDisjointRanges(flattenRanges);
-      coverage.push({url, ranges, text});
-    }
-    return coverage;
-  }
-}
-
-class CSSCoverage {
-  /**
-   * @param {!Puppeteer.CDPSession} client
-   */
-  constructor(client) {
-    this._client = client;
-    this._enabled = false;
-    this._stylesheetURLs = new Map();
-    this._stylesheetSources = new Map();
-    this._eventListeners = [];
-    this._resetOnNavigation = false;
-  }
-
-  /**
-   * @param {!Object} options
-   */
-  async start(options = {}) {
-    console.assert(!this._enabled, 'CSSCoverage is already enabled');
-    this._resetOnNavigation = options.resetOnNavigation === undefined ? true : !!options.resetOnNavigation;
-    this._enabled = true;
-    this._stylesheetURLs.clear();
-    this._stylesheetSources.clear();
-    this._eventListeners = [
-      helper.addEventListener(this._client, 'CSS.styleSheetAdded', this._onStyleSheet.bind(this)),
-      helper.addEventListener(this._client, 'Runtime.executionContextsCleared', this._onExecutionContextsCleared.bind(this)),
-    ];
-    await Promise.all([
-      this._client.send('DOM.enable'),
-      this._client.send('CSS.enable'),
-      this._client.send('CSS.startRuleUsageTracking'),
-    ]);
-  }
-
-  _onExecutionContextsCleared() {
-    if (!this._resetOnNavigation)
-      return;
-    this._stylesheetURLs.clear();
-    this._stylesheetSources.clear();
-  }
-
-  /**
-   * @param {!Protocol.CSS.styleSheetAddedPayload} event
-   */
-  async _onStyleSheet(event) {
-    const header = event.header;
-    // Ignore anonymous scripts
-    if (!header.sourceURL)
-      return;
-    try {
-      const response = await this._client.send('CSS.getStyleSheetText', {styleSheetId: header.styleSheetId});
-      this._stylesheetURLs.set(header.styleSheetId, header.sourceURL);
-      this._stylesheetSources.set(header.styleSheetId, response.text);
-    } catch (e) {
-      // This might happen if the page has already navigated away.
-      debugError(e);
-    }
-  }
-
-  /**
-   * @return {!Promise<!Array<!CoverageEntry>>}
-   */
-  async stop() {
-    console.assert(this._enabled, 'CSSCoverage is not enabled');
-    this._enabled = false;
-    const [ruleTrackingResponse] = await Promise.all([
-      this._client.send('CSS.stopRuleUsageTracking'),
-      this._client.send('CSS.disable'),
-      this._client.send('DOM.disable'),
-    ]);
-    helper.removeEventListeners(this._eventListeners);
-
-    // aggregate by styleSheetId
-    const styleSheetIdToCoverage = new Map();
-    for (const entry of ruleTrackingResponse.ruleUsage) {
-      let ranges = styleSheetIdToCoverage.get(entry.styleSheetId);
-      if (!ranges) {
-        ranges = [];
-        styleSheetIdToCoverage.set(entry.styleSheetId, ranges);
-      }
-      ranges.push({
-        startOffset: entry.startOffset,
-        endOffset: entry.endOffset,
-        count: entry.used ? 1 : 0,
-      });
-    }
-
-    const coverage = [];
-    for (const styleSheetId of this._stylesheetURLs.keys()) {
-      const url = this._stylesheetURLs.get(styleSheetId);
-      const text = this._stylesheetSources.get(styleSheetId);
-      const ranges = convertToDisjointRanges(styleSheetIdToCoverage.get(styleSheetId) || []);
-      coverage.push({url, ranges, text});
-    }
-
-    return coverage;
-  }
-}
-
-/**
- * @param {!Array<!{startOffset:number, endOffset:number, count:number}>} nestedRanges
- * @return {!Array<!{start:number, end:number}>}
- */
-function convertToDisjointRanges(nestedRanges) {
-  const points = [];
-  for (const range of nestedRanges) {
-    points.push({ offset: range.startOffset, type: 0, range });
-    points.push({ offset: range.endOffset, type: 1, range });
-  }
-  // Sort points to form a valid parenthesis sequence.
-  points.sort((a, b) => {
-    // Sort with increasing offsets.
-    if (a.offset !== b.offset)
-      return a.offset - b.offset;
-    // All "end" points should go before "start" points.
-    if (a.type !== b.type)
-      return b.type - a.type;
-    const aLength = a.range.endOffset - a.range.startOffset;
-    const bLength = b.range.endOffset - b.range.startOffset;
-    // For two "start" points, the one with longer range goes first.
-    if (a.type === 0)
-      return bLength - aLength;
-    // For two "end" points, the one with shorter range goes first.
-    return aLength - bLength;
-  });
-
-  const hitCountStack = [];
-  const results = [];
-  let lastOffset = 0;
-  // Run scanning line to intersect all ranges.
-  for (const point of points) {
-    if (hitCountStack.length && lastOffset < point.offset && hitCountStack[hitCountStack.length - 1] > 0) {
-      const lastResult = results.length ? results[results.length - 1] : null;
-      if (lastResult && lastResult.end === lastOffset)
-        lastResult.end = point.offset;
-      else
-        results.push({start: lastOffset, end: point.offset});
-    }
-    lastOffset = point.offset;
-    if (point.type === 0)
-      hitCountStack.push(point.range.count);
-    else
-      hitCountStack.pop();
-  }
-  // Filter out empty ranges.
-  return results.filter(range => range.end - range.start > 1);
-}
-

data/node_modules/puppeteer/lib/Dialog.js

@@ -1,84 +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');
-
-class Dialog {
-  /**
-   * @param {!Puppeteer.CDPSession} client
-   * @param {string} type
-   * @param {string} message
-   * @param {(string|undefined)} defaultValue
-   */
-  constructor(client, type, message, defaultValue = '') {
-    this._client = client;
-    this._type = type;
-    this._message = message;
-    this._handled = false;
-    this._defaultValue = defaultValue;
-  }
-
-  /**
-   * @return {string}
-   */
-  type() {
-    return this._type;
-  }
-
-  /**
-   * @return {string}
-   */
-  message() {
-    return this._message;
-  }
-
-  /**
-   * @return {string}
-   */
-  defaultValue() {
-    return this._defaultValue;
-  }
-
-  /**
-   * @param {string=} promptText
-   */
-  async accept(promptText) {
-    console.assert(!this._handled, 'Cannot accept dialog which is already handled!');
-    this._handled = true;
-    await this._client.send('Page.handleJavaScriptDialog', {
-      accept: true,
-      promptText: promptText
-    });
-  }
-
-  async dismiss() {
-    console.assert(!this._handled, 'Cannot dismiss dialog which is already handled!');
-    this._handled = true;
-    await this._client.send('Page.handleJavaScriptDialog', {
-      accept: false
-    });
-  }
-}
-
-Dialog.Type = {
-  Alert: 'alert',
-  BeforeUnload: 'beforeunload',
-  Confirm: 'confirm',
-  Prompt: 'prompt'
-};
-
-module.exports = Dialog;
-helper.tracePublicAPI(Dialog);

data/node_modules/puppeteer/lib/ElementHandle.js

@@ -1,328 +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 path = require('path');
-const {JSHandle} = require('./ExecutionContext');
-const {helper, debugError} = require('./helper');
-
-class ElementHandle extends JSHandle {
-  /**
-   * @param {!Puppeteer.ExecutionContext} context
-   * @param {!Puppeteer.CDPSession} client
-   * @param {!Protocol.Runtime.RemoteObject} remoteObject
-   * @param {!Puppeteer.Page} page
-   * @param {!Puppeteer.FrameManager} frameManager
-   */
-  constructor(context, client, remoteObject, page, frameManager) {
-    super(context, client, remoteObject);
-    this._client = client;
-    this._remoteObject = remoteObject;
-    this._page = page;
-    this._frameManager = frameManager;
-    this._disposed = false;
-  }
-
-  /**
-   * @override
-   * @return {?ElementHandle}
-   */
-  asElement() {
-    return this;
-  }
-
-  /**
-   * @return {!Promise<?Puppeteer.Frame>}
-   */
-  async contentFrame() {
-    const nodeInfo = await this._client.send('DOM.describeNode', {
-      objectId: this._remoteObject.objectId
-    });
-    if (typeof nodeInfo.node.frameId !== 'string')
-      return null;
-    return this._frameManager.frame(nodeInfo.node.frameId);
-  }
-
-  async _scrollIntoViewIfNeeded() {
-    const error = await this.executionContext().evaluate(element => {
-      if (!element.isConnected)
-        return 'Node is detached from document';
-      if (element.nodeType !== Node.ELEMENT_NODE)
-        return 'Node is not of type HTMLElement';
-      element.scrollIntoViewIfNeeded();
-      return false;
-    }, this);
-    if (error)
-      throw new Error(error);
-  }
-
-  /**
-   * @return {!Promise<{x: number, y: number}>}
-   */
-  async _visibleCenter() {
-    await this._scrollIntoViewIfNeeded();
-    const box = await this._assertBoundingBox();
-    return {
-      x: box.x + box.width / 2,
-      y: box.y + box.height / 2
-    };
-  }
-
-  /**
-   * @return {!Promise<void|Protocol.DOM.getBoxModelReturnValue>}
-   */
-  _getBoxModel() {
-    return this._client.send('DOM.getBoxModel', {
-      objectId: this._remoteObject.objectId
-    }).catch(error => debugError(error));
-  }
-
-  /**
-   * @param {!Array<number>} quad
-   * @return {!Array<object>}
-   */
-  _fromProtocolQuad(quad) {
-    return [
-      {x: quad[0], y: quad[1]},
-      {x: quad[2], y: quad[3]},
-      {x: quad[4], y: quad[5]},
-      {x: quad[6], y: quad[7]}
-    ];
-  }
-
-  async hover() {
-    const {x, y} = await this._visibleCenter();
-    await this._page.mouse.move(x, y);
-  }
-
-  /**
-   * @param {!Object=} options
-   */
-  async click(options = {}) {
-    const {x, y} = await this._visibleCenter();
-    await this._page.mouse.click(x, y, options);
-  }
-
-  /**
-   * @param {!Array<string>} filePaths
-   * @return {!Promise}
-   */
-  async uploadFile(...filePaths) {
-    const files = filePaths.map(filePath => path.resolve(filePath));
-    const objectId = this._remoteObject.objectId;
-    return this._client.send('DOM.setFileInputFiles', { objectId, files });
-  }
-
-  async tap() {
-    const {x, y} = await this._visibleCenter();
-    await this._page.touchscreen.tap(x, y);
-  }
-
-  async focus() {
-    await this.executionContext().evaluate(element => element.focus(), this);
-  }
-
-  /**
-   * @param {string} text
-   * @param {{delay: (number|undefined)}=} options
-   */
-  async type(text, options) {
-    await this.focus();
-    await this._page.keyboard.type(text, options);
-  }
-
-  /**
-   * @param {string} key
-   * @param {!Object=} options
-   */
-  async press(key, options) {
-    await this.focus();
-    await this._page.keyboard.press(key, options);
-  }
-
-  /**
-   * @return {!Promise<?{x: number, y: number, width: number, height: number}>}
-   */
-  async boundingBox() {
-    const result = await this._getBoxModel();
-
-    if (!result)
-      return null;
-
-    const quad = result.model.border;
-    const x = Math.min(quad[0], quad[2], quad[4], quad[6]);
-    const y = Math.min(quad[1], quad[3], quad[5], quad[7]);
-    const width = Math.max(quad[0], quad[2], quad[4], quad[6]) - x;
-    const height = Math.max(quad[1], quad[3], quad[5], quad[7]) - y;
-
-    return {x, y, width, height};
-  }
-
-  /**
-   * @return {!Promise<?object>}
-   */
-  async boxModel() {
-    const result = await this._getBoxModel();
-
-    if (!result)
-      return null;
-
-    const {content, padding, border, margin, width, height} = result.model;
-    return {
-      content: this._fromProtocolQuad(content),
-      padding: this._fromProtocolQuad(padding),
-      border: this._fromProtocolQuad(border),
-      margin: this._fromProtocolQuad(margin),
-      width,
-      height
-    };
-  }
-
-  /**
-   * @return {!Promise<?{x: number, y: number, width: number, height: number}>}
-   */
-  async _assertBoundingBox() {
-    const boundingBox = await this.boundingBox();
-    if (boundingBox)
-      return boundingBox;
-
-    throw new Error('Node is either not visible or not an HTMLElement');
-  }
-
-  /**
-   *
-   * @param {!Object=} options
-   * @returns {!Promise<Object>}
-   */
-  async screenshot(options = {}) {
-    let needsViewportReset = false;
-
-    let boundingBox = await this._assertBoundingBox();
-
-    const viewport = this._page.viewport();
-
-    if (boundingBox.width > viewport.width || boundingBox.height > viewport.height) {
-      const newViewport = {
-        width: Math.max(viewport.width, Math.ceil(boundingBox.width)),
-        height: Math.max(viewport.height, Math.ceil(boundingBox.height)),
-      };
-      await this._page.setViewport(Object.assign({}, viewport, newViewport));
-
-      needsViewportReset = true;
-    }
-
-    await this.executionContext().evaluate(function(element) {
-      element.scrollIntoView({block: 'center', inline: 'center', behavior: 'instant'});
-    }, this);
-
-    boundingBox = await this._assertBoundingBox();
-
-    const { layoutViewport: { pageX, pageY } } = await this._client.send('Page.getLayoutMetrics');
-
-    const clip = Object.assign({}, boundingBox);
-    clip.x += pageX;
-    clip.y += pageY;
-
-    const imageData = await this._page.screenshot(Object.assign({}, {
-      clip
-    }, options));
-
-    if (needsViewportReset)
-      await this._page.setViewport(viewport);
-
-    return imageData;
-  }
-
-  /**
-   * @param {string} selector
-   * @return {!Promise<?ElementHandle>}
-   */
-  async $(selector) {
-    const handle = await this.executionContext().evaluateHandle(
-        (element, selector) => element.querySelector(selector),
-        this, selector
-    );
-    const element = handle.asElement();
-    if (element)
-      return element;
-    await handle.dispose();
-    return null;
-  }
-
-  /**
-   * @param {string} selector
-   * @return {!Promise<!Array<!ElementHandle>>}
-   */
-  async $$(selector) {
-    const arrayHandle = await this.executionContext().evaluateHandle(
-        (element, selector) => element.querySelectorAll(selector),
-        this, selector
-    );
-    const properties = await arrayHandle.getProperties();
-    await arrayHandle.dispose();
-    const result = [];
-    for (const property of properties.values()) {
-      const elementHandle = property.asElement();
-      if (elementHandle)
-        result.push(elementHandle);
-    }
-    return result;
-  }
-
-  /**
-   * @param {string} selector
-   * @param {Function|String} pageFunction
-   * @param {!Array<*>} args
-   * @return {!Promise<(!Object|undefined)>}
-   */
-  async $eval(selector, pageFunction, ...args) {
-    const elementHandle = await this.$(selector);
-    if (!elementHandle)
-      throw new Error(`Error: failed to find element matching selector "${selector}"`);
-    const result = await this.executionContext().evaluate(pageFunction, elementHandle, ...args);
-    await elementHandle.dispose();
-    return result;
-  }
-
-  /**
-   * @param {string} expression
-   * @return {!Promise<!Array<!ElementHandle>>}
-   */
-  async $x(expression) {
-    const arrayHandle = await this.executionContext().evaluateHandle(
-        (element, expression) => {
-          const document = element.ownerDocument || element;
-          const iterator = document.evaluate(expression, element, null, XPathResult.ORDERED_NODE_ITERATOR_TYPE);
-          const array = [];
-          let item;
-          while ((item = iterator.iterateNext()))
-            array.push(item);
-          return array;
-        },
-        this, expression
-    );
-    const properties = await arrayHandle.getProperties();
-    await arrayHandle.dispose();
-    const result = [];
-    for (const property of properties.values()) {
-      const elementHandle = property.asElement();
-      if (elementHandle)
-        result.push(elementHandle);
-    }
-    return result;
-  }
-}
-
-module.exports = ElementHandle;
-helper.tracePublicAPI(ElementHandle);