@socketsecurity/lib 0.0.0 → 1.0.0

package/dist/functions.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @fileoverview Common function utilities for control flow and caching.
+ * Provides noop, once, and other foundational function helpers.
+ */
+// Type definitions
+export type AsyncFunction<TArgs extends unknown[], TResult> = (...args: TArgs) => Promise<TResult>;
+export type AnyFunction = (...args: unknown[]) => unknown;
+/**
+ * A no-op function that does nothing.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function noop(): void;
+/**
+ * Create a function that only executes once.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function once<T extends AnyFunction>(fn: T): T;
+/**
+ * Wrap an async function to silently catch and ignore errors.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function silentWrapAsync<TArgs extends unknown[], TResult>(fn: AsyncFunction<TArgs, TResult>): (...args: TArgs) => Promise<TResult | undefined>;
+/**
+ * Execute a function with tail call optimization via trampoline.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function trampoline<T extends AnyFunction>(fn: T): T;

package/dist/functions.js

@@ -0,0 +1,70 @@
+/* Socket Lib - Built with esbuild */
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var functions_exports = {};
+__export(functions_exports, {
+  noop: () => noop,
+  once: () => once,
+  silentWrapAsync: () => silentWrapAsync,
+  trampoline: () => trampoline
+});
+module.exports = __toCommonJS(functions_exports);
+// @__NO_SIDE_EFFECTS__
+function noop() {
+}
+// @__NO_SIDE_EFFECTS__
+function once(fn) {
+  let called = false;
+  let result;
+  return function(...args) {
+    if (!called) {
+      called = true;
+      result = fn.apply(this, args);
+    }
+    return result;
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function silentWrapAsync(fn) {
+  return async (...args) => {
+    try {
+      const result = await fn(...args);
+      return result === null ? void 0 : result;
+    } catch {
+    }
+    return void 0;
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function trampoline(fn) {
+  return function(...args) {
+    let result = fn.apply(this, args);
+    while (typeof result === "function") {
+      result = result();
+    }
+    return result;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  noop,
+  once,
+  silentWrapAsync,
+  trampoline
+});
+//# sourceMappingURL=functions.js.map

package/dist/functions.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/functions.ts"],
+  "sourcesContent": ["/**\n * @fileoverview Common function utilities for control flow and caching.\n * Provides noop, once, and other foundational function helpers.\n */\n\n// Type definitions\nexport type AsyncFunction<TArgs extends unknown[], TResult> = (\n  ...args: TArgs\n) => Promise<TResult>\nexport type AnyFunction = (...args: unknown[]) => unknown\n\n/**\n * A no-op function that does nothing.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function noop(): void {}\n\n/**\n * Create a function that only executes once.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function once<T extends AnyFunction>(fn: T): T {\n  let called = false\n  let result: ReturnType<T>\n  return function (\n    this: ThisParameterType<T>,\n    ...args: Parameters<T>\n  ): ReturnType<T> {\n    if (!called) {\n      called = true\n      result = fn.apply(this, args) as ReturnType<T>\n    }\n    return result as ReturnType<T>\n  } as T\n}\n\n/**\n * Wrap an async function to silently catch and ignore errors.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function silentWrapAsync<TArgs extends unknown[], TResult>(\n  fn: AsyncFunction<TArgs, TResult>,\n): (...args: TArgs) => Promise<TResult | undefined> {\n  return async (...args: TArgs): Promise<TResult | undefined> => {\n    try {\n      const result = await fn(...args)\n      return result === null ? undefined : result\n    } catch {}\n    return undefined\n  }\n}\n\n/**\n * Execute a function with tail call optimization via trampoline.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function trampoline<T extends AnyFunction>(fn: T): T {\n  return function (\n    this: ThisParameterType<T>,\n    ...args: Parameters<T>\n  ): ReturnType<T> {\n    let result: ReturnType<T> | (() => ReturnType<T>) = fn.apply(this, args) as\n      | ReturnType<T>\n      | (() => ReturnType<T>)\n    while (typeof result === 'function') {\n      result = (result as () => ReturnType<T> | (() => ReturnType<T>))() as\n        | ReturnType<T>\n        | (() => ReturnType<T>)\n    }\n    return result as ReturnType<T>\n  } as T\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAeO,SAAS,OAAa;AAAC;AAAA;AAMvB,SAAS,KAA4B,IAAU;AACpD,MAAI,SAAS;AACb,MAAI;AACJ,SAAO,YAEF,MACY;AACf,QAAI,CAAC,QAAQ;AACX,eAAS;AACT,eAAS,GAAG,MAAM,MAAM,IAAI;AAAA,IAC9B;AACA,WAAO;AAAA,EACT;AACF;AAAA;AAMO,SAAS,gBACd,IACkD;AAClD,SAAO,UAAU,SAA8C;AAC7D,QAAI;AACF,YAAM,SAAS,MAAM,GAAG,GAAG,IAAI;AAC/B,aAAO,WAAW,OAAO,SAAY;AAAA,IACvC,QAAQ;AAAA,IAAC;AACT,WAAO;AAAA,EACT;AACF;AAAA;AAMO,SAAS,WAAkC,IAAU;AAC1D,SAAO,YAEF,MACY;AACf,QAAI,SAAgD,GAAG,MAAM,MAAM,IAAI;AAGvE,WAAO,OAAO,WAAW,YAAY;AACnC,eAAU,OAAuD;AAAA,IAGnE;AACA,WAAO;AAAA,EACT;AACF;",
+  "names": []
+}

package/dist/git.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Options for git diff operations.
+ */
+export interface GitDiffOptions {
+    absolute?: boolean;
+    cache?: boolean;
+    cwd?: string;
+    porcelain?: boolean;
+    asSet?: boolean;
+    [key: string]: unknown;
+}
+/**
+ * Options for package filtering operations.
+ */
+export interface FilterPackagesByChangesOptions {
+    force?: boolean;
+    packageKey?: string;
+    [key: string]: unknown;
+}
+/**
+ * Find git repository root by walking up from the given directory.
+ * Returns the directory itself if it contains .git, or the original path if no .git found.
+ * Exported for testing.
+ */
+export declare function findGitRoot(startPath: string): string;
+/**
+ * Get all changed files including staged, unstaged, and untracked files.
+ * Uses `git status --porcelain` which returns the full working tree status
+ * with status codes (M=modified, A=added, D=deleted, ??=untracked, etc.).
+ * This is the most comprehensive check - captures everything that differs
+ * from the last commit.
+ */
+export declare function getChangedFiles(options?: GitDiffOptions): Promise<string[]>;
+/**
+ * Get all changed files including staged, unstaged, and untracked files.
+ * Uses `git status --porcelain` which returns the full working tree status
+ * with status codes (M=modified, A=added, D=deleted, ??=untracked, etc.).
+ * This is the most comprehensive check - captures everything that differs
+ * from the last commit.
+ */
+export declare function getChangedFilesSync(options?: GitDiffOptions): string[];
+/**
+ * Get unstaged modified files (changes not yet staged for commit).
+ * Uses `git diff --name-only` which returns only unstaged modifications
+ * to tracked files. Does not include untracked files or staged changes.
+ * This is a focused check for uncommitted changes to existing files.
+ */
+export declare function getUnstagedFiles(options?: GitDiffOptions): Promise<string[]>;
+/**
+ * Get unstaged modified files (changes not yet staged for commit).
+ * Uses `git diff --name-only` which returns only unstaged modifications
+ * to tracked files. Does not include untracked files or staged changes.
+ * This is a focused check for uncommitted changes to existing files.
+ */
+export declare function getUnstagedFilesSync(options?: GitDiffOptions): string[];
+/**
+ * Get staged files ready for commit (changes added with `git add`).
+ * Uses `git diff --cached --name-only` which returns only staged changes.
+ * Does not include unstaged modifications or untracked files.
+ * This is a focused check for what will be included in the next commit.
+ */
+export declare function getStagedFiles(options?: GitDiffOptions): Promise<string[]>;
+/**
+ * Get staged files ready for commit (changes added with `git add`).
+ * Uses `git diff --cached --name-only` which returns only staged changes.
+ * Does not include unstaged modifications or untracked files.
+ * This is a focused check for what will be included in the next commit.
+ */
+export declare function getStagedFilesSync(options?: GitDiffOptions): string[];
+/**
+ * Check if pathname has any changes (staged, unstaged, or untracked).
+ */
+export declare function isChanged(pathname: string, options?: GitDiffOptions): Promise<boolean>;
+/**
+ * Check if pathname has any changes (staged, unstaged, or untracked).
+ */
+export declare function isChangedSync(pathname: string, options?: GitDiffOptions): boolean;
+/**
+ * Check if pathname has unstaged changes (modified but not staged).
+ */
+export declare function isUnstaged(pathname: string, options?: GitDiffOptions): Promise<boolean>;
+/**
+ * Check if pathname has unstaged changes (modified but not staged).
+ */
+export declare function isUnstagedSync(pathname: string, options?: GitDiffOptions): boolean;
+/**
+ * Check if pathname is staged for commit.
+ */
+export declare function isStaged(pathname: string, options?: GitDiffOptions): Promise<boolean>;
+/**
+ * Check if pathname is staged for commit.
+ */
+export declare function isStagedSync(pathname: string, options?: GitDiffOptions): boolean;

package/dist/git.js

@@ -0,0 +1,321 @@
+/* Socket Lib - Built with esbuild */
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var git_exports = {};
+__export(git_exports, {
+  findGitRoot: () => findGitRoot,
+  getChangedFiles: () => getChangedFiles,
+  getChangedFilesSync: () => getChangedFilesSync,
+  getStagedFiles: () => getStagedFiles,
+  getStagedFilesSync: () => getStagedFilesSync,
+  getUnstagedFiles: () => getUnstagedFiles,
+  getUnstagedFilesSync: () => getUnstagedFilesSync,
+  isChanged: () => isChanged,
+  isChangedSync: () => isChangedSync,
+  isStaged: () => isStaged,
+  isStagedSync: () => isStagedSync,
+  isUnstaged: () => isUnstaged,
+  isUnstagedSync: () => isUnstagedSync
+});
+module.exports = __toCommonJS(git_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_globs = require("./globs");
+var import_path = require("./path");
+var import_spawn = require("./spawn");
+var import_strings = require("./strings");
+const gitDiffCache = /* @__PURE__ */ new Map();
+let _fs;
+// @__NO_SIDE_EFFECTS__
+function getFs() {
+  if (_fs === void 0) {
+    _fs = require("node:fs");
+  }
+  return _fs;
+}
+let _path;
+// @__NO_SIDE_EFFECTS__
+function getPath() {
+  if (_path === void 0) {
+    _path = require("node:path");
+  }
+  return _path;
+}
+function getGitPath() {
+  return "git";
+}
+function getCwd() {
+  return (/* @__PURE__ */ getFs()).realpathSync(process.cwd());
+}
+function getGitDiffSpawnArgs(cwd) {
+  const resolvedCwd = cwd ? (/* @__PURE__ */ getFs()).realpathSync(cwd) : getCwd();
+  return {
+    all: [
+      getGitPath(),
+      ["status", "--porcelain"],
+      {
+        cwd: resolvedCwd,
+        shell: process.platform === "win32"
+      }
+    ],
+    unstaged: [
+      getGitPath(),
+      ["diff", "--name-only"],
+      {
+        cwd: resolvedCwd
+      }
+    ],
+    staged: [
+      getGitPath(),
+      ["diff", "--cached", "--name-only"],
+      {
+        cwd: resolvedCwd,
+        shell: process.platform === "win32"
+      }
+    ]
+  };
+}
+async function innerDiff(args, options) {
+  const { cache = true, ...parseOptions } = { __proto__: null, ...options };
+  const cacheKey = cache ? JSON.stringify({ args, parseOptions }) : void 0;
+  if (cache && cacheKey) {
+    const result2 = gitDiffCache.get(cacheKey);
+    if (result2) {
+      return result2;
+    }
+  }
+  let result;
+  try {
+    const spawnResult = await (0, import_spawn.spawn)(args[0], args[1], {
+      ...args[2],
+      stdioString: false
+    });
+    const stdout = Buffer.isBuffer(spawnResult.stdout) ? spawnResult.stdout.toString("utf8") : String(spawnResult.stdout);
+    const spawnCwd = typeof args[2]["cwd"] === "string" ? args[2]["cwd"] : void 0;
+    result = parseGitDiffStdout(stdout, parseOptions, spawnCwd);
+  } catch {
+    return [];
+  }
+  if (cache && cacheKey) {
+    gitDiffCache.set(cacheKey, result);
+  }
+  return result;
+}
+function innerDiffSync(args, options) {
+  const { cache = true, ...parseOptions } = { __proto__: null, ...options };
+  const cacheKey = cache ? JSON.stringify({ args, parseOptions }) : void 0;
+  if (cache && cacheKey) {
+    const result2 = gitDiffCache.get(cacheKey);
+    if (result2) {
+      return result2;
+    }
+  }
+  let result;
+  try {
+    const spawnResult = (0, import_spawn.spawnSync)(args[0], args[1], {
+      ...args[2],
+      stdioString: false
+    });
+    const stdout = Buffer.isBuffer(spawnResult.stdout) ? spawnResult.stdout.toString("utf8") : String(spawnResult.stdout);
+    const spawnCwd = typeof args[2]["cwd"] === "string" ? args[2]["cwd"] : void 0;
+    result = parseGitDiffStdout(stdout, parseOptions, spawnCwd);
+  } catch {
+    return [];
+  }
+  if (cache && cacheKey) {
+    gitDiffCache.set(cacheKey, result);
+  }
+  return result;
+}
+function findGitRoot(startPath) {
+  const fs = /* @__PURE__ */ getFs();
+  const path2 = /* @__PURE__ */ getPath();
+  let currentPath = startPath;
+  while (true) {
+    try {
+      const gitPath = path2.join(currentPath, ".git");
+      if (fs.existsSync(gitPath)) {
+        return currentPath;
+      }
+    } catch {
+    }
+    const parentPath = path2.dirname(currentPath);
+    if (parentPath === currentPath) {
+      return startPath;
+    }
+    currentPath = parentPath;
+  }
+}
+function parseGitDiffStdout(stdout, options, spawnCwd) {
+  const defaultRoot = spawnCwd ? findGitRoot(spawnCwd) : getCwd();
+  const {
+    absolute = false,
+    cwd: cwdOption = defaultRoot,
+    porcelain = false,
+    ...matcherOptions
+  } = { __proto__: null, ...options };
+  const cwd = cwdOption === defaultRoot ? defaultRoot : (/* @__PURE__ */ getFs()).realpathSync(cwdOption);
+  const rootPath = defaultRoot;
+  let rawFiles = stdout ? (0, import_strings.stripAnsi)(stdout).split("\n").map((line) => line.trimEnd()).filter((line) => line) : [];
+  if (porcelain) {
+    rawFiles = rawFiles.map((line) => {
+      return line.length > 3 ? line.substring(3) : line;
+    });
+  }
+  const files = absolute ? rawFiles.map((relPath2) => (0, import_path.normalizePath)(import_node_path.default.join(rootPath, relPath2))) : rawFiles.map((relPath2) => (0, import_path.normalizePath)(relPath2));
+  if (cwd === rootPath) {
+    return files;
+  }
+  const relPath = (0, import_path.normalizePath)(import_node_path.default.relative(rootPath, cwd));
+  const matcher = (0, import_globs.getGlobMatcher)([`${relPath}/**`], {
+    ...matcherOptions,
+    absolute,
+    cwd: rootPath
+  });
+  const filtered = [];
+  for (const filepath of files) {
+    if (matcher(filepath)) {
+      filtered.push(filepath);
+    }
+  }
+  return filtered;
+}
+async function getChangedFiles(options) {
+  const args = getGitDiffSpawnArgs(options?.cwd).all;
+  return await innerDiff(args, {
+    __proto__: null,
+    ...options,
+    porcelain: true
+  });
+}
+function getChangedFilesSync(options) {
+  const args = getGitDiffSpawnArgs(options?.cwd).all;
+  return innerDiffSync(args, {
+    __proto__: null,
+    ...options,
+    porcelain: true
+  });
+}
+async function getUnstagedFiles(options) {
+  const args = getGitDiffSpawnArgs(options?.cwd).unstaged;
+  return await innerDiff(args, options);
+}
+function getUnstagedFilesSync(options) {
+  const args = getGitDiffSpawnArgs(options?.cwd).unstaged;
+  return innerDiffSync(args, options);
+}
+async function getStagedFiles(options) {
+  const args = getGitDiffSpawnArgs(options?.cwd).staged;
+  return await innerDiff(args, options);
+}
+function getStagedFilesSync(options) {
+  const args = getGitDiffSpawnArgs(options?.cwd).staged;
+  return innerDiffSync(args, options);
+}
+async function isChanged(pathname, options) {
+  const files = await getChangedFiles({
+    __proto__: null,
+    ...options,
+    absolute: false
+  });
+  const resolvedPathname = (/* @__PURE__ */ getFs()).realpathSync(pathname);
+  const baseCwd = options?.cwd ? (/* @__PURE__ */ getFs()).realpathSync(options["cwd"]) : getCwd();
+  const relativePath = (0, import_path.normalizePath)(import_node_path.default.relative(baseCwd, resolvedPathname));
+  return files.includes(relativePath);
+}
+function isChangedSync(pathname, options) {
+  const files = getChangedFilesSync({
+    __proto__: null,
+    ...options,
+    absolute: false
+  });
+  const resolvedPathname = (/* @__PURE__ */ getFs()).realpathSync(pathname);
+  const baseCwd = options?.cwd ? (/* @__PURE__ */ getFs()).realpathSync(options["cwd"]) : getCwd();
+  const relativePath = (0, import_path.normalizePath)(import_node_path.default.relative(baseCwd, resolvedPathname));
+  return files.includes(relativePath);
+}
+async function isUnstaged(pathname, options) {
+  const files = await getUnstagedFiles({
+    __proto__: null,
+    ...options,
+    absolute: false
+  });
+  const resolvedPathname = (/* @__PURE__ */ getFs()).realpathSync(pathname);
+  const baseCwd = options?.cwd ? (/* @__PURE__ */ getFs()).realpathSync(options["cwd"]) : getCwd();
+  const relativePath = (0, import_path.normalizePath)(import_node_path.default.relative(baseCwd, resolvedPathname));
+  return files.includes(relativePath);
+}
+function isUnstagedSync(pathname, options) {
+  const files = getUnstagedFilesSync({
+    __proto__: null,
+    ...options,
+    absolute: false
+  });
+  const resolvedPathname = (/* @__PURE__ */ getFs()).realpathSync(pathname);
+  const baseCwd = options?.cwd ? (/* @__PURE__ */ getFs()).realpathSync(options["cwd"]) : getCwd();
+  const relativePath = (0, import_path.normalizePath)(import_node_path.default.relative(baseCwd, resolvedPathname));
+  return files.includes(relativePath);
+}
+async function isStaged(pathname, options) {
+  const files = await getStagedFiles({
+    __proto__: null,
+    ...options,
+    absolute: false
+  });
+  const resolvedPathname = (/* @__PURE__ */ getFs()).realpathSync(pathname);
+  const baseCwd = options?.cwd ? (/* @__PURE__ */ getFs()).realpathSync(options["cwd"]) : getCwd();
+  const relativePath = (0, import_path.normalizePath)(import_node_path.default.relative(baseCwd, resolvedPathname));
+  return files.includes(relativePath);
+}
+function isStagedSync(pathname, options) {
+  const files = getStagedFilesSync({
+    __proto__: null,
+    ...options,
+    absolute: false
+  });
+  const resolvedPathname = (/* @__PURE__ */ getFs()).realpathSync(pathname);
+  const baseCwd = options?.cwd ? (/* @__PURE__ */ getFs()).realpathSync(options["cwd"]) : getCwd();
+  const relativePath = (0, import_path.normalizePath)(import_node_path.default.relative(baseCwd, resolvedPathname));
+  return files.includes(relativePath);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findGitRoot,
+  getChangedFiles,
+  getChangedFilesSync,
+  getStagedFiles,
+  getStagedFilesSync,
+  getUnstagedFiles,
+  getUnstagedFilesSync,
+  isChanged,
+  isChangedSync,
+  isStaged,
+  isStagedSync,
+  isUnstaged,
+  isUnstagedSync
+});
+//# sourceMappingURL=git.js.map

package/dist/git.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/git.ts"],
+  "sourcesContent": ["import path from 'node:path'\n\nimport { getGlobMatcher } from './globs'\nimport { normalizePath } from './path'\nimport { spawn, spawnSync } from './spawn'\nimport { stripAnsi } from './strings'\n\n/**\n * Options for git diff operations.\n */\nexport interface GitDiffOptions {\n  absolute?: boolean\n  cache?: boolean\n  cwd?: string\n  porcelain?: boolean\n  asSet?: boolean\n  [key: string]: unknown\n}\n\n/**\n * Options for package filtering operations.\n */\nexport interface FilterPackagesByChangesOptions {\n  force?: boolean\n  packageKey?: string\n  [key: string]: unknown\n}\n\ntype SpawnArgs = [string, string[], Record<string, unknown>]\n\ninterface GitDiffSpawnArgs {\n  all: SpawnArgs\n  unstaged: SpawnArgs\n  staged: SpawnArgs\n}\n\nconst gitDiffCache = new Map<string, string[]>()\n\nlet _fs: typeof import('fs') | undefined\n/**\n * Lazily load the fs module to avoid Webpack errors.\n */\n/*@__NO_SIDE_EFFECTS__*/\nfunction getFs() {\n  if (_fs === undefined) {\n    // Use non-'node:' prefixed require to avoid Webpack errors.\n\n    _fs = /*@__PURE__*/ require('node:fs')\n  }\n  return _fs as typeof import('fs')\n}\n\nlet _path: typeof import('path') | undefined\n/**\n * Lazily load the path module to avoid Webpack errors.\n */\n/*@__NO_SIDE_EFFECTS__*/\nfunction getPath() {\n  if (_path === undefined) {\n    _path = /*@__PURE__*/ require('node:path')\n  }\n  return _path as typeof import('path')\n}\n\n/**\n * Get git executable path.\n */\nfunction getGitPath(): string {\n  return 'git'\n}\n\n/**\n * Get current working directory for git operations.\n * Returns the real path to handle symlinks like /tmp -> /private/tmp.\n */\nfunction getCwd(): string {\n  return getFs().realpathSync(process.cwd())\n}\n\nfunction getGitDiffSpawnArgs(cwd?: string): GitDiffSpawnArgs {\n  const resolvedCwd = cwd ? getFs().realpathSync(cwd) : getCwd()\n  return {\n    all: [\n      getGitPath(),\n      ['status', '--porcelain'],\n      {\n        cwd: resolvedCwd,\n        shell: process.platform === 'win32',\n      },\n    ],\n    unstaged: [\n      getGitPath(),\n      ['diff', '--name-only'],\n      {\n        cwd: resolvedCwd,\n      },\n    ],\n    staged: [\n      getGitPath(),\n      ['diff', '--cached', '--name-only'],\n      {\n        cwd: resolvedCwd,\n        shell: process.platform === 'win32',\n      },\n    ],\n  }\n}\n\nasync function innerDiff(\n  args: SpawnArgs,\n  options?: GitDiffOptions,\n): Promise<string[]> {\n  const { cache = true, ...parseOptions } = { __proto__: null, ...options }\n  const cacheKey = cache ? JSON.stringify({ args, parseOptions }) : undefined\n  if (cache && cacheKey) {\n    const result = gitDiffCache.get(cacheKey)\n    if (result) {\n      return result\n    }\n  }\n  let result: string[]\n  try {\n    // Use stdioString: false to get raw Buffer, then convert ourselves to preserve exact output.\n    const spawnResult = await spawn(args[0], args[1], {\n      ...args[2],\n      stdioString: false,\n    })\n    const stdout = Buffer.isBuffer(spawnResult.stdout)\n      ? spawnResult.stdout.toString('utf8')\n      : String(spawnResult.stdout)\n    // Extract spawn cwd from args to pass to parser\n    const spawnCwd =\n      typeof args[2]['cwd'] === 'string' ? args[2]['cwd'] : undefined\n    result = parseGitDiffStdout(stdout, parseOptions, spawnCwd)\n  } catch {\n    return []\n  }\n  if (cache && cacheKey) {\n    gitDiffCache.set(cacheKey, result)\n  }\n  return result\n}\n\nfunction innerDiffSync(args: SpawnArgs, options?: GitDiffOptions): string[] {\n  const { cache = true, ...parseOptions } = { __proto__: null, ...options }\n  const cacheKey = cache ? JSON.stringify({ args, parseOptions }) : undefined\n  if (cache && cacheKey) {\n    const result = gitDiffCache.get(cacheKey)\n    if (result) {\n      return result\n    }\n  }\n  let result: string[]\n  try {\n    // Use stdioString: false to get raw Buffer, then convert ourselves to preserve exact output.\n    const spawnResult = spawnSync(args[0], args[1], {\n      ...args[2],\n      stdioString: false,\n    })\n    const stdout = Buffer.isBuffer(spawnResult.stdout)\n      ? spawnResult.stdout.toString('utf8')\n      : String(spawnResult.stdout)\n    // Extract spawn cwd from args to pass to parser\n    const spawnCwd =\n      typeof args[2]['cwd'] === 'string' ? args[2]['cwd'] : undefined\n    result = parseGitDiffStdout(stdout, parseOptions, spawnCwd)\n  } catch {\n    return []\n  }\n  if (cache && cacheKey) {\n    gitDiffCache.set(cacheKey, result)\n  }\n  return result\n}\n\n/**\n * Find git repository root by walking up from the given directory.\n * Returns the directory itself if it contains .git, or the original path if no .git found.\n * Exported for testing.\n */\nexport function findGitRoot(startPath: string): string {\n  const fs = getFs()\n  const path = getPath()\n  let currentPath = startPath\n  // Walk up the directory tree looking for .git\n  while (true) {\n    try {\n      const gitPath = path.join(currentPath, '.git')\n      if (fs.existsSync(gitPath)) {\n        return currentPath\n      }\n    } catch {\n      // Ignore errors and continue walking up\n    }\n    const parentPath = path.dirname(currentPath)\n    // Stop if we've reached the root or can't go up anymore\n    if (parentPath === currentPath) {\n      // Return original path if no .git found\n      return startPath\n    }\n    currentPath = parentPath\n  }\n}\n\nfunction parseGitDiffStdout(\n  stdout: string,\n  options?: GitDiffOptions,\n  spawnCwd?: string,\n): string[] {\n  // Find git repo root from spawnCwd. Git always returns paths relative to the repo root,\n  // not the cwd where it was run. So we need to find the repo root to correctly parse paths.\n  const defaultRoot = spawnCwd ? findGitRoot(spawnCwd) : getCwd()\n  const {\n    absolute = false,\n    cwd: cwdOption = defaultRoot,\n    porcelain = false,\n    ...matcherOptions\n  } = { __proto__: null, ...options }\n  // Resolve cwd to handle symlinks.\n  const cwd =\n    cwdOption === defaultRoot ? defaultRoot : getFs().realpathSync(cwdOption)\n  const rootPath = defaultRoot\n  // Split into lines without trimming to preserve leading spaces in porcelain format.\n  let rawFiles = stdout\n    ? stripAnsi(stdout)\n        .split('\\n')\n        .map(line => line.trimEnd())\n        .filter(line => line)\n    : []\n  // Parse porcelain format: strip status codes.\n  // Git status --porcelain format is: XY filename\n  // where X and Y are single characters and there's a space before the filename.\n  if (porcelain) {\n    rawFiles = rawFiles.map(line => {\n      // Status is first 2 chars, then space, then filename.\n      return line.length > 3 ? line.substring(3) : line\n    })\n  }\n  const files = absolute\n    ? rawFiles.map(relPath => normalizePath(path.join(rootPath, relPath)))\n    : rawFiles.map(relPath => normalizePath(relPath))\n  if (cwd === rootPath) {\n    return files\n  }\n  const relPath = normalizePath(path.relative(rootPath, cwd))\n  const matcher = getGlobMatcher([`${relPath}/**`], {\n    ...(matcherOptions as {\n      dot?: boolean\n      ignore?: string[]\n      nocase?: boolean\n    }),\n    absolute,\n    cwd: rootPath,\n  } as {\n    absolute?: boolean\n    cwd?: string\n    dot?: boolean\n    ignore?: string[]\n    nocase?: boolean\n  })\n  const filtered: string[] = []\n  for (const filepath of files) {\n    if (matcher(filepath)) {\n      filtered.push(filepath)\n    }\n  }\n  return filtered\n}\n\n/**\n * Get all changed files including staged, unstaged, and untracked files.\n * Uses `git status --porcelain` which returns the full working tree status\n * with status codes (M=modified, A=added, D=deleted, ??=untracked, etc.).\n * This is the most comprehensive check - captures everything that differs\n * from the last commit.\n */\nexport async function getChangedFiles(\n  options?: GitDiffOptions,\n): Promise<string[]> {\n  const args = getGitDiffSpawnArgs(options?.cwd).all\n  return await innerDiff(args, {\n    __proto__: null,\n    ...options,\n    porcelain: true,\n  })\n}\n\n/**\n * Get all changed files including staged, unstaged, and untracked files.\n * Uses `git status --porcelain` which returns the full working tree status\n * with status codes (M=modified, A=added, D=deleted, ??=untracked, etc.).\n * This is the most comprehensive check - captures everything that differs\n * from the last commit.\n */\nexport function getChangedFilesSync(options?: GitDiffOptions): string[] {\n  const args = getGitDiffSpawnArgs(options?.cwd).all\n  return innerDiffSync(args, {\n    __proto__: null,\n    ...options,\n    porcelain: true,\n  })\n}\n\n/**\n * Get unstaged modified files (changes not yet staged for commit).\n * Uses `git diff --name-only` which returns only unstaged modifications\n * to tracked files. Does not include untracked files or staged changes.\n * This is a focused check for uncommitted changes to existing files.\n */\nexport async function getUnstagedFiles(\n  options?: GitDiffOptions,\n): Promise<string[]> {\n  const args = getGitDiffSpawnArgs(options?.cwd).unstaged\n  return await innerDiff(args, options)\n}\n\n/**\n * Get unstaged modified files (changes not yet staged for commit).\n * Uses `git diff --name-only` which returns only unstaged modifications\n * to tracked files. Does not include untracked files or staged changes.\n * This is a focused check for uncommitted changes to existing files.\n */\nexport function getUnstagedFilesSync(options?: GitDiffOptions): string[] {\n  const args = getGitDiffSpawnArgs(options?.cwd).unstaged\n  return innerDiffSync(args, options)\n}\n\n/**\n * Get staged files ready for commit (changes added with `git add`).\n * Uses `git diff --cached --name-only` which returns only staged changes.\n * Does not include unstaged modifications or untracked files.\n * This is a focused check for what will be included in the next commit.\n */\nexport async function getStagedFiles(\n  options?: GitDiffOptions,\n): Promise<string[]> {\n  const args = getGitDiffSpawnArgs(options?.cwd).staged\n  return await innerDiff(args, options)\n}\n\n/**\n * Get staged files ready for commit (changes added with `git add`).\n * Uses `git diff --cached --name-only` which returns only staged changes.\n * Does not include unstaged modifications or untracked files.\n * This is a focused check for what will be included in the next commit.\n */\nexport function getStagedFilesSync(options?: GitDiffOptions): string[] {\n  const args = getGitDiffSpawnArgs(options?.cwd).staged\n  return innerDiffSync(args, options)\n}\n\n/**\n * Check if pathname has any changes (staged, unstaged, or untracked).\n */\nexport async function isChanged(\n  pathname: string,\n  options?: GitDiffOptions,\n): Promise<boolean> {\n  const files = await getChangedFiles({\n    __proto__: null,\n    ...options,\n    absolute: false,\n  })\n  // Resolve pathname to handle symlinks before computing relative path.\n  const resolvedPathname = getFs().realpathSync(pathname)\n  const baseCwd = options?.cwd ? getFs().realpathSync(options['cwd']) : getCwd()\n  const relativePath = normalizePath(path.relative(baseCwd, resolvedPathname))\n  return files.includes(relativePath)\n}\n\n/**\n * Check if pathname has any changes (staged, unstaged, or untracked).\n */\nexport function isChangedSync(\n  pathname: string,\n  options?: GitDiffOptions,\n): boolean {\n  const files = getChangedFilesSync({\n    __proto__: null,\n    ...options,\n    absolute: false,\n  })\n  // Resolve pathname to handle symlinks before computing relative path.\n  const resolvedPathname = getFs().realpathSync(pathname)\n  const baseCwd = options?.cwd ? getFs().realpathSync(options['cwd']) : getCwd()\n  const relativePath = normalizePath(path.relative(baseCwd, resolvedPathname))\n  return files.includes(relativePath)\n}\n\n/**\n * Check if pathname has unstaged changes (modified but not staged).\n */\nexport async function isUnstaged(\n  pathname: string,\n  options?: GitDiffOptions,\n): Promise<boolean> {\n  const files = await getUnstagedFiles({\n    __proto__: null,\n    ...options,\n    absolute: false,\n  })\n  // Resolve pathname to handle symlinks before computing relative path.\n  const resolvedPathname = getFs().realpathSync(pathname)\n  const baseCwd = options?.cwd ? getFs().realpathSync(options['cwd']) : getCwd()\n  const relativePath = normalizePath(path.relative(baseCwd, resolvedPathname))\n  return files.includes(relativePath)\n}\n\n/**\n * Check if pathname has unstaged changes (modified but not staged).\n */\nexport function isUnstagedSync(\n  pathname: string,\n  options?: GitDiffOptions,\n): boolean {\n  const files = getUnstagedFilesSync({\n    __proto__: null,\n    ...options,\n    absolute: false,\n  })\n  // Resolve pathname to handle symlinks before computing relative path.\n  const resolvedPathname = getFs().realpathSync(pathname)\n  const baseCwd = options?.cwd ? getFs().realpathSync(options['cwd']) : getCwd()\n  const relativePath = normalizePath(path.relative(baseCwd, resolvedPathname))\n  return files.includes(relativePath)\n}\n\n/**\n * Check if pathname is staged for commit.\n */\nexport async function isStaged(\n  pathname: string,\n  options?: GitDiffOptions,\n): Promise<boolean> {\n  const files = await getStagedFiles({\n    __proto__: null,\n    ...options,\n    absolute: false,\n  })\n  // Resolve pathname to handle symlinks before computing relative path.\n  const resolvedPathname = getFs().realpathSync(pathname)\n  const baseCwd = options?.cwd ? getFs().realpathSync(options['cwd']) : getCwd()\n  const relativePath = normalizePath(path.relative(baseCwd, resolvedPathname))\n  return files.includes(relativePath)\n}\n\n/**\n * Check if pathname is staged for commit.\n */\nexport function isStagedSync(\n  pathname: string,\n  options?: GitDiffOptions,\n): boolean {\n  const files = getStagedFilesSync({\n    __proto__: null,\n    ...options,\n    absolute: false,\n  })\n  // Resolve pathname to handle symlinks before computing relative path.\n  const resolvedPathname = getFs().realpathSync(pathname)\n  const baseCwd = options?.cwd ? getFs().realpathSync(options['cwd']) : getCwd()\n  const relativePath = normalizePath(path.relative(baseCwd, resolvedPathname))\n  return files.includes(relativePath)\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uBAAiB;AAEjB,mBAA+B;AAC/B,kBAA8B;AAC9B,mBAAiC;AACjC,qBAA0B;AA+B1B,MAAM,eAAe,oBAAI,IAAsB;AAE/C,IAAI;AAAA;AAKJ,SAAS,QAAQ;AACf,MAAI,QAAQ,QAAW;AAGrB,UAAoB,QAAQ,SAAS;AAAA,EACvC;AACA,SAAO;AACT;AAEA,IAAI;AAAA;AAKJ,SAAS,UAAU;AACjB,MAAI,UAAU,QAAW;AACvB,YAAsB,QAAQ,WAAW;AAAA,EAC3C;AACA,SAAO;AACT;AAKA,SAAS,aAAqB;AAC5B,SAAO;AACT;AAMA,SAAS,SAAiB;AACxB,UAAO,sBAAM,GAAE,aAAa,QAAQ,IAAI,CAAC;AAC3C;AAEA,SAAS,oBAAoB,KAAgC;AAC3D,QAAM,cAAc,OAAM,sBAAM,GAAE,aAAa,GAAG,IAAI,OAAO;AAC7D,SAAO;AAAA,IACL,KAAK;AAAA,MACH,WAAW;AAAA,MACX,CAAC,UAAU,aAAa;AAAA,MACxB;AAAA,QACE,KAAK;AAAA,QACL,OAAO,QAAQ,aAAa;AAAA,MAC9B;AAAA,IACF;AAAA,IACA,UAAU;AAAA,MACR,WAAW;AAAA,MACX,CAAC,QAAQ,aAAa;AAAA,MACtB;AAAA,QACE,KAAK;AAAA,MACP;AAAA,IACF;AAAA,IACA,QAAQ;AAAA,MACN,WAAW;AAAA,MACX,CAAC,QAAQ,YAAY,aAAa;AAAA,MAClC;AAAA,QACE,KAAK;AAAA,QACL,OAAO,QAAQ,aAAa;AAAA,MAC9B;AAAA,IACF;AAAA,EACF;AACF;AAEA,eAAe,UACb,MACA,SACmB;AACnB,QAAM,EAAE,QAAQ,MAAM,GAAG,aAAa,IAAI,EAAE,WAAW,MAAM,GAAG,QAAQ;AACxE,QAAM,WAAW,QAAQ,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC,IAAI;AAClE,MAAI,SAAS,UAAU;AACrB,UAAMA,UAAS,aAAa,IAAI,QAAQ;AACxC,QAAIA,SAAQ;AACV,aAAOA;AAAA,IACT;AAAA,EACF;AACA,MAAI;AACJ,MAAI;AAEF,UAAM,cAAc,UAAM,oBAAM,KAAK,CAAC,GAAG,KAAK,CAAC,GAAG;AAAA,MAChD,GAAG,KAAK,CAAC;AAAA,MACT,aAAa;AAAA,IACf,CAAC;AACD,UAAM,SAAS,OAAO,SAAS,YAAY,MAAM,IAC7C,YAAY,OAAO,SAAS,MAAM,IAClC,OAAO,YAAY,MAAM;AAE7B,UAAM,WACJ,OAAO,KAAK,CAAC,EAAE,KAAK,MAAM,WAAW,KAAK,CAAC,EAAE,KAAK,IAAI;AACxD,aAAS,mBAAmB,QAAQ,cAAc,QAAQ;AAAA,EAC5D,QAAQ;AACN,WAAO,CAAC;AAAA,EACV;AACA,MAAI,SAAS,UAAU;AACrB,iBAAa,IAAI,UAAU,MAAM;AAAA,EACnC;AACA,SAAO;AACT;AAEA,SAAS,cAAc,MAAiB,SAAoC;AAC1E,QAAM,EAAE,QAAQ,MAAM,GAAG,aAAa,IAAI,EAAE,WAAW,MAAM,GAAG,QAAQ;AACxE,QAAM,WAAW,QAAQ,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC,IAAI;AAClE,MAAI,SAAS,UAAU;AACrB,UAAMA,UAAS,aAAa,IAAI,QAAQ;AACxC,QAAIA,SAAQ;AACV,aAAOA;AAAA,IACT;AAAA,EACF;AACA,MAAI;AACJ,MAAI;AAEF,UAAM,kBAAc,wBAAU,KAAK,CAAC,GAAG,KAAK,CAAC,GAAG;AAAA,MAC9C,GAAG,KAAK,CAAC;AAAA,MACT,aAAa;AAAA,IACf,CAAC;AACD,UAAM,SAAS,OAAO,SAAS,YAAY,MAAM,IAC7C,YAAY,OAAO,SAAS,MAAM,IAClC,OAAO,YAAY,MAAM;AAE7B,UAAM,WACJ,OAAO,KAAK,CAAC,EAAE,KAAK,MAAM,WAAW,KAAK,CAAC,EAAE,KAAK,IAAI;AACxD,aAAS,mBAAmB,QAAQ,cAAc,QAAQ;AAAA,EAC5D,QAAQ;AACN,WAAO,CAAC;AAAA,EACV;AACA,MAAI,SAAS,UAAU;AACrB,iBAAa,IAAI,UAAU,MAAM;AAAA,EACnC;AACA,SAAO;AACT;AAOO,SAAS,YAAY,WAA2B;AACrD,QAAM,KAAK,sBAAM;AACjB,QAAMC,QAAO,wBAAQ;AACrB,MAAI,cAAc;AAElB,SAAO,MAAM;AACX,QAAI;AACF,YAAM,UAAUA,MAAK,KAAK,aAAa,MAAM;AAC7C,UAAI,GAAG,WAAW,OAAO,GAAG;AAC1B,eAAO;AAAA,MACT;AAAA,IACF,QAAQ;AAAA,IAER;AACA,UAAM,aAAaA,MAAK,QAAQ,WAAW;AAE3C,QAAI,eAAe,aAAa;AAE9B,aAAO;AAAA,IACT;AACA,kBAAc;AAAA,EAChB;AACF;AAEA,SAAS,mBACP,QACA,SACA,UACU;AAGV,QAAM,cAAc,WAAW,YAAY,QAAQ,IAAI,OAAO;AAC9D,QAAM;AAAA,IACJ,WAAW;AAAA,IACX,KAAK,YAAY;AAAA,IACjB,YAAY;AAAA,IACZ,GAAG;AAAA,EACL,IAAI,EAAE,WAAW,MAAM,GAAG,QAAQ;AAElC,QAAM,MACJ,cAAc,cAAc,eAAc,sBAAM,GAAE,aAAa,SAAS;AAC1E,QAAM,WAAW;AAEjB,MAAI,WAAW,aACX,0BAAU,MAAM,EACb,MAAM,IAAI,EACV,IAAI,UAAQ,KAAK,QAAQ,CAAC,EAC1B,OAAO,UAAQ,IAAI,IACtB,CAAC;AAIL,MAAI,WAAW;AACb,eAAW,SAAS,IAAI,UAAQ;AAE9B,aAAO,KAAK,SAAS,IAAI,KAAK,UAAU,CAAC,IAAI;AAAA,IAC/C,CAAC;AAAA,EACH;AACA,QAAM,QAAQ,WACV,SAAS,IAAI,CAAAC,iBAAW,2BAAc,iBAAAD,QAAK,KAAK,UAAUC,QAAO,CAAC,CAAC,IACnE,SAAS,IAAI,CAAAA,iBAAW,2BAAcA,QAAO,CAAC;AAClD,MAAI,QAAQ,UAAU;AACpB,WAAO;AAAA,EACT;AACA,QAAM,cAAU,2BAAc,iBAAAD,QAAK,SAAS,UAAU,GAAG,CAAC;AAC1D,QAAM,cAAU,6BAAe,CAAC,GAAG,OAAO,KAAK,GAAG;AAAA,IAChD,GAAI;AAAA,IAKJ;AAAA,IACA,KAAK;AAAA,EACP,CAMC;AACD,QAAM,WAAqB,CAAC;AAC5B,aAAW,YAAY,OAAO;AAC5B,QAAI,QAAQ,QAAQ,GAAG;AACrB,eAAS,KAAK,QAAQ;AAAA,IACxB;AAAA,EACF;AACA,SAAO;AACT;AASA,eAAsB,gBACpB,SACmB;AACnB,QAAM,OAAO,oBAAoB,SAAS,GAAG,EAAE;AAC/C,SAAO,MAAM,UAAU,MAAM;AAAA,IAC3B,WAAW;AAAA,IACX,GAAG;AAAA,IACH,WAAW;AAAA,EACb,CAAC;AACH;AASO,SAAS,oBAAoB,SAAoC;AACtE,QAAM,OAAO,oBAAoB,SAAS,GAAG,EAAE;AAC/C,SAAO,cAAc,MAAM;AAAA,IACzB,WAAW;AAAA,IACX,GAAG;AAAA,IACH,WAAW;AAAA,EACb,CAAC;AACH;AAQA,eAAsB,iBACpB,SACmB;AACnB,QAAM,OAAO,oBAAoB,SAAS,GAAG,EAAE;AAC/C,SAAO,MAAM,UAAU,MAAM,OAAO;AACtC;AAQO,SAAS,qBAAqB,SAAoC;AACvE,QAAM,OAAO,oBAAoB,SAAS,GAAG,EAAE;AAC/C,SAAO,cAAc,MAAM,OAAO;AACpC;AAQA,eAAsB,eACpB,SACmB;AACnB,QAAM,OAAO,oBAAoB,SAAS,GAAG,EAAE;AAC/C,SAAO,MAAM,UAAU,MAAM,OAAO;AACtC;AAQO,SAAS,mBAAmB,SAAoC;AACrE,QAAM,OAAO,oBAAoB,SAAS,GAAG,EAAE;AAC/C,SAAO,cAAc,MAAM,OAAO;AACpC;AAKA,eAAsB,UACpB,UACA,SACkB;AAClB,QAAM,QAAQ,MAAM,gBAAgB;AAAA,IAClC,WAAW;AAAA,IACX,GAAG;AAAA,IACH,UAAU;AAAA,EACZ,CAAC;AAED,QAAM,oBAAmB,sBAAM,GAAE,aAAa,QAAQ;AACtD,QAAM,UAAU,SAAS,OAAM,sBAAM,GAAE,aAAa,QAAQ,KAAK,CAAC,IAAI,OAAO;AAC7E,QAAM,mBAAe,2BAAc,iBAAAA,QAAK,SAAS,SAAS,gBAAgB,CAAC;AAC3E,SAAO,MAAM,SAAS,YAAY;AACpC;AAKO,SAAS,cACd,UACA,SACS;AACT,QAAM,QAAQ,oBAAoB;AAAA,IAChC,WAAW;AAAA,IACX,GAAG;AAAA,IACH,UAAU;AAAA,EACZ,CAAC;AAED,QAAM,oBAAmB,sBAAM,GAAE,aAAa,QAAQ;AACtD,QAAM,UAAU,SAAS,OAAM,sBAAM,GAAE,aAAa,QAAQ,KAAK,CAAC,IAAI,OAAO;AAC7E,QAAM,mBAAe,2BAAc,iBAAAA,QAAK,SAAS,SAAS,gBAAgB,CAAC;AAC3E,SAAO,MAAM,SAAS,YAAY;AACpC;AAKA,eAAsB,WACpB,UACA,SACkB;AAClB,QAAM,QAAQ,MAAM,iBAAiB;AAAA,IACnC,WAAW;AAAA,IACX,GAAG;AAAA,IACH,UAAU;AAAA,EACZ,CAAC;AAED,QAAM,oBAAmB,sBAAM,GAAE,aAAa,QAAQ;AACtD,QAAM,UAAU,SAAS,OAAM,sBAAM,GAAE,aAAa,QAAQ,KAAK,CAAC,IAAI,OAAO;AAC7E,QAAM,mBAAe,2BAAc,iBAAAA,QAAK,SAAS,SAAS,gBAAgB,CAAC;AAC3E,SAAO,MAAM,SAAS,YAAY;AACpC;AAKO,SAAS,eACd,UACA,SACS;AACT,QAAM,QAAQ,qBAAqB;AAAA,IACjC,WAAW;AAAA,IACX,GAAG;AAAA,IACH,UAAU;AAAA,EACZ,CAAC;AAED,QAAM,oBAAmB,sBAAM,GAAE,aAAa,QAAQ;AACtD,QAAM,UAAU,SAAS,OAAM,sBAAM,GAAE,aAAa,QAAQ,KAAK,CAAC,IAAI,OAAO;AAC7E,QAAM,mBAAe,2BAAc,iBAAAA,QAAK,SAAS,SAAS,gBAAgB,CAAC;AAC3E,SAAO,MAAM,SAAS,YAAY;AACpC;AAKA,eAAsB,SACpB,UACA,SACkB;AAClB,QAAM,QAAQ,MAAM,eAAe;AAAA,IACjC,WAAW;AAAA,IACX,GAAG;AAAA,IACH,UAAU;AAAA,EACZ,CAAC;AAED,QAAM,oBAAmB,sBAAM,GAAE,aAAa,QAAQ;AACtD,QAAM,UAAU,SAAS,OAAM,sBAAM,GAAE,aAAa,QAAQ,KAAK,CAAC,IAAI,OAAO;AAC7E,QAAM,mBAAe,2BAAc,iBAAAA,QAAK,SAAS,SAAS,gBAAgB,CAAC;AAC3E,SAAO,MAAM,SAAS,YAAY;AACpC;AAKO,SAAS,aACd,UACA,SACS;AACT,QAAM,QAAQ,mBAAmB;AAAA,IAC/B,WAAW;AAAA,IACX,GAAG;AAAA,IACH,UAAU;AAAA,EACZ,CAAC;AAED,QAAM,oBAAmB,sBAAM,GAAE,aAAa,QAAQ;AACtD,QAAM,UAAU,SAAS,OAAM,sBAAM,GAAE,aAAa,QAAQ,KAAK,CAAC,IAAI,OAAO;AAC7E,QAAM,mBAAe,2BAAc,iBAAAA,QAAK,SAAS,SAAS,gBAAgB,CAAC;AAC3E,SAAO,MAAM,SAAS,YAAY;AACpC;",
+  "names": ["result", "path", "relPath"]
+}