@netlify/edge-bundler 8.8.0 → 8.8.1

package/deno/lib/common.ts

@@ -1,6 +1,6 @@
-import { load } from "https://deno.land/x/eszip@v0.28.0/loader.ts";
-import { LoadResponse } from "https://deno.land/x/eszip@v0.28.0/mod.ts";
-import * as path from "https://deno.land/std@0.127.0/path/mod.ts";
+import { load } from "https://deno.land/x/eszip@v0.37.0/loader.ts";
+import { LoadResponse } from "https://deno.land/x/eszip@v0.37.0/mod.ts";
+import * as path from "https://deno.land/std@0.178.0/path/mod.ts";
 import { retryAsync } from "https://deno.land/x/retry@v2.0.0/mod.ts";
 import { isTooManyTries } from "https://deno.land/x/retry@v2.0.0/retry/tooManyTries.ts";
 

package/deno/lib/stage2.ts

@@ -1,6 +1,6 @@
-import { build, LoadResponse } from 'https://deno.land/x/eszip@v0.28.0/mod.ts'
+import { build, LoadResponse } from 'https://deno.land/x/eszip@v0.37.0/mod.ts'
 
-import * as path from 'https://deno.land/std@0.127.0/path/mod.ts'
+import * as path from 'https://deno.land/std@0.178.0/path/mod.ts'
 
 import type { InputFunction, WriteStage2Options } from '../../shared/stage2.ts'
 import { importMapSpecifier, virtualRoot } from '../../shared/consts.ts'

package/deno/vendor/deno.land/std@0.178.0/_util/asserts.ts

@@ -0,0 +1,25 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * All internal non-test code, that is files that do not have `test` or `bench` in the name, must use the assertion functions within `_utils/asserts.ts` and not `testing/asserts.ts`. This is to create a separation of concerns between internal and testing assertions.
+ */
+
+export class DenoStdInternalError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "DenoStdInternalError";
+  }
+}
+
+/** Make an assertion, if not `true`, then throw. */
+export function assert(expr: unknown, msg = ""): asserts expr {
+  if (!expr) {
+    throw new DenoStdInternalError(msg);
+  }
+}
+
+/** Use this to assert unreachable code. */
+export function unreachable(): never {
+  throw new DenoStdInternalError("unreachable");
+}

package/deno/vendor/deno.land/{std@0.127.0 → std@0.178.0}/_util/os.ts

