@hugojosefson/cli 0.11.0

package/esm/node_modules/@jsr/std__path/is_glob.ts

@@ -0,0 +1,49 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+
+/**
+ * Test whether the given string is a glob.
+ *
+ * @example Usage
+ * ```ts
+ * import { isGlob } from "@std/path/is-glob";
+ * import { assert } from "@std/assert";
+ *
+ * assert(!isGlob("foo/bar/../baz"));
+ * assert(isGlob("foo/*ar/../baz"));
+ * ```
+ *
+ * @param str String to test.
+ * @returns `true` if the given string is a glob, otherwise `false`
+ */
+export function isGlob(str: string): boolean {
+  const chars: Record<string, string> = { "{": "}", "(": ")", "[": "]" };
+  const regex =
+    /\\(.)|(^!|\*|\?|[\].+)]\?|\[[^[\\\]]+\]|\{[^{\\}]+\}|\(\?[:!=][^\\)]+\)|\([^(|]+\|[^\\)]+\)|@\([^)]+\))/;
+
+  if (str === "") {
+    return false;
+  }
+
+  let match: RegExpExecArray | null;
+
+  while ((match = regex.exec(str))) {
+    if (match[2]) return true;
+    let idx = match.index + match[0].length;
+
+    // if an open bracket/brace/paren is escaped,
+    // set the index to the next closing character
+    const open = match[1];
+    const close = open ? chars[open] : null;
+    if (open && close) {
+      const n = str.indexOf(close, idx);
+      if (n !== -1) {
+        idx = n + 1;
+      }
+    }
+
+    str = str.slice(idx);
+  }
+
+  return false;
+}

package/esm/node_modules/@jsr/std__path/is_glob_test.ts

