@lousy-agents/lint 5.13.6 → 5.14.0

package/dist/{27.js → 475.js}

@@ -1,7 +1,7 @@
-export const __rspack_esm_id = 27;
-export const __rspack_esm_ids = [27];
+export const __rspack_esm_id = 475;
+export const __rspack_esm_ids = [475];
 export const __webpack_modules__ = {
-9774(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+4710(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 // ESM COMPAT FLAG
 __webpack_require__.r(__webpack_exports__);
 
@@ -23,7 +23,7 @@ var promises_ = __webpack_require__(1455);
 var external_node_path_ = __webpack_require__(6760);
 // EXTERNAL MODULE: external "node:stream"
 var external_node_stream_ = __webpack_require__(7075);
-;// CONCATENATED MODULE: ../../node_modules/c12/node_modules/readdirp/index.js
+;// CONCATENATED MODULE: ../../node_modules/readdirp/index.js
 
 
 
@@ -299,7 +299,7 @@ function readdirpPromise(root, options = {}) {
 
 // EXTERNAL MODULE: external "node:os"
 var external_node_os_ = __webpack_require__(8161);
-;// CONCATENATED MODULE: ../../node_modules/c12/node_modules/chokidar/handler.js
+;// CONCATENATED MODULE: ../../node_modules/chokidar/handler.js
 
 
 
@@ -933,7 +933,7 @@ class NodeFsHandler {
     }
 }
 
-;// CONCATENATED MODULE: ../../node_modules/c12/node_modules/chokidar/index.js
+;// CONCATENATED MODULE: ../../node_modules/chokidar/index.js
 /*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */
 
 

package/dist/index.js

@@ -566,7 +566,7 @@ module.exports = webpackEmptyAsyncContext;
 
 
 },
-9491(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+5144(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
@@ -765,14 +765,17 @@ var dist = __webpack_require__(3519);
  * Extracts YAML data between leading `---` delimiters.
  */ 
 /**
- * Parses YAML frontmatter from markdown content.
- *
- * Returns `null` when the content has no opening `---`, no closing `---`,
- * or contains invalid YAML.
- */ function parseFrontmatter(content) {
+ * Parses YAML frontmatter and returns a tagged result:
+ * - `{ ok: true, data }` on success
+ * - `{ ok: false, reason: 'missing' }` when no frontmatter delimiters found
+ * - `{ ok: false, reason: 'invalid', detail }` when YAML is malformed (with error detail)
+ */ function parseFrontmatterWithError(content) {
     const lines = content.split("\n");
     if (lines[0]?.trim() !== "---") {
-        return null;
+        return {
+            ok: false,
+            reason: "missing"
+        };
     }
     let endIndex = -1;
     for(let i = 1; i < lines.length; i++){
@@ -782,7 +785,10 @@ var dist = __webpack_require__(3519);
         }
     }
     if (endIndex === -1) {
-        return null;
+        return {
+            ok: false,
+            reason: "missing"
+        };
     }
     const yamlContent = lines.slice(1, endIndex).join("\n");
     let data;
@@ -791,23 +797,39 @@ var dist = __webpack_require__(3519);
             maxAliasCount: 0
         });
         data = parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
-    } catch  {
-        return null;
+    } catch (error) {
+        const detail = error instanceof Error ? error.message : "Unknown YAML parse error";
+        return {
+            ok: false,
+            reason: "invalid",
+            detail
+        };
     }
     const fieldLines = new Map();
     for(let i = 1; i < endIndex; i++){
-        // Match YAML top-level field names: non-whitespace start, any chars except colon, then colon followed by whitespace or end-of-line
         const match = lines[i]?.match(/^([^\s:][^:]*?):(?:\s|$)/);
         if (match?.[1]) {
             fieldLines.set(match[1], i + 1);
         }
     }
     return {
-        data: data ?? {},
-        fieldLines,
-        frontmatterStartLine: 1
+        ok: true,
+        data: {
+            data: data ?? {},
+            fieldLines,
+            frontmatterStartLine: 1
+        }
     };
 }
+/**
+ * Parses YAML frontmatter from markdown content.
+ *
+ * Returns `null` when the content has no opening `---`, no closing `---`,
+ * or contains invalid YAML.
+ */ function parseFrontmatter(content) {
+    const result = parseFrontmatterWithError(content);
+    return result.ok ? result.data : null;
+}
 
 // EXTERNAL MODULE: external "node:fs"
 var external_node_fs_ = __webpack_require__(3024);
@@ -17418,7 +17440,7 @@ function default_ok() {}
 
 function unreachable() {}
 
-;// CONCATENATED MODULE: ../../node_modules/unified/node_modules/is-plain-obj/index.js
+;// CONCATENATED MODULE: ../../node_modules/is-plain-obj/index.js
 function isPlainObject(value) {
 	if (typeof value !== 'object' || value === null) {
 		return false;
@@ -31430,371 +31452,317 @@ var jsonc = __webpack_require__(5975);
 
 
 
-
 const defaultFindOptions = {
-  startingFrom: ".",
-  rootPattern: /^node_modules$/,
-  reverse: false,
-  test: (filePath) => {
-    try {
-      if ((0,external_node_fs_.statSync)(filePath).isFile()) {
-        return true;
-      }
-    } catch {
-    }
-  }
+	startingFrom: ".",
+	rootPattern: /^node_modules$/,
+	reverse: false,
+	test: (filePath) => {
+		try {
+			if ((0,external_node_fs_.statSync)(filePath).isFile()) return true;
+		} catch {}
+	}
 };
 async function findFile(filename, _options = {}) {
-  const filenames = Array.isArray(filename) ? filename : [filename];
-  const options = { ...defaultFindOptions, ..._options };
-  const basePath = pathe_M_eThtNZ_resolve(options.startingFrom);
-  const leadingSlash = basePath[0] === "/";
-  const segments = basePath.split("/").filter(Boolean);
-  if (filenames.includes(segments.at(-1)) && await options.test(basePath)) {
-    return basePath;
-  }
-  if (leadingSlash) {
-    segments[0] = "/" + segments[0];
-  }
-  let root = segments.findIndex((r) => r.match(options.rootPattern));
-  if (root === -1) {
-    root = 0;
-  }
-  if (options.reverse) {
-    for (let index = root + 1; index <= segments.length; index++) {
-      for (const filename2 of filenames) {
-        const filePath = pathe_M_eThtNZ_join(...segments.slice(0, index), filename2);
-        if (await options.test(filePath)) {
-          return filePath;
-        }
-      }
-    }
-  } else {
-    for (let index = segments.length; index > root; index--) {
-      for (const filename2 of filenames) {
-        const filePath = pathe_M_eThtNZ_join(...segments.slice(0, index), filename2);
-        if (await options.test(filePath)) {
-          return filePath;
-        }
-      }
-    }
-  }
-  throw new Error(
-    `Cannot find matching ${filename} in ${options.startingFrom} or parent directories`
-  );
+	const filenames = Array.isArray(filename) ? filename : [filename];
+	const options = {
+		...defaultFindOptions,
+		..._options
+	};
+	const basePath = pathe_M_eThtNZ_resolve(options.startingFrom);
+	const leadingSlash = basePath[0] === "/";
+	const segments = basePath.split("/").filter(Boolean);
+	if (filenames.includes(segments.at(-1)) && await options.test(basePath)) return basePath;
+	if (leadingSlash) segments[0] = "/" + segments[0];
+	let root = segments.findIndex((r) => r.match(options.rootPattern));
+	if (root === -1) root = 0;
+	if (options.reverse) for (let index = root + 1; index <= segments.length; index++) for (const filename of filenames) {
+		const filePath = pathe_M_eThtNZ_join(...segments.slice(0, index), filename);
+		if (await options.test(filePath)) return filePath;
+	}
+	else for (let index = segments.length; index > root; index--) for (const filename of filenames) {
+		const filePath = pathe_M_eThtNZ_join(...segments.slice(0, index), filename);
+		if (await options.test(filePath)) return filePath;
+	}
+	throw new Error(`Cannot find matching ${filename} in ${options.startingFrom} or parent directories`);
 }
 function findNearestFile(filename, options = {}) {
-  return findFile(filename, options);
+	return findFile(filename, options);
 }
 function findFarthestFile(filename, options = {}) {
-  return findFile(filename, { ...options, reverse: true });
+	return findFile(filename, {
+		...options,
+		reverse: true
+	});
 }
-
 function _resolvePath(id, opts = {}) {
-  if (id instanceof URL || id.startsWith("file://")) {
-    return normalize((0,external_node_url_.fileURLToPath)(id));
-  }
-  if (isAbsolute(id)) {
-    return normalize(id);
-  }
-  return resolveModulePath(id, {
-    ...opts,
-    from: opts.from || opts.parent || opts.url
-  });
+	if (id instanceof URL || id.startsWith("file://")) return normalize((0,external_node_url_.fileURLToPath)(id));
+	if (isAbsolute(id)) return normalize(id);
+	return resolveModulePath(id, {
+		...opts,
+		from: opts.from || opts.parent || opts.url
+	});
 }
-
 const FileCache$1 = /* @__PURE__ */ (/* unused pure expression or super */ null && (new Map()));
 function defineTSConfig(tsconfig) {
-  return tsconfig;
+	return tsconfig;
 }
 async function readTSConfig(id, options = {}) {
-  const resolvedPath = await resolveTSConfig(id, options);
-  const cache = options.cache && typeof options.cache !== "boolean" ? options.cache : FileCache$1;
-  if (options.cache && cache.has(resolvedPath)) {
-    return cache.get(resolvedPath);
-  }
-  const text = await promises.readFile(resolvedPath, "utf8");
-  const parsed = parseJSONC(text);
-  cache.set(resolvedPath, parsed);
-  return parsed;
+	const resolvedPath = await resolveTSConfig(id, options);
+	const cache = options.cache && typeof options.cache !== "boolean" ? options.cache : FileCache$1;
+	if (options.cache && cache.has(resolvedPath)) return cache.get(resolvedPath);
+	const parsed = parseJSONC(await promises.readFile(resolvedPath, "utf8"));
+	cache.set(resolvedPath, parsed);
+	return parsed;
 }
 async function writeTSConfig(path, tsconfig) {
-  await promises.writeFile(path, stringifyJSONC(tsconfig));
+	await promises.writeFile(path, stringifyJSONC(tsconfig));
 }
 async function resolveTSConfig(id = process.cwd(), options = {}) {
-  return findNearestFile("tsconfig.json", {
-    ...options,
-    startingFrom: _resolvePath(id, options)
-  });
+	return findNearestFile("tsconfig.json", {
+		...options,
+		startingFrom: _resolvePath(id, options)
+	});
 }
-
 const lockFiles = [
-  "yarn.lock",
-  "package-lock.json",
-  "pnpm-lock.yaml",
-  "npm-shrinkwrap.json",
-  "bun.lockb",
-  "bun.lock",
-  "deno.lock"
+	"yarn.lock",
+	"package-lock.json",
+	"pnpm-lock.yaml",
+	"npm-shrinkwrap.json",
+	"bun.lockb",
+	"bun.lock",
+	"deno.lock"
+];
+const packageFiles = [
+	"package.json",
+	"package.json5",
+	"package.yaml"
 ];
-const packageFiles = ["package.json", "package.json5", "package.yaml"];
 const workspaceFiles = [
-  "pnpm-workspace.yaml",
-  "lerna.json",
-  "turbo.json",
-  "rush.json",
-  "deno.json",
-  "deno.jsonc"
+	"pnpm-workspace.yaml",
+	"lerna.json",
+	"turbo.json",
+	"rush.json",
+	"deno.json",
+	"deno.jsonc"
 ];
 const FileCache = /* @__PURE__ */ new Map();
 function definePackageJSON(pkg) {
-  return pkg;
+	return pkg;
 }
 async function findPackage(id = process.cwd(), options = {}) {
-  return findNearestFile(packageFiles, {
-    ...options,
-    startingFrom: _resolvePath(id, options)
-  });
+	return findNearestFile(packageFiles, {
+		...options,
+		startingFrom: _resolvePath(id, options)
+	});
 }
 async function readPackage(id, options = {}) {
-  const resolvedPath = await findPackage(id, options);
-  const cache = options.cache && typeof options.cache !== "boolean" ? options.cache : FileCache;
-  if (options.cache && cache.has(resolvedPath)) {
-    return cache.get(resolvedPath);
-  }
-  const blob = await promises.readFile(resolvedPath, "utf8");
-  let parsed;
-  if (resolvedPath.endsWith(".json5")) {
-    parsed = parseJSON5(blob);
-  } else if (resolvedPath.endsWith(".yaml")) {
-    parsed = parseYAML(blob);
-  } else {
-    try {
-      parsed = parseJSON(blob);
-    } catch {
-      parsed = parseJSONC(blob);
-    }
-  }
-  cache.set(resolvedPath, parsed);
-  return parsed;
+	const resolvedPath = await findPackage(id, options);
+	const cache = options.cache && typeof options.cache !== "boolean" ? options.cache : FileCache;
+	if (options.cache && cache.has(resolvedPath)) return cache.get(resolvedPath);
+	const blob = await promises.readFile(resolvedPath, "utf8");
+	let parsed;
+	if (resolvedPath.endsWith(".json5")) parsed = parseJSON5(blob);
+	else if (resolvedPath.endsWith(".yaml")) parsed = parseYAML(blob);
+	else try {
+		parsed = parseJSON(blob);
+	} catch {
+		parsed = parseJSONC(blob);
+	}
+	cache.set(resolvedPath, parsed);
+	return parsed;
 }
 async function writePackage(path, pkg) {
-  let content;
-  if (path.endsWith(".json5")) {
-    content = stringifyJSON5(pkg);
-  } else if (path.endsWith(".yaml")) {
-    content = stringifyYAML(pkg);
-  } else {
-    content = stringifyJSON(pkg);
-  }
-  await promises.writeFile(path, content);
+	let content;
+	if (path.endsWith(".json5")) content = stringifyJSON5(pkg);
+	else if (path.endsWith(".yaml")) content = stringifyYAML(pkg);
+	else content = stringifyJSON(pkg);
+	await promises.writeFile(path, content);
 }
 async function readPackageJSON(id, options = {}) {
-  const resolvedPath = await resolvePackageJSON(id, options);
-  const cache = options.cache && typeof options.cache !== "boolean" ? options.cache : FileCache;
-  if (options.cache && cache.has(resolvedPath)) {
-    return cache.get(resolvedPath);
-  }
-  const blob = await external_node_fs_.promises.readFile(resolvedPath, "utf8");
-  let parsed;
-  try {
-    parsed = json_n(blob);
-  } catch {
-    parsed = (0,jsonc.parseJSONC)(blob);
-  }
-  cache.set(resolvedPath, parsed);
-  return parsed;
+	const resolvedPath = await resolvePackageJSON(id, options);
+	const cache = options.cache && typeof options.cache !== "boolean" ? options.cache : FileCache;
+	if (options.cache && cache.has(resolvedPath)) return cache.get(resolvedPath);
+	const blob = await external_node_fs_.promises.readFile(resolvedPath, "utf8");
+	let parsed;
+	try {
+		parsed = json_n(blob);
+	} catch {
+		parsed = (0,jsonc.parseJSONC)(blob);
+	}
+	cache.set(resolvedPath, parsed);
+	return parsed;
 }
 async function writePackageJSON(path, pkg) {
-  await promises.writeFile(path, stringifyJSON(pkg));
+	await promises.writeFile(path, stringifyJSON(pkg));
 }
 async function resolvePackageJSON(id = process.cwd(), options = {}) {
-  return findNearestFile("package.json", {
-    ...options,
-    startingFrom: _resolvePath(id, options)
-  });
+	return findNearestFile("package.json", {
+		...options,
+		startingFrom: _resolvePath(id, options)
+	});
 }
 async function resolveLockfile(id = process.cwd(), options = {}) {
-  return findNearestFile(lockFiles, {
-    ...options,
-    startingFrom: _resolvePath(id, options)
-  });
+	return findNearestFile(lockFiles, {
+		...options,
+		startingFrom: _resolvePath(id, options)
+	});
 }
 const workspaceTests = {
-  workspaceFile: (opts) => findFile(workspaceFiles, opts).then((r) => pathe_M_eThtNZ_dirname(r)),
-  gitConfig: (opts) => findFile(".git/config", opts).then((r) => pathe_M_eThtNZ_resolve(r, "../..")),
-  lockFile: (opts) => findFile(lockFiles, opts).then((r) => pathe_M_eThtNZ_dirname(r)),
-  packageJson: (opts) => findFile(packageFiles, opts).then((r) => pathe_M_eThtNZ_dirname(r))
+	workspaceFile: (opts) => findFile(workspaceFiles, opts).then((r) => pathe_M_eThtNZ_dirname(r)),
+	gitConfig: (opts) => findFile(".git/config", opts).then((r) => pathe_M_eThtNZ_resolve(r, "../..")),
+	lockFile: (opts) => findFile(lockFiles, opts).then((r) => pathe_M_eThtNZ_dirname(r)),
+	packageJson: (opts) => findFile(packageFiles, opts).then((r) => pathe_M_eThtNZ_dirname(r))
 };
 async function findWorkspaceDir(id = process.cwd(), options = {}) {
-  const startingFrom = _resolvePath(id, options);
-  const tests = options.tests || ["workspaceFile", "gitConfig", "lockFile", "packageJson"];
-  for (const testName of tests) {
-    const test = workspaceTests[testName];
-    if (options[testName] === false || !test) {
-      continue;
-    }
-    const direction = options[testName] || (testName === "gitConfig" ? "closest" : "furthest");
-    const detected = await test({
-      ...options,
-      startingFrom,
-      reverse: direction === "furthest"
-    }).catch(() => {
-    });
-    if (detected) {
-      return detected;
-    }
-  }
-  throw new Error(`Cannot detect workspace root from ${id}`);
+	const startingFrom = _resolvePath(id, options);
+	const tests = options.tests || [
+		"workspaceFile",
+		"gitConfig",
+		"lockFile",
+		"packageJson"
+	];
+	for (const testName of tests) {
+		const test = workspaceTests[testName];
+		if (options[testName] === false || !test) continue;
+		const direction = options[testName] || (testName === "gitConfig" ? "closest" : "furthest");
+		const detected = await test({
+			...options,
+			startingFrom,
+			reverse: direction === "furthest"
+		}).catch(() => {});
+		if (detected) return detected;
+	}
+	throw new Error(`Cannot detect workspace root from ${id}`);
 }
 async function updatePackage(id, callback, options = {}) {
-  const resolvedPath = await findPackage(id, options);
-  const pkg = await readPackage(id, options);
-  const proxy = new Proxy(pkg, {
-    get(target, prop) {
-      if (typeof prop === "string" && objectKeys.has(prop) && !Object.hasOwn(target, prop)) {
-        target[prop] = {};
-      }
-      return Reflect.get(target, prop);
-    }
-  });
-  const updated = await callback(proxy) || pkg;
-  await writePackage(resolvedPath, updated);
+	const resolvedPath = await findPackage(id, options);
+	const pkg = await readPackage(id, options);
+	await writePackage(resolvedPath, await callback(new Proxy(pkg, { get(target, prop) {
+		if (typeof prop === "string" && objectKeys.has(prop) && !Object.hasOwn(target, prop)) target[prop] = {};
+		return Reflect.get(target, prop);
+	} })) || pkg);
 }
 function sortPackage(pkg) {
-  const sorted = {};
-  const originalKeys = Object.keys(pkg);
-  const knownKeysPresent = defaultFieldOrder.filter(
-    (key) => Object.hasOwn(pkg, key)
-  );
-  for (const key of originalKeys) {
-    const currentIndex = knownKeysPresent.indexOf(key);
-    if (currentIndex === -1) {
-      sorted[key] = pkg[key];
-      continue;
-    }
-    for (let i = 0; i <= currentIndex; i++) {
-      const knownKey = knownKeysPresent[i];
-      if (!Object.hasOwn(sorted, knownKey)) {
-        sorted[knownKey] = pkg[knownKey];
-      }
-    }
-  }
-  for (const key of [...dependencyKeys, "scripts"]) {
-    const value = sorted[key];
-    if (dist_isObject(value)) {
-      sorted[key] = sortObject(value);
-    }
-  }
-  return sorted;
+	const sorted = {};
+	const originalKeys = Object.keys(pkg);
+	const knownKeysPresent = defaultFieldOrder.filter((key) => Object.hasOwn(pkg, key));
+	for (const key of originalKeys) {
+		const currentIndex = knownKeysPresent.indexOf(key);
+		if (currentIndex === -1) {
+			sorted[key] = pkg[key];
+			continue;
+		}
+		for (let i = 0; i <= currentIndex; i++) {
+			const knownKey = knownKeysPresent[i];
+			if (!Object.hasOwn(sorted, knownKey)) sorted[knownKey] = pkg[knownKey];
+		}
+	}
+	for (const key of [...dependencyKeys, "scripts"]) {
+		const value = sorted[key];
+		if (dist_isObject(value)) sorted[key] = sortObject(value);
+	}
+	return sorted;
 }
 function normalizePackage(pkg) {
-  const normalized = sortPackage(pkg);
-  for (const key of dependencyKeys) {
-    if (!Object.hasOwn(normalized, key)) {
-      continue;
-    }
-    const value = normalized[key];
-    if (!dist_isObject(value)) {
-      delete normalized[key];
-    }
-  }
-  return normalized;
+	const normalized = sortPackage(pkg);
+	for (const key of dependencyKeys) {
+		if (!Object.hasOwn(normalized, key)) continue;
+		const value = normalized[key];
+		if (!dist_isObject(value)) delete normalized[key];
+	}
+	return normalized;
 }
 function dist_isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function sortObject(obj) {
-  return Object.fromEntries(
-    Object.entries(obj).sort(([a], [b]) => a.localeCompare(b))
-  );
+	return Object.fromEntries(Object.entries(obj).sort(([a], [b]) => a.localeCompare(b)));
 }
 const dependencyKeys = (/* unused pure expression or super */ null && ([
-  "dependencies",
-  "devDependencies",
-  "optionalDependencies",
-  "peerDependencies"
+	"dependencies",
+	"devDependencies",
+	"optionalDependencies",
+	"peerDependencies"
 ]));
-const objectKeys = /* @__PURE__ */ (/* unused pure expression or super */ null && (new Set([
-  "typesVersions",
-  "scripts",
-  "resolutions",
-  "overrides",
-  "dependencies",
-  "devDependencies",
-  "dependenciesMeta",
-  "peerDependencies",
-  "peerDependenciesMeta",
-  "optionalDependencies",
-  "engines",
-  "publishConfig"
-])));
+const objectKeys = new Set([
+	"typesVersions",
+	"scripts",
+	"resolutions",
+	"overrides",
+	"dependencies",
+	"devDependencies",
+	"dependenciesMeta",
+	"peerDependencies",
+	"peerDependenciesMeta",
+	"optionalDependencies",
+	"engines",
+	"publishConfig"
+]);
 const defaultFieldOrder = (/* unused pure expression or super */ null && ([
-  "$schema",
-  "name",
-  "version",
-  "private",
-  "description",
-  "keywords",
-  "homepage",
-  "bugs",
-  "repository",
-  "funding",
-  "license",
-  "author",
-  "sideEffects",
-  "type",
-  "imports",
-  "exports",
-  "main",
-  "module",
-  "browser",
-  "types",
-  "typesVersions",
-  "typings",
-  "bin",
-  "man",
-  "files",
-  "workspaces",
-  "scripts",
-  "resolutions",
-  "overrides",
-  "dependencies",
-  "devDependencies",
-  "dependenciesMeta",
-  "peerDependencies",
-  "peerDependenciesMeta",
-  "optionalDependencies",
-  "bundledDependencies",
-  "bundleDependencies",
-  "packageManager",
-  "engines",
-  "publishConfig"
+	"$schema",
+	"name",
+	"version",
+	"private",
+	"description",
+	"keywords",
+	"homepage",
+	"bugs",
+	"repository",
+	"funding",
+	"license",
+	"author",
+	"sideEffects",
+	"type",
+	"imports",
+	"exports",
+	"main",
+	"module",
+	"browser",
+	"types",
+	"typesVersions",
+	"typings",
+	"bin",
+	"man",
+	"files",
+	"workspaces",
+	"scripts",
+	"resolutions",
+	"overrides",
+	"dependencies",
+	"devDependencies",
+	"dependenciesMeta",
+	"peerDependencies",
+	"peerDependenciesMeta",
+	"optionalDependencies",
+	"bundledDependencies",
+	"bundleDependencies",
+	"packageManager",
+	"engines",
+	"publishConfig"
 ]));
-
 function defineGitConfig(config) {
-  return config;
+	return config;
 }
 async function resolveGitConfig(dir, opts) {
-  return findNearestFile(".git/config", { ...opts, startingFrom: dir });
+	return findNearestFile(".git/config", {
+		...opts,
+		startingFrom: dir
+	});
 }
 async function readGitConfig(dir, opts) {
-  const path = await resolveGitConfig(dir, opts);
-  const ini = await readFile(path, "utf8");
-  return parseGitConfig(ini);
+	return parseGitConfig(await readFile(await resolveGitConfig(dir, opts), "utf8"));
 }
 async function writeGitConfig(path, config) {
-  await writeFile(path, stringifyGitConfig(config));
+	await writeFile(path, stringifyGitConfig(config));
 }
 function parseGitConfig(ini) {
-  return parseINI(ini.replaceAll(/^\[(\w+) "(.+)"\]$/gm, "[$1.$2]"));
+	return parseINI(ini.replaceAll(/^\[(\w+) "(.+)"\]$/gm, "[$1.$2]"));
 }
 function stringifyGitConfig(config) {
-  return stringifyINI(config).replaceAll(/^\[(\w+)\.(\w+)\]$/gm, '[$1 "$2"]');
+	return stringifyINI(config).replaceAll(/^\[(\w+)\.(\w+)\]$/gm, "[$1 \"$2\"]");
 }
 
 
-
 ;// CONCATENATED MODULE: ../../node_modules/c12/dist/index.mjs
 
 
@@ -32165,7 +32133,7 @@ async function watchConfig(options) {
 		options.rcFile && resolve(l.cwd, typeof options.rcFile === "string" ? options.rcFile : `.${configName}rc`),
 		options.packageJson && resolve(l.cwd, "package.json")
 	]).filter(Boolean))];
