@feiyoug/skill-lab 0.0.1 → 0.0.2

package/src/deps/jsr.io/@std/path/1.1.4/posix/relative.ts

@@ -0,0 +1,103 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+
+import { isPosixPathSeparator } from "./_util.js";
+import { resolve } from "./resolve.js";
+import { assertArgs } from "../_common/relative.js";
+
+/**
+ * Return the relative path from `from` to `to` based on current working directory.
+ *
+ * If `from` and `to` are the same, return an empty string.
+ *
+ * @example Usage
+ * ```ts
+ * import { relative } from "@std/path/posix/relative";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const path = relative("/data/orandea/test/aaa", "/data/orandea/impl/bbb");
+ * assertEquals(path, "../../impl/bbb");
+ * ```
+ *
+ * @param from The path to start from.
+ * @param to The path to reach.
+ * @returns The relative path.
+ */
+export function relative(from: string, to: string): string {
+  assertArgs(from, to);
+
+  from = resolve(from);
+  to = resolve(to);
+
+  if (from === to) return "";
+
+  // Trim any leading backslashes
+  let fromStart = 1;
+  const fromEnd = from.length;
+  for (; fromStart < fromEnd; ++fromStart) {
+    if (!isPosixPathSeparator(from.charCodeAt(fromStart))) break;
+  }
+  const fromLen = fromEnd - fromStart;
+
+  // Trim any leading backslashes
+  let toStart = 1;
+  const toEnd = to.length;
+  for (; toStart < toEnd; ++toStart) {
+    if (!isPosixPathSeparator(to.charCodeAt(toStart))) break;
+  }
+  const toLen = toEnd - toStart;
+
+  // Compare paths to find the longest common path from root
+  const length = fromLen < toLen ? fromLen : toLen;
+  let lastCommonSep = -1;
+  let i = 0;
+  for (; i <= length; ++i) {
+    if (i === length) {
+      if (toLen > length) {
+        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);
+        } else if (i === 0) {
+          // We get here if `from` is the root
+          // For example: from='/'; to='/foo'
+          return to.slice(toStart + i);
+        }
+      } else if (fromLen > length) {
+        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;
+        } else if (i === 0) {
+          // We get here if `to` is the root.
+          // For example: from='/foo'; to='/'
+          lastCommonSep = 0;
+        }
+      }
+      break;
+    }
+    const fromCode = from.charCodeAt(fromStart + i);
+    const toCode = to.charCodeAt(toStart + i);
+    if (fromCode !== toCode) break;
+    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 || isPosixPathSeparator(from.charCodeAt(i))) {
+      if (out.length === 0) out += "..";
+      else out += "/..";
+    }
+  }
+
+  // Lastly, append the rest of the destination (`to`) path that comes after
+  // the common path parts
+  if (out.length > 0) return out + to.slice(toStart + lastCommonSep);
+  else {
+    toStart += lastCommonSep;
+    if (isPosixPathSeparator(to.charCodeAt(toStart))) ++toStart;
+    return to.slice(toStart);
+  }
+}

package/src/deps/jsr.io/@std/path/1.1.4/posix/resolve.ts