@@ -0,0 +1,152 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+import { assert, assertEquals } from "jsr:@std/assert@^1.0.19";
+import { isGlob } from "./is_glob.ts";
+import { disposableStack } from "../internal/_testing.ts";
+import { Worker } from "node:worker_threads";
+
+Deno.test({
+  name: "isGlob()",
+  fn() {
+    // should be true if valid glob pattern
+    assert(isGlob("!foo.js"));
+    assert(isGlob("*.js"));
+    assert(isGlob("f?o.js"));
+    assert(isGlob("!*.js"));
+    assert(isGlob("!foo"));
+    assert(isGlob("!foo.js"));
+    assert(isGlob("**/abc.js"));
+    assert(isGlob("abc/*.js"));
+    assert(isGlob("@.(?:abc)"));
+    assert(isGlob("@.(?!abc)"));
+
+    // should be false if invalid glob pattern
+    assert(!isGlob(""));
+    assert(!isGlob("~/abc"));
+    assert(!isGlob("~/abc"));
+    assert(!isGlob("~/(abc)"));
+    assert(!isGlob("+~(abc)"));
+    assert(!isGlob("."));
+    assert(!isGlob("@.(abc)"));
+    assert(!isGlob("aa"));
+    assert(!isGlob("abc!/def/!ghi.js"));
+    assert(!isGlob("abc.js"));
+    assert(!isGlob("abc/def/!ghi.js"));
+    assert(!isGlob("abc/def/ghi.js"));
+
+    // Should be true if path has regex capture group
+    assert(isGlob("abc/(?!foo).js"));
+    assert(isGlob("abc/(?:foo).js"));
+    assert(isGlob("abc/(?=foo).js"));
+    assert(isGlob("abc/(a|b).js"));
+    assert(isGlob("abc/(a|b|c).js"));
+    assert(isGlob("abc/(foo bar)/*.js"));
+
+    // Should be false if the path has parens but is not a valid capture group
+    assert(!isGlob("abc/(a b c).js"));
+    assert(!isGlob("abc/(ab).js"));
+    assert(!isGlob("abc/(abc).js"));
+    assert(!isGlob("abc/(foo bar).js"));
+
+    // should be false if the capture group is imbalanced
+    assert(!isGlob("abc/(ab.js"));
+    assert(!isGlob("abc/(a|b.js"));
+    assert(!isGlob("abc/(a|b|c.js"));
+
+    // should be true if the path has a regex character class
+    assert(isGlob("abc/[abc].js"));
+    assert(isGlob("abc/[^abc].js"));
+    assert(isGlob("abc/[1-3].js"));
+
+    // should be false if the character class is not balanced
+    assert(!isGlob("abc/[abc.js"));
+    assert(!isGlob("abc/[^abc.js"));
+    assert(!isGlob("abc/[1-3.js"));
+
+    // should be false if the character class is escaped
+    assert(!isGlob("abc/\\[abc].js"));
+    assert(!isGlob("abc/\\[^abc].js"));
+    assert(!isGlob("abc/\\[1-3].js"));
+
+    // should be true if the path has brace characters
+    assert(isGlob("abc/{a,b}.js"));
+    assert(isGlob("abc/{a..z}.js"));
+    assert(isGlob("abc/{a..z..2}.js"));
+
+    // should be false if (basic) braces are not balanced
+    assert(!isGlob("abc/\\{a,b}.js"));
+    assert(!isGlob("abc/\\{a..z}.js"));
+    assert(!isGlob("abc/\\{a..z..2}.js"));
+
+    // should be true if the path has regex characters
+    assert(isGlob("!&(abc)"));
+    assert(isGlob("!*.js"));
+    assert(isGlob("!foo"));
+    assert(isGlob("!foo.js"));
+    assert(isGlob("**/abc.js"));
+    assert(isGlob("*.js"));
+    assert(isGlob("*z(abc)"));
+    assert(isGlob("[1-10].js"));
+    assert(isGlob("[^abc].js"));
+    assert(isGlob("[a-j]*[^c]b/c"));
+    assert(isGlob("[abc].js"));
+    assert(isGlob("a/b/c/[a-z].js"));
+    assert(isGlob("abc/(aaa|bbb).js"));
+    assert(isGlob("abc/*.js"));
+    assert(isGlob("abc/{a}.js"));
+    assert(isGlob("abc/{a,b}.js"));
+    assert(isGlob("abc/@(a).js"));
+    assert(isGlob("abc/@(a|b).js"));
+    assert(isGlob("abc/{a..z..2}.js"));
+    assert(isGlob("abc/{a..z}.js"));
+
+    assert(!isGlob("$(abc)"));
+    assert(!isGlob("&(abc)"));
+
+    // should be false if regex characters are escaped
+    assert(!isGlob("\\?.js"));
+    assert(!isGlob("\\[1-10\\].js"));
+    assert(!isGlob("\\[^abc\\].js"));
+    assert(!isGlob("\\[a-j\\]\\*\\[^c\\]b/c"));
+    assert(!isGlob("\\[abc\\].js"));
+    assert(!isGlob("\\a/b/c/\\[a-z\\].js"));
+    assert(!isGlob("abc/\\(aaa|bbb).js"));
+    assert(!isGlob("abc/\\?.js"));
+  },
+});
+
+// ref https://github.com/denoland/std/pull/6764
+Deno.test(
+  "isGlob works with the input that includes large number of open brackets",
+  async () => {
+    const { promise, resolve, reject } = Promise.withResolvers<void>();
+    const timer = setTimeout(() => {
+      reject(new Error("isGlob() did not finish in time"));
+    }, 20000);
+    const worker = new Worker(
+      new URL(
+        `data:text/javascript,
+        import { parentPort, workerData } from "node:worker_threads";
+        const { isGlob } = await import(workerData.isGlobUrl);
+        parentPort.postMessage([
+          isGlob("[".repeat(1_000_000) + "x"),
+          isGlob("{".repeat(1_000_000) + "x"),
+          isGlob("(".repeat(1_000_000) + "x"),
+        ]);`,
+      ),
+      {
+        workerData: {
+          isGlobUrl: new URL("./is_glob.ts", import.meta.url).href,
+        },
+      },
+    );
+    using disposable = disposableStack();
+    disposable.defer(() => worker.terminate());
+    worker.on("message", (results: boolean[]) => {
+      clearTimeout(timer);
+      assertEquals(results, [false, false, false]);
+      resolve();
+    });
+
+    await promise;
+  },
+);

package/esm/node_modules/@jsr/std__path/join.js

