test('it handles a cancellation followed by a new request', async () => {
    const source = CancelToken.source();
    const promise1 = cache.getOrCompute('key', async () => {
      while (true) {
        await Promise.resolve();
        source.token.throwIfRequested();
      }
    }, source.token);
    source.cancel();
    await assertIsCancelled(promise1);

    const source2 = CancelToken.source();
    const promise2 = cache.getOrCompute('key', async () => {
      await Promise.resolve();
      return 'finished!';
    }, source2.token);
    assert.equal(await promise2, 'finished!');
  });

  test(`analyze() does not complete when cancelled`, async () => {
    const {analyzer} = await createForDirectory(fixtureDir);
    const cancelSource = CancelToken.source();

    const analysisPromise = analyzer.analyze(
        ['vanilla-elements.js'], {cancelToken: cancelSource.token});
    cancelSource.cancel();
    const analysis = await analysisPromise;
    const result = analysis.getDocument('vanilla-element.js');
    if (result.successful) {
      throw new Error(`Did not expect analysis to succeed when cancelled.`);
    }
  });

 * This code may only be used under the BSD style license found at
 * http://polymer.github.io/LICENSE.txt
 * The complete set of authors may be found at
 * http://polymer.github.io/AUTHORS.txt
 * The complete set of contributors may be found at
 * http://polymer.github.io/CONTRIBUTORS.txt
 * Code distributed by Google as part of the polymer project is also
 * subject to an additional IP rights grant found at
 * http://polymer.github.io/PATENTS.txt
 */

import {CancelToken} from 'cancel-token';

/**
 * The analyzer only uses one method from CancelTokens, and it's likely to be
 * the least contentious, so even if other parts change on the way to
 * standardization,
 * this probably won't.
 */
export interface MinimalCancelToken {
  /**
   * If the token has been cancelled then this method throws a Cancel, otherwise
   * it returns undefined.
   *
   * A Cancel is an object constructed by a constructor named 'Cancel'.
   */
  throwIfRequested(): void;
}

export const neverCancels: MinimalCancelToken = CancelToken.source().token;

 */

import './collections';

import {CancelToken} from 'cancel-token';
import {Analysis, Analyzer, Document, ParsedDocument, ResolvedUrl, Severity, Warning, WarningCarryingException} from 'polymer-analyzer';

import {AnalyzeOptions} from 'polymer-analyzer/lib/core/analyzer';
import {MinimalCancelToken} from 'polymer-analyzer/lib/core/cancel-token';

import {Rule} from './rule';

export {registry} from './registry';
export {Rule, RuleCollection} from './rule';

const {token: neverCancels} = CancelToken.source();

/**
 * The Linter is a simple class which groups together a set of Rules and applies
 * them to a set of file urls which can be resolved and loaded by the provided
 * Analyzer.  A default Analyzer is prepared if one is not provided.
 */
export class Linter {
  private _analyzer: Analyzer;
  private _rules: Rule[];

  constructor(rules: Iterable<Rule>, analyzer: Analyzer) {
    this._analyzer = analyzer;
    this._rules = Array.from(rules);
  }