@@ -0,0 +1,71 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import * as dntShim from "../../../../../../_dnt.shims.js";
+
+
+import { normalizeString } from "../_common/normalize_string.js";
+import { assertPath } from "../_common/assert_path.js";
+import { isPosixPathSeparator } from "./_util.js";
+
+/**
+ * Resolves path segments into a `path`.
+ *
+ * @example Usage
+ * ```ts
+ * import { resolve } from "@std/path/posix/resolve";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const path = resolve("/foo", "bar", "baz/asdf", "quux", "..");
+ * assertEquals(path, "/foo/bar/baz/asdf");
+ * ```
+ *
+ * @param pathSegments The path segments to resolve.
+ * @returns The resolved path.
+ */
+export function resolve(...pathSegments: string[]): string {
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+
+  for (let i = pathSegments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+    let path: string;
+
+    if (i >= 0) path = pathSegments[i]!;
+    else {
+      // deno-lint-ignore no-explicit-any
+      const { Deno } = dntShim.dntGlobalThis as any;
+      if (typeof Deno?.cwd !== "function") {
+        throw new TypeError(
+          "Resolved a relative path without a current working directory (CWD)",
+        );
+      }
+      path = Deno.cwd();
+    }
+
+    assertPath(path);
+
+    // Skip empty entries
+    if (path.length === 0) {
+      continue;
+    }
+
+    resolvedPath = `${path}/${resolvedPath}`;
+    resolvedAbsolute = isPosixPathSeparator(path.charCodeAt(0));
+  }
+
+  // At this point the path should be resolved to a full absolute path, but
+  // handle relative paths to be safe (might happen when Deno.cwd() fails)
+
+  // Normalize the path
+  resolvedPath = normalizeString(
+    resolvedPath,
+    !resolvedAbsolute,
+    "/",
+    isPosixPathSeparator,
+  );
+
+  if (resolvedAbsolute) {
+    if (resolvedPath.length > 0) return `/${resolvedPath}`;
+    else return "/";
+  } else if (resolvedPath.length > 0) return resolvedPath;
+  else return ".";
+}

package/src/deps/jsr.io/@std/path/1.1.4/posix/to_file_url.ts

@@ -0,0 +1,32 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+
+import { encodeWhitespace } from "../_common/to_file_url.js";
+import { isAbsolute } from "./is_absolute.js";
+
+/**
+ * Converts a path string to a file URL.
+ *
+ * @example Usage
+ * ```ts
+ * import { toFileUrl } from "@std/path/posix/to-file-url";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(toFileUrl("/home/foo"), new URL("file:///home/foo"));
+ * assertEquals(toFileUrl("/home/foo bar"), new URL("file:///home/foo%20bar"));
+ * ```
+ *
+ * @param path The path to convert.
+ * @returns The file URL.
+ */
+export function toFileUrl(path: string): URL {
+  if (!isAbsolute(path)) {
+    throw new TypeError(`Path must be absolute: received "${path}"`);
+  }
+
+  const url = new URL("file:///");
+  url.pathname = encodeWhitespace(
+    path.replace(/%/g, "%25").replace(/\\/g, "%5C"),
+  );
+  return url;
+}

package/src/deps/jsr.io/@std/path/1.1.4/posix/to_namespaced_path.ts

@@ -0,0 +1,21 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+
+/**
+ * Converts a path to a namespaced path. This function returns the path as is on posix.
+ *
+ * @example Usage
+ * ```ts
+ * import { toNamespacedPath } from "@std/path/posix/to-namespaced-path";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(toNamespacedPath("/home/foo"), "/home/foo");
+ * ```
+ *
+ * @param path The path.
+ * @returns The namespaced path.
+ */
+export function toNamespacedPath(path: string): string {
+  // Non-op on posix systems
+  return path;
+}

package/src/deps/jsr.io/@std/path/1.1.4/relative.ts

@@ -0,0 +1,32 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+
+import { isWindows } from "../../internal/1.0.12/os.js";
+import { relative as posixRelative } from "./posix/relative.js";
+import { relative as windowsRelative } from "./windows/relative.js";
+
+/**
+ * Return the relative path from `from` to `to` based on current working
+ * directory.
+ *
+ * @example Usage
+ * ```ts
+ * import { relative } from "@std/path/relative";
+ * import { assertEquals } from "@std/assert";
+ *
+ * if (Deno.build.os === "windows") {
+ *   const path = relative("C:\\foobar\\test\\aaa", "C:\\foobar\\impl\\bbb");
+ *   assertEquals(path, "..\\..\\impl\\bbb");
+ * } else {
+ *   const path = relative("/data/foobar/test/aaa", "/data/foobar/impl/bbb");
+ *   assertEquals(path, "../../impl/bbb");
+ * }
+ * ```
+ *
+ * @param from Path in current working directory.
+ * @param to Path in current working directory.
+ * @returns The relative path from `from` to `to`.
+ */
+export function relative(from: string, to: string): string {
+  return isWindows ? windowsRelative(from, to) : posixRelative(from, to);
+}

package/src/deps/jsr.io/@std/path/1.1.4/resolve.ts

