@netlify/plugin-nextjs 5.9.0 → 5.9.2

package/edge-runtime/vendor/deno.land/x/html_rewriter@v0.1.0-pre.17/index.ts

@@ -1,133 +0,0 @@
-// FIXME: replace multiple 1 import from skypack!?
-import type {
-  HTMLRewriter as BaseHTMLRewriter,
-  ContentTypeOptions,
-  Element,
-  EndTag,
-  Comment,
-  TextChunk,
-  Doctype,
-  DocumentEnd,
-  ElementHandlers,
-  DocumentHandlers,
-} from "./vendor/html_rewriter.d.ts";
-import * as _base from './vendor/html_rewriter.js'
-const { default: initWASM } = _base;
-const base: typeof import("./vendor/html_rewriter.d.ts") = _base;
-
-export type { 
-  ContentTypeOptions,
-  Element,
-  EndTag,
-  Comment,
-  TextChunk,
-  Doctype,
-  DocumentEnd,
-  ElementHandlers,
-  DocumentHandlers,
-}
-
-import { ResolvablePromise } from 'https://ghuc.cc/worker-tools/resolvable-promise/index.ts'
-
-type SelectorElementHandlers = [selector: string, handlers: ElementHandlers];
-
-const kEnableEsiTags = Symbol("kEnableEsiTags");
-
-// In case a server doesn't return the proper mime type (e.g. githubusercontent.com)..
-const toWASMResponse = (response: Response) => {
-  if (response.headers.get('content-type')?.startsWith('application/wasm')) return response;
-  const { body, headers: hs, ...props } = response
-  const headers = new Headers(hs)
-  headers.set('content-type', 'application/wasm')
-  return new Response(body, { ...props, headers })
-}
-
-const initialized = new ResolvablePromise<void>();
-let executing = false;
-
-export class HTMLRewriter {
-  readonly #elementHandlers: SelectorElementHandlers[] = [];
-  readonly #documentHandlers: DocumentHandlers[] = [];
-  [kEnableEsiTags] = false;
-
-  constructor() {
-    if (!initialized.settled && !executing) {
-      executing = true;
-      fetch(new URL("./vendor/html_rewriter_bg.wasm", import.meta.url).href)
-        .then(r => r.ok ? r : (() => { throw Error('WASM response not ok') })())
-        .then(toWASMResponse)
-        .then(initWASM)
-        .then(() => initialized.resolve())
-        .catch(err => { 
-          executing = false; 
-          console.error(err);
-        })
-    }
-  }
-
-  on(selector: string, handlers: ElementHandlers): this {
-    this.#elementHandlers.push([selector, handlers]);
-    return this;
-  }
-
-  onDocument(handlers: DocumentHandlers): this {
-    this.#documentHandlers.push(handlers);
-    return this;
-  }
-
-  transform(response: Response): Response {
-    const body = response.body as ReadableStream<Uint8Array> | null;
-    // HTMLRewriter doesn't run the end handler if the body is null, so it's
-    // pointless to setup the transform stream.
-    if (body === null) return new Response(body, response);
-
-    if (response instanceof Response) {
-      // Make sure we validate chunks are BufferSources and convert them to
-      // Uint8Arrays as required by the Rust glue code.
-      response = new Response(response.body, response);
-    }
-
-    let rewriter: BaseHTMLRewriter;
-    const transformStream = new TransformStream<Uint8Array, Uint8Array>({
-      start: async (controller) => {
-        // Create a rewriter instance for this transformation that writes its
-        // output to the transformed response's stream. Note that each
-        // BaseHTMLRewriter can only be used once. 
-        await initialized;
-        rewriter = new base.HTMLRewriter(
-          (output) => {
-            // enqueue will throw on empty chunks
-            if (output.length !== 0) controller.enqueue(output);
-          },
-          { enableEsiTags: this[kEnableEsiTags] }
-        );
-        // Add all registered handlers
-        for (const [selector, handlers] of this.#elementHandlers) {
-          rewriter.on(selector, handlers);
-        }
-        for (const handlers of this.#documentHandlers) {
-          rewriter.onDocument(handlers);
-        }
-      },
-      // The finally() below will ensure the rewriter is always freed.
-      // chunk is guaranteed to be a Uint8Array as we're using the
-      // @miniflare/core Response class, which transforms to a byte stream.
-      transform: (chunk) => rewriter.write(chunk),
-      flush: () => rewriter.end(),
-    });
-    const promise = body.pipeTo(transformStream.writable);
-    promise.catch(() => {}).finally(() => rewriter?.free());
-
-    // Return a response with the transformed body, copying over headers, etc
-    const res = new Response(transformStream.readable, response);
-    // If Content-Length is set, it's probably going to be wrong, since we're
-    // rewriting content, so remove it
-    res.headers.delete("Content-Length");
-    return res;
-  }
-}
-
-export function withEnableEsiTags(rewriter: HTMLRewriter): HTMLRewriter {
-  rewriter[kEnableEsiTags] = true;
-  return rewriter;
-}

