@netlify/plugin-nextjs 4.40.1 → 4.40.2

package/src/templates/vendor/deno.land/std@0.175.0/types.d.ts

@@ -0,0 +1,89 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+
+/** See the Contributing > Types section in the README for an explanation of this file. */
+
+/** An abstract interface which when implemented provides an interface to read bytes into an array buffer asynchronously. */
+export interface Reader {
+  /** Reads up to `p.byteLength` bytes into `p`. It resolves to the number of
+   * bytes read (`0` < `n` <= `p.byteLength`) and rejects if any error
+   * encountered. Even if `read()` resolves to `n` < `p.byteLength`, it may
+   * use all of `p` as scratch space during the call. If some data is
+   * available but not `p.byteLength` bytes, `read()` conventionally resolves
+   * to what is available instead of waiting for more.
+   *
+   * When `read()` encounters end-of-file condition, it resolves to EOF
+   * (`null`).
+   *
+   * When `read()` encounters an error, it rejects with an error.
+   *
+   * Callers should always process the `n` > `0` bytes returned before
+   * considering the EOF (`null`). Doing so correctly handles I/O errors that
+   * happen after reading some bytes and also both of the allowed EOF
+   * behaviors.
+   *
+   * Implementations should not retain a reference to `p`.
+   *
+   * Use iterateReader() from https://deno.land/std@$STD_VERSION/streams/iterate_reader.ts to turn a Reader into an
+   * AsyncIterator.
+   */
+  read(p: Uint8Array): Promise<number | null>;
+}
+
+/** An abstract interface which when implemented provides an interface to read bytes into an array buffer synchronously. */
+export interface ReaderSync {
+  /** Reads up to `p.byteLength` bytes into `p`. It resolves to the number
+   * of bytes read (`0` < `n` <= `p.byteLength`) and rejects if any error
+   * encountered. Even if `read()` returns `n` < `p.byteLength`, it may use
+   * all of `p` as scratch space during the call. If some data is available
+   * but not `p.byteLength` bytes, `read()` conventionally returns what is
+   * available instead of waiting for more.
+   *
+   * When `readSync()` encounters end-of-file condition, it returns EOF
+   * (`null`).
+   *
+   * When `readSync()` encounters an error, it throws with an error.
+   *
+   * Callers should always process the `n` > `0` bytes returned before
+   * considering the EOF (`null`). Doing so correctly handles I/O errors that happen
+   * after reading some bytes and also both of the allowed EOF behaviors.
+   *
+   * Implementations should not retain a reference to `p`.
+   *
+   * Use iterateReaderSync() from https://deno.land/std@$STD_VERSION/streams/iterate_reader.ts to turn a ReaderSync
+   * into an Iterator.
+   */
+  readSync(p: Uint8Array): number | null;
+}
+
+/** An abstract interface which when implemented provides an interface to write bytes from an array buffer to a file/resource asynchronously. */
+export interface Writer {
+  /** Writes `p.byteLength` bytes from `p` to the underlying data stream. It
+   * resolves to the number of bytes written from `p` (`0` <= `n` <=
+   * `p.byteLength`) or reject with the error encountered that caused the
+   * write to stop early. `write()` must reject with a non-null error if
+   * would resolve to `n` < `p.byteLength`. `write()` must not modify the
+   * slice data, even temporarily.
+   *
+   * Implementations should not retain a reference to `p`.
+   */
+  write(p: Uint8Array): Promise<number>;
+}
+/** An abstract interface which when implemented provides an interface to write bytes from an array buffer to a file/resource synchronously. */
+export interface WriterSync {
+  /** Writes `p.byteLength` bytes from `p` to the underlying data
+   * stream. It returns the number of bytes written from `p` (`0` <= `n`
+   * <= `p.byteLength`) and any error encountered that caused the write to
+   * stop early. `writeSync()` must throw a non-null error if it returns `n` <
+   * `p.byteLength`. `writeSync()` must not modify the slice data, even
+   * temporarily.
+   *
+   * Implementations should not retain a reference to `p`.
+   */
+  writeSync(p: Uint8Array): number;
+}
+
+/** An abstract interface which when implemented provides an interface to close files/resources that were previously opened. */
+export interface Closer {
+  /** Closes the resource, "freeing" the backing file/resource. */
+  close(): void;
+}

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