@@ -0,0 +1,32 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+
+import { isWindows } from "../../internal/1.0.12/os.js";
+import { resolve as posixResolve } from "./posix/resolve.js";
+import { resolve as windowsResolve } from "./windows/resolve.js";
+
+/**
+ * Resolves path segments into a path.
+ *
+ * @example Usage
+ * ```ts
+ * import { resolve } from "@std/path/resolve";
+ * import { assertEquals } from "@std/assert";
+ *
+ * if (Deno.build.os === "windows") {
+ *   assertEquals(resolve("C:\\foo", "bar", "baz"), "C:\\foo\\bar\\baz");
+ *   assertEquals(resolve("C:\\foo", "C:\\bar", "baz"), "C:\\bar\\baz");
+ * } else {
+ *   assertEquals(resolve("/foo", "bar", "baz"), "/foo/bar/baz");
+ *   assertEquals(resolve("/foo", "/bar", "baz"), "/bar/baz");
+ * }
+ * ```
+ *
+ * @param pathSegments Path segments to process to path.
+ * @returns The resolved path.
+ */
+export function resolve(...pathSegments: string[]): string {
+  return isWindows
+    ? windowsResolve(...pathSegments)
+    : posixResolve(...pathSegments);
+}

package/src/deps/jsr.io/@std/path/1.1.4/to_file_url.ts

@@ -0,0 +1,30 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+
+import { isWindows } from "../../internal/1.0.12/os.js";
+import { toFileUrl as posixToFileUrl } from "./posix/to_file_url.js";
+import { toFileUrl as windowsToFileUrl } from "./windows/to_file_url.js";
+
+/**
+ * Converts a path string to a file URL.
+ *
+ * @example Usage
+ * ```ts
+ * import { toFileUrl } from "@std/path/to-file-url";
+ * import { assertEquals } from "@std/assert";
+ *
+ * if (Deno.build.os === "windows") {
+ *   assertEquals(toFileUrl("\\home\\foo"), new URL("file:///home/foo"));
+ *   assertEquals(toFileUrl("C:\\Users\\foo"), new URL("file:///C:/Users/foo"));
+ *   assertEquals(toFileUrl("\\\\127.0.0.1\\home\\foo"), new URL("file://127.0.0.1/home/foo"));
+ * } else {
+ *   assertEquals(toFileUrl("/home/foo"), new URL("file:///home/foo"));
+ * }
+ * ```
+ *
+ * @param path Path to convert to file URL.
+ * @returns The file URL equivalent to the path.
+ */
+export function toFileUrl(path: string): URL {
+  return isWindows ? windowsToFileUrl(path) : posixToFileUrl(path);
+}

package/src/deps/jsr.io/@std/path/1.1.4/to_namespaced_path.ts

@@ -0,0 +1,31 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+
+import { isWindows } from "../../internal/1.0.12/os.js";
+import { toNamespacedPath as posixToNamespacedPath } from "./posix/to_namespaced_path.js";
+import { toNamespacedPath as windowsToNamespacedPath } from "./windows/to_namespaced_path.js";
+
+/**
+ * Resolves path to a namespace path.  This is a no-op on
+ * non-windows systems.
+ *
+ * @example Usage
+ * ```ts
+ * import { toNamespacedPath } from "@std/path/to-namespaced-path";
+ * import { assertEquals } from "@std/assert";
+ *
+ * if (Deno.build.os === "windows") {
+ *   assertEquals(toNamespacedPath("C:\\foo\\bar"), "\\\\?\\C:\\foo\\bar");
+ * } else {
+ *   assertEquals(toNamespacedPath("/foo/bar"), "/foo/bar");
+ * }
+ * ```
+ *
+ * @param path Path to resolve to namespace.
+ * @returns The resolved namespace path.
+ */
+export function toNamespacedPath(path: string): string {
+  return isWindows
+    ? windowsToNamespacedPath(path)
+    : posixToNamespacedPath(path);
+}

package/src/deps/jsr.io/@std/path/1.1.4/types.ts

