async function fetch(
  script: HTMLScriptElement,
  timeout: number,
): Promise<Either<Error, FetchData>> {
  if (!script.hasAttribute('src')) return Right<FetchData>([script, script.text]);
  if (script.type.toLowerCase() === 'module') return Right<FetchData>([script, '']);
  return AtomicPromise.race([
    window.fetch(script.src, {
      headers: new Headers({
        Accept: 'application/javascript',
      }),
      integrity: script.integrity,
    }),
    wait(timeout).then(() => AtomicPromise.reject(new Error(`${script.src}: Timeout.`))),
  ])
    .then(
      async res =>
        res.ok
          ? Right<FetchData>([script, await res.text()])
          : script.matches('[src][async]')
            ? retry(script)
                .then(
                  () => Right<FetchData>([script, '']),
                  () => Left(new Error(`${script.src}: ${res.statusText}`)))
            : Left(new Error(res.statusText)),
      (error: Error) => Left(error));
}

 function run(responses: Either<Error, FetchData>[]): Either<Error, AtomicPromise<Result>> {
   return responses
     .reduce(
       (results, m) => m.bind(() => results),
       responses
         .reduce((results, m) =>
           results
             .bind(cancellation.either)
             .bind(([sp, ap]) => m
               .fmap(([script, code]) =>
                 io.evaluate(script, code, selector.logger, skip, AtomicPromise.all(sp), cancellation))
               .bind(m =>
                 m.extract(
                   p => Right(tuple([concat(sp, [p]), ap])),
                   p => Right(tuple([sp, concat(ap, [p])])))))
       , Right<Error, [AtomicPromise<Either<Error, HTMLScriptElement>>[], AtomicPromise<Either<Error, HTMLScriptElement>>[]]>([[], []])))
     .fmap(([sp, ap]) =>
       AtomicPromise.all(sp)
         .then(m => Either.sequence(m))
         .then(sm =>
           sm.fmap(ss => tuple([
             ss,
             Promise.all(ap)
               .then(m => Either.sequence(m))
           ]))));
 }

 function evaluate(): AtomicPromise<Either<Error, HTMLScriptElement>> {
   if (script.matches('[type="module"][src]')) {
     return AtomicPromise.resolve(import(script.src))
       .catch((reason: Error) =>
         reason.message.startsWith('Failed to load ') && script.matches('[src][async]')
           ? retry(script).catch(() => AtomicPromise.reject(reason))
           : AtomicPromise.reject(reason))
       .then(
         () => (
           void script.dispatchEvent(new Event('load')),
           Right(script)),
         reason => (
           void script.dispatchEvent(new Event('error')),
           Left(new FatalError(reason instanceof Error ? reason.message : reason + ''))));
   }
   else {
     try {
       if (new URL(standardize(window.location.href)).path !== new URL(standardize(window.location.href)).path) throw new FatalError('Expired.');
       if (skip.has(new URL(standardize(window.location.href)).reference)) throw new FatalError('Expired.');
       void (0, eval)(code);
       script.hasAttribute('src') && void script.dispatchEvent(new Event('load'));
       return AtomicPromise.resolve(Right(script));
     }
     catch (reason) {
       script.hasAttribute('src') && void script.dispatchEvent(new Event('error'));
       return AtomicPromise.resolve(Left(new FatalError(reason instanceof Error ? reason.message : reason + '')));
     }
   }
 }

export async function route(
  entity: RouterEntity,
  io: {
    document: Document;
  }
): Promise<RouterResult> {
  return Right<Error, void>(undefined)
    .bind(entity.state.process.either)
    .bind(() =>
      match(io.document, entity.config.areas)
        ? Right(undefined)
        : Left(new Error(`Failed to match areas.`)))
    .fmap(() =>
      fetch(entity.event.request, entity.config, entity.state.process))
    .fmap(async p => (await p)
      .fmap(([res, seq]) =>
        update(entity, res, seq, {
          document: io.document,
          position: loadPosition
        }))
      .extract<Left<Error>>(Left))
    .extract<Left<Error>>(Left);

  function match(
    document: Document,
    areas: string[]
  ): boolean {
    return separate({ src: document, dst: document }, areas)
      .extract(
        () => false,
        () => true);
  }
}

 .fmap(([ss2, ap2]) =>
   AtomicPromise.all([as1, Right<Error, HTMLScriptElement[]>(ss2), ap2])
     .then(sst =>
       sst.reduce((m1, m2) =>
         m1.bind(s1 =>
           m2.fmap(s2 =>
             concat(s1, s2))))))

 m.bind(link =>
   !link.has(dst) && compare(src, dst)
     ? (
       void link.set(dst, concat(link.get(null) || [], [src])),
       void link.delete(null),
       Left(link))
     : Right(link))

 async res =>
   res.ok
     ? Right<FetchData>([script, await res.text()])
     : script.matches('[src][async]')
       ? retry(script)
           .then(
             () => Right<FetchData>([script, '']),
             () => Left(new Error(`${script.src}: ${res.statusText}`)))
       : Left(new Error(res.statusText)),

 .bind(xhr => {
   const url = new URL(standardize(xhr.responseURL));
   switch (true) {
     case !xhr.responseURL:
       return Left(new Error(`Failed to get the response URL.`));
     case url.origin !== new URL(window.location.origin).origin:
       return Left(new Error(`Redirected to another origin.`));
     case !/2..|304/.test(`${xhr.status}`):
       return Left(new Error(`Failed to validate the status of response.`));
     case !xhr.responseXML:
       return method === 'GET' && xhr.status === 304 && caches.has(url.path)
         ? Right(caches.get(url.path)!.xhr)
         : Left(new Error(`Failed to get the response body.`));
     case !match(xhr.getResponseHeader('Content-Type'), 'text/html'):
       return Left(new Error(`Failed to validate the content type of response.`));
     default:
       return Right(xhr);
   }
 });

 .reduce<Map<T | null, T[]>>((link, src) =>
   dsts.length === 0
     ? link.set(null, concat(link.get(null) || [], [src]))
     : dsts
         .reduce<Either<typeof link, typeof link>>((m, dst) =>
           m.bind(link =>
             !link.has(dst) && compare(src, dst)
               ? (
                 void link.set(dst, concat(link.get(null) || [], [src])),
                 void link.delete(null),
                 Left(link))
               : Right(link))
         , Right(link))
         .fmap(link =>
           link.set(null, concat(link.get(null) || [], [src])))
         .extract(link =>
           link)

 p => Right(tuple([sp, concat(ap, [p])])))))