@soda-gql/builder 0.11.26 → 0.12.0

package/dist/{service-B381lWB2.mjs → service-CqUHXFUE.mjs}

@@ -1,3 +1,4 @@
+import "node:module";
 import { existsSync, readFileSync, realpathSync, statSync, unlinkSync } from "node:fs";
 import { readFile, stat } from "node:fs/promises";
 import { err, ok } from "neverthrow";
@@ -5,7 +6,7 @@ import { z } from "zod";
 import { createHash } from "node:crypto";
 import { extname, join, normalize, resolve } from "node:path";
 import { Script, createContext } from "node:vm";
-import { CanonicalIdSchema, Effect, Effects, ParallelEffect, cachedFn, createAliasResolver, createAsyncScheduler, createCanonicalId, createCanonicalTracker, createSyncScheduler, getPortableFS, getPortableHasher, isExternalSpecifier, isRelativeSpecifier, normalizePath, parseCanonicalId, resolveRelativeImportWithExistenceCheck, resolveRelativeImportWithReferences, validateCanonicalId } from "@soda-gql/common";
+import { CanonicalIdSchema, Effect, Effects, ParallelEffect, cachedFn, createAliasResolver, createAsyncScheduler, createCanonicalId, createCanonicalTracker, createSwcSpanConverter, createSyncScheduler, getPortableFS, getPortableHasher, isExternalSpecifier, isRelativeSpecifier, normalizePath, parseCanonicalId, resolveRelativeImportWithExistenceCheck, resolveRelativeImportWithReferences, validateCanonicalId } from "@soda-gql/common";
 import { parseSync, transformSync } from "@swc/core";
 import * as sandboxCore from "@soda-gql/core";
 import { Fragment, GqlDefine, GqlElement, Operation } from "@soda-gql/core";
@@ -15,6 +16,34 @@ import * as sandboxRuntime from "@soda-gql/runtime";
 import ts from "typescript";
 import fg from "fast-glob";
 