@@ -0,0 +1,40 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+
+/**
+ * A parsed path object generated by path.parse() or consumed by path.format().
+ *
+ * @example
+ * ```ts
+ * import { parse } from "@std/path";
+ *
+ * const parsedPathObj = parse("c:\\path\\dir\\index.html");
+ * parsedPathObj.root; // "c:\\"
+ * parsedPathObj.dir; // "c:\\path\\dir"
+ * parsedPathObj.base; // "index.html"
+ * parsedPathObj.ext; // ".html"
+ * parsedPathObj.name; // "index"
+ * ```
+ */
+export interface ParsedPath {
+  /**
+   * The root of the path such as '/' or 'c:\'
+   */
+  root: string;
+  /**
+   * The full directory path of the parent such as '/home/user/dir' or 'c:\path\dir'
+   */
+  dir: string;
+  /**
+   * The file name including extension (if any) such as 'index.html'
+   */
+  base: string;
+  /**
+   * The file extension (if any) such as '.html'
+   */
+  ext: string;
+  /**
+   * The file name without extension (if any) such as 'index'
+   */
+  name: string;
+}

package/src/deps/jsr.io/@std/path/1.1.4/windows/_util.ts

@@ -0,0 +1,28 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright the Browserify authors. MIT License.
+// Ported from https://github.com/browserify/path-browserify/
+// This module is browser compatible.
+
+import {
+  CHAR_BACKWARD_SLASH,
+  CHAR_FORWARD_SLASH,
+  CHAR_LOWERCASE_A,
+  CHAR_LOWERCASE_Z,
+  CHAR_UPPERCASE_A,
+  CHAR_UPPERCASE_Z,
+} from "../_common/constants.js";
+
+export function isPosixPathSeparator(code: number): boolean {
+  return code === CHAR_FORWARD_SLASH;
+}
+
+export function isPathSeparator(code: number): boolean {
+  return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+}
+
+export function isWindowsDeviceRoot(code: number): boolean {
+  return (
+    (code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z) ||
+    (code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z)
+  );
+}

package/src/deps/jsr.io/@std/path/1.1.4/windows/basename.ts

@@ -0,0 +1,54 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+
+import {
+  assertArgs,
+  lastPathSegment,
+  stripSuffix,
+} from "../_common/basename.js";
+import { CHAR_COLON } from "../_common/constants.js";
+import { stripTrailingSeparators } from "../_common/strip_trailing_separators.js";
+import { isPathSeparator, isWindowsDeviceRoot } from "./_util.js";
+import { fromFileUrl } from "./from_file_url.js";
+
+/**
+ * Return the last portion of a `path`.
+ * Trailing directory separators are ignored, and optional suffix is removed.
+ *
+ * @example Usage
+ * ```ts
+ * import { basename } from "@std/path/windows/basename";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(basename("C:\\user\\Documents\\"), "Documents");
+ * assertEquals(basename("C:\\user\\Documents\\image.png"), "image.png");
+ * assertEquals(basename("C:\\user\\Documents\\image.png", ".png"), "image");
+ * assertEquals(basename(new URL("file:///C:/user/Documents/image.png")), "image.png");
+ * assertEquals(basename(new URL("file:///C:/user/Documents/image.png"), ".png"), "image");
+ * ```
+ *
+ * @param path The path to extract the name from.
+ * @param suffix The suffix to remove from extracted name.
+ * @returns The extracted name.
+ */
+export function basename(path: string | URL, suffix = ""): string {
+  if (path instanceof URL) {
+    path = fromFileUrl(path);
+  }
+  assertArgs(path, suffix);
+
+  // Check for a drive letter prefix so as not to mistake the following
+  // path separator as an extra separator at the end of the path that can be
+  // disregarded
+  let start = 0;
+  if (path.length >= 2) {
+    const drive = path.charCodeAt(0);
+    if (isWindowsDeviceRoot(drive)) {
+      if (path.charCodeAt(1) === CHAR_COLON) start = 2;
+    }
+  }
+
+  const lastSegment = lastPathSegment(path, isPathSeparator, start);
+  const strippedSegment = stripTrailingSeparators(lastSegment, isPathSeparator);
+  return suffix ? stripSuffix(strippedSegment, suffix) : strippedSegment;
+}