@@ -0,0 +1,133 @@
+// 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("https://deno.land/x/html_rewriter@v0.1.0-pre.17/vendor/html_rewriter_bg.wasm")
+        .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/src/templates/vendor/deno.land/x/html_rewriter@v0.1.0-pre.17/vendor/asyncify.js

@@ -0,0 +1,112 @@
+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 };

package/src/templates/vendor/deno.land/x/html_rewriter@v0.1.0-pre.17/vendor/html_rewriter.d.ts

@@ -0,0 +1,88 @@
+export interface ContentTypeOptions {
+  html?: boolean;
+}
+
+export class Element {
+  before(content: string, options?: ContentTypeOptions): this;
+  after(content: string, options?: ContentTypeOptions): this;
+  replace(content: string, options?: ContentTypeOptions): this;
+  remove(): this;
+  getAttribute(name: string): string | null;
+  hasAttribute(name: string): boolean;
+  setAttribute(name: string, value: string): this;
+  removeAttribute(name: string): this;
+  prepend(content: string, options?: ContentTypeOptions): this;
+  append(content: string, options?: ContentTypeOptions): this;
+  setInnerContent(content: string, options?: ContentTypeOptions): this;
+  removeAndKeepContent(): this;
+  readonly attributes: IterableIterator<[string, string]>;
+  readonly namespaceURI: string;
+  readonly removed: boolean;
+  tagName: string;
+  onEndTag(handler: (this: this, endTag: EndTag) => void | Promise<void>): void;
+}
+
+export class EndTag {
+  before(content: string, options?: ContentTypeOptions): this;
+  after(content: string, options?: ContentTypeOptions): this;
+  remove(): this;
+  name: string;
+}
+
+export class Comment {
+  before(content: string, options?: ContentTypeOptions): this;
+  after(content: string, options?: ContentTypeOptions): this;
+  replace(content: string, options?: ContentTypeOptions): this;
+  remove(): this;
+  readonly removed: boolean;
+  text: string;
+}
+
+export class TextChunk {
+  before(content: string, options?: ContentTypeOptions): this;
+  after(content: string, options?: ContentTypeOptions): this;
+  replace(content: string, options?: ContentTypeOptions): this;
+  remove(): this;
+  readonly lastInTextNode: boolean;
+  readonly removed: boolean;
+  readonly text: string;
+}
+
+export class Doctype {
+  readonly name: string | null;
+  readonly publicId: string | null;
+  readonly systemId: string | null;
+}
+
+export class DocumentEnd {
+  append(content: string, options?: ContentTypeOptions): this;
+}
+
+export interface ElementHandlers {
+  element?(element: Element): void | Promise<void>;
+  comments?(comment: Comment): void | Promise<void>;
+  text?(text: TextChunk): void | Promise<void>;
+}
+
+export interface DocumentHandlers {
+  doctype?(doctype: Doctype): void | Promise<void>;
+  comments?(comment: Comment): void | Promise<void>;
+  text?(text: TextChunk): void | Promise<void>;
+  end?(end: DocumentEnd): void | Promise<void>;
+}
+
+export interface HTMLRewriterOptions {
+  enableEsiTags?: boolean;
+}
+
+export class HTMLRewriter {
+  constructor(
+    outputSink: (chunk: Uint8Array) => void,
+    options?: HTMLRewriterOptions
+  );
+  on(selector: string, handlers: ElementHandlers): this;
+  onDocument(handlers: DocumentHandlers): this;
+  write(chunk: Uint8Array): Promise<void>;
+  end(): Promise<void>;
+  free(): void;
+}