@@ -1,7 +1,7 @@
-// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 
-export type OSType = "windows" | "linux" | "darwin";
+export type OSType = "windows" | "linux" | "darwin" | "freebsd";
 
 export const osType: OSType = (() => {
   // deno-lint-ignore no-explicit-any
@@ -12,7 +12,7 @@ export const osType: OSType = (() => {
 
   // deno-lint-ignore no-explicit-any
   const { navigator } = globalThis as any;
-  if (navigator?.appVersion?.includes?.("Win") ?? false) {
+  if (navigator?.appVersion?.includes?.("Win")) {
     return "windows";
   }
 
@@ -20,3 +20,4 @@ export const osType: OSType = (() => {
 })();
 
 export const isWindows = osType === "windows";
+export const isLinux = osType === "linux";

package/deno/vendor/deno.land/{std@0.127.0 → std@0.178.0}/path/_constants.ts

@@ -1,4 +1,4 @@
-// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 // Copyright the Browserify authors. MIT License.
 // Ported from https://github.com/browserify/path-browserify/
 // This module is browser compatible.

package/deno/vendor/deno.land/{std@0.127.0 → std@0.178.0}/path/_interface.ts

@@ -1,4 +1,4 @@
-// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 
 /**

package/deno/vendor/deno.land/{std@0.127.0 → std@0.178.0}/path/_util.ts

@@ -1,4 +1,4 @@
-// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 // Copyright the Browserify authors. MIT License.
 // Ported from https://github.com/browserify/path-browserify/
 // This module is browser compatible.
@@ -14,7 +14,7 @@ import {
   CHAR_UPPERCASE_Z,
 } from "./_constants.ts";
 
-export function assertPath(path: string): void {
+export function assertPath(path: string) {
   if (typeof path !== "string") {
     throw new TypeError(
       `Path must be a string. Received ${JSON.stringify(path)}`,
@@ -113,6 +113,7 @@ export function _format(
   const base: string = pathObject.base ||
     (pathObject.name || "") + (pathObject.ext || "");
   if (!dir) return base;
+  if (base === sep) return dir;
   if (dir === pathObject.root) return dir + base;
   return dir + sep + base;
 }
@@ -131,3 +132,63 @@ export function encodeWhitespace(string: string): string {
     return WHITESPACE_ENCODINGS[c] ?? c;
   });
 }
+
+export function lastPathSegment(
+  path: string,
+  isSep: (char: number) => boolean,
+  start = 0,
+): string {
+  let matchedNonSeparator = false;
+  let end = path.length;
+
+  for (let i = path.length - 1; i >= start; --i) {
+    if (isSep(path.charCodeAt(i))) {
+      if (matchedNonSeparator) {
+        start = i + 1;
+        break;
+      }
+    } else if (!matchedNonSeparator) {
+      matchedNonSeparator = true;
+      end = i + 1;
+    }
+  }
+
+  return path.slice(start, end);
+}
+
+export function stripTrailingSeparators(
+  segment: string,
+  isSep: (char: number) => boolean,
+): string {
+  if (segment.length <= 1) {
+    return segment;
+  }
+
+  let end = segment.length;
+
+  for (let i = segment.length - 1; i > 0; i--) {
+    if (isSep(segment.charCodeAt(i))) {
+      end = i;
+    } else {
+      break;
+    }
+  }
+
+  return segment.slice(0, end);
+}
+
+export function stripSuffix(name: string, suffix: string): string {
+  if (suffix.length >= name.length) {
+    return name;
+  }
+
+  const lenDiff = name.length - suffix.length;
+
+  for (let i = suffix.length - 1; i >= 0; --i) {
+    if (name.charCodeAt(lenDiff + i) !== suffix.charCodeAt(i)) {
+      return name;
+    }
+  }
+
+  return name.slice(0, -suffix.length);
+}

package/deno/vendor/deno.land/{std@0.127.0 → std@0.178.0}/path/common.ts

@@ -1,4 +1,4 @@
-// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 
 import { SEP } from "./separator.ts";

package/deno/vendor/deno.land/{std@0.127.0 → std@0.178.0}/path/glob.ts

@@ -1,4 +1,4 @@
-// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 
 import { isWindows, osType } from "../_util/os.ts";
@@ -12,14 +12,19 @@ const { join, normalize } = path;
 
 export interface GlobOptions {
   /** Extended glob syntax.
-   * See https://www.linuxjournal.com/content/bash-extended-globbing. Defaults
-   * to true. */
+   * See https://www.linuxjournal.com/content/bash-extended-globbing.
+   *
+   * @default {true}
+   */
   extended?: boolean;
   /** Globstar syntax.
    * See https://www.linuxjournal.com/content/globstar-new-bash-globbing-option.
-   * If false, `**` is treated like `*`. Defaults to true. */
+   * If false, `**` is treated like `*`.
+   *
+   * @default {true}
+   */
   globstar?: boolean;
-  /** Whether globstar should be case insensitive. */
+  /** Whether globstar should be case-insensitive. */
   caseInsensitive?: boolean;
   /** Operating system. Defaults to the native OS. */
   os?: OSType;

package/deno/vendor/deno.land/{std@0.127.0 → std@0.178.0}/path/mod.ts

@@ -1,7 +1,25 @@
-// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 // Copyright the Browserify authors. MIT License.
 // Ported mostly from https://github.com/browserify/path-browserify/
-// This module is browser compatible.
+
+/**
+ * Utilities for working with OS-specific file paths.
+ *
+ * Codes in the examples uses POSIX path but it automatically use Windows path
+ * on Windows. Use methods under `posix` or `win32` object instead to handle non
+ * platform specific path like:
+ * ```ts
+ * import { posix, win32 } from "https://deno.land/std@$STD_VERSION/path/mod.ts";
+ * const p1 = posix.fromFileUrl("file:///home/foo");
+ * const p2 = win32.fromFileUrl("file:///home/foo");
+ * console.log(p1); // "/home/foo"
+ * console.log(p2); // "\\home\\foo"
+ * ```
+ *
+ * This module is browser compatible.
+ *
+ * @module
+ */
 
 import { isWindows } from "../_util/os.ts";
 import * as _win32 from "./win32.ts";

package/deno/vendor/deno.land/{std@0.127.0 → std@0.178.0}/path/posix.ts

@@ -1,17 +1,20 @@
-// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 // Copyright the Browserify authors. MIT License.
 // Ported from https://github.com/browserify/path-browserify/
 // This module is browser compatible.
 
 import type { FormatInputPathObject, ParsedPath } from "./_interface.ts";
-import { CHAR_DOT, CHAR_FORWARD_SLASH } from "./_constants.ts";
+import { CHAR_DOT } from "./_constants.ts";
 
 import {
   _format,
   assertPath,
   encodeWhitespace,
   isPosixPathSeparator,
+  lastPathSegment,
   normalizeString,
+  stripSuffix,
+  stripTrailingSeparators,
 } from "./_util.ts";
 
 export const sep = "/";
@@ -47,7 +50,7 @@ export function resolve(...pathSegments: string[]): string {
     }
 
     resolvedPath = `${path}/${resolvedPath}`;
-    resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
+    resolvedAbsolute = isPosixPathSeparator(path.charCodeAt(0));
   }
 
   // At this point the path should be resolved to a full absolute path, but
@@ -70,6 +73,8 @@ export function resolve(...pathSegments: string[]): string {
 
 /**
  * Normalize the `path`, resolving `'..'` and `'.'` segments.
+ * Note that resolving these segments does not necessarily mean that all will be eliminated.
+ * A `'..'` at the top-level will be preserved, and an empty path is canonically `'.'`.
  * @param path to be normalized
  */
 export function normalize(path: string): string {
@@ -77,9 +82,10 @@ export function normalize(path: string): string {
 
   if (path.length === 0) return ".";
 
-  const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
-  const trailingSeparator =
-    path.charCodeAt(path.length - 1) === CHAR_FORWARD_SLASH;
+  const isAbsolute = isPosixPathSeparator(path.charCodeAt(0));
+  const trailingSeparator = isPosixPathSeparator(
+    path.charCodeAt(path.length - 1),
+  );
 
   // Normalize the path
   path = normalizeString(path, !isAbsolute, "/", isPosixPathSeparator);
@@ -97,7 +103,7 @@ export function normalize(path: string): string {
  */
 export function isAbsolute(path: string): boolean {
   assertPath(path);
-  return path.length > 0 && path.charCodeAt(0) === CHAR_FORWARD_SLASH;
+  return path.length > 0 && isPosixPathSeparator(path.charCodeAt(0));
 }
 
 /**
@@ -139,7 +145,7 @@ export function relative(from: string, to: string): string {
   let fromStart = 1;
   const fromEnd = from.length;
   for (; fromStart < fromEnd; ++fromStart) {
-    if (from.charCodeAt(fromStart) !== CHAR_FORWARD_SLASH) break;
+    if (!isPosixPathSeparator(from.charCodeAt(fromStart))) break;
   }
   const fromLen = fromEnd - fromStart;
 
@@ -147,7 +153,7 @@ export function relative(from: string, to: string): string {
   let toStart = 1;
   const toEnd = to.length;
   for (; toStart < toEnd; ++toStart) {
-    if (to.charCodeAt(toStart) !== CHAR_FORWARD_SLASH) break;
+    if (!isPosixPathSeparator(to.charCodeAt(toStart))) break;
   }
   const toLen = toEnd - toStart;
 
@@ -158,7 +164,7 @@ export function relative(from: string, to: string): string {
   for (; i <= length; ++i) {
     if (i === length) {
       if (toLen > length) {
-        if (to.charCodeAt(toStart + i) === CHAR_FORWARD_SLASH) {
+        if (isPosixPathSeparator(to.charCodeAt(toStart + i))) {
           // We get here if `from` is the exact base path for `to`.
           // For example: from='/foo/bar'; to='/foo/bar/baz'
           return to.slice(toStart + i + 1);
@@ -168,7 +174,7 @@ export function relative(from: string, to: string): string {
           return to.slice(toStart + i);
         }
       } else if (fromLen > length) {
-        if (from.charCodeAt(fromStart + i) === CHAR_FORWARD_SLASH) {
+        if (isPosixPathSeparator(from.charCodeAt(fromStart + i))) {
           // We get here if `to` is the exact base path for `from`.
           // For example: from='/foo/bar/baz'; to='/foo/bar'
           lastCommonSep = i;
@@ -183,14 +189,14 @@ export function relative(from: string, to: string): string {
     const fromCode = from.charCodeAt(fromStart + i);
     const toCode = to.charCodeAt(toStart + i);
     if (fromCode !== toCode) break;
-    else if (fromCode === CHAR_FORWARD_SLASH) lastCommonSep = i;
+    else if (isPosixPathSeparator(fromCode)) lastCommonSep = i;
   }
 
   let out = "";
   // Generate the relative path based on the path difference between `to`
   // and `from`
   for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
-    if (i === fromEnd || from.charCodeAt(i) === CHAR_FORWARD_SLASH) {
+    if (i === fromEnd || isPosixPathSeparator(from.charCodeAt(i))) {
       if (out.length === 0) out += "..";
       else out += "/..";
     }
@@ -201,7 +207,7 @@ export function relative(from: string, to: string): string {
   if (out.length > 0) return out + to.slice(toStart + lastCommonSep);
   else {
     toStart += lastCommonSep;
-    if (to.charCodeAt(toStart) === CHAR_FORWARD_SLASH) ++toStart;
+    if (isPosixPathSeparator(to.charCodeAt(toStart))) ++toStart;
     return to.slice(toStart);
   }
 }
@@ -216,114 +222,73 @@ export function toNamespacedPath(path: string): string {
 }
 
 /**
- * Return the directory name of a `path`.
- * @param path to determine name for
+ * Return the directory path of a `path`.
+ * @param path - path to extract the directory from.
  */
 export function dirname(path: string): string {
-  assertPath(path);
   if (path.length === 0) return ".";
-  const hasRoot = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
+
   let end = -1;
-  let matchedSlash = true;
+  let matchedNonSeparator = false;
+
   for (let i = path.length - 1; i >= 1; --i) {
-    if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {
-      if (!matchedSlash) {
+    if (isPosixPathSeparator(path.charCodeAt(i))) {
+      if (matchedNonSeparator) {
         end = i;
         break;
       }
     } else {
-      // We saw the first non-path separator
-      matchedSlash = false;
+      matchedNonSeparator = true;
     }
   }
 
-  if (end === -1) return hasRoot ? "/" : ".";
-  if (hasRoot && end === 1) return "//";
-  return path.slice(0, end);
+  // No matches. Fallback based on provided path:
+  //
+  // - leading slashes paths
+  //     "/foo" => "/"
+  //     "///foo" => "/"
+  // - no slash path
+  //     "foo" => "."
+  if (end === -1) {
+    return isPosixPathSeparator(path.charCodeAt(0)) ? "/" : ".";
+  }
+
+  return stripTrailingSeparators(
+    path.slice(0, end),
+    isPosixPathSeparator,
+  );
 }
 
 /**
- * Return the last portion of a `path`. Trailing directory separators are ignored.
- * @param path to process
- * @param ext of path directory
+ * Return the last portion of a `path`.
+ * Trailing directory separators are ignored, and optional suffix is removed.
+ *
+ * @param path - path to extract the name from.
+ * @param [suffix] - suffix to remove from extracted name.
  */
-export function basename(path: string, ext = ""): string {
-  if (ext !== undefined && typeof ext !== "string") {
-    throw new TypeError('"ext" argument must be a string');
-  }
+export function basename(path: string, suffix = ""): string {
   assertPath(path);
 
-  let start = 0;
-  let end = -1;
-  let matchedSlash = true;
-  let i: number;
-
-  if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
-    if (ext.length === path.length && ext === path) return "";
-    let extIdx = ext.length - 1;
-    let firstNonSlashEnd = -1;
-    for (i = path.length - 1; i >= 0; --i) {
-      const code = path.charCodeAt(i);
-      if (code === CHAR_FORWARD_SLASH) {
-        // If we reached a path separator that was not part of a set of path
-        // separators at the end of the string, stop now
-        if (!matchedSlash) {
-          start = i + 1;
-          break;
-        }
-      } else {
-        if (firstNonSlashEnd === -1) {
-          // We saw the first non-path separator, remember this index in case
-          // we need it if the extension ends up not matching
-          matchedSlash = false;
-          firstNonSlashEnd = i + 1;
-        }
-        if (extIdx >= 0) {
-          // Try to match the explicit extension
-          if (code === ext.charCodeAt(extIdx)) {
-            if (--extIdx === -1) {
-              // We matched the extension, so mark this as the end of our path
-              // component
-              end = i;
-            }
-          } else {
-            // Extension does not match, so our result is the entire path
-            // component
-            extIdx = -1;
-            end = firstNonSlashEnd;
-          }
-        }
-      }
-    }
-
-    if (start === end) end = firstNonSlashEnd;
-    else if (end === -1) end = path.length;
-    return path.slice(start, end);
-  } else {
-    for (i = path.length - 1; i >= 0; --i) {
-      if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {
-        // If we reached a path separator that was not part of a set of path
-        // separators at the end of the string, stop now
-        if (!matchedSlash) {
-          start = i + 1;
-          break;
-        }
-      } else if (end === -1) {
-        // We saw the first non-path separator, mark this as the end of our
-        // path component
-        matchedSlash = false;
-        end = i + 1;
-      }
-    }
+  if (path.length === 0) return path;
 
-    if (end === -1) return "";
-    return path.slice(start, end);
+  if (typeof suffix !== "string") {
+    throw new TypeError(
+      `Suffix must be a string. Received ${JSON.stringify(suffix)}`,
+    );
   }
+
+  const lastSegment = lastPathSegment(path, isPosixPathSeparator);
+  const strippedSegment = stripTrailingSeparators(
+    lastSegment,
+    isPosixPathSeparator,
+  );
+  return suffix ? stripSuffix(strippedSegment, suffix) : strippedSegment;
 }
 
 /**
- * Return the extension of the `path`.
+ * Return the extension of the `path` with leading period.
  * @param path with extension
+ * @returns extension (ex. for `file.ts` returns `.ts`)
  */
 export function extname(path: string): string {
   assertPath(path);
@@ -336,7 +301,7 @@ export function extname(path: string): string {
   let preDotState = 0;
   for (let i = path.length - 1; i >= 0; --i) {
     const code = path.charCodeAt(i);
-    if (code === CHAR_FORWARD_SLASH) {
+    if (isPosixPathSeparator(code)) {
       // If we reached a path separator that was not part of a set of path
       // separators at the end of the string, stop now
       if (!matchedSlash) {
@@ -397,7 +362,7 @@ export function parse(path: string): ParsedPath {
 
   const ret: ParsedPath = { root: "", dir: "", base: "", ext: "", name: "" };
   if (path.length === 0) return ret;
-  const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
+  const isAbsolute = isPosixPathSeparator(path.charCodeAt(0));
   let start: number;
   if (isAbsolute) {
     ret.root = "/";
@@ -418,7 +383,7 @@ export function parse(path: string): ParsedPath {
   // Get non-dir info
   for (; i >= start; --i) {
     const code = path.charCodeAt(i);
-    if (code === CHAR_FORWARD_SLASH) {
+    if (isPosixPathSeparator(code)) {
       // If we reached a path separator that was not part of a set of path
       // separators at the end of the string, stop now
       if (!matchedSlash) {
@@ -459,6 +424,8 @@ export function parse(path: string): ParsedPath {
         ret.base = ret.name = path.slice(startPart, end);
       }
     }
+    // Fallback to '/' in case there is no basename
+    ret.base = ret.base || "/";
   } else {
     if (startPart === 0 && isAbsolute) {
       ret.name = path.slice(1, startDot);
@@ -470,8 +437,12 @@ export function parse(path: string): ParsedPath {
     ret.ext = path.slice(startDot, end);
   }
 
-  if (startPart > 0) ret.dir = path.slice(0, startPart - 1);
-  else if (isAbsolute) ret.dir = "/";
+  if (startPart > 0) {
+    ret.dir = stripTrailingSeparators(
+      path.slice(0, startPart - 1),
+      isPosixPathSeparator,
+    );
+  } else if (isAbsolute) ret.dir = "/";
 
   return ret;
 }
@@ -480,7 +451,7 @@ export function parse(path: string): ParsedPath {
  * Converts a file URL to a path string.
  *
  * ```ts
- *      import { fromFileUrl } from "./posix.ts";
+ *      import { fromFileUrl } from "https://deno.land/std@$STD_VERSION/path/posix.ts";
  *      fromFileUrl("file:///home/foo"); // "/home/foo"
  * ```
  * @param url of a file URL
@@ -499,7 +470,7 @@ export function fromFileUrl(url: string | URL): string {
  * Converts a path string to a file URL.
  *
  * ```ts
- *      import { toFileUrl } from "./posix.ts";
+ *      import { toFileUrl } from "https://deno.land/std@$STD_VERSION/path/posix.ts";
  *      toFileUrl("/home/foo"); // new URL("file:///home/foo")
  * ```
  * @param path to convert to file URL

package/deno/vendor/deno.land/{std@0.127.0 → std@0.178.0}/path/separator.ts

@@ -1,4 +1,4 @@
-// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 
 import { isWindows } from "../_util/os.ts";