package/edge-runtime/vendor/deno.land/x/html_rewriter@v0.1.0-pre.17/vendor/asyncify.js

@@ -1,112 +0,0 @@
-import { assert, assertEquals } from "https://deno.land/std@0.134.0/testing/asserts.ts";
-
-/**
- * @typedef {object} WasmExports
- * @property {WebAssembly.Memory} memory
- * @property {function} asyncify_get_state
- * @property {function} asyncify_start_unwind
- * @property {function} asyncify_stop_unwind
- * @property {function} asyncify_start_rewind
- * @property {function} asyncify_stop_rewind
- */
-
-/**
- * @type {WasmExports}
- */
-let wasm;
-
-/**
- * @param {WasmExports} wasmExports
- */
-function setWasmExports(wasmExports) {
-  wasm = wasmExports;
-}
-
-/**
- * @type {Int32Array}
- */
-let cachedInt32Memory = null;
-
-/**
- * @returns {Int32Array}
- */
-function getInt32Memory() {
-  if (
-    cachedInt32Memory === null ||
-    cachedInt32Memory.buffer !== wasm.memory.buffer
-  ) {
-    cachedInt32Memory = new Int32Array(wasm.memory.buffer);
-  }
-  return cachedInt32Memory;
-}
-
-// https://github.com/WebAssembly/binaryen/blob/fb9de9d391a7272548dcc41cd8229076189d7398/src/passes/Asyncify.cpp#L99
-const State = {
-  NONE: 0,
-  UNWINDING: 1,
-  REWINDING: 2,
-};
-
-function assertNoneState() {
-  assertEquals(wasm.asyncify_get_state(), State.NONE);
-}
-
-/**
- * Maps `HTMLRewriter`s (their `asyncifyStackPtr`s) to `Promise`s.
- * `asyncifyStackPtr` acts as unique reference to `HTMLRewriter`.
- * Each rewriter MUST have AT MOST ONE pending promise at any time.
- * @type {Map<number, Promise>}
- */
-const promises = new Map();
-
-/**
- * @param {number} stackPtr
- * @param {Promise} promise
- */
-function awaitPromise(stackPtr, promise) {
-  if (wasm.asyncify_get_state() === State.REWINDING) {
-    wasm.asyncify_stop_rewind();
-    return;
-  }
-
-  assertNoneState();
-
-  // https://github.com/WebAssembly/binaryen/blob/fb9de9d391a7272548dcc41cd8229076189d7398/src/passes/Asyncify.cpp#L106
-  assertEquals(stackPtr % 4, 0);
-  getInt32Memory().set([stackPtr + 8, stackPtr + 1024], stackPtr / 4);
-
-  wasm.asyncify_start_unwind(stackPtr);
-
-  assert(!promises.has(stackPtr));
-  promises.set(stackPtr, promise);
-}
-
-/**
- * @param {HTMLRewriter} rewriter
- * @param {Function} fn
- * @param args
- */
-async function wrap(rewriter, fn, ...args) {
-  const stackPtr = rewriter.asyncifyStackPtr;
-
-  assertNoneState();
-  let result = fn(...args);
-
-  while (wasm.asyncify_get_state() === State.UNWINDING) {
-    wasm.asyncify_stop_unwind();
-
-    assertNoneState();
-    assert(promises.has(stackPtr));
-    await promises.get(stackPtr);
-    promises.delete(stackPtr);
-
-    assertNoneState();
-    wasm.asyncify_start_rewind(stackPtr);
-    result = fn();
-  }
-
-  assertNoneState();
-  return result;
-}
-
-export { awaitPromise, setWasmExports, wrap };