+//#region rolldown:runtime
+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 __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
 //#region packages/builder/src/schemas/artifact.ts
 const BuilderArtifactElementMetadataSchema = z.object({
 	sourcePath: z.string(),
@@ -1681,9 +1710,9 @@ const createPathTracker = () => {
 * Create an export bindings map from module exports.
 * Maps local variable names to their exported names.
 */
-const createExportBindingsMap = (exports) => {
+const createExportBindingsMap = (exports$1) => {
 	const exportBindings = new Map();
-	exports.forEach((exp) => {
+	exports$1.forEach((exp) => {
 		if (exp.kind === "named" && exp.local && !exp.isTypeOnly) {
 			exportBindings.set(exp.local, exp.exported);
 		}
@@ -1697,7 +1726,7 @@ const createExportBindingsMap = (exports) => {
 * SWC adapter for the analyzer core.
 * Implements parser-specific logic using the SWC parser.
 */
-const collectImports$1 = (module) => {
+const collectImports$1 = (module$1) => {
 	const imports = [];
 	const handle = (declaration) => {
 		const source = declaration.source.value;
@@ -1730,7 +1759,7 @@ const collectImports$1 = (module) => {
 			}
 		});
 	};
-	module.body.forEach((item) => {
+	module$1.body.forEach((item) => {
 		if (item.type === "ImportDeclaration") {
 			handle(item);
 			return;
@@ -1741,14 +1770,14 @@ const collectImports$1 = (module) => {
 	});
 	return imports;
 };
-const collectExports$1 = (module) => {
-	const exports = [];
+const collectExports$1 = (module$1) => {
+	const exports$1 = [];
 	const handle = (declaration) => {
 		if (declaration.type === "ExportDeclaration") {
 			if (declaration.declaration.type === "VariableDeclaration") {
 				declaration.declaration.declarations.forEach((decl) => {
 					if (decl.id.type === "Identifier") {
-						exports.push({
+						exports$1.push({
 							kind: "named",
 							exported: decl.id.value,
 							local: decl.id.value,
@@ -1760,7 +1789,7 @@ const collectExports$1 = (module) => {
 			if (declaration.declaration.type === "FunctionDeclaration") {
 				const ident = declaration.declaration.identifier;
 				if (ident) {
-					exports.push({
+					exports$1.push({
 						kind: "named",
 						exported: ident.value,
 						local: ident.value,
@@ -1779,7 +1808,7 @@ const collectExports$1 = (module) => {
 				const exported = specifier.exported ? specifier.exported.value : specifier.orig.value;
 				const local = specifier.orig.value;
 				if (source) {
-					exports.push({
+					exports$1.push({
 						kind: "reexport",
 						exported,
 						local,
@@ -1788,7 +1817,7 @@ const collectExports$1 = (module) => {
 					});
 					return;
 				}
-				exports.push({
+				exports$1.push({
 					kind: "named",
 					exported,
 					local,
@@ -1798,7 +1827,7 @@ const collectExports$1 = (module) => {
 			return;
 		}
 		if (declaration.type === "ExportAllDeclaration") {
-			exports.push({
+			exports$1.push({
 				kind: "reexport",
 				exported: "*",
 				source: declaration.source.value,
@@ -1807,7 +1836,7 @@ const collectExports$1 = (module) => {
 			return;
 		}
 		if (declaration.type === "ExportDefaultDeclaration" || declaration.type === "ExportDefaultExpression") {
-			exports.push({
+			exports$1.push({
 				kind: "named",
 				exported: "default",
 				local: "default",
@@ -1815,7 +1844,7 @@ const collectExports$1 = (module) => {
 			});
 		}
 	};
-	module.body.forEach((item) => {
+	module$1.body.forEach((item) => {
 		if (item.type === "ExportDeclaration" || item.type === "ExportNamedDeclaration" || item.type === "ExportAllDeclaration" || item.type === "ExportDefaultDeclaration" || item.type === "ExportDefaultExpression") {
 			handle(item);
 			return;
@@ -1827,17 +1856,17 @@ const collectExports$1 = (module) => {
 			}
 		}
 	});
-	return exports;
+	return exports$1;
 };
-const collectGqlIdentifiers = (module, helper) => {
+const collectGqlIdentifiers = (module$1, helper) => {
 	const identifiers = new Set();
-	module.body.forEach((item) => {
+	module$1.body.forEach((item) => {
 		const declaration = item.type === "ImportDeclaration" ? item : "declaration" in item && item.declaration && item.declaration.type === "ImportDeclaration" ? item.declaration : null;
 		if (!declaration) {
 			return;
 		}
 		if (!helper.isGraphqlSystemImportSpecifier({
-			filePath: module.__filePath,
+			filePath: module$1.__filePath,
 			specifier: declaration.source.value
 		})) {
 			return;
@@ -1890,7 +1919,7 @@ const unwrapMethodChains$1 = (identifiers, node) => {
 	}
 	return unwrapMethodChains$1(identifiers, callee.object);
 };
-const collectAllDefinitions$1 = ({ module, gqlIdentifiers, imports: _imports, exports, source, baseDir }) => {
+const collectAllDefinitions$1 = ({ module: module$1, gqlIdentifiers, imports: _imports, exports: exports$1, source, baseDir }) => {
 	const getPropertyName$1 = (property) => {
 		if (!property) {
 			return null;
@@ -1905,9 +1934,9 @@ const collectAllDefinitions$1 = ({ module, gqlIdentifiers, imports: _imports, ex
 	};
 	const pending = [];
 	const handledCalls = [];
-	const exportBindings = createExportBindingsMap(exports);
+	const exportBindings = createExportBindingsMap(exports$1);
 	const tracker = createCanonicalTracker({
-		filePath: module.__filePath,
+		filePath: module$1.__filePath,
 		baseDir,
 		getExportName: (localName) => exportBindings.get(localName)
 	});
@@ -1934,9 +1963,10 @@ const collectAllDefinitions$1 = ({ module, gqlIdentifiers, imports: _imports, ex
 		}
 	};
 	const expressionFromCall = (call) => {
-		const spanOffset = module.__spanOffset;
-		let start = call.span.start - spanOffset;
-		const end = call.span.end - spanOffset;
+		const spanOffset = module$1.__spanOffset;
+		const converter = module$1.__spanConverter;
+		let start = converter.byteOffsetToCharIndex(call.span.start - spanOffset);
+		const end = converter.byteOffsetToCharIndex(call.span.end - spanOffset);
 		if (start > 0 && source[start] === "q" && source[start - 1] === "g" && source.slice(start, start + 3) === "ql.") {
 			start -= 1;
 		}
@@ -2079,11 +2109,11 @@ const collectAllDefinitions$1 = ({ module, gqlIdentifiers, imports: _imports, ex
 			}
 		}
 	};
-	module.body.forEach((statement) => {
+	module$1.body.forEach((statement) => {
 		visit(statement, []);
 	});
 	const definitions = pending.map((item) => ({
-		canonicalId: createCanonicalId(module.__filePath, item.astPath, { baseDir }),
+		canonicalId: createCanonicalId(module$1.__filePath, item.astPath, { baseDir }),
 		astPath: item.astPath,
 		isTopLevel: item.isTopLevel,
 		isExported: item.isExported,
@@ -2098,9 +2128,10 @@ const collectAllDefinitions$1 = ({ module, gqlIdentifiers, imports: _imports, ex
 /**
 * Get location from an SWC node span
 */
-const getLocation$1 = (module, span) => {
-	const start = span.start - module.__spanOffset;
-	const end = span.end - module.__spanOffset;
+const getLocation$1 = (module$1, span) => {
+	const converter = module$1.__spanConverter;
+	const start = converter.byteOffsetToCharIndex(span.start - module$1.__spanOffset);
+	const end = converter.byteOffsetToCharIndex(span.end - module$1.__spanOffset);
 	return {
 		start,
 		end
@@ -2109,32 +2140,32 @@ const getLocation$1 = (module, span) => {
 /**
 * Collect diagnostics for invalid import patterns from graphql-system
 */
-const collectImportDiagnostics$1 = (module, helper) => {
+const collectImportDiagnostics$1 = (module$1, helper) => {
 	const diagnostics = [];
-	module.body.forEach((item) => {
+	module$1.body.forEach((item) => {
 		const declaration = item.type === "ImportDeclaration" ? item : "declaration" in item && item.declaration && "type" in item.declaration && item.declaration.type === "ImportDeclaration" ? item.declaration : null;
 		if (!declaration) {
 			return;
 		}
 		if (!helper.isGraphqlSystemImportSpecifier({
-			filePath: module.__filePath,
+			filePath: module$1.__filePath,
 			specifier: declaration.source.value
 		})) {
 			return;
 		}
 		declaration.specifiers?.forEach((specifier) => {
 			if (specifier.type === "ImportDefaultSpecifier") {
-				diagnostics.push(createStandardDiagnostic("DEFAULT_IMPORT", getLocation$1(module, specifier.span), undefined));
+				diagnostics.push(createStandardDiagnostic("DEFAULT_IMPORT", getLocation$1(module$1, specifier.span), undefined));
 				return;
 			}
 			if (specifier.type === "ImportNamespaceSpecifier") {
-				diagnostics.push(createStandardDiagnostic("STAR_IMPORT", getLocation$1(module, specifier.span), { namespaceAlias: specifier.local.value }));
+				diagnostics.push(createStandardDiagnostic("STAR_IMPORT", getLocation$1(module$1, specifier.span), { namespaceAlias: specifier.local.value }));
 				return;
 			}
 			if (specifier.type === "ImportSpecifier") {
 				const imported = specifier.imported ? specifier.imported.value : specifier.local.value;
 				if (imported === "gql" && specifier.imported) {
-					diagnostics.push(createStandardDiagnostic("RENAMED_IMPORT", getLocation$1(module, specifier.span), { importedAs: specifier.local.value }));
+					diagnostics.push(createStandardDiagnostic("RENAMED_IMPORT", getLocation$1(module$1, specifier.span), { importedAs: specifier.local.value }));
 				}
 			}
 		});
@@ -2185,14 +2216,14 @@ const getArgumentType$1 = (node) => {
 /**
 * Collect diagnostics for invalid gql call patterns
 */
-const collectCallDiagnostics$1 = (module, gqlIdentifiers) => {
+const collectCallDiagnostics$1 = (module$1, gqlIdentifiers) => {
 	const diagnostics = [];
 	const visit = (node) => {
 		if (!node || typeof node !== "object") {
 			return;
 		}
 		if (node.type === "CallExpression") {
-			const diagnostic = checkCallExpression$1(module, node, gqlIdentifiers);
+			const diagnostic = checkCallExpression$1(module$1, node, gqlIdentifiers);
 			if (diagnostic) {
 				diagnostics.push(diagnostic);
 			}
@@ -2207,23 +2238,23 @@ const collectCallDiagnostics$1 = (module, gqlIdentifiers) => {
 			}
 		}
 	};
-	module.body.forEach(visit);
+	module$1.body.forEach(visit);
 	return diagnostics;
 };
 /**
 * Check a call expression for invalid gql patterns
 */
-const checkCallExpression$1 = (module, call, gqlIdentifiers) => {
+const checkCallExpression$1 = (module$1, call, gqlIdentifiers) => {
 	const callee = call.callee;
 	if (callee.type === "Identifier" && gqlIdentifiers.has(callee.value)) {
-		return createStandardDiagnostic("NON_MEMBER_CALLEE", getLocation$1(module, call.span), undefined);
+		return createStandardDiagnostic("NON_MEMBER_CALLEE", getLocation$1(module$1, call.span), undefined);
 	}
 	if (callee.type === "OptionalChainingExpression") {
 		const base = callee.base;
 		if (base?.type === "MemberExpression") {
 			const object$1 = base.object;
 			if (object$1?.type === "Identifier" && gqlIdentifiers.has(object$1.value)) {
-				return createStandardDiagnostic("OPTIONAL_CHAINING", getLocation$1(module, call.span), undefined);
+				return createStandardDiagnostic("OPTIONAL_CHAINING", getLocation$1(module$1, call.span), undefined);
 			}
 		}
 		return null;
@@ -2234,11 +2265,11 @@ const checkCallExpression$1 = (module, call, gqlIdentifiers) => {
 	const object = callee.object;
 	const property = callee.property;
 	if (property?.type === "Computed" && object?.type === "Identifier" && gqlIdentifiers.has(object.value)) {
-		return createStandardDiagnostic("COMPUTED_PROPERTY", getLocation$1(module, call.span), undefined);
+		return createStandardDiagnostic("COMPUTED_PROPERTY", getLocation$1(module$1, call.span), undefined);
 	}
 	if (object?.type !== "Identifier") {
 		if (containsGqlIdentifier$1(object, gqlIdentifiers)) {
-			return createStandardDiagnostic("DYNAMIC_CALLEE", getLocation$1(module, call.span), undefined);
+			return createStandardDiagnostic("DYNAMIC_CALLEE", getLocation$1(module$1, call.span), undefined);
 		}
 		return null;
 	}
@@ -2246,28 +2277,28 @@ const checkCallExpression$1 = (module, call, gqlIdentifiers) => {
 		return null;
 	}
 	if (!call.arguments || call.arguments.length === 0) {
-		return createStandardDiagnostic("MISSING_ARGUMENT", getLocation$1(module, call.span), undefined);
+		return createStandardDiagnostic("MISSING_ARGUMENT", getLocation$1(module$1, call.span), undefined);
 	}
 	const firstArg = call.arguments[0];
 	const firstArgAny = firstArg;
 	if (firstArgAny?.spread) {
-		return createStandardDiagnostic("SPREAD_ARGUMENT", getLocation$1(module, call.span), undefined);
+		return createStandardDiagnostic("SPREAD_ARGUMENT", getLocation$1(module$1, call.span), undefined);
 	}
 	const expression = firstArgAny?.expression;
 	if (expression && expression.type !== "ArrowFunctionExpression") {
 		const actualType = getArgumentType$1(expression);
-		return createStandardDiagnostic("INVALID_ARGUMENT_TYPE", getLocation$1(module, call.span), { actualType });
+		return createStandardDiagnostic("INVALID_ARGUMENT_TYPE", getLocation$1(module$1, call.span), { actualType });
 	}
 	if (call.arguments.length > 1) {
 		const extraCount = call.arguments.length - 1;
-		return createStandardDiagnostic("EXTRA_ARGUMENTS", getLocation$1(module, call.span), { extraCount: String(extraCount) });
+		return createStandardDiagnostic("EXTRA_ARGUMENTS", getLocation$1(module$1, call.span), { extraCount: String(extraCount) });
 	}
 	return null;
 };
 /**
 * Collect diagnostics for gql calls in class properties
 */
-const collectClassPropertyDiagnostics$1 = (module, gqlIdentifiers) => {
+const collectClassPropertyDiagnostics$1 = (module$1, gqlIdentifiers) => {
 	const diagnostics = [];
 	const containsGqlCall = (node) => {
 		if (!node || typeof node !== "object") {
@@ -2299,7 +2330,7 @@ const collectClassPropertyDiagnostics$1 = (module, gqlIdentifiers) => {
 			node.body?.forEach((member) => {
 				if (member.type === "ClassProperty" && member.value) {
 					if (containsGqlCall(member.value)) {
-						diagnostics.push(createStandardDiagnostic("CLASS_PROPERTY", getLocation$1(module, member.span), undefined));
+						diagnostics.push(createStandardDiagnostic("CLASS_PROPERTY", getLocation$1(module$1, member.span), undefined));
 					}
 				}
 			});
@@ -2314,7 +2345,7 @@ const collectClassPropertyDiagnostics$1 = (module, gqlIdentifiers) => {
 			}
 		}
 	};
-	module.body.forEach(visit);
+	module$1.body.forEach(visit);
 	return diagnostics;
 };
 /**
@@ -2333,18 +2364,20 @@ const swcAdapter = { analyze(input, helper) {
 	if (program.type !== "Module") {
 		return null;
 	}
-	const spanOffset = program.span.end - input.source.length + 1;
+	const converter = createSwcSpanConverter(input.source);
+	const spanOffset = program.span.end - converter.byteLength + 1;
 	const swcModule = program;
 	swcModule.__filePath = input.filePath;
 	swcModule.__spanOffset = spanOffset;
+	swcModule.__spanConverter = converter;
 	const gqlIdentifiers = collectGqlIdentifiers(swcModule, helper);
 	const imports = collectImports$1(swcModule);
-	const exports = collectExports$1(swcModule);
+	const exports$1 = collectExports$1(swcModule);
 	const { definitions } = collectAllDefinitions$1({
 		module: swcModule,
 		gqlIdentifiers,
 		imports,
-		exports,
+		exports: exports$1,
 		source: input.source,
 		baseDir: input.baseDir
 	});
@@ -2355,7 +2388,7 @@ const swcAdapter = { analyze(input, helper) {
 	];
 	return {
 		imports,
-		exports,
+		exports: exports$1,
 		definitions,
 		diagnostics
 	};
@@ -2436,14 +2469,14 @@ const collectImports = (sourceFile) => {
 	return imports;
 };
 const collectExports = (sourceFile) => {
-	const exports = [];
+	const exports$1 = [];
 	sourceFile.statements.forEach((statement) => {
 		if (ts.isExportDeclaration(statement)) {
 			const moduleSpecifier = statement.moduleSpecifier ? statement.moduleSpecifier.text : undefined;
 			if (statement.exportClause && ts.isNamedExports(statement.exportClause)) {
 				statement.exportClause.elements.forEach((element) => {
 					if (moduleSpecifier) {
-						exports.push({
+						exports$1.push({
 							kind: "reexport",
 							exported: element.name.text,
 							local: element.propertyName ? element.propertyName.text : undefined,
@@ -2451,7 +2484,7 @@ const collectExports = (sourceFile) => {
 							isTypeOnly: Boolean(statement.isTypeOnly || element.isTypeOnly)
 						});
 					} else {
-						exports.push({
+						exports$1.push({
 							kind: "named",
 							exported: element.name.text,
 							local: element.propertyName ? element.propertyName.text : element.name.text,
@@ -2462,7 +2495,7 @@ const collectExports = (sourceFile) => {
 				return;
 			}
 			if (moduleSpecifier) {
-				exports.push({
+				exports$1.push({
 					kind: "reexport",
 					exported: "*",
 					source: moduleSpecifier,
@@ -2472,7 +2505,7 @@ const collectExports = (sourceFile) => {
 			return;
 		}
 		if (ts.isExportAssignment(statement)) {
-			exports.push({
+			exports$1.push({
 				kind: "named",
 				exported: "default",
 				local: "default",
@@ -2482,7 +2515,7 @@ const collectExports = (sourceFile) => {
 		if (ts.isVariableStatement(statement) && statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) {
 			statement.declarationList.declarations.forEach((declaration) => {
 				if (ts.isIdentifier(declaration.name)) {
-					exports.push({
+					exports$1.push({
 						kind: "named",
 						exported: declaration.name.text,
 						local: declaration.name.text,
@@ -2492,7 +2525,7 @@ const collectExports = (sourceFile) => {
 			});
 		}
 		if (ts.isFunctionDeclaration(statement) && statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) && statement.name) {
-			exports.push({
+			exports$1.push({
 				kind: "named",
 				exported: statement.name.text,
 				local: statement.name.text,
@@ -2500,7 +2533,7 @@ const collectExports = (sourceFile) => {
 			});
 		}
 	});
-	return exports;
+	return exports$1;
 };
 /**
 * Unwrap NonNullExpression nodes to get the underlying expression.
@@ -2559,10 +2592,10 @@ const getPropertyName = (name) => {
 /**
 * Collect all gql definitions (exported, non-exported, top-level, nested)
 */
-const collectAllDefinitions = ({ sourceFile, identifiers, exports, baseDir }) => {
+const collectAllDefinitions = ({ sourceFile, identifiers, exports: exports$1, baseDir }) => {
 	const pending = [];
 	const handledCalls = [];
-	const exportBindings = createExportBindingsMap(exports);
+	const exportBindings = createExportBindingsMap(exports$1);
 	const tracker = createCanonicalTracker({
 		filePath: sourceFile.fileName,
 		baseDir,
@@ -2909,11 +2942,11 @@ const typescriptAdapter = { analyze(input, helper) {
 	const sourceFile = createSourceFile(input.filePath, input.source);
 	const gqlIdentifiers = collectGqlImports(sourceFile, helper);
 	const imports = collectImports(sourceFile);
-	const exports = collectExports(sourceFile);
+	const exports$1 = collectExports(sourceFile);
 	const { definitions } = collectAllDefinitions({
 		sourceFile,
 		identifiers: gqlIdentifiers,
-		exports,
+		exports: exports$1,
 		baseDir: input.baseDir
 	});
 	const diagnostics = [
@@ -2923,7 +2956,7 @@ const typescriptAdapter = { analyze(input, helper) {
 	];
 	return {
 		imports,
-		exports,
+		exports: exports$1,
 		definitions,
 		diagnostics
 	};
@@ -3739,6 +3772,1856 @@ const discoverModulesAsync = async (options) => {
 	return ok(result.value);
 };
 
+//#endregion
+//#region node_modules/picomatch/lib/constants.js
+var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const WIN_SLASH = "\\\\/";
+	const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+	/**
+	* Posix glob regex
+	*/
+	const DOT_LITERAL = "\\.";
+	const PLUS_LITERAL = "\\+";
+	const QMARK_LITERAL = "\\?";
+	const SLASH_LITERAL = "\\/";
+	const ONE_CHAR = "(?=.)";
+	const QMARK = "[^/]";
+	const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+	const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+	const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+	const NO_DOT = `(?!${DOT_LITERAL})`;
+	const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+	const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+	const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+	const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+	const STAR = `${QMARK}*?`;
+	const SEP = "/";
+	const POSIX_CHARS = {
+		DOT_LITERAL,
+		PLUS_LITERAL,
+		QMARK_LITERAL,
+		SLASH_LITERAL,
+		ONE_CHAR,
+		QMARK,
+		END_ANCHOR,
+		DOTS_SLASH,
+		NO_DOT,
+		NO_DOTS,
+		NO_DOT_SLASH,
+		NO_DOTS_SLASH,
+		QMARK_NO_DOT,
+		STAR,
+		START_ANCHOR,
+		SEP
+	};
+	/**
+	* Windows glob regex
+	*/
+	const WINDOWS_CHARS = {
+		...POSIX_CHARS,
+		SLASH_LITERAL: `[${WIN_SLASH}]`,
+		QMARK: WIN_NO_SLASH,
+		STAR: `${WIN_NO_SLASH}*?`,
+		DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+		NO_DOT: `(?!${DOT_LITERAL})`,
+		NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+		NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+		NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+		QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+		START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+		END_ANCHOR: `(?:[${WIN_SLASH}]|$)`,
+		SEP: "\\"
+	};
+	/**
+	* POSIX Bracket Regex
+	*/
+	const POSIX_REGEX_SOURCE$1 = {
+		alnum: "a-zA-Z0-9",
+		alpha: "a-zA-Z",
+		ascii: "\\x00-\\x7F",
+		blank: " \\t",
+		cntrl: "\\x00-\\x1F\\x7F",
+		digit: "0-9",
+		graph: "\\x21-\\x7E",
+		lower: "a-z",
+		print: "\\x20-\\x7E ",
+		punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",
+		space: " \\t\\r\\n\\v\\f",
+		upper: "A-Z",
+		word: "A-Za-z0-9_",
+		xdigit: "A-Fa-f0-9"
+	};
+	module.exports = {
+		MAX_LENGTH: 1024 * 64,
+		POSIX_REGEX_SOURCE: POSIX_REGEX_SOURCE$1,
+		REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+		REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+		REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+		REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+		REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+		REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+		REPLACEMENTS: {
+			__proto__: null,
+			"***": "*",
+			"**/**": "**",
+			"**/**/**": "**"
+		},
+		CHAR_0: 48,
+		CHAR_9: 57,
+		CHAR_UPPERCASE_A: 65,
+		CHAR_LOWERCASE_A: 97,
+		CHAR_UPPERCASE_Z: 90,
+		CHAR_LOWERCASE_Z: 122,
+		CHAR_LEFT_PARENTHESES: 40,
+		CHAR_RIGHT_PARENTHESES: 41,
+		CHAR_ASTERISK: 42,
+		CHAR_AMPERSAND: 38,
+		CHAR_AT: 64,
+		CHAR_BACKWARD_SLASH: 92,
+		CHAR_CARRIAGE_RETURN: 13,
+		CHAR_CIRCUMFLEX_ACCENT: 94,
+		CHAR_COLON: 58,
+		CHAR_COMMA: 44,
+		CHAR_DOT: 46,
+		CHAR_DOUBLE_QUOTE: 34,
+		CHAR_EQUAL: 61,
+		CHAR_EXCLAMATION_MARK: 33,
+		CHAR_FORM_FEED: 12,
+		CHAR_FORWARD_SLASH: 47,
+		CHAR_GRAVE_ACCENT: 96,
+		CHAR_HASH: 35,
+		CHAR_HYPHEN_MINUS: 45,
+		CHAR_LEFT_ANGLE_BRACKET: 60,
+		CHAR_LEFT_CURLY_BRACE: 123,
+		CHAR_LEFT_SQUARE_BRACKET: 91,
+		CHAR_LINE_FEED: 10,
+		CHAR_NO_BREAK_SPACE: 160,
+		CHAR_PERCENT: 37,
+		CHAR_PLUS: 43,
+		CHAR_QUESTION_MARK: 63,
+		CHAR_RIGHT_ANGLE_BRACKET: 62,
+		CHAR_RIGHT_CURLY_BRACE: 125,
+		CHAR_RIGHT_SQUARE_BRACKET: 93,
+		CHAR_SEMICOLON: 59,
+		CHAR_SINGLE_QUOTE: 39,
+		CHAR_SPACE: 32,
+		CHAR_TAB: 9,
+		CHAR_UNDERSCORE: 95,
+		CHAR_VERTICAL_LINE: 124,
+		CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
+		extglobChars(chars) {
+			return {
+				"!": {
+					type: "negate",
+					open: "(?:(?!(?:",
+					close: `))${chars.STAR})`
+				},
+				"?": {
+					type: "qmark",
+					open: "(?:",
+					close: ")?"
+				},
+				"+": {
+					type: "plus",
+					open: "(?:",
+					close: ")+"
+				},
+				"*": {
+					type: "star",
+					open: "(?:",
+					close: ")*"
+				},
+				"@": {
+					type: "at",
+					open: "(?:",
+					close: ")"
+				}
+			};
+		},
+		globChars(win32) {
+			return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
+		}
+	};
+}));
+
+//#endregion
+//#region node_modules/picomatch/lib/utils.js
+var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
+	const { REGEX_BACKSLASH, REGEX_REMOVE_BACKSLASH, REGEX_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_GLOBAL } = require_constants();
+	exports.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
+	exports.hasRegexChars = (str) => REGEX_SPECIAL_CHARS.test(str);
+	exports.isRegexChar = (str) => str.length === 1 && exports.hasRegexChars(str);
+	exports.escapeRegex = (str) => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, "\\$1");
+	exports.toPosixSlashes = (str) => str.replace(REGEX_BACKSLASH, "/");
+	exports.isWindows = () => {
+		if (typeof navigator !== "undefined" && navigator.platform) {
+			const platform = navigator.platform.toLowerCase();
+			return platform === "win32" || platform === "windows";
+		}
+		if (typeof process !== "undefined" && process.platform) {
+			return process.platform === "win32";
+		}
+		return false;
+	};
+	exports.removeBackslashes = (str) => {
+		return str.replace(REGEX_REMOVE_BACKSLASH, (match) => {
+			return match === "\\" ? "" : match;
+		});
+	};
+	exports.escapeLast = (input, char, lastIdx) => {
+		const idx = input.lastIndexOf(char, lastIdx);
+		if (idx === -1) return input;
+		if (input[idx - 1] === "\\") return exports.escapeLast(input, char, idx - 1);
+		return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+	};
+	exports.removePrefix = (input, state = {}) => {
+		let output = input;
+		if (output.startsWith("./")) {
+			output = output.slice(2);
+			state.prefix = "./";
+		}
+		return output;
+	};
+	exports.wrapOutput = (input, state = {}, options = {}) => {
+		const prepend = options.contains ? "" : "^";
+		const append = options.contains ? "" : "$";
+		let output = `${prepend}(?:${input})${append}`;
+		if (state.negated === true) {
+			output = `(?:^(?!${output}).*$)`;
+		}
+		return output;
+	};
+	exports.basename = (path, { windows } = {}) => {
+		const segs = path.split(windows ? /[\\/]/ : "/");
+		const last = segs[segs.length - 1];
+		if (last === "") {
+			return segs[segs.length - 2];
+		}
+		return last;
+	};
+}));
+
+//#endregion
+//#region node_modules/picomatch/lib/scan.js
+var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const utils$3 = require_utils();
+	const { CHAR_ASTERISK, CHAR_AT, CHAR_BACKWARD_SLASH, CHAR_COMMA, CHAR_DOT, CHAR_EXCLAMATION_MARK, CHAR_FORWARD_SLASH, CHAR_LEFT_CURLY_BRACE, CHAR_LEFT_PARENTHESES, CHAR_LEFT_SQUARE_BRACKET, CHAR_PLUS, CHAR_QUESTION_MARK, CHAR_RIGHT_CURLY_BRACE, CHAR_RIGHT_PARENTHESES, CHAR_RIGHT_SQUARE_BRACKET } = require_constants();
+	const isPathSeparator = (code) => {
+		return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+	};
+	const depth = (token) => {
+		if (token.isPrefix !== true) {
+			token.depth = token.isGlobstar ? Infinity : 1;
+		}
+	};
+	/**
+	* Quickly scans a glob pattern and returns an object with a handful of
+	* useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
+	* `glob` (the actual pattern), `negated` (true if the path starts with `!` but not
+	* with `!(`) and `negatedExtglob` (true if the path starts with `!(`).
+	*
+	* ```js
+	* const pm = require('picomatch');
+	* console.log(pm.scan('foo/bar/*.js'));
+	* { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }
+	* ```
+	* @param {String} `str`
+	* @param {Object} `options`
+	* @return {Object} Returns an object with tokens and regex source string.
+	* @api public
+	*/
+	const scan$1 = (input, options) => {
+		const opts = options || {};
+		const length = input.length - 1;
+		const scanToEnd = opts.parts === true || opts.scanToEnd === true;
+		const slashes = [];
+		const tokens = [];
+		const parts = [];
+		let str = input;
+		let index = -1;
+		let start = 0;
+		let lastIndex = 0;
+		let isBrace = false;
+		let isBracket = false;
+		let isGlob = false;
+		let isExtglob = false;
+		let isGlobstar = false;
+		let braceEscaped = false;
+		let backslashes = false;
+		let negated = false;
+		let negatedExtglob = false;
+		let finished = false;
+		let braces = 0;
+		let prev;
+		let code;
+		let token = {
+			value: "",
+			depth: 0,
+			isGlob: false
+		};
+		const eos = () => index >= length;
+		const peek = () => str.charCodeAt(index + 1);
+		const advance = () => {
+			prev = code;
+			return str.charCodeAt(++index);
+		};
+		while (index < length) {
+			code = advance();
+			let next;
+			if (code === CHAR_BACKWARD_SLASH) {
+				backslashes = token.backslashes = true;
+				code = advance();
+				if (code === CHAR_LEFT_CURLY_BRACE) {
+					braceEscaped = true;
+				}
+				continue;
+			}
+			if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
+				braces++;
+				while (eos() !== true && (code = advance())) {
+					if (code === CHAR_BACKWARD_SLASH) {
+						backslashes = token.backslashes = true;
+						advance();
+						continue;
+					}
+					if (code === CHAR_LEFT_CURLY_BRACE) {
+						braces++;
+						continue;
+					}
+					if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
+						isBrace = token.isBrace = true;
+						isGlob = token.isGlob = true;
+						finished = true;
+						if (scanToEnd === true) {
+							continue;
+						}
+						break;
+					}
+					if (braceEscaped !== true && code === CHAR_COMMA) {
+						isBrace = token.isBrace = true;
+						isGlob = token.isGlob = true;
+						finished = true;
+						if (scanToEnd === true) {
+							continue;
+						}
+						break;
+					}
+					if (code === CHAR_RIGHT_CURLY_BRACE) {
+						braces--;
+						if (braces === 0) {
+							braceEscaped = false;
+							isBrace = token.isBrace = true;
+							finished = true;
+							break;
+						}
+					}
+				}
+				if (scanToEnd === true) {
+					continue;
+				}
+				break;
+			}
+			if (code === CHAR_FORWARD_SLASH) {
+				slashes.push(index);
+				tokens.push(token);
+				token = {
+					value: "",
+					depth: 0,
+					isGlob: false
+				};
+				if (finished === true) continue;
+				if (prev === CHAR_DOT && index === start + 1) {
+					start += 2;
+					continue;
+				}
+				lastIndex = index + 1;
+				continue;
+			}
+			if (opts.noext !== true) {
+				const isExtglobChar = code === CHAR_PLUS || code === CHAR_AT || code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK || code === CHAR_EXCLAMATION_MARK;
+				if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
+					isGlob = token.isGlob = true;
+					isExtglob = token.isExtglob = true;
+					finished = true;
+					if (code === CHAR_EXCLAMATION_MARK && index === start) {
+						negatedExtglob = true;
+					}
+					if (scanToEnd === true) {
+						while (eos() !== true && (code = advance())) {
+							if (code === CHAR_BACKWARD_SLASH) {
+								backslashes = token.backslashes = true;
+								code = advance();
+								continue;
+							}
+							if (code === CHAR_RIGHT_PARENTHESES) {
+								isGlob = token.isGlob = true;
+								finished = true;
+								break;
+							}
+						}
+						continue;
+					}
+					break;
+				}
+			}
+			if (code === CHAR_ASTERISK) {
+				if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
+				isGlob = token.isGlob = true;
+				finished = true;
+				if (scanToEnd === true) {
+					continue;
+				}
+				break;
+			}
+			if (code === CHAR_QUESTION_MARK) {
+				isGlob = token.isGlob = true;
+				finished = true;
+				if (scanToEnd === true) {
+					continue;
+				}
+				break;
+			}
+			if (code === CHAR_LEFT_SQUARE_BRACKET) {
+				while (eos() !== true && (next = advance())) {
+					if (next === CHAR_BACKWARD_SLASH) {
+						backslashes = token.backslashes = true;
+						advance();
+						continue;
+					}
+					if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+						isBracket = token.isBracket = true;
+						isGlob = token.isGlob = true;
+						finished = true;
+						break;
+					}
+				}
+				if (scanToEnd === true) {
+					continue;
+				}
+				break;
+			}
+			if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
+				negated = token.negated = true;
+				start++;
+				continue;
+			}
+			if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
+				isGlob = token.isGlob = true;
+				if (scanToEnd === true) {
+					while (eos() !== true && (code = advance())) {
+						if (code === CHAR_LEFT_PARENTHESES) {
+							backslashes = token.backslashes = true;
+							code = advance();
+							continue;
+						}
+						if (code === CHAR_RIGHT_PARENTHESES) {
+							finished = true;
+							break;
+						}
+					}
+					continue;
+				}
+				break;
+			}
+			if (isGlob === true) {
+				finished = true;
+				if (scanToEnd === true) {
+					continue;
+				}
+				break;
+			}
+		}
+		if (opts.noext === true) {
+			isExtglob = false;
+			isGlob = false;
+		}
+		let base = str;
+		let prefix = "";
+		let glob = "";
+		if (start > 0) {
+			prefix = str.slice(0, start);
+			str = str.slice(start);
+			lastIndex -= start;
+		}
+		if (base && isGlob === true && lastIndex > 0) {
+			base = str.slice(0, lastIndex);
+			glob = str.slice(lastIndex);
+		} else if (isGlob === true) {
+			base = "";
+			glob = str;
+		} else {
+			base = str;
+		}
+		if (base && base !== "" && base !== "/" && base !== str) {
+			if (isPathSeparator(base.charCodeAt(base.length - 1))) {
+				base = base.slice(0, -1);
+			}
+		}
+		if (opts.unescape === true) {
+			if (glob) glob = utils$3.removeBackslashes(glob);
+			if (base && backslashes === true) {
+				base = utils$3.removeBackslashes(base);
+			}
+		}
+		const state = {
+			prefix,
+			input,
+			start,
+			base,
+			glob,
+			isBrace,
+			isBracket,
+			isGlob,
+			isExtglob,
+			isGlobstar,
+			negated,
+			negatedExtglob
+		};
+		if (opts.tokens === true) {
+			state.maxDepth = 0;
+			if (!isPathSeparator(code)) {
+				tokens.push(token);
+			}
+			state.tokens = tokens;
+		}
+		if (opts.parts === true || opts.tokens === true) {
+			let prevIndex;
+			for (let idx = 0; idx < slashes.length; idx++) {
+				const n = prevIndex ? prevIndex + 1 : start;
+				const i = slashes[idx];
+				const value = input.slice(n, i);
+				if (opts.tokens) {
+					if (idx === 0 && start !== 0) {
+						tokens[idx].isPrefix = true;
+						tokens[idx].value = prefix;
+					} else {
+						tokens[idx].value = value;
+					}
+					depth(tokens[idx]);
+					state.maxDepth += tokens[idx].depth;
+				}
+				if (idx !== 0 || value !== "") {
+					parts.push(value);
+				}
+				prevIndex = i;
+			}
+			if (prevIndex && prevIndex + 1 < input.length) {
+				const value = input.slice(prevIndex + 1);
+				parts.push(value);
+				if (opts.tokens) {
+					tokens[tokens.length - 1].value = value;
+					depth(tokens[tokens.length - 1]);
+					state.maxDepth += tokens[tokens.length - 1].depth;
+				}
+			}
+			state.slashes = slashes;
+			state.parts = parts;
+		}
+		return state;
+	};
+	module.exports = scan$1;
+}));
+
+//#endregion
+//#region node_modules/picomatch/lib/parse.js
+var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const constants$1 = require_constants();
+	const utils$2 = require_utils();
+	/**
+	* Constants
+	*/
+	const { MAX_LENGTH, POSIX_REGEX_SOURCE, REGEX_NON_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_BACKREF, REPLACEMENTS } = constants$1;
+	/**
+	* Helpers
+	*/
+	const expandRange = (args, options) => {
+		if (typeof options.expandRange === "function") {
+			return options.expandRange(...args, options);
+		}
+		args.sort();
+		const value = `[${args.join("-")}]`;
+		try {
+			new RegExp(value);
+		} catch (ex) {
+			return args.map((v) => utils$2.escapeRegex(v)).join("..");
+		}
+		return value;
+	};
+	/**
+	* Create the message for a syntax error
+	*/
+	const syntaxError = (type, char) => {
+		return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+	};
+	/**
+	* Parse the given input string.
+	* @param {String} input
+	* @param {Object} options
+	* @return {Object}
+	*/
+	const parse$1 = (input, options) => {
+		if (typeof input !== "string") {
+			throw new TypeError("Expected a string");
+		}
+		input = REPLACEMENTS[input] || input;
+		const opts = { ...options };
+		const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+		let len = input.length;
+		if (len > max) {
+			throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+		}
+		const bos = {
+			type: "bos",
+			value: "",
+			output: opts.prepend || ""
+		};
+		const tokens = [bos];
+		const capture = opts.capture ? "" : "?:";
+		const PLATFORM_CHARS = constants$1.globChars(opts.windows);
+		const EXTGLOB_CHARS = constants$1.extglobChars(PLATFORM_CHARS);
+		const { DOT_LITERAL: DOT_LITERAL$1, PLUS_LITERAL: PLUS_LITERAL$1, SLASH_LITERAL: SLASH_LITERAL$1, ONE_CHAR: ONE_CHAR$1, DOTS_SLASH: DOTS_SLASH$1, NO_DOT: NO_DOT$1, NO_DOT_SLASH: NO_DOT_SLASH$1, NO_DOTS_SLASH: NO_DOTS_SLASH$1, QMARK: QMARK$1, QMARK_NO_DOT: QMARK_NO_DOT$1, STAR: STAR$1, START_ANCHOR: START_ANCHOR$1 } = PLATFORM_CHARS;
+		const globstar = (opts$1) => {
+			return `(${capture}(?:(?!${START_ANCHOR$1}${opts$1.dot ? DOTS_SLASH$1 : DOT_LITERAL$1}).)*?)`;
+		};
+		const nodot = opts.dot ? "" : NO_DOT$1;
+		const qmarkNoDot = opts.dot ? QMARK$1 : QMARK_NO_DOT$1;
+		let star = opts.bash === true ? globstar(opts) : STAR$1;
+		if (opts.capture) {
+			star = `(${star})`;
+		}
+		if (typeof opts.noext === "boolean") {
+			opts.noextglob = opts.noext;
+		}
+		const state = {
+			input,
+			index: -1,
+			start: 0,
+			dot: opts.dot === true,
+			consumed: "",
+			output: "",
+			prefix: "",
+			backtrack: false,
+			negated: false,
+			brackets: 0,
+			braces: 0,
+			parens: 0,
+			quotes: 0,
+			globstar: false,
+			tokens
+		};
+		input = utils$2.removePrefix(input, state);
+		len = input.length;
+		const extglobs = [];
+		const braces = [];
+		const stack = [];
+		let prev = bos;
+		let value;
+		/**
+		* Tokenizing helpers
+		*/
+		const eos = () => state.index === len - 1;
+		const peek = state.peek = (n = 1) => input[state.index + n];
+		const advance = state.advance = () => input[++state.index] || "";
+		const remaining = () => input.slice(state.index + 1);
+		const consume = (value$1 = "", num = 0) => {
+			state.consumed += value$1;
+			state.index += num;
+		};
+		const append = (token) => {
+			state.output += token.output != null ? token.output : token.value;
+			consume(token.value);
+		};
+		const negate = () => {
+			let count = 1;
+			while (peek() === "!" && (peek(2) !== "(" || peek(3) === "?")) {
+				advance();
+				state.start++;
+				count++;
+			}
+			if (count % 2 === 0) {
+				return false;
+			}
+			state.negated = true;
+			state.start++;
+			return true;
+		};
+		const increment = (type) => {
+			state[type]++;
+			stack.push(type);
+		};
+		const decrement = (type) => {
+			state[type]--;
+			stack.pop();
+		};
+		/**
+		* Push tokens onto the tokens array. This helper speeds up
+		* tokenizing by 1) helping us avoid backtracking as much as possible,
+		* and 2) helping us avoid creating extra tokens when consecutive
+		* characters are plain text. This improves performance and simplifies
+		* lookbehinds.
+		*/
+		const push = (tok) => {
+			if (prev.type === "globstar") {
+				const isBrace = state.braces > 0 && (tok.type === "comma" || tok.type === "brace");
+				const isExtglob = tok.extglob === true || extglobs.length && (tok.type === "pipe" || tok.type === "paren");
+				if (tok.type !== "slash" && tok.type !== "paren" && !isBrace && !isExtglob) {
+					state.output = state.output.slice(0, -prev.output.length);
+					prev.type = "star";
+					prev.value = "*";
+					prev.output = star;
+					state.output += prev.output;
+				}
+			}
+			if (extglobs.length && tok.type !== "paren") {
+				extglobs[extglobs.length - 1].inner += tok.value;
+			}
+			if (tok.value || tok.output) append(tok);
+			if (prev && prev.type === "text" && tok.type === "text") {
+				prev.output = (prev.output || prev.value) + tok.value;
+				prev.value += tok.value;
+				return;
+			}
+			tok.prev = prev;
+			tokens.push(tok);
+			prev = tok;
+		};
+		const extglobOpen = (type, value$1) => {
+			const token = {
+				...EXTGLOB_CHARS[value$1],
+				conditions: 1,
+				inner: ""
+			};
+			token.prev = prev;
+			token.parens = state.parens;
+			token.output = state.output;
+			const output = (opts.capture ? "(" : "") + token.open;
+			increment("parens");
+			push({
+				type,
+				value: value$1,
+				output: state.output ? "" : ONE_CHAR$1
+			});
+			push({
+				type: "paren",
+				extglob: true,
+				value: advance(),
+				output
+			});
+			extglobs.push(token);
+		};
+		const extglobClose = (token) => {
+			let output = token.close + (opts.capture ? ")" : "");
+			let rest;
+			if (token.type === "negate") {
+				let extglobStar = star;
+				if (token.inner && token.inner.length > 1 && token.inner.includes("/")) {
+					extglobStar = globstar(opts);
+				}
+				if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
+					output = token.close = `)$))${extglobStar}`;
+				}
+				if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
+					const expression = parse$1(rest, {
+						...options,
+						fastpaths: false
+					}).output;
+					output = token.close = `)${expression})${extglobStar})`;
+				}
+				if (token.prev.type === "bos") {
+					state.negatedExtglob = true;
+				}
+			}
+			push({
+				type: "paren",
+				extglob: true,
+				value,
+				output
+			});
+			decrement("parens");
+		};
+		/**
+		* Fast paths
+		*/
+		if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+			let backslashes = false;
+			let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
+				if (first === "\\") {
+					backslashes = true;
+					return m;
+				}
+				if (first === "?") {
+					if (esc) {
+						return esc + first + (rest ? QMARK$1.repeat(rest.length) : "");
+					}
+					if (index === 0) {
+						return qmarkNoDot + (rest ? QMARK$1.repeat(rest.length) : "");
+					}
+					return QMARK$1.repeat(chars.length);
+				}
+				if (first === ".") {
+					return DOT_LITERAL$1.repeat(chars.length);
+				}
+				if (first === "*") {
+					if (esc) {
+						return esc + first + (rest ? star : "");
+					}
+					return star;
+				}
+				return esc ? m : `\\${m}`;
+			});
+			if (backslashes === true) {
+				if (opts.unescape === true) {
+					output = output.replace(/\\/g, "");
+				} else {
+					output = output.replace(/\\+/g, (m) => {
+						return m.length % 2 === 0 ? "\\\\" : m ? "\\" : "";
+					});
+				}
+			}
+			if (output === input && opts.contains === true) {
+				state.output = input;
+				return state;
+			}
+			state.output = utils$2.wrapOutput(output, state, options);
+			return state;
+		}
+		/**
+		* Tokenize input until we reach end-of-string
+		*/
+		while (!eos()) {
+			value = advance();
+			if (value === "\0") {
+				continue;
+			}
+			/**
+			* Escaped characters
+			*/
+			if (value === "\\") {
+				const next = peek();
+				if (next === "/" && opts.bash !== true) {
+					continue;
+				}
+				if (next === "." || next === ";") {
+					continue;
+				}
+				if (!next) {
+					value += "\\";
+					push({
+						type: "text",
+						value
+					});
+					continue;
+				}
+				const match = /^\\+/.exec(remaining());
+				let slashes = 0;
+				if (match && match[0].length > 2) {
+					slashes = match[0].length;
+					state.index += slashes;
+					if (slashes % 2 !== 0) {
+						value += "\\";
+					}
+				}
+				if (opts.unescape === true) {
+					value = advance();
+				} else {
+					value += advance();
+				}
+				if (state.brackets === 0) {
+					push({
+						type: "text",
+						value
+					});
+					continue;
+				}
+			}
+			/**
+			* If we're inside a regex character class, continue
+			* until we reach the closing bracket.
+			*/
+			if (state.brackets > 0 && (value !== "]" || prev.value === "[" || prev.value === "[^")) {
+				if (opts.posix !== false && value === ":") {
+					const inner = prev.value.slice(1);
+					if (inner.includes("[")) {
+						prev.posix = true;
+						if (inner.includes(":")) {
+							const idx = prev.value.lastIndexOf("[");
+							const pre = prev.value.slice(0, idx);
+							const rest$1 = prev.value.slice(idx + 2);
+							const posix = POSIX_REGEX_SOURCE[rest$1];
+							if (posix) {
+								prev.value = pre + posix;
+								state.backtrack = true;
+								advance();
+								if (!bos.output && tokens.indexOf(prev) === 1) {
+									bos.output = ONE_CHAR$1;
+								}
+								continue;
+							}
+						}
+					}
+				}
+				if (value === "[" && peek() !== ":" || value === "-" && peek() === "]") {
+					value = `\\${value}`;
+				}
+				if (value === "]" && (prev.value === "[" || prev.value === "[^")) {
+					value = `\\${value}`;
+				}
+				if (opts.posix === true && value === "!" && prev.value === "[") {
+					value = "^";
+				}
+				prev.value += value;
+				append({ value });
+				continue;
+			}
+			/**
+			* If we're inside a quoted string, continue
+			* until we reach the closing double quote.
+			*/
+			if (state.quotes === 1 && value !== "\"") {
+				value = utils$2.escapeRegex(value);
+				prev.value += value;
+				append({ value });
+				continue;
+			}
+			/**
+			* Double quotes
+			*/
+			if (value === "\"") {
+				state.quotes = state.quotes === 1 ? 0 : 1;
+				if (opts.keepQuotes === true) {
+					push({
+						type: "text",
+						value
+					});
+				}
+				continue;
+			}
+			/**
+			* Parentheses
+			*/
+			if (value === "(") {
+				increment("parens");
+				push({
+					type: "paren",
+					value
+				});
+				continue;
+			}
+			if (value === ")") {
+				if (state.parens === 0 && opts.strictBrackets === true) {
+					throw new SyntaxError(syntaxError("opening", "("));
+				}
+				const extglob = extglobs[extglobs.length - 1];
+				if (extglob && state.parens === extglob.parens + 1) {
+					extglobClose(extglobs.pop());
+					continue;
+				}
+				push({
+					type: "paren",
+					value,
+					output: state.parens ? ")" : "\\)"
+				});
+				decrement("parens");
+				continue;
+			}
+			/**
+			* Square brackets
+			*/
+			if (value === "[") {
+				if (opts.nobracket === true || !remaining().includes("]")) {
+					if (opts.nobracket !== true && opts.strictBrackets === true) {
+						throw new SyntaxError(syntaxError("closing", "]"));
+					}
+					value = `\\${value}`;
+				} else {
+					increment("brackets");
+				}
+				push({
+					type: "bracket",
+					value
+				});
+				continue;
+			}
+			if (value === "]") {
+				if (opts.nobracket === true || prev && prev.type === "bracket" && prev.value.length === 1) {
+					push({
+						type: "text",
+						value,
+						output: `\\${value}`
+					});
+					continue;
+				}
+				if (state.brackets === 0) {
+					if (opts.strictBrackets === true) {
+						throw new SyntaxError(syntaxError("opening", "["));
+					}
+					push({
+						type: "text",
+						value,
+						output: `\\${value}`
+					});
+					continue;
+				}
+				decrement("brackets");
+				const prevValue = prev.value.slice(1);
+				if (prev.posix !== true && prevValue[0] === "^" && !prevValue.includes("/")) {
+					value = `/${value}`;
+				}
+				prev.value += value;
+				append({ value });
+				if (opts.literalBrackets === false || utils$2.hasRegexChars(prevValue)) {
+					continue;
+				}
+				const escaped = utils$2.escapeRegex(prev.value);
+				state.output = state.output.slice(0, -prev.value.length);
+				if (opts.literalBrackets === true) {
+					state.output += escaped;
+					prev.value = escaped;
+					continue;
+				}
+				prev.value = `(${capture}${escaped}|${prev.value})`;
+				state.output += prev.value;
+				continue;
+			}
+			/**
+			* Braces
+			*/
+			if (value === "{" && opts.nobrace !== true) {
+				increment("braces");
+				const open = {
+					type: "brace",
+					value,
+					output: "(",
+					outputIndex: state.output.length,
+					tokensIndex: state.tokens.length
+				};
+				braces.push(open);
+				push(open);
+				continue;
+			}
+			if (value === "}") {
+				const brace = braces[braces.length - 1];
+				if (opts.nobrace === true || !brace) {
+					push({
+						type: "text",
+						value,
+						output: value
+					});
+					continue;
+				}
+				let output = ")";
+				if (brace.dots === true) {
+					const arr = tokens.slice();
+					const range = [];
+					for (let i = arr.length - 1; i >= 0; i--) {
+						tokens.pop();
+						if (arr[i].type === "brace") {
+							break;
+						}
+						if (arr[i].type !== "dots") {
+							range.unshift(arr[i].value);
+						}
+					}
+					output = expandRange(range, opts);
+					state.backtrack = true;
+				}
+				if (brace.comma !== true && brace.dots !== true) {
+					const out = state.output.slice(0, brace.outputIndex);
+					const toks = state.tokens.slice(brace.tokensIndex);
+					brace.value = brace.output = "\\{";
+					value = output = "\\}";
+					state.output = out;
+					for (const t of toks) {
+						state.output += t.output || t.value;
+					}
+				}
+				push({
+					type: "brace",
+					value,
+					output
+				});
+				decrement("braces");
+				braces.pop();
+				continue;
+			}
+			/**
+			* Pipes
+			*/
+			if (value === "|") {
+				if (extglobs.length > 0) {
+					extglobs[extglobs.length - 1].conditions++;
+				}
+				push({
+					type: "text",
+					value
+				});
+				continue;
+			}
+			/**
+			* Commas
+			*/
+			if (value === ",") {
+				let output = value;
+				const brace = braces[braces.length - 1];
+				if (brace && stack[stack.length - 1] === "braces") {
+					brace.comma = true;
+					output = "|";
+				}
+				push({
+					type: "comma",
+					value,
+					output
+				});
+				continue;
+			}
+			/**
+			* Slashes
+			*/
+			if (value === "/") {
+				if (prev.type === "dot" && state.index === state.start + 1) {
+					state.start = state.index + 1;
+					state.consumed = "";
+					state.output = "";
+					tokens.pop();
+					prev = bos;
+					continue;
+				}
+				push({
+					type: "slash",
+					value,
+					output: SLASH_LITERAL$1
+				});
+				continue;
+			}
+			/**
+			* Dots
+			*/
+			if (value === ".") {
+				if (state.braces > 0 && prev.type === "dot") {
+					if (prev.value === ".") prev.output = DOT_LITERAL$1;
+					const brace = braces[braces.length - 1];
+					prev.type = "dots";
+					prev.output += value;
+					prev.value += value;
+					brace.dots = true;
+					continue;
+				}
+				if (state.braces + state.parens === 0 && prev.type !== "bos" && prev.type !== "slash") {
+					push({
+						type: "text",
+						value,
+						output: DOT_LITERAL$1
+					});
+					continue;
+				}
+				push({
+					type: "dot",
+					value,
+					output: DOT_LITERAL$1
+				});
+				continue;
+			}
+			/**
+			* Question marks
+			*/
+			if (value === "?") {
+				const isGroup = prev && prev.value === "(";
+				if (!isGroup && opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+					extglobOpen("qmark", value);
+					continue;
+				}
+				if (prev && prev.type === "paren") {
+					const next = peek();
+					let output = value;
+					if (prev.value === "(" && !/[!=<:]/.test(next) || next === "<" && !/<([!=]|\w+>)/.test(remaining())) {
+						output = `\\${value}`;
+					}
+					push({
+						type: "text",
+						value,
+						output
+					});
+					continue;
+				}
+				if (opts.dot !== true && (prev.type === "slash" || prev.type === "bos")) {
+					push({
+						type: "qmark",
+						value,
+						output: QMARK_NO_DOT$1
+					});
+					continue;
+				}
+				push({
+					type: "qmark",
+					value,
+					output: QMARK$1
+				});
+				continue;
+			}
+			/**
+			* Exclamation
+			*/
+			if (value === "!") {
+				if (opts.noextglob !== true && peek() === "(") {
+					if (peek(2) !== "?" || !/[!=<:]/.test(peek(3))) {
+						extglobOpen("negate", value);
+						continue;
+					}
+				}
+				if (opts.nonegate !== true && state.index === 0) {
+					negate();
+					continue;
+				}
+			}
+			/**
+			* Plus
+			*/
+			if (value === "+") {
+				if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+					extglobOpen("plus", value);
+					continue;
+				}
+				if (prev && prev.value === "(" || opts.regex === false) {
+					push({
+						type: "plus",
+						value,
+						output: PLUS_LITERAL$1
+					});
+					continue;
+				}
+				if (prev && (prev.type === "bracket" || prev.type === "paren" || prev.type === "brace") || state.parens > 0) {
+					push({
+						type: "plus",
+						value
+					});
+					continue;
+				}
+				push({
+					type: "plus",
+					value: PLUS_LITERAL$1
+				});
+				continue;
+			}
+			/**
+			* Plain text
+			*/
+			if (value === "@") {
+				if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+					push({
+						type: "at",
+						extglob: true,
+						value,
+						output: ""
+					});
+					continue;
+				}
+				push({
+					type: "text",
+					value
+				});
+				continue;
+			}
+			/**
+			* Plain text
+			*/
+			if (value !== "*") {
+				if (value === "$" || value === "^") {
+					value = `\\${value}`;
+				}
+				const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+				if (match) {
+					value += match[0];
+					state.index += match[0].length;
+				}
+				push({
+					type: "text",
+					value
+				});
+				continue;
+			}
+			/**
+			* Stars
+			*/
+			if (prev && (prev.type === "globstar" || prev.star === true)) {
+				prev.type = "star";
+				prev.star = true;
+				prev.value += value;
+				prev.output = star;
+				state.backtrack = true;
+				state.globstar = true;
+				consume(value);
+				continue;
+			}
+			let rest = remaining();
+			if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
+				extglobOpen("star", value);
+				continue;
+			}
+			if (prev.type === "star") {
+				if (opts.noglobstar === true) {
+					consume(value);
+					continue;
+				}
+				const prior = prev.prev;
+				const before = prior.prev;
+				const isStart = prior.type === "slash" || prior.type === "bos";
+				const afterStar = before && (before.type === "star" || before.type === "globstar");
+				if (opts.bash === true && (!isStart || rest[0] && rest[0] !== "/")) {
+					push({
+						type: "star",
+						value,
+						output: ""
+					});
+					continue;
+				}
+				const isBrace = state.braces > 0 && (prior.type === "comma" || prior.type === "brace");
+				const isExtglob = extglobs.length && (prior.type === "pipe" || prior.type === "paren");
+				if (!isStart && prior.type !== "paren" && !isBrace && !isExtglob) {
+					push({
+						type: "star",
+						value,
+						output: ""
+					});
+					continue;
+				}
+				while (rest.slice(0, 3) === "/**") {
+					const after = input[state.index + 4];
+					if (after && after !== "/") {
+						break;
+					}
+					rest = rest.slice(3);
+					consume("/**", 3);
+				}
+				if (prior.type === "bos" && eos()) {
+					prev.type = "globstar";
+					prev.value += value;
+					prev.output = globstar(opts);
+					state.output = prev.output;
+					state.globstar = true;
+					consume(value);
+					continue;
+				}
+				if (prior.type === "slash" && prior.prev.type !== "bos" && !afterStar && eos()) {
+					state.output = state.output.slice(0, -(prior.output + prev.output).length);
+					prior.output = `(?:${prior.output}`;
+					prev.type = "globstar";
+					prev.output = globstar(opts) + (opts.strictSlashes ? ")" : "|$)");
+					prev.value += value;
+					state.globstar = true;
+					state.output += prior.output + prev.output;
+					consume(value);
+					continue;
+				}
+				if (prior.type === "slash" && prior.prev.type !== "bos" && rest[0] === "/") {
+					const end = rest[1] !== void 0 ? "|$" : "";
+					state.output = state.output.slice(0, -(prior.output + prev.output).length);
+					prior.output = `(?:${prior.output}`;
+					prev.type = "globstar";
+					prev.output = `${globstar(opts)}${SLASH_LITERAL$1}|${SLASH_LITERAL$1}${end})`;
+					prev.value += value;
+					state.output += prior.output + prev.output;
+					state.globstar = true;
+					consume(value + advance());
+					push({
+						type: "slash",
+						value: "/",
+						output: ""
+					});
+					continue;
+				}
+				if (prior.type === "bos" && rest[0] === "/") {
+					prev.type = "globstar";
+					prev.value += value;
+					prev.output = `(?:^|${SLASH_LITERAL$1}|${globstar(opts)}${SLASH_LITERAL$1})`;
+					state.output = prev.output;
+					state.globstar = true;
+					consume(value + advance());
+					push({
+						type: "slash",
+						value: "/",
+						output: ""
+					});
+					continue;
+				}
+				state.output = state.output.slice(0, -prev.output.length);
+				prev.type = "globstar";
+				prev.output = globstar(opts);
+				prev.value += value;
+				state.output += prev.output;
+				state.globstar = true;
+				consume(value);
+				continue;
+			}
+			const token = {
+				type: "star",
+				value,
+				output: star
+			};
+			if (opts.bash === true) {
+				token.output = ".*?";
+				if (prev.type === "bos" || prev.type === "slash") {
+					token.output = nodot + token.output;
+				}
+				push(token);
+				continue;
+			}
+			if (prev && (prev.type === "bracket" || prev.type === "paren") && opts.regex === true) {
+				token.output = value;
+				push(token);
+				continue;
+			}
+			if (state.index === state.start || prev.type === "slash" || prev.type === "dot") {
+				if (prev.type === "dot") {
+					state.output += NO_DOT_SLASH$1;
+					prev.output += NO_DOT_SLASH$1;
+				} else if (opts.dot === true) {
+					state.output += NO_DOTS_SLASH$1;
+					prev.output += NO_DOTS_SLASH$1;
+				} else {
+					state.output += nodot;
+					prev.output += nodot;
+				}
+				if (peek() !== "*") {
+					state.output += ONE_CHAR$1;
+					prev.output += ONE_CHAR$1;
+				}
+			}
+			push(token);
+		}
+		while (state.brackets > 0) {
+			if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
+			state.output = utils$2.escapeLast(state.output, "[");
+			decrement("brackets");
+		}
+		while (state.parens > 0) {
+			if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", ")"));
+			state.output = utils$2.escapeLast(state.output, "(");
+			decrement("parens");
+		}
+		while (state.braces > 0) {
+			if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "}"));
+			state.output = utils$2.escapeLast(state.output, "{");
+			decrement("braces");
+		}
+		if (opts.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) {
+			push({
+				type: "maybe_slash",
+				value: "",
+				output: `${SLASH_LITERAL$1}?`
+			});
+		}
+		if (state.backtrack === true) {
+			state.output = "";
+			for (const token of state.tokens) {
+				state.output += token.output != null ? token.output : token.value;
+				if (token.suffix) {
+					state.output += token.suffix;
+				}
+			}
+		}
+		return state;
+	};
+	/**
+	* Fast paths for creating regular expressions for common glob patterns.
+	* This can significantly speed up processing and has very little downside
+	* impact when none of the fast paths match.
+	*/
+	parse$1.fastpaths = (input, options) => {
+		const opts = { ...options };
+		const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+		const len = input.length;
+		if (len > max) {
+			throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+		}
+		input = REPLACEMENTS[input] || input;
+		const { DOT_LITERAL: DOT_LITERAL$1, SLASH_LITERAL: SLASH_LITERAL$1, ONE_CHAR: ONE_CHAR$1, DOTS_SLASH: DOTS_SLASH$1, NO_DOT: NO_DOT$1, NO_DOTS: NO_DOTS$1, NO_DOTS_SLASH: NO_DOTS_SLASH$1, STAR: STAR$1, START_ANCHOR: START_ANCHOR$1 } = constants$1.globChars(opts.windows);
+		const nodot = opts.dot ? NO_DOTS$1 : NO_DOT$1;
+		const slashDot = opts.dot ? NO_DOTS_SLASH$1 : NO_DOT$1;
+		const capture = opts.capture ? "" : "?:";
+		const state = {
+			negated: false,
+			prefix: ""
+		};
+		let star = opts.bash === true ? ".*?" : STAR$1;
+		if (opts.capture) {
+			star = `(${star})`;
+		}
+		const globstar = (opts$1) => {
+			if (opts$1.noglobstar === true) return star;
+			return `(${capture}(?:(?!${START_ANCHOR$1}${opts$1.dot ? DOTS_SLASH$1 : DOT_LITERAL$1}).)*?)`;
+		};
+		const create = (str) => {
+			switch (str) {
+				case "*": return `${nodot}${ONE_CHAR$1}${star}`;
+				case ".*": return `${DOT_LITERAL$1}${ONE_CHAR$1}${star}`;
+				case "*.*": return `${nodot}${star}${DOT_LITERAL$1}${ONE_CHAR$1}${star}`;
+				case "*/*": return `${nodot}${star}${SLASH_LITERAL$1}${ONE_CHAR$1}${slashDot}${star}`;
+				case "**": return nodot + globstar(opts);
+				case "**/*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL$1})?${slashDot}${ONE_CHAR$1}${star}`;
+				case "**/*.*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL$1})?${slashDot}${star}${DOT_LITERAL$1}${ONE_CHAR$1}${star}`;
+				case "**/.*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL$1})?${DOT_LITERAL$1}${ONE_CHAR$1}${star}`;
+				default: {
+					const match = /^(.*?)\.(\w+)$/.exec(str);
+					if (!match) return;
+					const source$1 = create(match[1]);
+					if (!source$1) return;
+					return source$1 + DOT_LITERAL$1 + match[2];
+				}
+			}
+		};
+		const output = utils$2.removePrefix(input, state);
+		let source = create(output);
+		if (source && opts.strictSlashes !== true) {
+			source += `${SLASH_LITERAL$1}?`;
+		}
+		return source;
+	};
+	module.exports = parse$1;
+}));
+
+//#endregion
+//#region node_modules/picomatch/lib/picomatch.js
+var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const scan = require_scan();
+	const parse = require_parse();
+	const utils$1 = require_utils();
+	const constants = require_constants();
+	const isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
+	/**
+	* Creates a matcher function from one or more glob patterns. The
+	* returned function takes a string to match as its first argument,
+	* and returns true if the string is a match. The returned matcher
+	* function also takes a boolean as the second argument that, when true,
+	* returns an object with additional information.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* // picomatch(glob[, options]);
+	*
+	* const isMatch = picomatch('*.!(*a)');
+	* console.log(isMatch('a.a')); //=> false
+	* console.log(isMatch('a.b')); //=> true
+	* ```
+	* @name picomatch
+	* @param {String|Array} `globs` One or more glob patterns.
+	* @param {Object=} `options`
+	* @return {Function=} Returns a matcher function.
+	* @api public
+	*/
+	const picomatch$2 = (glob, options, returnState = false) => {
+		if (Array.isArray(glob)) {
+			const fns = glob.map((input) => picomatch$2(input, options, returnState));
+			const arrayMatcher = (str) => {
+				for (const isMatch of fns) {
+					const state$1 = isMatch(str);
+					if (state$1) return state$1;
+				}
+				return false;
+			};
+			return arrayMatcher;
+		}
+		const isState = isObject(glob) && glob.tokens && glob.input;
+		if (glob === "" || typeof glob !== "string" && !isState) {
+			throw new TypeError("Expected pattern to be a non-empty string");
+		}
+		const opts = options || {};
+		const posix = opts.windows;
+		const regex = isState ? picomatch$2.compileRe(glob, options) : picomatch$2.makeRe(glob, options, false, true);
+		const state = regex.state;
+		delete regex.state;
+		let isIgnored = () => false;
+		if (opts.ignore) {
+			const ignoreOpts = {
+				...options,
+				ignore: null,
+				onMatch: null,
+				onResult: null
+			};
+			isIgnored = picomatch$2(opts.ignore, ignoreOpts, returnState);
+		}
+		const matcher = (input, returnObject = false) => {
+			const { isMatch, match, output } = picomatch$2.test(input, regex, options, {
+				glob,
+				posix
+			});
+			const result = {
+				glob,
+				state,
+				regex,
+				posix,
+				input,
+				output,
+				match,
+				isMatch
+			};
+			if (typeof opts.onResult === "function") {
+				opts.onResult(result);
+			}
+			if (isMatch === false) {
+				result.isMatch = false;
+				return returnObject ? result : false;
+			}
+			if (isIgnored(input)) {
+				if (typeof opts.onIgnore === "function") {
+					opts.onIgnore(result);
+				}
+				result.isMatch = false;
+				return returnObject ? result : false;
+			}
+			if (typeof opts.onMatch === "function") {
+				opts.onMatch(result);
+			}
+			return returnObject ? result : true;
+		};
+		if (returnState) {
+			matcher.state = state;
+		}
+		return matcher;
+	};
+	/**
+	* Test `input` with the given `regex`. This is used by the main
+	* `picomatch()` function to test the input string.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* // picomatch.test(input, regex[, options]);
+	*
+	* console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
+	* // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
+	* ```
+	* @param {String} `input` String to test.
+	* @param {RegExp} `regex`
+	* @return {Object} Returns an object with matching info.
+	* @api public
+	*/
+	picomatch$2.test = (input, regex, options, { glob, posix } = {}) => {
+		if (typeof input !== "string") {
+			throw new TypeError("Expected input to be a string");
+		}
+		if (input === "") {
+			return {
+				isMatch: false,
+				output: ""
+			};
+		}
+		const opts = options || {};
+		const format = opts.format || (posix ? utils$1.toPosixSlashes : null);
+		let match = input === glob;
+		let output = match && format ? format(input) : input;
+		if (match === false) {
+			output = format ? format(input) : input;
+			match = output === glob;
+		}
+		if (match === false || opts.capture === true) {
+			if (opts.matchBase === true || opts.basename === true) {
+				match = picomatch$2.matchBase(input, regex, options, posix);
+			} else {
+				match = regex.exec(output);
+			}
+		}
+		return {
+			isMatch: Boolean(match),
+			match,
+			output
+		};
+	};
+	/**
+	* Match the basename of a filepath.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* // picomatch.matchBase(input, glob[, options]);
+	* console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
+	* ```
+	* @param {String} `input` String to test.
+	* @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).
+	* @return {Boolean}
+	* @api public
+	*/
+	picomatch$2.matchBase = (input, glob, options) => {
+		const regex = glob instanceof RegExp ? glob : picomatch$2.makeRe(glob, options);
+		return regex.test(utils$1.basename(input));
+	};
+	/**
+	* Returns true if **any** of the given glob `patterns` match the specified `string`.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* // picomatch.isMatch(string, patterns[, options]);
+	*
+	* console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
+	* console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
+	* ```
+	* @param {String|Array} str The string to test.
+	* @param {String|Array} patterns One or more glob patterns to use for matching.
+	* @param {Object} [options] See available [options](#options).
+	* @return {Boolean} Returns true if any patterns match `str`
+	* @api public
+	*/
+	picomatch$2.isMatch = (str, patterns, options) => picomatch$2(patterns, options)(str);
+	/**
+	* Parse a glob pattern to create the source string for a regular
+	* expression.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* const result = picomatch.parse(pattern[, options]);
+	* ```
+	* @param {String} `pattern`
+	* @param {Object} `options`
+	* @return {Object} Returns an object with useful properties and output to be used as a regex source string.
+	* @api public
+	*/
+	picomatch$2.parse = (pattern, options) => {
+		if (Array.isArray(pattern)) return pattern.map((p) => picomatch$2.parse(p, options));
+		return parse(pattern, {
+			...options,
+			fastpaths: false
+		});
+	};
+	/**
+	* Scan a glob pattern to separate the pattern into segments.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* // picomatch.scan(input[, options]);
+	*
+	* const result = picomatch.scan('!./foo/*.js');
+	* console.log(result);
+	* { prefix: '!./',
+	*   input: '!./foo/*.js',
+	*   start: 3,
+	*   base: 'foo',
+	*   glob: '*.js',
+	*   isBrace: false,
+	*   isBracket: false,
+	*   isGlob: true,
+	*   isExtglob: false,
+	*   isGlobstar: false,
+	*   negated: true }
+	* ```
+	* @param {String} `input` Glob pattern to scan.
+	* @param {Object} `options`
+	* @return {Object} Returns an object with
+	* @api public
+	*/
+	picomatch$2.scan = (input, options) => scan(input, options);
+	/**
+	* Compile a regular expression from the `state` object returned by the
+	* [parse()](#parse) method.
+	*
+	* @param {Object} `state`
+	* @param {Object} `options`
+	* @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.
+	* @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
+	* @return {RegExp}
+	* @api public
+	*/
+	picomatch$2.compileRe = (state, options, returnOutput = false, returnState = false) => {
+		if (returnOutput === true) {
+			return state.output;
+		}
+		const opts = options || {};
+		const prepend = opts.contains ? "" : "^";
+		const append = opts.contains ? "" : "$";
+		let source = `${prepend}(?:${state.output})${append}`;
+		if (state && state.negated === true) {
+			source = `^(?!${source}).*$`;
+		}
+		const regex = picomatch$2.toRegex(source, options);
+		if (returnState === true) {
+			regex.state = state;
+		}
+		return regex;
+	};
+	/**
+	* Create a regular expression from a parsed glob pattern.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* const state = picomatch.parse('*.js');
+	* // picomatch.compileRe(state[, options]);
+	*
+	* console.log(picomatch.compileRe(state));
+	* //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+	* ```
+	* @param {String} `state` The object returned from the `.parse` method.
+	* @param {Object} `options`
+	* @param {Boolean} `returnOutput` Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.
+	* @param {Boolean} `returnState` Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
+	* @return {RegExp} Returns a regex created from the given pattern.
+	* @api public
+	*/
+	picomatch$2.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+		if (!input || typeof input !== "string") {
+			throw new TypeError("Expected a non-empty string");
+		}
+		let parsed = {
+			negated: false,
+			fastpaths: true
+		};
+		if (options.fastpaths !== false && (input[0] === "." || input[0] === "*")) {
+			parsed.output = parse.fastpaths(input, options);
+		}
+		if (!parsed.output) {
+			parsed = parse(input, options);
+		}
+		return picomatch$2.compileRe(parsed, options, returnOutput, returnState);
+	};
+	/**
+	* Create a regular expression from the given regex source string.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* // picomatch.toRegex(source[, options]);
+	*
+	* const { output } = picomatch.parse('*.js');
+	* console.log(picomatch.toRegex(output));
+	* //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+	* ```
+	* @param {String} `source` Regular expression source string.
+	* @param {Object} `options`
+	* @return {RegExp}
+	* @api public
+	*/
+	picomatch$2.toRegex = (source, options) => {
+		try {
+			const opts = options || {};
+			return new RegExp(source, opts.flags || (opts.nocase ? "i" : ""));
+		} catch (err$1) {
+			if (options && options.debug === true) throw err$1;
+			return /$^/;
+		}
+	};
+	/**
+	* Picomatch constants.
+	* @return {Object}
+	*/
+	picomatch$2.constants = constants;
+	/**
+	* Expose "picomatch"
+	*/
+	module.exports = picomatch$2;
+}));
+
+//#endregion
+//#region node_modules/picomatch/index.js
+var require_picomatch = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const pico = require_picomatch$1();
+	const utils = require_utils();
+	function picomatch$1(glob, options, returnState = false) {
+		if (options && (options.windows === null || options.windows === undefined)) {
+			options = {
+				...options,
+				windows: utils.isWindows()
+			};
+		}
+		return pico(glob, options, returnState);
+	}
+	Object.assign(picomatch$1, pico);
+	module.exports = picomatch$1;
+}));
+
 //#endregion
 //#region packages/builder/src/utils/glob.ts
 /**
@@ -3763,6 +5646,7 @@ const scanGlob = (patterns, cwd = process.cwd()) => {
 
 //#endregion
 //#region packages/builder/src/discovery/entry-paths.ts
+var import_picomatch = /* @__PURE__ */ __toESM(require_picomatch(), 1);
 /**
 * Resolve entry file paths from glob patterns or direct paths.
 * Used by the discovery system to find entry points for module traversal.
@@ -3770,8 +5654,9 @@ const scanGlob = (patterns, cwd = process.cwd()) => {
 * Uses Node.js normalize() + backslash replacement to match normalizePath from @soda-gql/common.
 *
 * @param entries - Include patterns (glob or direct paths). Supports negation patterns (e.g., "!./path/to/exclude.ts")
+* @param exclude - Exclude patterns from config.exclude. Converted to negation globs for filtering.
 */
-const resolveEntryPaths = (entries) => {
+const resolveEntryPaths = (entries, exclude = []) => {
 	const directPaths = [];
 	const globPatterns = [];
 	for (const entry of entries) {
@@ -3786,6 +5671,19 @@ const resolveEntryPaths = (entries) => {
 			globPatterns.push(entry);
 		}
 	}
+	if (exclude.length > 0 && directPaths.length > 0) {
+		const excludePatterns = exclude.map((p) => {
+			const raw = p.startsWith("!") ? p.slice(1) : p;
+			return normalize(resolve(raw)).replace(/\\/g, "/");
+		});
+		const isExcluded = (0, import_picomatch.default)(excludePatterns);
+		const filtered = directPaths.filter((p) => !isExcluded(p));
+		directPaths.length = 0;
+		directPaths.push(...filtered);
+	}
+	for (const pattern of exclude) {
+		globPatterns.push(pattern.startsWith("!") ? pattern : `!${pattern}`);
+	}
 	const globMatches = globPatterns.length > 0 ? scanGlob(globPatterns, process.cwd()).map((match) => {
 		return normalize(resolve(match)).replace(/\\/g, "/");
 	}) : [];
@@ -3812,7 +5710,7 @@ const resolveEntryPaths = (entries) => {
 const createFileTracker = () => {
 	let currentScan = { files: new Map() };
 	let nextScan = null;
-	const scan = (extraPaths) => {
+	const scan$2 = (extraPaths) => {
 		const allPathsToScan = new Set([...extraPaths, ...currentScan.files.keys()]);
 		const files = new Map();
 		for (const path of allPathsToScan) {
@@ -3853,12 +5751,12 @@ const createFileTracker = () => {
 			removed
 		};
 	};
-	const update = (scan$1) => {
-		currentScan = scan$1;
+	const update = (scan$3) => {
+		currentScan = scan$3;
 		nextScan = null;
 	};
 	return {
-		scan,
+		scan: scan$2,
 		detectChanges,
 		update
 	};
@@ -4062,7 +5960,7 @@ const createBuilderSession = (options) => {
 	* Returns either a skip result or the input for buildGen.
 	*/
 	const prepareBuildInput = (force) => {
-		const entryPathsResult = resolveEntryPaths(Array.from(entrypoints));
+		const entryPathsResult = resolveEntryPaths(Array.from(entrypoints), config.exclude);
 		if (entryPathsResult.isErr()) {
 			return err(entryPathsResult.error);
 		}
@@ -4341,4 +6239,4 @@ const createBuilderService = ({ config, entrypointsOverride }) => {
 
 //#endregion
 export { getSeverity as _, createGraphqlSystemIdentifyHelper as a, BuilderArtifactSchema as b, BuilderEffects as c, formatBuilderErrorForCLI as d, formatBuilderErrorStructured as f, diagnosticMessages as g, createStandardDiagnostic as h, extractModuleAdjacency as i, FileReadEffect as l, createDiagnostic as m, createBuilderSession as n, __clearGqlCache as o, builderErrors as p, collectAffectedFiles as r, executeSandbox as s, createBuilderService as t, FileStatEffect as u, loadArtifact as v, loadArtifactSync as y };
-//# sourceMappingURL=service-B381lWB2.mjs.map
+//# sourceMappingURL=service-CqUHXFUE.mjs.map