@@ -0,0 +1,29 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+import { isWindows } from "@jsr/std__internal/os";
+import { join as posixJoin } from "./posix/join.js";
+import { join as windowsJoin } from "./windows/join.js";
+/**
+ * Joins a sequence of paths, then normalizes the resulting path.
+ *
+ * @example Usage
+ * ```ts
+ * import { join } from "@std/path/join";
+ * import { assertEquals } from "@std/assert";
+ *
+ * if (Deno.build.os === "windows") {
+ *   assertEquals(join("C:\\foo", "bar", "baz\\quux", "garply", ".."), "C:\\foo\\bar\\baz\\quux");
+ *   assertEquals(join(new URL("file:///C:/foo"), "bar", "baz/asdf", "quux", ".."), "C:\\foo\\bar\\baz\\asdf");
+ * } else {
+ *   assertEquals(join("/foo", "bar", "baz/quux", "garply", ".."), "/foo/bar/baz/quux");
+ *   assertEquals(join(new URL("file:///foo"), "bar", "baz/asdf", "quux", ".."), "/foo/bar/baz/asdf");
+ * }
+ * ```
+ *
+ * @param path The path to join. This can be string or file URL.
+ * @param paths Paths to be joined and normalized.
+ * @returns The joined and normalized path.
+ */ export function join(path, ...paths) {
+  return isWindows ? windowsJoin(path, ...paths) : posixJoin(path, ...paths);
+}
+//# sourceMappingURL=join.js.map

package/esm/node_modules/@jsr/std__path/join.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"join.js","sources":["./join.ts"],"names":[],"mappings":"AAAA,qDAAqD;AACrD,qCAAqC;AAErC,SAAS,SAAS,gCAAuC;AACzD,SAAS,QAAQ,SAAS,0BAA0B;AACpD,SAAS,QAAQ,WAAW,4BAA4B;AAExD;;;;;;;;;;;;;;;;;;;;CAoBC,GACD,OAAO,SAAS,KAAK,IAAkB,EAAE,GAAG,KAAe;EACzD,OAAO,YAAY,YAAY,SAAS,SAAS,UAAU,SAAS;AACtE"}

package/esm/node_modules/@jsr/std__path/join.ts

@@ -0,0 +1,31 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+
+import { isWindows } from "@jsr/std__internal/os";
+import { join as posixJoin } from "./posix/join.js";
+import { join as windowsJoin } from "./windows/join.js";
+
+/**
+ * Joins a sequence of paths, then normalizes the resulting path.
+ *
+ * @example Usage
+ * ```ts
+ * import { join } from "@std/path/join";
+ * import { assertEquals } from "@std/assert";
+ *
+ * if (Deno.build.os === "windows") {
+ *   assertEquals(join("C:\\foo", "bar", "baz\\quux", "garply", ".."), "C:\\foo\\bar\\baz\\quux");
+ *   assertEquals(join(new URL("file:///C:/foo"), "bar", "baz/asdf", "quux", ".."), "C:\\foo\\bar\\baz\\asdf");
+ * } else {
+ *   assertEquals(join("/foo", "bar", "baz/quux", "garply", ".."), "/foo/bar/baz/quux");
+ *   assertEquals(join(new URL("file:///foo"), "bar", "baz/asdf", "quux", ".."), "/foo/bar/baz/asdf");
+ * }
+ * ```
+ *
+ * @param path The path to join. This can be string or file URL.
+ * @param paths Paths to be joined and normalized.
+ * @returns The joined and normalized path.
+ */
+export function join(path: string | URL, ...paths: string[]): string {
+  return isWindows ? windowsJoin(path, ...paths) : posixJoin(path, ...paths);
+}

package/esm/node_modules/@jsr/std__path/join_globs.js