package/src/deps/jsr.io/@std/path/1.1.4/windows/constants.ts

@@ -0,0 +1,15 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+
+/**
+ * The character used to separate entries in the PATH environment variable.
+ */
+export const DELIMITER = ";" as const;
+/**
+ * The character used to separate components of a file path.
+ */
+export const SEPARATOR = "\\" as const;
+/**
+ * A regular expression that matches one or more path separators.
+ */
+export const SEPARATOR_PATTERN = /[\\/]+/;

package/src/deps/jsr.io/@std/path/1.1.4/windows/dirname.ts

@@ -0,0 +1,118 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+
+import { assertArg } from "../_common/dirname.js";
+import { CHAR_COLON } from "../_common/constants.js";
+import { stripTrailingSeparators } from "../_common/strip_trailing_separators.js";
+import {
+  isPathSeparator,
+  isPosixPathSeparator,
+  isWindowsDeviceRoot,
+} from "./_util.js";
+import { fromFileUrl } from "./from_file_url.js";
+
+/**
+ * Return the directory path of a `path`.
+ *
+ * @example Usage
+ * ```ts
+ * import { dirname } from "@std/path/windows/dirname";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(dirname("C:\\foo\\bar\\baz.ext"), "C:\\foo\\bar");
+ * assertEquals(dirname(new URL("file:///C:/foo/bar/baz.ext")), "C:\\foo\\bar");
+ * ```
+ *
+ * @param path The path to get the directory from.
+ * @returns The directory path.
+ */
+export function dirname(path: string | URL): string {
+  if (path instanceof URL) {
+    path = fromFileUrl(path);
+  }
+  assertArg(path);
+
+  const len = path.length;
+  let rootEnd = -1;
+  let end = -1;
+  let matchedSlash = true;
+  let offset = 0;
+  const code = path.charCodeAt(0);
+
+  // Try to match a root
+  if (len > 1) {
+    if (isPathSeparator(code)) {
+      // Possible UNC root
+
+      rootEnd = offset = 1;
+
+      if (isPathSeparator(path.charCodeAt(1))) {
+        // Matched double path separator at beginning
+        let j = 2;
+        let last = j;
+        // Match 1 or more non-path separators
+        for (; j < len; ++j) {
+          if (isPathSeparator(path.charCodeAt(j))) break;
+        }
+        if (j < len && j !== last) {
+          // Matched!
+          last = j;
+          // Match 1 or more path separators
+          for (; j < len; ++j) {
+            if (!isPathSeparator(path.charCodeAt(j))) break;
+          }
+          if (j < len && j !== last) {
+            // Matched!
+            last = j;
+            // Match 1 or more non-path separators
+            for (; j < len; ++j) {
+              if (isPathSeparator(path.charCodeAt(j))) break;
+            }
+            if (j === len) {
+              // We matched a UNC root only
+              return path;
+            }
+            if (j !== last) {
+              // We matched a UNC root with leftovers
+
+              // Offset by 1 to include the separator after the UNC root to
+              // treat it as a "normal root" on top of a (UNC) root
+              rootEnd = offset = j + 1;
+            }
+          }
+        }
+      }
+    } else if (isWindowsDeviceRoot(code)) {
+      // Possible device root
+
+      if (path.charCodeAt(1) === CHAR_COLON) {
+        rootEnd = offset = 2;
+        if (len > 2) {
+          if (isPathSeparator(path.charCodeAt(2))) rootEnd = offset = 3;
+        }
+      }
+    }
+  } else if (isPathSeparator(code)) {
+    // `path` contains just a path separator, exit early to avoid
+    // unnecessary work
+    return path;
+  }
+
+  for (let i = len - 1; i >= offset; --i) {
+    if (isPathSeparator(path.charCodeAt(i))) {
+      if (!matchedSlash) {
+        end = i;
+        break;
+      }
+    } else {
+      // We saw the first non-path separator
+      matchedSlash = false;
+    }
+  }
+
+  if (end === -1) {
+    if (rootEnd === -1) return ".";
+    else end = rootEnd;
+  }
+  return stripTrailingSeparators(path.slice(0, end), isPosixPathSeparator);
+}