@zaly/agent 0.0.4 → 0.0.6

package/dist/{registry-CFmR5G3J.mjs → registry-Bao6L4Ue.mjs}

@@ -1,4 +1,4 @@
-import { a as __toESM, n as parseBash, r as __commonJSMin, t as TOOLS } from "./tools-DW1dbcCz.mjs";
+import { a as __toESM, n as parseBash, r as __commonJSMin, t as TOOLS } from "./tools-CZvBFp-v.mjs";
 import { normPath, prettyPath } from "@zaly/shared";
 import { createRegistry } from "@zaly/shared/registry";
 import { dirname, isAbsolute, relative } from "pathe";
@@ -24,11 +24,18 @@ import { dirname, isAbsolute, relative } from "pathe";
 */
 const bashHandler = { validate(input, ctx) {
 	const parsed = parseBash(input);
-	if (!parsed.ok) return {
-		ask: `Allow this bash command? (${parsed.reason})`,
-		reason: parsed.reason,
-		verdict: "ask"
-	};
+	if (!parsed.ok) {
+		if ([
+			"bash",
+			"read",
+			"write"
+		].every((scope) => ctx.allowsAll?.(scope))) return { verdict: "allow" };
+		return {
+			ask: `Allow this bash command? (${parsed.reason})`,
+			reason: parsed.reason,
+			verdict: "ask"
+		};
+	}
 	let verdict = "allow";
 	let reason;
 	const suggestions = [];
@@ -55,7 +62,7 @@ const bashHandler = { validate(input, ctx) {
 		const reads = [...spec?.reads?.(seg.args) ?? [], ...seg.reads];
 		const writes = [...spec?.writes?.(seg.args) ?? [], ...seg.writes.map((w) => w.path)];
 		for (const path of reads) {
-			if (seg.dyn?.has(path)) {
+			if (seg.dyn?.has(path) && !ctx.allowsAll?.("read")) {
 				segVerdict = combine(segVerdict, "ask");
 				segReason ??= `${seg.cmd}: read ${path}: dynamic path`;
 				suggestions.push({
@@ -74,7 +81,7 @@ const bashHandler = { validate(input, ctx) {
 			if (segVerdict === "deny") break;
 		}
 		if (segVerdict !== "deny") for (const path of writes) {
-			if (seg.dyn?.has(path)) {
+			if (seg.dyn?.has(path) && !ctx.allowsAll?.("write")) {
 				segVerdict = combine(segVerdict, "ask");
 				segReason ??= `${seg.cmd}: write ${path}: dynamic path`;
 				suggestions.push({
@@ -156,13 +163,15 @@ var import_ignore = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exp
 	const EMPTY = "";
 	const SPACE = " ";
 	const ESCAPE = "\\";
-	const REGEX_TEST_BLANK_LINE = /^\s+$/;
+	const REGEX_LITERAL_SPECIAL = /[.*+?()[\]{}^$|\\/]/;
+	const BOM = "";
 	const REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
 	const REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
 	const REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
 	const REGEX_SPLITALL_CRLF = /\r?\n/g;
-	const REGEX_TEST_INVALID_PATH = /^\.{0,2}\/|^\.{1,2}$/;
-	const REGEX_TEST_TRAILING_SLASH = /\/$/;
+	const DOUBLE_SLASH = "//";
+	const SLASH_CODE = 47;
+	const DOT_CODE = 46;
 	const SLASH = "/";
 	let TMP_KEY_IGNORE = "node-ignore";
 	/* istanbul ignore else */
@@ -172,51 +181,316 @@ var import_ignore = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exp
 		Object.defineProperty(object, key, { value });
 		return value;
 	};
-	const REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
 	const RETURN_FALSE = () => false;
-	const sanitizeRange = (range) => range.replace(REGEX_REGEXP_RANGE, (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY);
 	const cleanRangeBackSlash = (slashes) => {
 		const { length } = slashes;
 		return slashes.slice(0, length - length % 2);
 	};
+	const POSIX_CLASSES = {
+		alnum: "0-9A-Za-z",
+		alpha: "A-Za-z",
+		blank: " \\t",
+		cntrl: "\\x00-\\x1f\\x7f",
+		digit: "0-9",
+		graph: "!-.0-~",
+		lower: "a-z",
+		print: " -.0-~",
+		punct: "!-.:-@\\[-`{-~",
+		space: " \\t\\n\\r",
+		upper: "A-Z",
+		xdigit: "0-9A-Fa-f"
+	};
+	const CLASS_MEMBERS_TO_ESCAPE = "\\]^-[";
+	const escapeMember = (char) => CLASS_MEMBERS_TO_ESCAPE.indexOf(char) < 0 ? char : ESCAPE + char;
+	const NON_SLASH = "(?!\\/)";
+	const classSource = (negated, body) => {
+		if (negated) return `[^\\/${body}]`;
+		const source = `[${body}]`;
+		return new RegExp(source).test("/") ? NON_SLASH + source : source;
+	};
+	const scanBracket = (pattern, start) => {
+		const { length } = pattern;
+		let index = start + 1;
+		let negated = EMPTY;
+		const lead = pattern[index];
+		if (lead === "!" || lead === "^") {
+			negated = "^";
+			index++;
+		}
+		let body = EMPTY;
+		let prev = EMPTY;
+		for (;;) {
+			const char = pattern[index];
+			if (char === UNDEFINED) return null;
+			if (char === ESCAPE) {
+				const escaped = pattern[index + 1];
+				if (escaped === UNDEFINED) return null;
+				body += escapeMember(escaped);
+				prev = escaped;
+				index++;
+			} else if (char === "-" && prev && index + 1 < length && pattern[index + 1] !== "]") {
+				index++;
+				let to = pattern[index];
+				if (to === ESCAPE) to = pattern[index += 1];
+				if (prev <= to) body += `-${escapeMember(to)}`;
+				prev = EMPTY;
+			} else if (char === "[" && pattern[index + 1] === ":") {
+				const nameStart = index + 2;
+				let end = nameStart;
+				while (end < length && pattern[end] !== "]") end++;
+				if (end === length) return null;
+				if (end > nameStart && pattern[end - 1] === ":") {
+					const expanded = POSIX_CLASSES[pattern.slice(nameStart, end - 1)];
+					if (expanded === UNDEFINED) return null;
+					body += expanded;
+					prev = EMPTY;
+					index = end;
+				} else {
+					body += escapeMember("[");
+					prev = "[";
+					index = nameStart - 2;
+				}
+			} else {
+				body += escapeMember(char);
+				prev = char;
+			}
+			index++;
+			if (pattern[index] === "]") return {
+				end: index,
+				source: classSource(negated, body)
+			};
+		}
+	};
+	const NEVER_MATCH = "[]";
+	const PLACEHOLDER = "\0";
+	const REGEX_RESTORE_PLACEHOLDER = new RegExp(`${PLACEHOLDER}(\\d+)${PLACEHOLDER}`, "g");
+	const TRAILING_WILDCARD = "";
+	const TRAILING_DOUBLESTAR = "";
+	const extractBrackets = (pattern) => {
+		const sources = [];
+		const hold = (source) => `${PLACEHOLDER}${sources.push(source) - 1}${PLACEHOLDER}`;
+		const { length } = pattern;
+		let out = EMPTY;
+		let index = 0;
+		while (index < length) {
+			const char = pattern[index];
+			if (char === ESCAPE) {
+				const escaped = pattern[index + 1];
+				if (escaped === UNDEFINED || escaped === SLASH && index + 2 === length) out += hold(NEVER_MATCH);
+				else if (escaped === "*" || escaped === "[" || escaped === SPACE || escaped === ESCAPE) out += pattern.slice(index, index + 2);
+				else out += hold(REGEX_LITERAL_SPECIAL.test(escaped) ? ESCAPE + escaped : escaped);
+				index += 2;
+			} else if (char === PLACEHOLDER) {
+				out += hold(`[${PLACEHOLDER}]`);
+				index++;
+			} else if (char === "[") {
+				const scanned = scanBracket(pattern, index);
+				if (scanned === null) {
+					out += hold(NEVER_MATCH);
+					index = length;
+				} else {
+					out += hold(scanned.source);
+					index = scanned.end + 1;
+				}
+			} else {
+				out += char;
+				index++;
+			}
+		}
+		return {
+			source: out,
+			sources
+		};
+	};
+	const DIRECT = null;
+	const REGEX_INNER_SLASH = /\/(?!$)/;
 	const REPLACERS = [
-		[/^\uFEFF/, () => EMPTY],
-		[/((?:\\\\)*?)(\\?\s+)$/, (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY)],
-		[/(\\+?)\s/g, (_, m1) => {
-			const { length } = m1;
-			return m1.slice(0, length - length % 2) + SPACE;
-		}],
+		[
+			/(\\+)( ?)/g,
+			(_, run, space) => space ? run.slice(0, run.length - run.length % 2) + SPACE : run,
+			"\\ "
+		],
 		[/[\\$.|*+(){^]/g, (match) => `\\${match}`],
-		[/(?!\\)\?/g, () => "[^/]"],
-		[/^\//, () => "^"],
-		[/\//g, () => "\\/"],
-		[/^\^*\\\*\\\*\\\//, () => "^(?:.*\\/)?"],
-		[/^(?=[^^])/, function startingReplacer() {
-			return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
+		[
+			/(?!\\)\?/g,
+			() => "[^/]",
+			"?"
+		],
+		[
+			/^\//,
+			() => "^",
+			SLASH
+		],
+		[
+			/\//g,
+			() => "\\/",
+			SLASH
+		],
+		[
+			/^\^*(?:\\\*\\\*\\\/)+/,
+			() => "^(?:.*\\/)?",
+			"*"
+		],
+		[DIRECT, (source, pattern) => {
+			if (!source || source[0] === "^") return source;
+			return (!REGEX_INNER_SLASH.test(pattern) ? "(?:^|\\/)" : "^") + source;
 		}],
-		[/\\\/\\\*\\\*(?=\\\/|$)/g, (_, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"],
-		[/(^|[^\\]+)(\\\*)+(?=.+)/g, (_, p1, p2) => {
-			return p1 + p2.replace(/\\\*/g, "[^\\/]*");
-		}],
-		[/\\\\\\(?=[$.|*+(){^])/g, () => ESCAPE],
-		[/\\\\/g, () => ESCAPE],
-		[/(\\)?\[([^\]/]*?)(\\*)($|\])/g, (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"],
-		[/(?:[^*])$/, (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`]
+		[
+			/\\\/\\\*\\\*(?=\\\/|$)/g,
+			(_, index, str) => index + 6 < str.length ? str.slice(index + 6) === "\\/" ? "(?:\\/[^\\/]+)+" : "(?:\\/[^\\/]+)*" : `\\/${TRAILING_DOUBLESTAR}`,
+			"*"
+		],
+		[
+			/(^|[^\\]+)(\\\*)+(?=.+)/g,
+			(_, p1, p2) => {
+				return p1 + p2.replace(/\\\*/g, "[^\\/]*");
+			},
+			"*"
+		],
+		[
+			/(^|[^\\])((?:\\\\)*)\\\*$/,
+			(match, p1, p2) => p2.length / 2 % 2 === 0 ? p1 + p2 + TRAILING_WILDCARD : match,
+			"*"
+		],
+		[
+			/\\\\\\(?=[$.|*+(){^])/g,
+			() => ESCAPE,
+			"\\\\"
+		],
+		[
+			/\\\\/g,
+			() => ESCAPE,
+			"\\\\"
+		],
+		[
+			/\\\[([^\]/]*?)(\\*)($|\])/g,
+			(match, range, endEscape, close) => `\\[${range}${cleanRangeBackSlash(endEscape)}${close}`,
+			"["
+		],
+		[DIRECT, (source) => {
+			const last = source[source.length - 1];
+			if (!last || last === TRAILING_WILDCARD || last === TRAILING_DOUBLESTAR) return source;
+			return last === SLASH ? `${source}$` : `${source}(?=$|\\/$)`;
+		}]
 	];
-	const REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\\\*$/;
+	const REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\uE000$/;
 	const MODE_IGNORE = "regex";
 	const MODE_CHECK_IGNORE = "checkRegex";
-	const TRAILING_WILD_CARD_REPLACERS = {
-		[MODE_IGNORE](_, p1) {
-			return `${p1 ? `${p1}[^/]+` : "[^/]*"}(?=$|\\/$)`;
-		},
-		[MODE_CHECK_IGNORE](_, p1) {
-			return `${p1 ? `${p1}[^/]*` : "[^/]*"}(?=$|\\/$)`;
+	const replaceTrailingWildcard = (_, p1) => {
+		return `${p1 ? `${p1}[^/]+` : "[^/]*"}(?=$|\\/$)`;
+	};
+	const REGEX_REPLACE_TRAILING_DOUBLESTAR = /\uE001$/;
+	const replaceTrailingDoublestar = () => ".+(?=$|\\/$)";
+	const WILDCARD = "[^\\/]*";
+	const separatorAfter = (run, at) => {
+		let separator = EMPTY;
+		for (let index = at + 1; index < run.length && !run[index].wildcard; index++) separator += run[index].single;
+		return separator;
+	};
+	const pinWildcards = (source) => {
+		if (source.indexOf(WILDCARD) < 0) return source;
+		const tokens = [];
+		const { length } = source;
+		let index = 0;
+		while (index < length) {
+			const char = source[index];
+			if (source.startsWith(WILDCARD, index)) {
+				tokens.push({ wildcard: true });
+				index += 6;
+			} else if (char === "[") {
+				let end = index + 1;
+				if (source[end] === "^") end++;
+				if (source[end] === "]") end++;
+				while (end < length && source[end] !== "]") end += source[end] === ESCAPE ? 2 : 1;
+				end++;
+				tokens.push({ single: source.slice(index, end) });
+				index = end;
+			} else if (char === ESCAPE) {
+				tokens.push({ single: source.slice(index, index + 2) });
+				index += 2;
+			} else if (char === "(") {
+				let depth = 0;
+				let end = index;
+				do {
+					if (source[end] === ESCAPE) end++;
+					else if (source[end] === "(") depth++;
+					else if (source[end] === ")") depth--;
+					end++;
+				} while (end < length && depth > 0);
+				if ("*+?".indexOf(source[end]) >= 0) end++;
+				tokens.push({ boundary: source.slice(index, end) });
+				index = end;
+			} else if (char === "^" || char === "$") {
+				tokens.push({ boundary: char });
+				index++;
+			} else {
+				tokens.push({ single: char });
+				index++;
+			}
 		}
+		let out = EMPTY;
+		let run = [];
+		const flush = () => {
+			let lastWildcard;
+			run.forEach((token, at) => {
+				if (token.wildcard) lastWildcard = at;
+			});
+			run.forEach((token, at) => {
+				if (!token.wildcard) {
+					out += token.single;
+					return;
+				}
+				out += at === lastWildcard ? WILDCARD : `(?:(?!${separatorAfter(run, at)})[^\\/])*`;
+			});
+			run = [];
+		};
+		tokens.forEach((token) => {
+			if (token.boundary === void 0) {
+				run.push(token);
+				return;
+			}
+			flush();
+			out += token.boundary;
+		});
+		flush();
+		return out;
+	};
+	const makeRegexPrefix = (pattern) => {
+		const { source, sources } = extractBrackets(pattern);
+		const replaced = REPLACERS.reduce((prev, [matcher, replacer, required]) => {
+			if (matcher === DIRECT) return replacer(prev, pattern);
+			if (required !== UNDEFINED && prev.indexOf(required) < 0) return prev;
+			return matcher.test(prev) ? prev.replace(matcher, replacer.bind(pattern)) : prev;
+		}, source);
+		return sources.length ? replaced.replace(REGEX_RESTORE_PLACEHOLDER, (match, index) => sources[index]) : replaced;
+	};
+	const checkSourceOf = (body, prefix) => {
+		if (body[body.length - 1] === SLASH) prefix = makeRegexPrefix(body.slice(0, -1));
+		const head = prefix.slice(0, -1);
+		const last = prefix[prefix.length - 1];
+		return last === TRAILING_WILDCARD ? `${head}$` : last === TRAILING_DOUBLESTAR ? `${head}.*$` : NEVER_MATCH;
+	};
+	const matchesBasename = (body) => {
+		const index = body.indexOf(SLASH);
+		return index < 0 || index === body.length - 1;
+	};
+	const basenameOf = (path) => {
+		const end = path.length - 1;
+		const index = path.lastIndexOf(SLASH, path[end] === SLASH ? end - 1 : end);
+		return index < 0 ? path : path.slice(index + 1);
+	};
+	const parentOf = (path) => {
+		if (path.charCodeAt(0) === SLASH_CODE || path.indexOf(DOUBLE_SLASH) >= 0) {
+			const slices = path.split(SLASH).filter(Boolean);
+			slices.pop();
+			return slices.length ? slices.join(SLASH) + SLASH : EMPTY;
+		}
+		const end = path.length - 1;
+		const cut = path.lastIndexOf(SLASH, path.charCodeAt(end) === SLASH_CODE ? end - 1 : end);
+		return cut < 0 ? EMPTY : path.slice(0, cut + 1);
 	};
-	const makeRegexPrefix = (pattern) => REPLACERS.reduce((prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)), pattern);
 	const isString = (subject) => typeof subject === "string";
-	const checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
+	const checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern);
 	const splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean);
 	var IgnoreRule = class {
 		constructor(pattern, mark, body, ignoreCase, negative, prefix) {
@@ -227,6 +501,9 @@ var import_ignore = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exp
 			define(this, "ignoreCase", ignoreCase);
 			define(this, "regexPrefix", prefix);
 		}
+		get _basenameOnly() {
+			return define(this, "_basenameOnly", matchesBasename(this.body));
+		}
 		get regex() {
 			const key = "_regex";
 			if (this[key]) return this[key];
@@ -238,18 +515,33 @@ var import_ignore = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exp
 			return this._make(MODE_CHECK_IGNORE, key);
 		}
 		_make(mode, key) {
-			const str = this.regexPrefix.replace(REGEX_REPLACE_TRAILING_WILDCARD, TRAILING_WILD_CARD_REPLACERS[mode]);
+			const str = pinWildcards(mode === MODE_IGNORE ? this.regexPrefix.replace(REGEX_REPLACE_TRAILING_WILDCARD, replaceTrailingWildcard).replace(REGEX_REPLACE_TRAILING_DOUBLESTAR, replaceTrailingDoublestar) : checkSourceOf(this.body, this.regexPrefix));
 			const regex = this.ignoreCase ? new RegExp(str, "i") : new RegExp(str);
 			return define(this, key, regex);
 		}
 	};
+	const isLineEnd = (char) => char === "\r" || char === "\n";
+	const trimEnd = (body) => {
+		let end = body.length;
+		while (end && isLineEnd(body[end - 1])) end--;
+		const lineEnd = end;
+		while (end && body[end - 1] === SPACE) end--;
+		if (end === lineEnd) return body.slice(0, end);
+		let backslashes = 0;
+		while (backslashes < end && body[end - backslashes - 1] === ESCAPE) backslashes++;
+		return backslashes % 2 ? body.slice(0, end - 1) + SPACE : body.slice(0, end);
+	};
 	const createRule = ({ pattern, mark }, ignoreCase) => {
+		let body = pattern[0] === BOM ? pattern.slice(1) : pattern;
+		if (body[0] === "#") return;
 		let negative = false;
-		let body = pattern;
-		if (body.indexOf("!") === 0) {
+		if (body[0] === "!") {
 			negative = true;
-			body = body.substr(1);
+			body = body.slice(1);
 		}
+		const last = body[body.length - 1];
+		if (last === SPACE || last === "\r" || last === "\n") body = trimEnd(body);
+		if (!body) return;
 		body = body.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
 		const regexPrefix = makeRegexPrefix(body);
 		return new IgnoreRule(pattern, mark, body, ignoreCase, negative, regexPrefix);
@@ -258,37 +550,67 @@ var import_ignore = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exp
 		constructor(ignoreCase) {
 			this._ignoreCase = ignoreCase;
 			this._rules = [];
+			this._basenameCount = 0;
 		}
 		_add(pattern) {
 			if (pattern && pattern[KEY_IGNORE]) {
 				this._rules = this._rules.concat(pattern._rules._rules);
+				this._basenameCount += pattern._rules._basenameCount;
 				this._added = true;
 				return;
 			}
 			if (isString(pattern)) pattern = { pattern };
-			if (checkPattern(pattern.pattern)) {
-				const rule = createRule(pattern, this._ignoreCase);
+			const rule = checkPattern(pattern.pattern) && createRule(pattern, this._ignoreCase);
+			if (rule) {
 				this._added = true;
 				this._rules.push(rule);
+				if (matchesBasename(rule.body)) this._basenameCount++;
 			}
 		}
 		add(pattern) {
 			this._added = false;
 			makeArray(isString(pattern) ? splitPattern(pattern) : pattern).forEach(this._add, this);
+			if (this._added) this._literalRules = UNDEFINED;
 			return this._added;
 		}
+		testLiteral(path) {
+			const rules = this._literalRules || (this._literalRules = this._rules.filter(({ body }) => body[body.length - (body[body.length - 1] === SLASH ? 2 : 1)] === "*"));
+			let ignored = false;
+			let unignored = false;
+			let matchedRule;
+			for (let index = rules.length - 1; index >= 0; index--) {
+				const rule = rules[index];
+				if (rule.checkRegex.test(path)) {
+					ignored = !rule.negative;
+					unignored = rule.negative;
+					matchedRule = rule.negative ? UNDEFINED : rule;
+					break;
+				}
+			}
+			const ret = {
+				ignored,
+				unignored
+			};
+			if (matchedRule) ret.rule = matchedRule;
+			return ret;
+		}
 		test(path, checkUnignored, mode) {
 			let ignored = false;
 			let unignored = false;
 			let matchedRule;
-			this._rules.forEach((rule) => {
+			const rules = this._rules;
+			const { length } = rules;
+			const shortcut = this._basenameCount * 2 >= length;
+			const basename = shortcut ? basenameOf(path) : path;
+			for (let index = 0; index < length; index++) {
+				const rule = rules[index];
 				const { negative } = rule;
-				if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) return;
-				if (!rule[mode].test(path)) return;
-				ignored = !negative;
-				unignored = negative;
-				matchedRule = negative ? UNDEFINED : rule;
-			});
+				if (!(unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) && rule[mode].test(shortcut && rule._basenameOnly ? basename : path)) {
+					ignored = !negative;
+					unignored = negative;
+					matchedRule = negative ? UNDEFINED : rule;
+				}
+			}
 			const ret = {
 				ignored,
 				unignored
@@ -306,7 +628,16 @@ var import_ignore = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exp
 		if (checkPath.isNotRelative(path)) return doThrow(`path should be a \`path.relative()\`d string, but got "${originalPath}"`, RangeError);
 		return true;
 	};
-	const isNotRelative = (path) => REGEX_TEST_INVALID_PATH.test(path);
+	const isNotRelative = (path) => {
+		const first = path.charCodeAt(0);
+		if (first === SLASH_CODE) return true;
+		if (first !== DOT_CODE) return false;
+		if (path.length === 1) return true;
+		const second = path.charCodeAt(1);
+		if (second === SLASH_CODE) return true;
+		if (second !== DOT_CODE) return false;
+		return path.length === 2 || path.charCodeAt(2) === SLASH_CODE;
+	};
 	checkPath.isNotRelative = isNotRelative;
 	/* istanbul ignore next */
 	checkPath.convert = (p) => p;
@@ -328,28 +659,23 @@ var import_ignore = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exp
 		addPattern(pattern) {
 			return this.add(pattern);
 		}
-		_test(originalPath, cache, checkUnignored, slices) {
+		_test(originalPath, cache, checkUnignored) {
 			const path = originalPath && checkPath.convert(originalPath);
 			checkPath(path, originalPath, this._strictPathCheck ? throwError : RETURN_FALSE);
-			return this._t(path, cache, checkUnignored, slices);
+			return this._t(path, cache, checkUnignored);
 		}
 		checkIgnore(path) {
-			if (!REGEX_TEST_TRAILING_SLASH.test(path)) return this.test(path);
-			const slices = path.split(SLASH).filter(Boolean);
-			slices.pop();
-			if (slices.length) {
-				const parent = this._t(slices.join(SLASH) + SLASH, this._testCache, true, slices);
-				if (parent.ignored) return parent;
-			}
-			return this._rules.test(path, false, MODE_CHECK_IGNORE);
+			if (path.charCodeAt(path.length - 1) !== SLASH_CODE) return this.test(path);
+			const dir = this._t(path, this._testCache, true);
+			if (dir.ignored) return dir;
+			const literal = this._rules.testLiteral(path);
+			return literal.ignored || literal.unignored ? literal : dir;
 		}
-		_t(path, cache, checkUnignored, slices) {
+		_t(path, cache, checkUnignored) {
 			if (path in cache) return cache[path];
-			if (!slices) slices = path.split(SLASH).filter(Boolean);
-			slices.pop();
-			if (!slices.length) return cache[path] = this._rules.test(path, checkUnignored, MODE_IGNORE);
-			const parent = this._t(slices.join(SLASH) + SLASH, cache, checkUnignored, slices);
-			return cache[path] = parent.ignored ? parent : this._rules.test(path, checkUnignored, MODE_IGNORE);
+			const parentPath = parentOf(path);
+			const parent = parentPath ? this._t(parentPath, cache, checkUnignored) : UNDEFINED;
+			return cache[path] = parent && parent.ignored ? parent : this._rules.test(path, checkUnignored, MODE_IGNORE);
 		}
 		ignores(path) {
 			return this._test(path, this._ignoreCache, false).ignored;
@@ -561,4 +887,4 @@ const handlerRegistry = createRegistry("scope").from({
 //#endregion
 export { handlerRegistry as t };
 
-//# sourceMappingURL=registry-CFmR5G3J.mjs.map
+//# sourceMappingURL=registry-Bao6L4Ue.mjs.map