@@ -0,0 +1,32 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+import { isWindows } from "@jsr/std__internal/os";
+import { joinGlobs as posixJoinGlobs } from "./posix/join_globs.js";
+import { joinGlobs as windowsJoinGlobs } from "./windows/join_globs.js";
+/**
+ * Joins a sequence of globs, then normalizes the resulting glob.
+ *
+ * Behaves like {@linkcode https://jsr.io/@std/path/doc/~/join | join()}, but
+ * doesn't collapse `**\/..` when `globstar` is true.
+ *
+ * @example Usage
+ * ```ts
+ * import { joinGlobs } from "@std/path/join-globs";
+ * import { assertEquals } from "@std/assert";
+ *
+ * if (Deno.build.os === "windows") {
+ *   assertEquals(joinGlobs(["foo", "bar", "..", "baz"]), "foo\\baz");
+ *   assertEquals(joinGlobs(["foo", "**", "bar", "..", "baz"], { globstar: true }), "foo\\**\\baz");
+ * } else {
+ *   assertEquals(joinGlobs(["foo", "bar", "..", "baz"]), "foo/baz");
+ *   assertEquals(joinGlobs(["foo", "**", "bar", "..", "baz"], { globstar: true }), "foo/**\/baz");
+ * }
+ * ```
+ *
+ * @param globs Globs to be joined and normalized.
+ * @param options Glob options.
+ * @returns The joined and normalized glob string.
+ */ export function joinGlobs(globs, options = {}) {
+  return isWindows ? windowsJoinGlobs(globs, options) : posixJoinGlobs(globs, options);
+}
+//# sourceMappingURL=join_globs.js.map

package/esm/node_modules/@jsr/std__path/join_globs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"join_globs.js","sources":["./join_globs.ts"],"names":[],"mappings":"AAAA,qDAAqD;AACrD,qCAAqC;AAGrC,SAAS,SAAS,gCAAuC;AACzD,SAAS,aAAa,cAAc,gCAAgC;AACpE,SAAS,aAAa,gBAAgB,kCAAkC;AAIxE;;;;;;;;;;;;;;;;;;;;;;;CAuBC,GACD,OAAO,SAAS,UACd,KAAe,EACf,UAAuB,CAAC,CAAC;EAEzB,OAAO,YACH,iBAAiB,OAAO,WACxB,eAAe,OAAO;AAC5B"}

package/esm/node_modules/@jsr/std__path/join_globs.ts

@@ -0,0 +1,42 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+
+import type { GlobOptions } from "./_common/glob_to_reg_exp.ts";
+import { isWindows } from "@jsr/std__internal/os";
+import { joinGlobs as posixJoinGlobs } from "./posix/join_globs.js";
+import { joinGlobs as windowsJoinGlobs } from "./windows/join_globs.js";
+
+export type { GlobOptions };
+
+/**
+ * Joins a sequence of globs, then normalizes the resulting glob.
+ *
+ * Behaves like {@linkcode https://jsr.io/@std/path/doc/~/join | join()}, but
+ * doesn't collapse `**\/..` when `globstar` is true.
+ *
+ * @example Usage
+ * ```ts
+ * import { joinGlobs } from "@std/path/join-globs";
+ * import { assertEquals } from "@std/assert";
+ *
+ * if (Deno.build.os === "windows") {
+ *   assertEquals(joinGlobs(["foo", "bar", "..", "baz"]), "foo\\baz");
+ *   assertEquals(joinGlobs(["foo", "**", "bar", "..", "baz"], { globstar: true }), "foo\\**\\baz");
+ * } else {
+ *   assertEquals(joinGlobs(["foo", "bar", "..", "baz"]), "foo/baz");
+ *   assertEquals(joinGlobs(["foo", "**", "bar", "..", "baz"], { globstar: true }), "foo/**\/baz");
+ * }
+ * ```
+ *
+ * @param globs Globs to be joined and normalized.
+ * @param options Glob options.
+ * @returns The joined and normalized glob string.
+ */
+export function joinGlobs(
+  globs: string[],
+  options: GlobOptions = {},
+): string {
+  return isWindows
+    ? windowsJoinGlobs(globs, options)
+    : posixJoinGlobs(globs, options);
+}

package/esm/node_modules/@jsr/std__path/join_globs_test.ts

@@ -0,0 +1,34 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+import { assertEquals } from "jsr:@std/assert@^1.0.19";
+import * as windows from "./windows/mod.ts";
+import * as posix from "./posix/mod.ts";
+
+Deno.test("windows.joinGlobs() joins the glob patterns", function () {
+  assertEquals(
+    windows.joinGlobs(["foo", "*", "bar"]),
+    `foo\\*\\bar`,
+  );
+  assertEquals(
+    windows.joinGlobs([""], { globstar: true }),
+    ".",
+  );
+  assertEquals(
+    windows.joinGlobs(["**", ".."], { globstar: true }),
+    `**\\..`,
+  );
+});
+
+Deno.test("windows.joinGlobs() joins the glob patterns", function () {
+  assertEquals(
+    posix.joinGlobs(["foo", "*", "bar"]),
+    `foo/*/bar`,
+  );
+  assertEquals(
+    posix.joinGlobs([""], { globstar: true }),
+    ".",
+  );
+  assertEquals(
+    posix.joinGlobs(["**", ".."], { globstar: true }),
+    `**/..`,
+  );
+});