-	const watch = await __webpack_require__.e(/* import() */ 27).then(__webpack_require__.bind(__webpack_require__, 9774)).then((r) => r.watch || r.default || r);
+	const watch = await __webpack_require__.e(/* import() */ 475).then(__webpack_require__.bind(__webpack_require__, 4710)).then((r) => r.watch || r.default || r);
 	const { diff } = await __webpack_require__.e(/* import() */ 164).then(__webpack_require__.bind(__webpack_require__, 263));
 	const _fswatcher = watch(watchingFiles, {
 		ignoreInitial: true,
@@ -42371,7 +42339,7 @@ if (installedChunkData !== 0) { // 0 means "already installed".'
 // module factories are used so entry inlining is disabled
 // startup
 // Load entry module and return exports
-var __webpack_exports__ = __webpack_require__(9491);
+var __webpack_exports__ = __webpack_require__(5144);
 var __webpack_exports__DEFAULT_LINT_RULES = __webpack_exports__.Kd;
 var __webpack_exports__LintValidationError = __webpack_exports__.F5;
 var __webpack_exports__createFormatter = __webpack_exports__.xi;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lousy-agents/lint",
-    "version": "5.13.6",
+    "version": "5.14.0",
     "description": "Programmatic lint API for validating AI coding assistant configurations — skills, agents, hooks, and instructions",
     "type": "module",
     "repository": {