package/esm/node_modules/@jsr/std__path/join_test.ts

@@ -0,0 +1,179 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+import { assertEquals } from "jsr:@std/assert@^1.0.19";
+import * as posix from "./posix/mod.ts";
+import * as windows from "./windows/mod.ts";
+import { join } from "./join.ts";
+import process from "node:process";
+
+const backslashRE = /\\/g;
+
+type TestCase = [string[], string];
+type UrlTestCase = [[URL, ...string[]], string];
+
+const joinTests: TestCase[] =
+  // arguments                     result
+  [
+    [[".", "x/b", "..", "/b/c.js"], "x/b/c.js"],
+    [[], "."],
+    [["/.", "x/b", "..", "/b/c.js"], "/x/b/c.js"],
+    [["/foo", "../../../bar"], "/bar"],
+    [["foo", "../../../bar"], "../../bar"],
+    [["foo/", "../../../bar"], "../../bar"],
+    [["foo/x", "../../../bar"], "../bar"],
+    [["foo/x", "./bar"], "foo/x/bar"],
+    [["foo/x/", "./bar"], "foo/x/bar"],
+    [["foo/x/", ".", "bar"], "foo/x/bar"],
+    [["./"], "./"],
+    [[".", "./"], "./"],
+    [[".", ".", "."], "."],
+    [[".", "./", "."], "."],
+    [[".", "/./", "."], "."],
+    [[".", "/////./", "."], "."],
+    [["."], "."],
+    [["", "."], "."],
+    [["", "foo"], "foo"],
+    [["foo", "/bar"], "foo/bar"],
+    [["", "/foo"], "/foo"],
+    [["", "", "/foo"], "/foo"],
+    [["", "", "foo"], "foo"],
+    [["foo", ""], "foo"],
+    [["foo/", ""], "foo/"],
+    [["foo", "", "/bar"], "foo/bar"],
+    [["./", "..", "/foo"], "../foo"],
+    [["./", "..", "..", "/foo"], "../../foo"],
+    [[".", "..", "..", "/foo"], "../../foo"],
+    [["", "..", "..", "/foo"], "../../foo"],
+    [["/"], "/"],
+    [["/", "."], "/"],
+    [["/", ".."], "/"],
+    [["/", "..", ".."], "/"],
+    [[""], "."],
+    [["", ""], "."],
+    [[" /foo"], " /foo"],
+    [[" ", "foo"], " /foo"],
+    [[" ", "."], " "],
+    [[" ", "/"], " /"],
+    [[" ", ""], " "],
+    [["/", "foo"], "/foo"],
+    [["/", "/foo"], "/foo"],
+    [["/", "//foo"], "/foo"],
+    [["/", "", "/foo"], "/foo"],
+    [["", "/", "foo"], "/foo"],
+    [["", "/", "/foo"], "/foo"],
+  ];
+
+const joinUrlTests: UrlTestCase[] = [
+  // URLs
+  [[new URL("file:///"), "x/b", "..", "/b/c.js"], "/x/b/c.js"],
+  [[new URL("file:///foo"), "../../../bar"], "/bar"],
+  [
+    [new URL("file:///foo"), "bar", "baz/asdf", "quux", ".."],
+    "/foo/bar/baz/asdf",
+  ],
+];
+
+// Windows-specific join tests
+const windowsJoinTests: TestCase[] = [
+  // arguments                     result
+  // UNC path expected
+  [["//foo/bar"], "\\\\foo\\bar\\"],
+  [["\\/foo/bar"], "\\\\foo\\bar\\"],
+  [["\\\\foo/bar"], "\\\\foo\\bar\\"],
+  // UNC path expected - server and share separate
+  [["//foo", "bar"], "\\\\foo\\bar\\"],
+  [["//foo/", "bar"], "\\\\foo\\bar\\"],
+  [["//foo", "/bar"], "\\\\foo\\bar\\"],
+  // UNC path expected - questionable
+  [["//foo", "", "bar"], "\\\\foo\\bar\\"],
+  [["//foo/", "", "bar"], "\\\\foo\\bar\\"],
+  [["//foo/", "", "/bar"], "\\\\foo\\bar\\"],
+  // UNC path expected - even more questionable
+  [["", "//foo", "bar"], "\\\\foo\\bar\\"],
+  [["", "//foo/", "bar"], "\\\\foo\\bar\\"],
+  [["", "//foo/", "/bar"], "\\\\foo\\bar\\"],
+  // No UNC path expected (no double slash in first component)
+  [["\\", "foo/bar"], "\\foo\\bar"],
+  [["\\", "/foo/bar"], "\\foo\\bar"],
+  [["", "/", "/foo/bar"], "\\foo\\bar"],
+  // No UNC path expected (no non-slashes in first component -
+  // questionable)
+  [["//", "foo/bar"], "\\foo\\bar"],
+  [["//", "/foo/bar"], "\\foo\\bar"],
+  [["\\\\", "/", "/foo/bar"], "\\foo\\bar"],
+  [["//"], "\\"],
+  // No UNC path expected (share name missing - questionable).
+  [["//foo"], "\\foo"],
+  [["//foo/"], "\\foo\\"],
+  [["//foo", "/"], "\\foo\\"],
+  [["//foo", "", "/"], "\\foo\\"],
+  // No UNC path expected (too many leading slashes - questionable)
+  [["///foo/bar"], "\\foo\\bar"],
+  [["////foo", "bar"], "\\foo\\bar"],
+  [["\\\\\\/foo/bar"], "\\foo\\bar"],
+  // Drive-relative vs drive-absolute paths. This merely describes the
+  // status quo, rather than being obviously right
+  [["c:"], "c:."],
+  [["c:."], "c:."],
+  [["c:", ""], "c:."],
+  [["", "c:"], "c:."],
+  [["c:.", "/"], "c:.\\"],
+  [["c:.", "file"], "c:file"],
+  [["c:", "/"], "c:\\"],
+  [["c:", "file"], "c:\\file"],
+];
+const windowsJoinUrlTests: UrlTestCase[] = [
+  // URLs
+  [[new URL("file:///c:")], "c:\\"],
+  [[new URL("file:///c:"), "file"], "c:\\file"],
+  [[new URL("file:///c:/"), "file"], "c:\\file"],
+];
+
+Deno.test("posix.join()", function () {
+  joinTests.forEach(function (p) {
+    const _p = p[0];
+    const actual = posix.join.apply(null, _p);
+    assertEquals(actual, p[1]);
+  });
+
+  joinUrlTests.forEach(function (p) {
+    const _p = p[0];
+    const actual = posix.join.apply(null, _p);
+    assertEquals(actual, p[1]);
+  });
+});
+
+Deno.test("windows.join()", function () {
+  joinTests.forEach(function (p) {
+    const _p = p[0];
+    const actual = windows.join.apply(null, _p).replace(backslashRE, "/");
+    assertEquals(actual, p[1]);
+  });
+  windowsJoinTests.forEach(function (p) {
+    const _p = p[0];
+    const actual = windows.join.apply(null, _p);
+    assertEquals(actual, p[1]);
+  });
+
+  joinUrlTests.forEach(function (p) {
+    const _p = p[0];
+    const actual = windows.join.apply(null, _p).replace(
+      backslashRE,
+      "/",
+    );
+    assertEquals(actual, p[1]);
+  });
+  windowsJoinUrlTests.forEach(function (p) {
+    const _p = p[0];
+    const actual = windows.join.apply(null, _p);
+    assertEquals(actual, p[1]);
+  });
+});
+
+Deno.test(`join() returns "." if input is empty`, function () {
+  assertEquals(join(""), ".");
+  assertEquals(join("", ""), ".");
+
+  const pwd = process.cwd();
+  assertEquals(join(pwd), pwd);
+  assertEquals(join(pwd, ""), pwd);
+});