@promptscript/cli 1.0.0-alpha.6 → 1.0.0-alpha.8

package/index.js

@@ -1,7 +1,7 @@
 // packages/cli/src/cli.ts
 import { Command } from "commander";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname7 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { dirname as dirname9 } from "path";
 
 // packages/core/src/types/constants.ts
 var BLOCK_TYPES = [
@@ -306,7 +306,7 @@ var noopLogger = {
 
 // packages/cli/src/commands/init.ts
 import { fileURLToPath } from "url";
-import { dirname as dirname2 } from "path";
+import { dirname as dirname3 } from "path";
 
 // packages/cli/src/services.ts
 import { writeFile, mkdir, readFile, readdir } from "fs/promises";
@@ -1366,9 +1366,410 @@ Before completing migration:
 - No duplicate content across blocks
 `;
 
+// packages/cli/src/utils/manifest-loader.ts
+import { join as join3, dirname as dirname2 } from "path";
+import { parse as parseYaml2 } from "yaml";
+var OFFICIAL_REGISTRY = {
+  name: "PromptScript Official Registry",
+  url: "https://github.com/mrwogu/promptscript-registry.git",
+  branch: "main",
+  manifestUrl: "https://raw.githubusercontent.com/mrwogu/promptscript-registry/main/registry-manifest.yaml"
+};
+var ManifestLoadError = class extends Error {
+  originalCause;
+  constructor(message, cause) {
+    super(message);
+    this.name = "ManifestLoadError";
+    this.originalCause = cause;
+  }
+};
+var manifestCache = /* @__PURE__ */ new Map();
+var MANIFEST_FILENAME = "registry-manifest.yaml";
+async function loadManifest(options = {}, services = createDefaultServices()) {
+  const { registryPath = findDefaultRegistryPath(services), useCache = true } = options;
+  const manifestPath = resolveManifestPath(registryPath, services);
+  if (useCache && manifestCache.has(manifestPath)) {
+    return {
+      manifest: manifestCache.get(manifestPath),
+      path: manifestPath,
+      cached: true
+    };
+  }
+  const manifest = await loadManifestFromPath(manifestPath, services);
+  validateManifest(manifest);
+  if (useCache) {
+    manifestCache.set(manifestPath, manifest);
+  }
+  return {
+    manifest,
+    path: manifestPath,
+    cached: false
+  };
+}
+function findDefaultRegistryPath(services) {
+  const candidates = ["./registry", "../promptscript-registry", "./.promptscript-registry"];
+  for (const candidate of candidates) {
+    const manifestPath = join3(services.cwd, candidate, MANIFEST_FILENAME);
+    if (services.fs.existsSync(manifestPath)) {
+      return candidate;
+    }
+  }
+  return "./registry";
+}
+function resolveManifestPath(registryPath, services) {
+  if (registryPath.endsWith(".yaml") || registryPath.endsWith(".yml")) {
+    return join3(services.cwd, registryPath);
+  }
+  return join3(services.cwd, registryPath, MANIFEST_FILENAME);
+}
+async function loadManifestFromPath(manifestPath, services) {
+  if (!services.fs.existsSync(manifestPath)) {
+    throw new ManifestLoadError(
+      `Registry manifest not found at: ${manifestPath}
+Run \`prs pull\` to fetch the registry or check your registry configuration.`
+    );
+  }
+  try {
+    const content = await services.fs.readFile(manifestPath, "utf-8");
+    const manifest = parseYaml2(content);
+    return manifest;
+  } catch (error) {
+    throw new ManifestLoadError(
+      `Failed to parse manifest: ${manifestPath}`,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+function validateManifest(manifest) {
+  if (!manifest.version) {
+    throw new ManifestLoadError("Manifest missing required field: version");
+  }
+  if (manifest.version !== "1") {
+    throw new ManifestLoadError(`Unsupported manifest version: ${manifest.version}`);
+  }
+  if (!manifest.meta) {
+    throw new ManifestLoadError("Manifest missing required field: meta");
+  }
+  if (!manifest.catalog) {
+    throw new ManifestLoadError("Manifest missing required field: catalog");
+  }
+  if (!Array.isArray(manifest.catalog)) {
+    throw new ManifestLoadError("Manifest catalog must be an array");
+  }
+}
+async function loadManifestFromUrl(url = OFFICIAL_REGISTRY.manifestUrl, useCache = true) {
+  if (useCache && manifestCache.has(url)) {
+    return {
+      manifest: manifestCache.get(url),
+      url,
+      cached: true
+    };
+  }
+  try {
+    const response = await fetch(url, {
+      headers: {
+        Accept: "application/x-yaml, text/yaml, text/plain",
+        "User-Agent": "PromptScript-CLI"
+      }
+    });
+    if (!response.ok) {
+      throw new ManifestLoadError(
+        `Failed to fetch manifest from ${url}: ${response.status} ${response.statusText}`
+      );
+    }
+    const content = await response.text();
+    const manifest = parseYaml2(content);
+    validateManifest(manifest);
+    if (useCache) {
+      manifestCache.set(url, manifest);
+    }
+    return {
+      manifest,
+      url,
+      cached: false
+    };
+  } catch (error) {
+    if (error instanceof ManifestLoadError) {
+      throw error;
+    }
+    throw new ManifestLoadError(
+      `Failed to load manifest from ${url}`,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+function isValidGitUrl(url, allowedHosts) {
+  try {
+    if (url.startsWith("git@")) {
+      const hostMatch = url.match(/^git@([^:]+):/);
+      if (hostMatch && hostMatch[1]) {
+        const host = hostMatch[1];
+        return allowedHosts ? allowedHosts.includes(host) : true;
+      }
+      return false;
+    }
+    if (!url.startsWith("https://") && !url.startsWith("http://")) {
+      return false;
+    }
+    const parsed = new URL(url);
+    if (!parsed.hostname || parsed.hostname.length === 0) {
+      return false;
+    }
+    if (allowedHosts) {
+      return allowedHosts.includes(parsed.hostname);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// packages/cli/src/utils/suggestion-engine.ts
+async function buildProjectContext(projectInfo, services = createDefaultServices()) {
+  const files = await detectProjectFiles(services);
+  const dependencies = await detectDependencies(services);
+  return {
+    files,
+    dependencies,
+    languages: projectInfo.languages,
+    frameworks: projectInfo.frameworks
+  };
+}
+async function detectProjectFiles(services) {
+  const relevantFiles = [
+    "package.json",
+    "tsconfig.json",
+    "pyproject.toml",
+    "requirements.txt",
+    "Cargo.toml",
+    "go.mod",
+    "pom.xml",
+    "build.gradle",
+    ".git",
+    ".env",
+    ".env.example",
+    "jest.config.js",
+    "vitest.config.ts",
+    "vitest.config.js",
+    "pytest.ini",
+    "next.config.js",
+    "next.config.mjs",
+    "next.config.ts",
+    "nuxt.config.js",
+    "nuxt.config.ts",
+    "vite.config.js",
+    "vite.config.ts",
+    "Dockerfile",
+    "docker-compose.yml"
+  ];
+  const existingFiles = [];
+  for (const file of relevantFiles) {
+    if (services.fs.existsSync(file)) {
+      existingFiles.push(file);
+    }
+  }
+  return existingFiles;
+}
+async function detectDependencies(services) {
+  if (!services.fs.existsSync("package.json")) {
+    return [];
+  }
+  try {
+    const content = await services.fs.readFile("package.json", "utf-8");
+    const pkg = JSON.parse(content);
+    return [...Object.keys(pkg.dependencies ?? {}), ...Object.keys(pkg.devDependencies ?? {})];
+  } catch {
+    return [];
+  }
+}
+function calculateSuggestions(manifest, context) {
+  const result = {
+    inherit: void 0,
+    use: [],
+    skills: [],
+    reasoning: []
+  };
+  const suggestedUse = /* @__PURE__ */ new Set();
+  const suggestedSkills = /* @__PURE__ */ new Set();
+  for (const rule of manifest.suggestionRules) {
+    const match = matchCondition(rule.condition, context);
+    if (match.matches) {
+      if (rule.suggest.inherit) {
+        if (!result.inherit) {
+          result.inherit = rule.suggest.inherit;
+          result.reasoning.push({
+            suggestion: `inherit: ${rule.suggest.inherit}`,
+            reason: match.reason,
+            trigger: match.trigger,
+            matchedValue: match.matchedValue
+          });
+        }
+      }
+      if (rule.suggest.use) {
+        for (const useItem of rule.suggest.use) {
+          if (!suggestedUse.has(useItem)) {
+            suggestedUse.add(useItem);
+            result.use.push(useItem);
+            result.reasoning.push({
+              suggestion: `use: ${useItem}`,
+              reason: match.reason,
+              trigger: match.trigger,
+              matchedValue: match.matchedValue
+            });
+          }
+        }
+      }
+      if (rule.suggest.skills) {
+        for (const skill of rule.suggest.skills) {
+          if (!suggestedSkills.has(skill)) {
+            suggestedSkills.add(skill);
+            result.skills.push(skill);
+            result.reasoning.push({
+              suggestion: `skill: ${skill}`,
+              reason: match.reason,
+              trigger: match.trigger,
+              matchedValue: match.matchedValue
+            });
+          }
+        }
+      }
+    }
+  }
+  return result;
+}
+function matchCondition(condition, context) {
+  if (condition.always) {
+    return {
+      matches: true,
+      reason: "Default recommendation",
+      trigger: "always"
+    };
+  }
+  if (condition.files) {
+    for (const file of condition.files) {
+      if (context.files.includes(file)) {
+        return {
+          matches: true,
+          reason: `Detected file: ${file}`,
+          trigger: "file",
+          matchedValue: file
+        };
+      }
+    }
+  }
+  if (condition.dependencies) {
+    for (const dep of condition.dependencies) {
+      if (context.dependencies.includes(dep)) {
+        return {
+          matches: true,
+          reason: `Detected dependency: ${dep}`,
+          trigger: "dependency",
+          matchedValue: dep
+        };
+      }
+    }
+  }
+  if (condition.languages) {
+    for (const lang of condition.languages) {
+      if (context.languages.includes(lang)) {
+        return {
+          matches: true,
+          reason: `Detected language: ${lang}`,
+          trigger: "language",
+          matchedValue: lang
+        };
+      }
+    }
+  }
+  if (condition.frameworks) {
+    for (const framework of condition.frameworks) {
+      if (context.frameworks.includes(framework)) {
+        return {
+          matches: true,
+          reason: `Detected framework: ${framework}`,
+          trigger: "framework",
+          matchedValue: framework
+        };
+      }
+    }
+  }
+  return {
+    matches: false,
+    reason: "",
+    trigger: "always"
+  };
+}
+function formatSuggestionResult(result) {
+  const lines = [];
+  if (result.inherit) {
+    lines.push(`\u{1F4E6} Inherit: ${result.inherit}`);
+  }
+  if (result.use.length > 0) {
+    lines.push(`\u{1F527} Use: ${result.use.join(", ")}`);
+  }
+  if (result.skills.length > 0) {
+    lines.push(`\u26A1 Skills: ${result.skills.join(", ")}`);
+  }
+  if (result.reasoning.length > 0) {
+    lines.push("");
+    lines.push("Reasoning:");
+    for (const r of result.reasoning) {
+      lines.push(`  \u2022 ${r.suggestion} (${r.reason})`);
+    }
+  }
+  return lines;
+}
+function createSuggestionChoices(manifest, result) {
+  const choices = [];
+  if (result.inherit) {
+    const entry = manifest.catalog.find((e) => e.id === result.inherit);
+    choices.push({
+      name: `${result.inherit} (inherit)`,
+      value: `inherit:${result.inherit}`,
+      checked: true,
+      description: entry?.description
+    });
+  }
+  for (const use of result.use) {
+    const entry = manifest.catalog.find((e) => e.id === use);
+    choices.push({
+      name: `${use} (use)`,
+      value: `use:${use}`,
+      checked: true,
+      description: entry?.description
+    });
+  }
+  for (const skill of result.skills) {
+    const entry = manifest.catalog.find((e) => e.id === skill);
+    choices.push({
+      name: `${skill} (skill)`,
+      value: `skill:${skill}`,
+      checked: true,
+      description: entry?.description
+    });
+  }
+  return choices;
+}
+function parseSelectedChoices(selected) {
+  const result = {
+    use: [],
+    skills: []
+  };
+  for (const choice of selected) {
+    if (choice.startsWith("inherit:")) {
+      result.inherit = choice.slice("inherit:".length);
+    } else if (choice.startsWith("use:")) {
+      result.use.push(choice.slice("use:".length));
+    } else if (choice.startsWith("skill:")) {
+      result.skills.push(choice.slice("skill:".length));
+    }
+  }
+  return result;
+}
+
 // packages/cli/src/commands/init.ts
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname2(__filename);
+var __dirname = dirname3(__filename);
 async function initCommand(options, services = createDefaultServices()) {
   const { fs: fs4 } = services;
   if (fs4.existsSync("promptscript.yaml") && !options.force) {
@@ -1380,11 +1781,22 @@ async function initCommand(options, services = createDefaultServices()) {
     const projectInfo = await detectProject(services);
     const aiToolsDetection = await detectAITools(services);
     const prettierConfigPath = findPrettierConfig(process.cwd());
+    let manifest;
+    try {
+      const registryPath = options.registry ?? "./registry";
+      const { manifest: loadedManifest } = await loadManifest({ registryPath }, services);
+      manifest = loadedManifest;
+    } catch (error) {
+      if (!(error instanceof ManifestLoadError)) {
+        throw error;
+      }
+    }
     const config = await resolveConfig(
       options,
       projectInfo,
       aiToolsDetection,
       prettierConfigPath,
+      manifest,
       services
     );
     const spinner = createSpinner("Creating PromptScript configuration...").start();
@@ -1440,7 +1852,14 @@ async function initCommand(options, services = createDefaultServices()) {
       ConsoleOutput.muted(`  Inherit: ${config.inherit}`);
     }
     if (config.registry) {
-      ConsoleOutput.muted(`  Registry: ${config.registry}`);
+      if (config.registry.type === "git") {
+        ConsoleOutput.muted(`  Registry: ${config.registry.url} (${config.registry.ref})`);
+      } else {
+        ConsoleOutput.muted(`  Registry: ${config.registry.path} (local)`);
+      }
+    }
+    if (config.use && config.use.length > 0) {
+      ConsoleOutput.muted(`  Use: ${config.use.join(", ")}`);
     }
     ConsoleOutput.newline();
     if (config.prettierConfigPath) {
@@ -1494,23 +1913,46 @@ async function initCommand(options, services = createDefaultServices()) {
     process.exit(1);
   }
 }
-async function resolveConfig(options, projectInfo, aiToolsDetection, prettierConfigPath, services) {
+async function resolveConfig(options, projectInfo, aiToolsDetection, prettierConfigPath, manifest, services) {
   if (options.yes) {
+    let inherit = options.inherit;
+    let use;
+    let activeManifest = manifest;
+    if (!activeManifest) {
+      try {
+        const { manifest: remoteManifest } = await loadManifestFromUrl();
+        activeManifest = remoteManifest;
+      } catch {
+      }
+    }
+    if (activeManifest) {
+      const context = await buildProjectContext(projectInfo, services);
+      const suggestions = calculateSuggestions(activeManifest, context);
+      if (!inherit && suggestions.inherit) {
+        inherit = suggestions.inherit;
+      }
+      if (suggestions.use.length > 0) {
+        use = suggestions.use;
+      }
+    }
+    const registry = options.registry ? { type: "local", path: options.registry } : { type: "git", url: OFFICIAL_REGISTRY.url, ref: OFFICIAL_REGISTRY.branch };
     return {
       projectId: options.name ?? projectInfo.name,
       team: options.team,
-      inherit: options.inherit,
-      registry: options.registry ?? "./registry",
+      inherit,
+      use,
+      registry,
       targets: options.targets ?? getSuggestedTargets(aiToolsDetection),
       prettierConfigPath
     };
   }
   if (!options.interactive && options.name && options.targets) {
+    const registry = options.registry ? { type: "local", path: options.registry } : void 0;
     return {
       projectId: options.name,
       team: options.team,
       inherit: options.inherit,
-      registry: options.registry,
+      registry,
       targets: options.targets,
       prettierConfigPath
     };
@@ -1520,10 +1962,11 @@ async function resolveConfig(options, projectInfo, aiToolsDetection, prettierCon
     projectInfo,
     aiToolsDetection,
     prettierConfigPath,
+    manifest,
     services
   );
 }
-async function runInteractivePrompts(options, projectInfo, aiToolsDetection, prettierConfigPath, services) {
+async function runInteractivePrompts(options, projectInfo, aiToolsDetection, prettierConfigPath, manifest, services) {
   const { prompts: prompts2 } = services;
   ConsoleOutput.newline();
   console.log("\u{1F680} PromptScript Setup");
@@ -1549,33 +1992,124 @@ async function runInteractivePrompts(options, projectInfo, aiToolsDetection, pre
     message: "Project name:",
     default: options.name ?? projectInfo.name
   });
-  const wantsInherit = await prompts2.confirm({
-    message: "Do you want to inherit from a parent configuration?",
-    default: false
+  let registry;
+  let activeManifest = manifest;
+  const registryChoice = await prompts2.select({
+    message: "Registry configuration:",
+    choices: [
+      {
+        name: `\u{1F4E6} Use official PromptScript Registry (${OFFICIAL_REGISTRY.url})`,
+        value: "official"
+      },
+      {
+        name: "\u{1F517} Connect to a custom Git registry",
+        value: "custom-git"
+      },
+      {
+        name: "\u{1F4C1} Use a local registry directory",
+        value: "local"
+      },
+      {
+        name: "\u23ED\uFE0F  Skip registry (configure later)",
+        value: "skip"
+      }
+    ],
+    default: manifest ? "official" : "skip"
   });
-  let inherit;
-  if (wantsInherit) {
-    inherit = await prompts2.input({
-      message: "Inheritance path (e.g., @company/team):",
-      default: options.inherit ?? "@company/team",
+  if (registryChoice === "official") {
+    registry = {
+      type: "git",
+      url: OFFICIAL_REGISTRY.url,
+      ref: OFFICIAL_REGISTRY.branch
+    };
+    if (!activeManifest) {
+      try {
+        ConsoleOutput.muted("Fetching registry manifest...");
+        const { manifest: remoteManifest } = await loadManifestFromUrl();
+        activeManifest = remoteManifest;
+        ConsoleOutput.success(
+          `Loaded ${remoteManifest.catalog.length} configurations from official registry`
+        );
+      } catch {
+        ConsoleOutput.warn("Could not fetch registry manifest - suggestions will be limited");
+      }
+    }
+  } else if (registryChoice === "custom-git") {
+    const gitUrl = await prompts2.input({
+      message: "Git repository URL:",
+      default: "https://github.com/your-org/your-registry.git",
       validate: (value) => {
-        if (!value.startsWith("@")) {
-          return "Inheritance path should start with @";
+        if (!isValidGitUrl(value)) {
+          return "Please enter a valid Git repository URL (https:// or git@)";
         }
         return true;
       }
     });
-  }
-  const wantsRegistry = await prompts2.confirm({
-    message: "Do you want to configure a registry?",
-    default: false
-  });
-  let registry;
-  if (wantsRegistry) {
-    registry = await prompts2.input({
-      message: "Registry path:",
+    const gitRef = await prompts2.input({
+      message: "Branch or tag:",
+      default: "main"
+    });
+    registry = {
+      type: "git",
+      url: gitUrl,
+      ref: gitRef
+    };
+  } else if (registryChoice === "local") {
+    const localPath = await prompts2.input({
+      message: "Local registry path:",
       default: options.registry ?? "./registry"
     });
+    registry = {
+      type: "local",
+      path: localPath
+    };
+  }
+  let inherit = options.inherit;
+  let use;
+  if (activeManifest) {
+    const context = await buildProjectContext(projectInfo, services);
+    const suggestions = calculateSuggestions(activeManifest, context);
+    if (suggestions.inherit || suggestions.use.length > 0) {
+      ConsoleOutput.newline();
+      console.log("\u{1F4E6} Suggested configurations based on your project:");
+      const suggestionLines = formatSuggestionResult(suggestions);
+      for (const line of suggestionLines) {
+        ConsoleOutput.muted(`  ${line}`);
+      }
+      ConsoleOutput.newline();
+      const choices = createSuggestionChoices(activeManifest, suggestions);
+      if (choices.length > 0) {
+        const selected = await prompts2.checkbox({
+          message: "Select configurations to use:",
+          choices: choices.map((c) => ({
+            name: c.description ? `${c.name} - ${c.description}` : c.name,
+            value: c.value,
+            checked: c.checked
+          }))
+        });
+        const parsed = parseSelectedChoices(selected);
+        inherit = parsed.inherit;
+        use = parsed.use.length > 0 ? parsed.use : void 0;
+      }
+    }
+  }
+  if (!inherit) {
+    const wantsInherit = await prompts2.confirm({
+      message: "Do you want to inherit from a parent configuration?",
+      default: false
+    });
+    if (wantsInherit) {
+      inherit = await prompts2.input({
+        message: "Inheritance path (e.g., @stacks/react):",
+        default: options.inherit ?? "@stacks/react",
+        validate: (value) => {
+          if (!value.startsWith("@")) {
+            return "Inheritance path should start with @";
+          }
+          return true;
+        }
+      });
+    }
   }
   const suggestedTargets = getSuggestedTargets(aiToolsDetection);
   const allTargets = getAllTargets();
@@ -1604,6 +2138,7 @@ async function runInteractivePrompts(options, projectInfo, aiToolsDetection, pre
     projectId,
     team,
     inherit,
+    use,
     registry,
     targets,
     prettierConfigPath
@@ -1627,13 +2162,34 @@ function generateConfig(config) {
   if (config.inherit) {
     lines.push(`inherit: '${config.inherit}'`);
   } else {
-    lines.push("# inherit: '@company/team'");
+    lines.push("# inherit: '@stacks/react'");
+  }
+  lines.push("");
+  if (config.use && config.use.length > 0) {
+    lines.push("use:");
+    for (const useItem of config.use) {
+      lines.push(`  - '${useItem}'`);
+    }
+  } else {
+    lines.push("# use:", "#   - '@fragments/testing'", "#   - '@fragments/typescript'");
   }
   lines.push("");
   if (config.registry) {
-    lines.push("registry:", `  path: '${config.registry}'`);
+    if (config.registry.type === "git") {
+      lines.push("registry:", "  git:", `    url: '${config.registry.url}'`);
+      if (config.registry.ref) {
+        lines.push(`    ref: '${config.registry.ref}'`);
+      }
+    } else {
+      lines.push("registry:", `  path: '${config.registry.path}'`);
+    }
   } else {
-    lines.push("# registry:", "#   path: './registry'");
+    lines.push(
+      "# registry:",
+      "#   git:",
+      "#     url: 'https://github.com/mrwogu/promptscript-registry.git'",
+      "#     ref: 'main'"
+    );
   }
   lines.push("", "targets:");
   for (const target of config.targets) {
@@ -1654,7 +2210,13 @@ function generateConfig(config) {
   return lines.join("\n");
 }
 function generateProjectPs(config, projectInfo) {
-  const inheritLine = config.inherit ? `@inherit ${config.inherit}` : "# @inherit @company/team";
+  const inheritLine = config.inherit ? `@inherit ${config.inherit}` : "# @inherit @stacks/react";
+  let useLines = "";
+  if (config.use && config.use.length > 0) {
+    useLines = config.use.map((u) => `@use ${u}`).join("\n");
+  } else {
+    useLines = "# @use @fragments/testing\n# @use @fragments/typescript";
+  }
   const languagesLine = projectInfo.languages.length > 0 ? `  languages: [${projectInfo.languages.join(", ")}]` : "  # languages: [typescript]";
   const frameworksLine = projectInfo.frameworks.length > 0 ? `  frameworks: [${projectInfo.frameworks.join(", ")}]` : "  # frameworks: []";
   const syntaxVersion = getPackageVersion(__dirname, "./package.json");
@@ -1667,11 +2229,12 @@ function generateProjectPs(config, projectInfo) {
 }
 
 ${inheritLine}
+${useLines}
 
 @identity {
   """
   You are working on the ${config.projectId} project.
-  
+
   [Describe your project here]
   """
 }
@@ -1700,7 +2263,7 @@ ${frameworksLine}
 }
 
 // packages/cli/src/commands/compile.ts
-import { resolve as resolve4, dirname as dirname5 } from "path";
+import { resolve as resolve4, dirname as dirname6 } from "path";
 import { writeFile as writeFile2, mkdir as mkdir2, readFile as readFile6 } from "fs/promises";
 import { existsSync as existsSync7 } from "fs";
 import chokidar from "chokidar";
@@ -1708,7 +2271,7 @@ import chokidar from "chokidar";
 // packages/cli/src/config/loader.ts
 import { readFile as readFile3 } from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
-import { parse as parseYaml2 } from "yaml";
+import { parse as parseYaml3 } from "yaml";
 var CONFIG_FILES = [
   "promptscript.yaml",
   "promptscript.yml",
@@ -1755,7 +2318,7 @@ async function loadConfig(customPath) {
   let content = await readFile3(configFile, "utf-8");
   content = interpolateEnvVars(content);
   try {
-    return parseYaml2(content);
+    return parseYaml3(content);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown parse error";
     throw new Error(`Failed to parse ${configFile}: ${message}`);
@@ -1963,8 +2526,284 @@ var conventionRenderers = {
   markdown: new ConventionRenderer(BUILT_IN_CONVENTIONS.markdown)
 };
 
+// packages/formatters/src/extractors/types.ts
+var NON_CODE_KEYS = ["git", "config", "documentation", "diagrams"];
+var DEFAULT_SECTION_TITLES = {
+  typescript: "TypeScript",
+  naming: "Naming Conventions",
+  errors: "Error Handling",
+  testing: "Testing",
+  security: "Security",
+  performance: "Performance",
+  accessibility: "Accessibility",
+  documentation: "Documentation"
+};
+function getSectionTitle(key) {
+  if (key in DEFAULT_SECTION_TITLES) {
+    return DEFAULT_SECTION_TITLES[key];
+  }
+  return key.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function normalizeSectionName(key) {
+  return key === "errors" ? "error-handling" : key;
+}
+
+// packages/formatters/src/extractors/standards-extractor.ts
+var StandardsExtractor = class {
+  options;
+  constructor(options = {}) {
+    this.options = {
+      supportLegacyFormat: options.supportLegacyFormat ?? true,
+      supportObjectFormat: options.supportObjectFormat ?? true
+    };
+  }
+  /**
+   * Extract standards from a @standards block.
+   * Dynamically iterates over ALL keys, not just hardcoded ones.
+   */
+  extract(content) {
+    const props = this.getProps(content);
+    const codeStandards = /* @__PURE__ */ new Map();
+    const git = this.extractGit(props);
+    const config = this.extractConfig(props);
+    const documentation = this.extractDocumentation(props);
+    const diagrams = this.extractDiagrams(props);
+    let legacyCodeHandled = false;
+    if (this.options.supportLegacyFormat) {
+      const code = props["code"];
+      if (code && typeof code === "object" && !Array.isArray(code)) {
+        const codeObj = code;
+        if ("style" in codeObj || "patterns" in codeObj) {
+          const items = [];
+          this.addArrayItems(items, codeObj["style"]);
+          this.addArrayItems(items, codeObj["patterns"]);
+          if (items.length > 0) {
+            codeStandards.set("code", {
+              key: "code",
+              sectionName: "code",
+              title: "Code Style",
+              items,
+              rawValue: code
+            });
+            legacyCodeHandled = true;
+          }
+        }
+      }
+    }
+    for (const [key, value] of Object.entries(props)) {
+      if (this.isNonCodeKey(key)) {
+        continue;
+      }
+      if (key === "code" && legacyCodeHandled) {
+        continue;
+      }
+      const entry = this.extractEntry(key, value);
+      if (entry && entry.items.length > 0) {
+        codeStandards.set(key, entry);
+      }
+    }
+    return {
+      codeStandards,
+      git,
+      config,
+      documentation,
+      diagrams
+    };
+  }
+  /**
+   * Extract standards from an AST Program with @standards block.
+   * Convenience method that finds the block first.
+   */
+  extractFromProgram(ast) {
+    const standards = ast.blocks.find((b) => b.name === "standards" && !b.name.startsWith("__"));
+    if (!standards) return null;
+    return this.extract(standards.content);
+  }
+  /**
+   * Extract a single standards entry from a key-value pair.
+   */
+  extractEntry(key, value) {
+    const items = [];
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        const str = this.valueToString(item);
+        if (str) items.push(str);
+      }
+    } else if (this.options.supportObjectFormat && value && typeof value === "object") {
+      this.extractFromObject(value, items);
+    } else if (typeof value === "string" && value.trim()) {
+      items.push(value.trim());
+    }
+    if (items.length === 0) return null;
+    return {
+      key,
+      sectionName: normalizeSectionName(key),
+      title: getSectionTitle(key),
+      items,
+      rawValue: value
+    };
+  }
+  /**
+   * Extract items from an object format like { strictMode: true }.
+   * Extracts ALL key-value pairs as items for complete representation.
+   */
+  extractFromObject(obj, items) {
+    for (const [objKey, objValue] of Object.entries(obj)) {
+      if (objValue === null || objValue === void 0) continue;
+      if (objValue === false) continue;
+      if (objValue === true) {
+        items.push(objKey);
+        continue;
+      }
+      const str = this.valueToString(objValue);
+      if (str) {
+        items.push(`${objKey}: ${str}`);
+      }
+    }
+  }
+  /**
+   * Extract git standards from @standards.git
+   */
+  extractGit(props) {
+    const git = props["git"];
+    if (!git || typeof git !== "object" || Array.isArray(git)) return void 0;
+    const g = git;
+    const result = {};
+    if (g["format"]) result.format = this.valueToString(g["format"]);
+    if (Array.isArray(g["types"])) {
+      result.types = g["types"].map((t) => this.valueToString(t)).filter(Boolean);
+    }
+    if (g["example"]) result.example = this.valueToString(g["example"]);
+    return Object.keys(result).length > 0 ? result : void 0;
+  }
+  /**
+   * Extract config standards from @standards.config
+   */
+  extractConfig(props) {
+    const config = props["config"];
+    if (!config || typeof config !== "object" || Array.isArray(config)) return void 0;
+    const c = config;
+    const result = {};
+    for (const [key, value] of Object.entries(c)) {
+      const str = this.valueToString(value);
+      if (str) result[key] = str;
+    }
+    return Object.keys(result).length > 0 ? result : void 0;
+  }
+  /**
+   * Extract documentation standards from @standards.documentation
+   * Handles both array format and object format.
+   */
+  extractDocumentation(props) {
+    const doc = props["documentation"];
+    if (!doc) return void 0;
+    const items = [];
+    if (Array.isArray(doc)) {
+      for (const item of doc) {
+        const str = this.valueToString(item);
+        if (str) items.push(str);
+      }
+    } else if (typeof doc === "object") {
+      this.extractFromObject(doc, items);
+    } else if (typeof doc === "string" && doc.trim()) {
+      items.push(doc.trim());
+    }
+    return items.length > 0 ? { items, rawValue: doc } : void 0;
+  }
+  /**
+   * Extract diagram standards from @standards.diagrams
+   * Supports both 'format' and 'tool' keys, with 'format' taking precedence.
+   */
+  extractDiagrams(props) {
+    const diagrams = props["diagrams"];
+    if (!diagrams || typeof diagrams !== "object" || Array.isArray(diagrams)) return void 0;
+    const d = diagrams;
+    let format2;
+    let types;
+    if (d["format"]) {
+      format2 = this.valueToString(d["format"]);
+    } else if (d["tool"]) {
+      format2 = this.valueToString(d["tool"]);
+    }
+    if (Array.isArray(d["types"])) {
+      types = d["types"].map((t) => this.valueToString(t)).filter(Boolean);
+    }
+    if (format2 || types && types.length > 0) {
+      return { format: format2, types, rawValue: diagrams };
+    }
+    return void 0;
+  }
+  /**
+   * Check if a key is a non-code key (git, config, documentation, diagrams).
+   */
+  isNonCodeKey(key) {
+    return NON_CODE_KEYS.includes(key);
+  }
+  /**
+   * Add array items to the items list.
+   */
+  addArrayItems(items, value) {
+    if (!Array.isArray(value)) return;
+    for (const item of value) {
+      const str = this.valueToString(item);
+      if (str) items.push(str);
+    }
+  }
+  /**
+   * Get properties from block content.
+   */
+  getProps(content) {
+    switch (content.type) {
+      case "ObjectContent":
+        return content.properties;
+      case "MixedContent":
+        return content.properties;
+      default:
+        return {};
+    }
+  }
+  /**
+   * Convert a value to string representation.
+   * Handles all Value union types including TextContent, TypeExpression, and plain objects.
+   */
+  valueToString(value) {
+    if (value === null || value === void 0) return "";
+    if (typeof value === "string") return value;
+    if (typeof value === "number" || typeof value === "boolean") {
+      return String(value);
+    }
+    if (Array.isArray(value)) {
+      return value.map((v) => this.valueToString(v)).join(", ");
+    }
+    if (typeof value === "object" && "type" in value) {
+      if (value.type === "TextContent" && typeof value.value === "string") {
+        return value.value.trim();
+      }
+      if (value.type === "TypeExpression" && "kind" in value) {
+        const kind = value.kind;
+        const params = "params" in value && Array.isArray(value.params) ? value.params : [];
+        if (params.length > 0) {
+          return `${kind}(${params.map((p) => this.valueToString(p)).join(", ")})`;
+        }
+        return kind;
+      }
+    }
+    if (typeof value === "object") {
+      const entries = Object.entries(value);
+      if (entries.length > 0) {
+        return entries.map(([k, v]) => `${k}: ${this.valueToString(v)}`).join(", ");
+      }
+    }
+    return "";
+  }
+};
+
 // packages/formatters/src/base-formatter.ts
 var BaseFormatter = class {
+  /**
+   * Shared standards extractor for consistent extraction across all formatters.
+   */
+  standardsExtractor = new StandardsExtractor();
   /**
    * Create a convention renderer for this formatter.
    * Uses the provided convention from options or falls back to the default.
@@ -2281,6 +3120,29 @@ var BaseFormatter = class {
       return "| " + cells.join(" | ") + " |";
     });
   }
+  /**
+   * Remove common leading whitespace from all lines (dedent).
+   * Handles the case where trim() was already called, causing the first line
+   * to lose its indentation while subsequent lines retain theirs.
+   * Calculates minimum indent from lines 2+ only.
+   */
+  dedent(text) {
+    const lines = text.split("\n");
+    if (lines.length <= 1) return text.trim();
+    const minIndent = lines.slice(1).filter((line) => line.trim().length > 0).reduce((min, line) => {
+      const match = line.match(/^(\s*)/);
+      const indent = match?.[1]?.length ?? 0;
+      return Math.min(min, indent);
+    }, Infinity);
+    if (minIndent === 0 || minIndent === Infinity) {
+      return text.trim();
+    }
+    const firstLine = lines[0] ?? "";
+    return [
+      firstLine.trim(),
+      ...lines.slice(1).map((line) => line.trim().length > 0 ? line.slice(minIndent) : "")
+    ].join("\n").trim();
+  }
 };
 
 // packages/formatters/src/registry.ts
@@ -2693,8 +3555,9 @@ var GitHubFormatter = class extends BaseFormatter {
       const normalizedContent = this.normalizeMarkdownForPrettier(dedentedContent);
       lines.push(normalizedContent);
     }
+    const cleanName = config.name.replace(/^\/+/, "");
     return {
-      path: `.github/prompts/${config.name}.prompt.md`,
+      path: `.github/prompts/${cleanName}.prompt.md`,
       content: lines.join("\n") + "\n"
     };
   }
@@ -2741,33 +3604,12 @@ var GitHubFormatter = class extends BaseFormatter {
       const normalizedContent = this.normalizeMarkdownForPrettier(dedentedContent);
       lines.push(normalizedContent);
     }
+    const cleanName = config.name.replace(/^\/+/, "");
     return {
-      path: `.github/skills/${config.name}/SKILL.md`,
+      path: `.github/skills/${cleanName}/SKILL.md`,
       content: lines.join("\n") + "\n"
     };
   }
-  /**
-   * Remove common leading indentation from multiline text.
-   * Calculates minimum indent from lines 2+ only, since line 1 may have been
-   * trimmed (losing its indentation) while subsequent lines retain theirs.
-   */
-  dedent(text) {
-    const lines = text.split("\n");
-    if (lines.length <= 1) return text.trim();
-    const minIndent = lines.slice(1).filter((line) => line.trim().length > 0).reduce((min, line) => {
-      const match = line.match(/^(\s*)/);
-      const indent = match?.[1]?.length ?? 0;
-      return Math.min(min, indent);
-    }, Infinity);
-    if (minIndent === 0 || minIndent === Infinity) {
-      return text.trim();
-    }
-    const firstLine = lines[0] ?? "";
-    return [
-      firstLine.trim(),
-      ...lines.slice(1).map((line) => line.trim().length > 0 ? line.slice(minIndent) : "")
-    ].join("\n").trim();
-  }
   // ============================================================
   // AGENTS.md Generation
   // ============================================================
@@ -2907,8 +3749,9 @@ var GitHubFormatter = class extends BaseFormatter {
       const normalizedContent = this.normalizeMarkdownForPrettier(dedentedContent);
       lines.push(normalizedContent);
     }
+    const cleanName = config.name.replace(/^\/+/, "");
     return {
-      path: `.github/agents/${config.name}.md`,
+      path: `.github/agents/${cleanName}.md`,
       content: lines.join("\n") + "\n"
     };
   }
@@ -2924,6 +3767,8 @@ var GitHubFormatter = class extends BaseFormatter {
     if (architecture) sections.push(architecture);
     const codeStandards = this.codeStandards(ast, renderer);
     if (codeStandards) sections.push(codeStandards);
+    const shortcuts = this.shortcutsSection(ast, renderer);
+    if (shortcuts) sections.push(shortcuts);
     const commands = this.commands(ast, renderer);
     if (commands) sections.push(commands);
     const gitCommits = this.gitCommits(ast, renderer);
@@ -2991,26 +3836,42 @@ var GitHubFormatter = class extends BaseFormatter {
   codeStandards(ast, renderer) {
     const standards = this.findBlock(ast, "standards");
     if (!standards) return null;
-    const props = this.getProps(standards.content);
+    const extracted = this.standardsExtractor.extract(standards.content);
     const subsections = [];
-    const sectionMap = {
-      typescript: "typescript",
-      naming: "naming",
-      errors: "error-handling",
-      testing: "testing"
-    };
-    for (const [key, sectionName] of Object.entries(sectionMap)) {
-      const value = props[key];
-      if (Array.isArray(value)) {
-        const items = this.formatStandardsList(value);
-        if (items.length > 0) {
-          subsections.push(renderer.renderSection(sectionName, renderer.renderList(items), 2));
-        }
+    for (const entry of extracted.codeStandards.values()) {
+      if (entry.items.length > 0) {
+        subsections.push(
+          renderer.renderSection(entry.sectionName, renderer.renderList(entry.items), 2)
+        );
       }
     }
     if (subsections.length === 0) return null;
     return renderer.renderSection("code-standards", subsections.join("\n\n"));
   }
+  /**
+   * Generate shortcuts section for copilot-instructions.md.
+   * Includes shortcuts that don't have prompt: true (those go to .prompt.md files).
+   */
+  shortcutsSection(ast, renderer) {
+    const block = this.findBlock(ast, "shortcuts");
+    if (!block) return null;
+    const props = this.getProps(block.content);
+    const items = [];
+    for (const [name, value] of Object.entries(props)) {
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        const obj = value;
+        if (obj["prompt"] === true || obj["type"] === "prompt") {
+          continue;
+        }
+        const desc = obj["description"] || obj["content"] || name;
+        items.push(`${name}: ${this.valueToString(desc).split("\n")[0]}`);
+      } else {
+        items.push(`${name}: ${this.valueToString(value).split("\n")[0]}`);
+      }
+    }
+    if (items.length === 0) return null;
+    return renderer.renderSection("shortcuts", renderer.renderList(items));
+  }
   commands(ast, renderer) {
     const knowledge = this.findBlock(ast, "knowledge");
     if (!knowledge) return null;
@@ -3470,28 +4331,6 @@ var ClaudeFormatter = class extends BaseFormatter {
       content: lines.join("\n") + "\n"
     };
   }
-  /**
-   * Remove common leading indentation from multiline text.
-   * Calculates minimum indent from lines 2+ only, since line 1 may have been
-   * trimmed (losing its indentation) while subsequent lines retain theirs.
-   */
-  dedent(text) {
-    const lines = text.split("\n");
-    if (lines.length <= 1) return text.trim();
-    const minIndent = lines.slice(1).filter((line) => line.trim().length > 0).reduce((min, line) => {
-      const match = line.match(/^(\s*)/);
-      const indent = match?.[1]?.length ?? 0;
-      return Math.min(min, indent);
-    }, Infinity);
-    if (minIndent === 0 || minIndent === Infinity) {
-      return text.trim();
-    }
-    const firstLine = lines[0] ?? "";
-    return [
-      firstLine.trim(),
-      ...lines.slice(1).map((line) => line.trim().length > 0 ? line.slice(minIndent) : "")
-    ].join("\n").trim();
-  }
   // ============================================================
   // Agent File Generation
   // ============================================================
@@ -3717,45 +4556,15 @@ var ClaudeFormatter = class extends BaseFormatter {
   codeStandards(ast, renderer) {
     const standards = this.findBlock(ast, "standards");
     if (!standards) return null;
-    const props = this.getProps(standards.content);
+    const extracted = this.standardsExtractor.extract(standards.content);
     const items = [];
-    const code = props["code"];
-    if (code && typeof code === "object" && !Array.isArray(code)) {
-      const codeObj = code;
-      this.addStyleItems(items, codeObj["style"]);
-      this.addStyleItems(items, codeObj["patterns"]);
-    }
-    if (items.length === 0) {
-      this.extractTypeScriptStandards(props, items);
-      this.extractNamingStandards(props, items);
-      this.extractTestingStandards(props, items);
+    for (const entry of extracted.codeStandards.values()) {
+      items.push(...entry.items);
     }
     if (items.length === 0) return null;
     const content = renderer.renderList(items);
     return renderer.renderSection("Code Style", content) + "\n";
   }
-  extractTypeScriptStandards(props, items) {
-    const ts = props["typescript"];
-    if (!ts || typeof ts !== "object" || Array.isArray(ts)) return;
-    const tsObj = ts;
-    if (tsObj["strictMode"]) items.push("Strict TypeScript, no `any`");
-    if (tsObj["exports"]) items.push("Named exports only");
-  }
-  extractNamingStandards(props, items) {
-    const naming = props["naming"];
-    if (!naming || typeof naming !== "object" || Array.isArray(naming)) return;
-    const n = naming;
-    if (n["files"]) items.push(`Files: ${this.valueToString(n["files"])}`);
-  }
-  extractTestingStandards(props, items) {
-    const testing = props["testing"];
-    if (!testing || typeof testing !== "object" || Array.isArray(testing)) return;
-    const t = testing;
-    const parts = [];
-    if (t["framework"]) parts.push(this.valueToString(t["framework"]));
-    if (t["coverage"]) parts.push(`>${this.valueToString(t["coverage"])}% coverage`);
-    if (parts.length > 0) items.push(`Testing: ${parts.join(", ")}`);
-  }
   gitCommits(ast, renderer) {
     const standards = this.findBlock(ast, "standards");
     if (!standards) return null;
@@ -3872,11 +4681,6 @@ var ClaudeFormatter = class extends BaseFormatter {
     }
     return [];
   }
-  addStyleItems(items, value) {
-    if (!value) return;
-    const arr = Array.isArray(value) ? value : [value];
-    for (const item of arr) items.push(this.valueToString(item));
-  }
 };
 
 // packages/formatters/src/formatters/cursor.ts
@@ -4206,28 +5010,6 @@ var CursorFormatter = class extends BaseFormatter {
     const orgSuffix = projectInfo.org ? ` at ${projectInfo.org}` : "";
     return `You are working on ${projectInfo.text}${orgSuffix}.`;
   }
-  /**
-   * Remove common leading whitespace from all lines (dedent).
-   * Handles the case where trim() was already called, causing the first line
-   * to lose its indentation while subsequent lines retain theirs.
-   */
-  dedent(text) {
-    const lines = text.split("\n");
-    if (lines.length <= 1) return text.trim();
-    const minIndent = lines.slice(1).filter((line) => line.trim().length > 0).reduce((min, line) => {
-      const match = line.match(/^(\s*)/);
-      const indent = match?.[1]?.length ?? 0;
-      return Math.min(min, indent);
-    }, Infinity);
-    if (minIndent === 0 || minIndent === Infinity) {
-      return text.trim();
-    }
-    const firstLine = lines[0] ?? "";
-    return [
-      firstLine.trim(),
-      ...lines.slice(1).map((line) => line.trim().length > 0 ? line.slice(minIndent) : "")
-    ].join("\n").trim();
-  }
   /**
    * Generate YAML frontmatter for Cursor MDC format.
    * @see https://cursor.com/docs/context/rules
@@ -4337,70 +5119,15 @@ ${text2.trim()}`;
 ${items.map((i) => "- " + i).join("\n")}`;
   }
   extractCodeStyleItems(ast) {
-    const codeKeys = ["typescript", "naming", "errors", "testing"];
-    const context = this.findBlock(ast, "context");
-    if (context) {
-      const standards = this.getProp(context.content, "standards");
-      if (standards && typeof standards === "object" && !Array.isArray(standards)) {
-        const filtered = this.filterByKeys(standards, codeKeys);
-        if (Object.keys(filtered).length > 0) {
-          return this.extractNestedRules(filtered);
-        }
-      }
-    }
     const standardsBlock = this.findBlock(ast, "standards");
-    if (standardsBlock) {
-      const props = this.getProps(standardsBlock.content);
-      const filtered = this.filterByKeys(props, codeKeys);
-      if (Object.keys(filtered).length > 0) {
-        return this.extractNestedRules(filtered);
-      }
-    }
-    return [];
-  }
-  filterByKeys(obj, keys2) {
-    const result = {};
-    for (const key of keys2) {
-      if (obj[key] !== void 0) {
-        result[key] = obj[key];
-      }
-    }
-    return result;
-  }
-  extractNestedRules(obj) {
+    if (!standardsBlock) return [];
+    const extracted = this.standardsExtractor.extract(standardsBlock.content);
     const items = [];
-    for (const rules of Object.values(obj)) {
-      this.flattenRules(rules, items);
+    for (const entry of extracted.codeStandards.values()) {
+      items.push(...entry.items);
     }
     return items;
   }
-  flattenRules(rules, items) {
-    if (Array.isArray(rules)) {
-      this.extractStringArray(rules, items);
-      return;
-    }
-    if (rules && typeof rules === "object") {
-      this.extractFromObject(rules, items);
-      return;
-    }
-    if (typeof rules === "string") {
-      items.push(rules);
-    }
-  }
-  extractStringArray(arr, items) {
-    for (const item of arr) {
-      if (typeof item === "string") items.push(item);
-    }
-  }
-  extractFromObject(obj, items) {
-    for (const [key, rule] of Object.entries(obj)) {
-      if (Array.isArray(rule)) {
-        this.extractStringArray(rule, items);
-      } else if (typeof rule === "string") {
-        items.push(`${key}: ${rule}`);
-      }
-    }
-  }
   gitCommits(ast) {
     const standardsBlock = this.findBlock(ast, "standards");
     if (standardsBlock) {
@@ -4923,28 +5650,18 @@ ${this.stripAllIndent(content)}`;
   }
   /**
    * Extract code standards from @standards block.
-   * Expects arrays of strings (pass-through format).
+   * Uses shared extractor for dynamic key iteration (parity with GitHub/Claude/Cursor).
    */
   codeStandards(ast, _renderer) {
     const standards = this.findBlock(ast, "standards");
     if (!standards) return null;
-    const props = this.getProps(standards.content);
+    const extracted = this.standardsExtractor.extract(standards.content);
     const subsections = [];
-    const sectionMap = {
-      typescript: "TypeScript",
-      naming: "Naming Conventions",
-      errors: "Error Handling",
-      testing: "Testing"
-    };
-    for (const [key, title] of Object.entries(sectionMap)) {
-      const value = props[key];
-      if (Array.isArray(value)) {
-        const items = this.formatStandardsList(value);
-        if (items.length > 0) {
-          subsections.push(`### ${title}
+    for (const entry of extracted.codeStandards.values()) {
+      if (entry.items.length > 0) {
+        subsections.push(`### ${entry.title}
 
-${items.map((i) => "- " + i).join("\n")}`);
-        }
+${entry.items.map((i) => "- " + i).join("\n")}`);
       }
     }
     if (subsections.length === 0) return null;
@@ -5168,20 +5885,20 @@ FormatterRegistry.register("claude", () => new ClaudeFormatter());
 FormatterRegistry.register("cursor", () => new CursorFormatter());
 FormatterRegistry.register("antigravity", () => new AntigravityFormatter());
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_freeGlobal.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_freeGlobal.js
 var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
 var freeGlobal_default = freeGlobal;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_root.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_root.js
 var freeSelf = typeof self == "object" && self && self.Object === Object && self;
 var root = freeGlobal_default || freeSelf || Function("return this")();
 var root_default = root;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_Symbol.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_Symbol.js
 var Symbol = root_default.Symbol;
 var Symbol_default = Symbol;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_getRawTag.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_getRawTag.js
 var objectProto = Object.prototype;
 var hasOwnProperty = objectProto.hasOwnProperty;
 var nativeObjectToString = objectProto.toString;
@@ -5205,7 +5922,7 @@ function getRawTag(value) {
 }
 var getRawTag_default = getRawTag;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_objectToString.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_objectToString.js
 var objectProto2 = Object.prototype;
 var nativeObjectToString2 = objectProto2.toString;
 function objectToString(value) {
@@ -5213,7 +5930,7 @@ function objectToString(value) {
 }
 var objectToString_default = objectToString;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseGetTag.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseGetTag.js
 var nullTag = "[object Null]";
 var undefinedTag = "[object Undefined]";
 var symToStringTag2 = Symbol_default ? Symbol_default.toStringTag : void 0;
@@ -5225,20 +5942,20 @@ function baseGetTag(value) {
 }
 var baseGetTag_default = baseGetTag;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isObjectLike.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isObjectLike.js
 function isObjectLike(value) {
   return value != null && typeof value == "object";
 }
 var isObjectLike_default = isObjectLike;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isSymbol.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isSymbol.js
 var symbolTag = "[object Symbol]";
 function isSymbol(value) {
   return typeof value == "symbol" || isObjectLike_default(value) && baseGetTag_default(value) == symbolTag;
 }
 var isSymbol_default = isSymbol;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_arrayMap.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_arrayMap.js
 function arrayMap(array, iteratee) {
   var index = -1, length = array == null ? 0 : array.length, result = Array(length);
   while (++index < length) {
@@ -5248,11 +5965,11 @@ function arrayMap(array, iteratee) {
 }
 var arrayMap_default = arrayMap;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isArray.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isArray.js
 var isArray = Array.isArray;
 var isArray_default = isArray;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseToString.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseToString.js
 var INFINITY = 1 / 0;
 var symbolProto = Symbol_default ? Symbol_default.prototype : void 0;
 var symbolToString = symbolProto ? symbolProto.toString : void 0;
@@ -5271,7 +5988,7 @@ function baseToString(value) {
 }
 var baseToString_default = baseToString;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_trimmedEndIndex.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_trimmedEndIndex.js
 var reWhitespace = /\s/;
 function trimmedEndIndex(string) {
   var index = string.length;
@@ -5281,21 +5998,21 @@ function trimmedEndIndex(string) {
 }
 var trimmedEndIndex_default = trimmedEndIndex;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseTrim.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseTrim.js
 var reTrimStart = /^\s+/;
 function baseTrim(string) {
   return string ? string.slice(0, trimmedEndIndex_default(string) + 1).replace(reTrimStart, "") : string;
 }
 var baseTrim_default = baseTrim;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isObject.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isObject.js
 function isObject(value) {
   var type = typeof value;
   return value != null && (type == "object" || type == "function");
 }
 var isObject_default = isObject;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/toNumber.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/toNumber.js
 var NAN = 0 / 0;
 var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
 var reIsBinary = /^0b[01]+$/i;
@@ -5321,7 +6038,7 @@ function toNumber(value) {
 }
 var toNumber_default = toNumber;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/toFinite.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/toFinite.js
 var INFINITY2 = 1 / 0;
 var MAX_INTEGER = 17976931348623157e292;
 function toFinite(value) {
@@ -5337,20 +6054,20 @@ function toFinite(value) {
 }
 var toFinite_default = toFinite;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/toInteger.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/toInteger.js
 function toInteger(value) {
   var result = toFinite_default(value), remainder = result % 1;
   return result === result ? remainder ? result - remainder : result : 0;
 }
 var toInteger_default = toInteger;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/identity.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/identity.js
 function identity(value) {
   return value;
 }
 var identity_default = identity;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isFunction.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isFunction.js
 var asyncTag = "[object AsyncFunction]";
 var funcTag = "[object Function]";
 var genTag = "[object GeneratorFunction]";
@@ -5364,11 +6081,11 @@ function isFunction(value) {
 }
 var isFunction_default = isFunction;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_coreJsData.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_coreJsData.js
 var coreJsData = root_default["__core-js_shared__"];
 var coreJsData_default = coreJsData;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_isMasked.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_isMasked.js
 var maskSrcKey = (function() {
   var uid = /[^.]+$/.exec(coreJsData_default && coreJsData_default.keys && coreJsData_default.keys.IE_PROTO || "");
   return uid ? "Symbol(src)_1." + uid : "";
@@ -5378,7 +6095,7 @@ function isMasked(func) {
 }
 var isMasked_default = isMasked;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_toSource.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_toSource.js
 var funcProto = Function.prototype;
 var funcToString = funcProto.toString;
 function toSource(func) {
@@ -5396,7 +6113,7 @@ function toSource(func) {
 }
 var toSource_default = toSource;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseIsNative.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseIsNative.js
 var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
 var reIsHostCtor = /^\[object .+?Constructor\]$/;
 var funcProto2 = Function.prototype;
@@ -5415,24 +6132,24 @@ function baseIsNative(value) {
 }
 var baseIsNative_default = baseIsNative;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_getValue.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_getValue.js
 function getValue(object, key) {
   return object == null ? void 0 : object[key];
 }
 var getValue_default = getValue;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_getNative.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_getNative.js
 function getNative(object, key) {
   var value = getValue_default(object, key);
   return baseIsNative_default(value) ? value : void 0;
 }
 var getNative_default = getNative;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_WeakMap.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_WeakMap.js
 var WeakMap = getNative_default(root_default, "WeakMap");
 var WeakMap_default = WeakMap;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseCreate.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseCreate.js
 var objectCreate = Object.create;
 var baseCreate = /* @__PURE__ */ (function() {
   function object() {
@@ -5452,7 +6169,7 @@ var baseCreate = /* @__PURE__ */ (function() {
 })();
 var baseCreate_default = baseCreate;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_apply.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_apply.js
 function apply(func, thisArg, args) {
   switch (args.length) {
     case 0:
@@ -5468,12 +6185,12 @@ function apply(func, thisArg, args) {
 }
 var apply_default = apply;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/noop.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/noop.js
 function noop() {
 }
 var noop_default = noop;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_copyArray.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_copyArray.js
 function copyArray(source, array) {
   var index = -1, length = source.length;
   array || (array = Array(length));
@@ -5484,7 +6201,7 @@ function copyArray(source, array) {
 }
 var copyArray_default = copyArray;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_shortOut.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_shortOut.js
 var HOT_COUNT = 800;
 var HOT_SPAN = 16;
 var nativeNow = Date.now;
@@ -5505,7 +6222,7 @@ function shortOut(func) {
 }
 var shortOut_default = shortOut;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/constant.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/constant.js
 function constant(value) {
   return function() {
     return value;
@@ -5513,7 +6230,7 @@ function constant(value) {
 }
 var constant_default = constant;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_defineProperty.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_defineProperty.js
 var defineProperty = (function() {
   try {
     var func = getNative_default(Object, "defineProperty");
@@ -5524,7 +6241,7 @@ var defineProperty = (function() {
 })();
 var defineProperty_default = defineProperty;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseSetToString.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseSetToString.js
 var baseSetToString = !defineProperty_default ? identity_default : function(func, string) {
   return defineProperty_default(func, "toString", {
     "configurable": true,
@@ -5535,11 +6252,11 @@ var baseSetToString = !defineProperty_default ? identity_default : function(func
 };
 var baseSetToString_default = baseSetToString;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_setToString.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_setToString.js
 var setToString = shortOut_default(baseSetToString_default);
 var setToString_default = setToString;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_arrayEach.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_arrayEach.js
 function arrayEach(array, iteratee) {
   var index = -1, length = array == null ? 0 : array.length;
   while (++index < length) {
@@ -5551,7 +6268,7 @@ function arrayEach(array, iteratee) {
 }
 var arrayEach_default = arrayEach;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseFindIndex.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseFindIndex.js
 function baseFindIndex(array, predicate, fromIndex, fromRight) {
   var length = array.length, index = fromIndex + (fromRight ? 1 : -1);
   while (fromRight ? index-- : ++index < length) {
@@ -5563,13 +6280,13 @@ function baseFindIndex(array, predicate, fromIndex, fromRight) {
 }
 var baseFindIndex_default = baseFindIndex;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseIsNaN.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseIsNaN.js
 function baseIsNaN(value) {
   return value !== value;
 }
 var baseIsNaN_default = baseIsNaN;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_strictIndexOf.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_strictIndexOf.js
 function strictIndexOf(array, value, fromIndex) {
   var index = fromIndex - 1, length = array.length;
   while (++index < length) {
@@ -5581,20 +6298,20 @@ function strictIndexOf(array, value, fromIndex) {
 }
 var strictIndexOf_default = strictIndexOf;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseIndexOf.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseIndexOf.js
 function baseIndexOf(array, value, fromIndex) {
   return value === value ? strictIndexOf_default(array, value, fromIndex) : baseFindIndex_default(array, baseIsNaN_default, fromIndex);
 }
 var baseIndexOf_default = baseIndexOf;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_arrayIncludes.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_arrayIncludes.js
 function arrayIncludes(array, value) {
   var length = array == null ? 0 : array.length;
   return !!length && baseIndexOf_default(array, value, 0) > -1;
 }
 var arrayIncludes_default = arrayIncludes;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_isIndex.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_isIndex.js
 var MAX_SAFE_INTEGER = 9007199254740991;
 var reIsUint = /^(?:0|[1-9]\d*)$/;
 function isIndex(value, length) {
@@ -5604,7 +6321,7 @@ function isIndex(value, length) {
 }
 var isIndex_default = isIndex;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseAssignValue.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseAssignValue.js
 function baseAssignValue(object, key, value) {
   if (key == "__proto__" && defineProperty_default) {
     defineProperty_default(object, key, {
@@ -5619,13 +6336,13 @@ function baseAssignValue(object, key, value) {
 }
 var baseAssignValue_default = baseAssignValue;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/eq.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/eq.js
 function eq(value, other) {
   return value === other || value !== value && other !== other;
 }
 var eq_default = eq;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_assignValue.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_assignValue.js
 var objectProto4 = Object.prototype;
 var hasOwnProperty3 = objectProto4.hasOwnProperty;
 function assignValue(object, key, value) {
@@ -5636,7 +6353,7 @@ function assignValue(object, key, value) {
 }
 var assignValue_default = assignValue;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_copyObject.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_copyObject.js
 function copyObject(source, props, object, customizer) {
   var isNew = !object;
   object || (object = {});
@@ -5657,7 +6374,7 @@ function copyObject(source, props, object, customizer) {
 }
 var copyObject_default = copyObject;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_overRest.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_overRest.js
 var nativeMax = Math.max;
 function overRest(func, start, transform) {
   start = nativeMax(start === void 0 ? func.length - 1 : start, 0);
@@ -5677,26 +6394,26 @@ function overRest(func, start, transform) {
 }
 var overRest_default = overRest;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseRest.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseRest.js
 function baseRest(func, start) {
   return setToString_default(overRest_default(func, start, identity_default), func + "");
 }
 var baseRest_default = baseRest;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isLength.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isLength.js
 var MAX_SAFE_INTEGER2 = 9007199254740991;
 function isLength(value) {
   return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER2;
 }
 var isLength_default = isLength;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isArrayLike.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isArrayLike.js
 function isArrayLike(value) {
   return value != null && isLength_default(value.length) && !isFunction_default(value);
 }
 var isArrayLike_default = isArrayLike;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_isIterateeCall.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_isIterateeCall.js
 function isIterateeCall(value, index, object) {
   if (!isObject_default(object)) {
     return false;
@@ -5709,7 +6426,7 @@ function isIterateeCall(value, index, object) {
 }
 var isIterateeCall_default = isIterateeCall;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_createAssigner.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_createAssigner.js
 function createAssigner(assigner) {
   return baseRest_default(function(object, sources) {
     var index = -1, length = sources.length, customizer = length > 1 ? sources[length - 1] : void 0, guard = length > 2 ? sources[2] : void 0;
@@ -5730,7 +6447,7 @@ function createAssigner(assigner) {
 }
 var createAssigner_default = createAssigner;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_isPrototype.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_isPrototype.js
 var objectProto5 = Object.prototype;
 function isPrototype(value) {
   var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto5;
@@ -5738,7 +6455,7 @@ function isPrototype(value) {
 }
 var isPrototype_default = isPrototype;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseTimes.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseTimes.js
 function baseTimes(n, iteratee) {
   var index = -1, result = Array(n);
   while (++index < n) {
@@ -5748,14 +6465,14 @@ function baseTimes(n, iteratee) {
 }
 var baseTimes_default = baseTimes;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseIsArguments.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseIsArguments.js
 var argsTag = "[object Arguments]";
 function baseIsArguments(value) {
   return isObjectLike_default(value) && baseGetTag_default(value) == argsTag;
 }
 var baseIsArguments_default = baseIsArguments;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isArguments.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isArguments.js
 var objectProto6 = Object.prototype;
 var hasOwnProperty4 = objectProto6.hasOwnProperty;
 var propertyIsEnumerable = objectProto6.propertyIsEnumerable;
@@ -5766,13 +6483,13 @@ var isArguments = baseIsArguments_default(/* @__PURE__ */ (function() {
 };
 var isArguments_default = isArguments;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/stubFalse.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/stubFalse.js
 function stubFalse() {
   return false;
 }
 var stubFalse_default = stubFalse;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isBuffer.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isBuffer.js
 var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
 var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
 var moduleExports = freeModule && freeModule.exports === freeExports;
@@ -5781,7 +6498,7 @@ var nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : void 0;
 var isBuffer = nativeIsBuffer || stubFalse_default;
 var isBuffer_default = isBuffer;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseIsTypedArray.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseIsTypedArray.js
 var argsTag2 = "[object Arguments]";
 var arrayTag = "[object Array]";
 var boolTag = "[object Boolean]";
@@ -5814,7 +6531,7 @@ function baseIsTypedArray(value) {
 }
 var baseIsTypedArray_default = baseIsTypedArray;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseUnary.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseUnary.js
 function baseUnary(func) {
   return function(value) {
     return func(value);
@@ -5822,7 +6539,7 @@ function baseUnary(func) {
 }
 var baseUnary_default = baseUnary;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_nodeUtil.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_nodeUtil.js
 var freeExports2 = typeof exports == "object" && exports && !exports.nodeType && exports;
 var freeModule2 = freeExports2 && typeof module == "object" && module && !module.nodeType && module;
 var moduleExports2 = freeModule2 && freeModule2.exports === freeExports2;
@@ -5839,12 +6556,12 @@ var nodeUtil = (function() {
 })();
 var nodeUtil_default = nodeUtil;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isTypedArray.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isTypedArray.js
 var nodeIsTypedArray = nodeUtil_default && nodeUtil_default.isTypedArray;
 var isTypedArray = nodeIsTypedArray ? baseUnary_default(nodeIsTypedArray) : baseIsTypedArray_default;
 var isTypedArray_default = isTypedArray;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_arrayLikeKeys.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_arrayLikeKeys.js
 var objectProto7 = Object.prototype;
 var hasOwnProperty5 = objectProto7.hasOwnProperty;
 function arrayLikeKeys(value, inherited) {
@@ -5862,7 +6579,7 @@ function arrayLikeKeys(value, inherited) {
 }
 var arrayLikeKeys_default = arrayLikeKeys;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_overArg.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_overArg.js
 function overArg(func, transform) {
   return function(arg) {
     return func(transform(arg));
@@ -5870,11 +6587,11 @@ function overArg(func, transform) {
 }
 var overArg_default = overArg;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_nativeKeys.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_nativeKeys.js
 var nativeKeys = overArg_default(Object.keys, Object);
 var nativeKeys_default = nativeKeys;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseKeys.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseKeys.js
 var objectProto8 = Object.prototype;
 var hasOwnProperty6 = objectProto8.hasOwnProperty;
 function baseKeys(object) {
@@ -5891,13 +6608,13 @@ function baseKeys(object) {
 }
 var baseKeys_default = baseKeys;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/keys.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/keys.js
 function keys(object) {
   return isArrayLike_default(object) ? arrayLikeKeys_default(object) : baseKeys_default(object);
 }
 var keys_default = keys;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/assign.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/assign.js
 var objectProto9 = Object.prototype;
 var hasOwnProperty7 = objectProto9.hasOwnProperty;
 var assign = createAssigner_default(function(object, source) {
@@ -5913,7 +6630,7 @@ var assign = createAssigner_default(function(object, source) {
 });
 var assign_default = assign;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_nativeKeysIn.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_nativeKeysIn.js
 function nativeKeysIn(object) {
   var result = [];
   if (object != null) {
@@ -5925,7 +6642,7 @@ function nativeKeysIn(object) {
 }
 var nativeKeysIn_default = nativeKeysIn;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseKeysIn.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseKeysIn.js
 var objectProto10 = Object.prototype;
 var hasOwnProperty8 = objectProto10.hasOwnProperty;
 function baseKeysIn(object) {
@@ -5942,13 +6659,13 @@ function baseKeysIn(object) {
 }
 var baseKeysIn_default = baseKeysIn;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/keysIn.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/keysIn.js
 function keysIn(object) {
   return isArrayLike_default(object) ? arrayLikeKeys_default(object, true) : baseKeysIn_default(object);
 }
 var keysIn_default = keysIn;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_isKey.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_isKey.js
 var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
 var reIsPlainProp = /^\w*$/;
 function isKey(value, object) {
@@ -5963,18 +6680,18 @@ function isKey(value, object) {
 }
 var isKey_default = isKey;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_nativeCreate.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_nativeCreate.js
 var nativeCreate = getNative_default(Object, "create");
 var nativeCreate_default = nativeCreate;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_hashClear.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_hashClear.js
 function hashClear() {
   this.__data__ = nativeCreate_default ? nativeCreate_default(null) : {};
   this.size = 0;
 }
 var hashClear_default = hashClear;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_hashDelete.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_hashDelete.js
 function hashDelete(key) {
   var result = this.has(key) && delete this.__data__[key];
   this.size -= result ? 1 : 0;
@@ -5982,7 +6699,7 @@ function hashDelete(key) {
 }
 var hashDelete_default = hashDelete;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_hashGet.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_hashGet.js
 var HASH_UNDEFINED = "__lodash_hash_undefined__";
 var objectProto11 = Object.prototype;
 var hasOwnProperty9 = objectProto11.hasOwnProperty;
@@ -5996,7 +6713,7 @@ function hashGet(key) {
 }
 var hashGet_default = hashGet;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_hashHas.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_hashHas.js
 var objectProto12 = Object.prototype;
 var hasOwnProperty10 = objectProto12.hasOwnProperty;
 function hashHas(key) {
@@ -6005,7 +6722,7 @@ function hashHas(key) {
 }
 var hashHas_default = hashHas;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_hashSet.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_hashSet.js
 var HASH_UNDEFINED2 = "__lodash_hash_undefined__";
 function hashSet(key, value) {
   var data = this.__data__;
@@ -6015,7 +6732,7 @@ function hashSet(key, value) {
 }
 var hashSet_default = hashSet;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_Hash.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_Hash.js
 function Hash(entries) {
   var index = -1, length = entries == null ? 0 : entries.length;
   this.clear();
@@ -6031,14 +6748,14 @@ Hash.prototype.has = hashHas_default;
 Hash.prototype.set = hashSet_default;
 var Hash_default = Hash;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_listCacheClear.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_listCacheClear.js
 function listCacheClear() {
   this.__data__ = [];
   this.size = 0;
 }
 var listCacheClear_default = listCacheClear;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_assocIndexOf.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_assocIndexOf.js
 function assocIndexOf(array, key) {
   var length = array.length;
   while (length--) {
@@ -6050,7 +6767,7 @@ function assocIndexOf(array, key) {
 }
 var assocIndexOf_default = assocIndexOf;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_listCacheDelete.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_listCacheDelete.js
 var arrayProto = Array.prototype;
 var splice = arrayProto.splice;
 function listCacheDelete(key) {
@@ -6069,20 +6786,20 @@ function listCacheDelete(key) {
 }
 var listCacheDelete_default = listCacheDelete;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_listCacheGet.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_listCacheGet.js
 function listCacheGet(key) {
   var data = this.__data__, index = assocIndexOf_default(data, key);
   return index < 0 ? void 0 : data[index][1];
 }
 var listCacheGet_default = listCacheGet;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_listCacheHas.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_listCacheHas.js
 function listCacheHas(key) {
   return assocIndexOf_default(this.__data__, key) > -1;
 }
 var listCacheHas_default = listCacheHas;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_listCacheSet.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_listCacheSet.js
 function listCacheSet(key, value) {
   var data = this.__data__, index = assocIndexOf_default(data, key);
   if (index < 0) {
@@ -6095,7 +6812,7 @@ function listCacheSet(key, value) {
 }
 var listCacheSet_default = listCacheSet;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_ListCache.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_ListCache.js
 function ListCache(entries) {
   var index = -1, length = entries == null ? 0 : entries.length;
   this.clear();
@@ -6111,11 +6828,11 @@ ListCache.prototype.has = listCacheHas_default;
 ListCache.prototype.set = listCacheSet_default;
 var ListCache_default = ListCache;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_Map.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_Map.js
 var Map2 = getNative_default(root_default, "Map");
 var Map_default = Map2;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_mapCacheClear.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_mapCacheClear.js
 function mapCacheClear() {
   this.size = 0;
   this.__data__ = {
@@ -6126,21 +6843,21 @@ function mapCacheClear() {
 }
 var mapCacheClear_default = mapCacheClear;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_isKeyable.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_isKeyable.js
 function isKeyable(value) {
   var type = typeof value;
   return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
 }
 var isKeyable_default = isKeyable;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_getMapData.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_getMapData.js
 function getMapData(map2, key) {
   var data = map2.__data__;
   return isKeyable_default(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
 }
 var getMapData_default = getMapData;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_mapCacheDelete.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_mapCacheDelete.js
 function mapCacheDelete(key) {
   var result = getMapData_default(this, key)["delete"](key);
   this.size -= result ? 1 : 0;
@@ -6148,19 +6865,19 @@ function mapCacheDelete(key) {
 }
 var mapCacheDelete_default = mapCacheDelete;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_mapCacheGet.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_mapCacheGet.js
 function mapCacheGet(key) {
   return getMapData_default(this, key).get(key);
 }
 var mapCacheGet_default = mapCacheGet;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_mapCacheHas.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_mapCacheHas.js
 function mapCacheHas(key) {
   return getMapData_default(this, key).has(key);
 }
 var mapCacheHas_default = mapCacheHas;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_mapCacheSet.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_mapCacheSet.js
 function mapCacheSet(key, value) {
   var data = getMapData_default(this, key), size = data.size;
   data.set(key, value);
@@ -6169,7 +6886,7 @@ function mapCacheSet(key, value) {
 }
 var mapCacheSet_default = mapCacheSet;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_MapCache.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_MapCache.js
 function MapCache(entries) {
   var index = -1, length = entries == null ? 0 : entries.length;
   this.clear();
@@ -6185,7 +6902,7 @@ MapCache.prototype.has = mapCacheHas_default;
 MapCache.prototype.set = mapCacheSet_default;
 var MapCache_default = MapCache;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/memoize.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/memoize.js
 var FUNC_ERROR_TEXT = "Expected a function";
 function memoize(func, resolver) {
   if (typeof func != "function" || resolver != null && typeof resolver != "function") {
@@ -6206,7 +6923,7 @@ function memoize(func, resolver) {
 memoize.Cache = MapCache_default;
 var memoize_default = memoize;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_memoizeCapped.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_memoizeCapped.js
 var MAX_MEMOIZE_SIZE = 500;
 function memoizeCapped(func) {
   var result = memoize_default(func, function(key) {
@@ -6220,7 +6937,7 @@ function memoizeCapped(func) {
 }
 var memoizeCapped_default = memoizeCapped;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_stringToPath.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_stringToPath.js
 var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
 var reEscapeChar = /\\(\\)?/g;
 var stringToPath = memoizeCapped_default(function(string) {
@@ -6235,13 +6952,13 @@ var stringToPath = memoizeCapped_default(function(string) {
 });
 var stringToPath_default = stringToPath;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/toString.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/toString.js
 function toString(value) {
   return value == null ? "" : baseToString_default(value);
 }
 var toString_default = toString;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_castPath.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_castPath.js
 function castPath(value, object) {
   if (isArray_default(value)) {
     return value;
@@ -6250,7 +6967,7 @@ function castPath(value, object) {
 }
 var castPath_default = castPath;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_toKey.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_toKey.js
 var INFINITY3 = 1 / 0;
 function toKey(value) {
   if (typeof value == "string" || isSymbol_default(value)) {
@@ -6261,7 +6978,7 @@ function toKey(value) {
 }
 var toKey_default = toKey;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseGet.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseGet.js
 function baseGet(object, path) {
   path = castPath_default(path, object);
   var index = 0, length = path.length;
@@ -6272,14 +6989,14 @@ function baseGet(object, path) {
 }
 var baseGet_default = baseGet;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/get.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/get.js
 function get(object, path, defaultValue) {
   var result = object == null ? void 0 : baseGet_default(object, path);
   return result === void 0 ? defaultValue : result;
 }
 var get_default = get;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_arrayPush.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_arrayPush.js
 function arrayPush(array, values2) {
   var index = -1, length = values2.length, offset = array.length;
   while (++index < length) {
@@ -6289,14 +7006,14 @@ function arrayPush(array, values2) {
 }
 var arrayPush_default = arrayPush;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_isFlattenable.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_isFlattenable.js
 var spreadableSymbol = Symbol_default ? Symbol_default.isConcatSpreadable : void 0;
 function isFlattenable(value) {
   return isArray_default(value) || isArguments_default(value) || !!(spreadableSymbol && value && value[spreadableSymbol]);
 }
 var isFlattenable_default = isFlattenable;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseFlatten.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseFlatten.js
 function baseFlatten(array, depth, predicate, isStrict, result) {
   var index = -1, length = array.length;
   predicate || (predicate = isFlattenable_default);
@@ -6317,18 +7034,18 @@ function baseFlatten(array, depth, predicate, isStrict, result) {
 }
 var baseFlatten_default = baseFlatten;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/flatten.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/flatten.js
 function flatten(array) {
   var length = array == null ? 0 : array.length;
   return length ? baseFlatten_default(array, 1) : [];
 }
 var flatten_default = flatten;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_getPrototype.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_getPrototype.js
 var getPrototype = overArg_default(Object.getPrototypeOf, Object);
 var getPrototype_default = getPrototype;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseSlice.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseSlice.js
 function baseSlice(array, start, end) {
   var index = -1, length = array.length;
   if (start < 0) {
@@ -6348,7 +7065,7 @@ function baseSlice(array, start, end) {
 }
 var baseSlice_default = baseSlice;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_arrayReduce.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_arrayReduce.js
 function arrayReduce(array, iteratee, accumulator, initAccum) {
   var index = -1, length = array == null ? 0 : array.length;
   if (initAccum && length) {
@@ -6361,14 +7078,14 @@ function arrayReduce(array, iteratee, accumulator, initAccum) {
 }
 var arrayReduce_default = arrayReduce;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_stackClear.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_stackClear.js
 function stackClear() {
   this.__data__ = new ListCache_default();
   this.size = 0;
 }
 var stackClear_default = stackClear;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_stackDelete.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_stackDelete.js
 function stackDelete(key) {
   var data = this.__data__, result = data["delete"](key);
   this.size = data.size;
@@ -6376,19 +7093,19 @@ function stackDelete(key) {
 }
 var stackDelete_default = stackDelete;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_stackGet.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_stackGet.js
 function stackGet(key) {
   return this.__data__.get(key);
 }
 var stackGet_default = stackGet;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_stackHas.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_stackHas.js
 function stackHas(key) {
   return this.__data__.has(key);
 }
 var stackHas_default = stackHas;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_stackSet.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_stackSet.js
 var LARGE_ARRAY_SIZE = 200;
 function stackSet(key, value) {
   var data = this.__data__;
@@ -6407,7 +7124,7 @@ function stackSet(key, value) {
 }
 var stackSet_default = stackSet;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_Stack.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_Stack.js
 function Stack(entries) {
   var data = this.__data__ = new ListCache_default(entries);
   this.size = data.size;
@@ -6419,19 +7136,19 @@ Stack.prototype.has = stackHas_default;
 Stack.prototype.set = stackSet_default;
 var Stack_default = Stack;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseAssign.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseAssign.js
 function baseAssign(object, source) {
   return object && copyObject_default(source, keys_default(source), object);
 }
 var baseAssign_default = baseAssign;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseAssignIn.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseAssignIn.js
 function baseAssignIn(object, source) {
   return object && copyObject_default(source, keysIn_default(source), object);
 }
 var baseAssignIn_default = baseAssignIn;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_cloneBuffer.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_cloneBuffer.js
 var freeExports3 = typeof exports == "object" && exports && !exports.nodeType && exports;
 var freeModule3 = freeExports3 && typeof module == "object" && module && !module.nodeType && module;
 var moduleExports3 = freeModule3 && freeModule3.exports === freeExports3;
@@ -6447,7 +7164,7 @@ function cloneBuffer(buffer, isDeep) {
 }
 var cloneBuffer_default = cloneBuffer;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_arrayFilter.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_arrayFilter.js
 function arrayFilter(array, predicate) {
   var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
   while (++index < length) {
@@ -6460,13 +7177,13 @@ function arrayFilter(array, predicate) {
 }
 var arrayFilter_default = arrayFilter;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/stubArray.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/stubArray.js
 function stubArray() {
   return [];
 }
 var stubArray_default = stubArray;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_getSymbols.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_getSymbols.js
 var objectProto13 = Object.prototype;
 var propertyIsEnumerable2 = objectProto13.propertyIsEnumerable;
 var nativeGetSymbols = Object.getOwnPropertySymbols;
@@ -6481,13 +7198,13 @@ var getSymbols = !nativeGetSymbols ? stubArray_default : function(object) {
 };
 var getSymbols_default = getSymbols;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_copySymbols.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_copySymbols.js
 function copySymbols(source, object) {
   return copyObject_default(source, getSymbols_default(source), object);
 }
 var copySymbols_default = copySymbols;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_getSymbolsIn.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_getSymbolsIn.js
 var nativeGetSymbols2 = Object.getOwnPropertySymbols;
 var getSymbolsIn = !nativeGetSymbols2 ? stubArray_default : function(object) {
   var result = [];
@@ -6499,44 +7216,44 @@ var getSymbolsIn = !nativeGetSymbols2 ? stubArray_default : function(object) {
 };
 var getSymbolsIn_default = getSymbolsIn;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_copySymbolsIn.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_copySymbolsIn.js
 function copySymbolsIn(source, object) {
   return copyObject_default(source, getSymbolsIn_default(source), object);
 }
 var copySymbolsIn_default = copySymbolsIn;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseGetAllKeys.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseGetAllKeys.js
 function baseGetAllKeys(object, keysFunc, symbolsFunc) {
   var result = keysFunc(object);
   return isArray_default(object) ? result : arrayPush_default(result, symbolsFunc(object));
 }
 var baseGetAllKeys_default = baseGetAllKeys;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_getAllKeys.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_getAllKeys.js
 function getAllKeys(object) {
   return baseGetAllKeys_default(object, keys_default, getSymbols_default);
 }
 var getAllKeys_default = getAllKeys;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_getAllKeysIn.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_getAllKeysIn.js
 function getAllKeysIn(object) {
   return baseGetAllKeys_default(object, keysIn_default, getSymbolsIn_default);
 }
 var getAllKeysIn_default = getAllKeysIn;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_DataView.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_DataView.js
 var DataView = getNative_default(root_default, "DataView");
 var DataView_default = DataView;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_Promise.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_Promise.js
 var Promise2 = getNative_default(root_default, "Promise");
 var Promise_default = Promise2;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_Set.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_Set.js
 var Set2 = getNative_default(root_default, "Set");
 var Set_default = Set2;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_getTag.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_getTag.js
 var mapTag2 = "[object Map]";
 var objectTag2 = "[object Object]";
 var promiseTag = "[object Promise]";
@@ -6571,7 +7288,7 @@ if (DataView_default && getTag(new DataView_default(new ArrayBuffer(1))) != data
 }
 var getTag_default = getTag;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_initCloneArray.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_initCloneArray.js
 var objectProto14 = Object.prototype;
 var hasOwnProperty11 = objectProto14.hasOwnProperty;
 function initCloneArray(array) {
@@ -6584,11 +7301,11 @@ function initCloneArray(array) {
 }
 var initCloneArray_default = initCloneArray;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_Uint8Array.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_Uint8Array.js
 var Uint8Array = root_default.Uint8Array;
 var Uint8Array_default = Uint8Array;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_cloneArrayBuffer.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_cloneArrayBuffer.js
 function cloneArrayBuffer(arrayBuffer) {
   var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
   new Uint8Array_default(result).set(new Uint8Array_default(arrayBuffer));
@@ -6596,14 +7313,14 @@ function cloneArrayBuffer(arrayBuffer) {
 }
 var cloneArrayBuffer_default = cloneArrayBuffer;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_cloneDataView.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_cloneDataView.js
 function cloneDataView(dataView, isDeep) {
   var buffer = isDeep ? cloneArrayBuffer_default(dataView.buffer) : dataView.buffer;
   return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
 }
 var cloneDataView_default = cloneDataView;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_cloneRegExp.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_cloneRegExp.js
 var reFlags = /\w*$/;
 function cloneRegExp(regexp) {
   var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
@@ -6612,7 +7329,7 @@ function cloneRegExp(regexp) {
 }
 var cloneRegExp_default = cloneRegExp;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_cloneSymbol.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_cloneSymbol.js
 var symbolProto2 = Symbol_default ? Symbol_default.prototype : void 0;
 var symbolValueOf = symbolProto2 ? symbolProto2.valueOf : void 0;
 function cloneSymbol(symbol) {
@@ -6620,14 +7337,14 @@ function cloneSymbol(symbol) {
 }
 var cloneSymbol_default = cloneSymbol;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_cloneTypedArray.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_cloneTypedArray.js
 function cloneTypedArray(typedArray, isDeep) {
   var buffer = isDeep ? cloneArrayBuffer_default(typedArray.buffer) : typedArray.buffer;
   return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
 }
 var cloneTypedArray_default = cloneTypedArray;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_initCloneByTag.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_initCloneByTag.js
 var boolTag2 = "[object Boolean]";
 var dateTag2 = "[object Date]";
 var mapTag3 = "[object Map]";
@@ -6682,37 +7399,37 @@ function initCloneByTag(object, tag, isDeep) {
 }
 var initCloneByTag_default = initCloneByTag;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_initCloneObject.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_initCloneObject.js
 function initCloneObject(object) {
   return typeof object.constructor == "function" && !isPrototype_default(object) ? baseCreate_default(getPrototype_default(object)) : {};
 }
 var initCloneObject_default = initCloneObject;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseIsMap.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseIsMap.js
 var mapTag4 = "[object Map]";
 function baseIsMap(value) {
   return isObjectLike_default(value) && getTag_default(value) == mapTag4;
 }
 var baseIsMap_default = baseIsMap;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isMap.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isMap.js
 var nodeIsMap = nodeUtil_default && nodeUtil_default.isMap;
 var isMap = nodeIsMap ? baseUnary_default(nodeIsMap) : baseIsMap_default;
 var isMap_default = isMap;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseIsSet.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseIsSet.js
 var setTag4 = "[object Set]";
 function baseIsSet(value) {
   return isObjectLike_default(value) && getTag_default(value) == setTag4;
 }
 var baseIsSet_default = baseIsSet;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isSet.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isSet.js
 var nodeIsSet = nodeUtil_default && nodeUtil_default.isSet;
 var isSet = nodeIsSet ? baseUnary_default(nodeIsSet) : baseIsSet_default;
 var isSet_default = isSet;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseClone.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseClone.js
 var CLONE_DEEP_FLAG = 1;
 var CLONE_FLAT_FLAG = 2;
 var CLONE_SYMBOLS_FLAG = 4;
@@ -6807,14 +7524,14 @@ function baseClone(value, bitmask, customizer, key, object, stack) {
 }
 var baseClone_default = baseClone;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/clone.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/clone.js
 var CLONE_SYMBOLS_FLAG2 = 4;
 function clone(value) {
   return baseClone_default(value, CLONE_SYMBOLS_FLAG2);
 }
 var clone_default = clone;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/compact.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/compact.js
 function compact(array) {
   var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
   while (++index < length) {
@@ -6827,7 +7544,7 @@ function compact(array) {
 }
 var compact_default = compact;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_setCacheAdd.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_setCacheAdd.js
 var HASH_UNDEFINED3 = "__lodash_hash_undefined__";
 function setCacheAdd(value) {
   this.__data__.set(value, HASH_UNDEFINED3);
@@ -6835,13 +7552,13 @@ function setCacheAdd(value) {
 }
 var setCacheAdd_default = setCacheAdd;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_setCacheHas.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_setCacheHas.js
 function setCacheHas(value) {
   return this.__data__.has(value);
 }
 var setCacheHas_default = setCacheHas;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_SetCache.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_SetCache.js
 function SetCache(values2) {
   var index = -1, length = values2 == null ? 0 : values2.length;
   this.__data__ = new MapCache_default();
@@ -6853,7 +7570,7 @@ SetCache.prototype.add = SetCache.prototype.push = setCacheAdd_default;
 SetCache.prototype.has = setCacheHas_default;
 var SetCache_default = SetCache;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_arraySome.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_arraySome.js
 function arraySome(array, predicate) {
   var index = -1, length = array == null ? 0 : array.length;
   while (++index < length) {
@@ -6865,13 +7582,13 @@ function arraySome(array, predicate) {
 }
 var arraySome_default = arraySome;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_cacheHas.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_cacheHas.js
 function cacheHas(cache, key) {
   return cache.has(key);
 }
 var cacheHas_default = cacheHas;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_equalArrays.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_equalArrays.js
 var COMPARE_PARTIAL_FLAG = 1;
 var COMPARE_UNORDERED_FLAG = 2;
 function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
@@ -6919,7 +7636,7 @@ function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
 }
 var equalArrays_default = equalArrays;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_mapToArray.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_mapToArray.js
 function mapToArray(map2) {
   var index = -1, result = Array(map2.size);
   map2.forEach(function(value, key) {
@@ -6929,7 +7646,7 @@ function mapToArray(map2) {
 }
 var mapToArray_default = mapToArray;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_setToArray.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_setToArray.js
 function setToArray(set) {
   var index = -1, result = Array(set.size);
   set.forEach(function(value) {
@@ -6939,7 +7656,7 @@ function setToArray(set) {
 }
 var setToArray_default = setToArray;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_equalByTag.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_equalByTag.js
 var COMPARE_PARTIAL_FLAG2 = 1;
 var COMPARE_UNORDERED_FLAG2 = 2;
 var boolTag4 = "[object Boolean]";
@@ -7003,7 +7720,7 @@ function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
 }
 var equalByTag_default = equalByTag;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_equalObjects.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_equalObjects.js
 var COMPARE_PARTIAL_FLAG3 = 1;
 var objectProto15 = Object.prototype;
 var hasOwnProperty12 = objectProto15.hasOwnProperty;
@@ -7052,7 +7769,7 @@ function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
 }
 var equalObjects_default = equalObjects;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseIsEqualDeep.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseIsEqualDeep.js
 var COMPARE_PARTIAL_FLAG4 = 1;
 var argsTag4 = "[object Arguments]";
 var arrayTag3 = "[object Array]";
@@ -7091,7 +7808,7 @@ function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
 }
 var baseIsEqualDeep_default = baseIsEqualDeep;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseIsEqual.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseIsEqual.js
 function baseIsEqual(value, other, bitmask, customizer, stack) {
   if (value === other) {
     return true;
@@ -7103,7 +7820,7 @@ function baseIsEqual(value, other, bitmask, customizer, stack) {
 }
 var baseIsEqual_default = baseIsEqual;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseIsMatch.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseIsMatch.js
 var COMPARE_PARTIAL_FLAG5 = 1;
 var COMPARE_UNORDERED_FLAG3 = 2;
 function baseIsMatch(object, source, matchData, customizer) {
@@ -7139,13 +7856,13 @@ function baseIsMatch(object, source, matchData, customizer) {
 }
 var baseIsMatch_default = baseIsMatch;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_isStrictComparable.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_isStrictComparable.js
 function isStrictComparable(value) {
   return value === value && !isObject_default(value);
 }
 var isStrictComparable_default = isStrictComparable;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_getMatchData.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_getMatchData.js
 function getMatchData(object) {
   var result = keys_default(object), length = result.length;
   while (length--) {
@@ -7156,7 +7873,7 @@ function getMatchData(object) {
 }
 var getMatchData_default = getMatchData;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_matchesStrictComparable.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_matchesStrictComparable.js
 function matchesStrictComparable(key, srcValue) {
   return function(object) {
     if (object == null) {
@@ -7167,7 +7884,7 @@ function matchesStrictComparable(key, srcValue) {
 }
 var matchesStrictComparable_default = matchesStrictComparable;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseMatches.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseMatches.js
 function baseMatches(source) {
   var matchData = getMatchData_default(source);
   if (matchData.length == 1 && matchData[0][2]) {
@@ -7179,13 +7896,13 @@ function baseMatches(source) {
 }
 var baseMatches_default = baseMatches;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseHasIn.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseHasIn.js
 function baseHasIn(object, key) {
   return object != null && key in Object(object);
 }
 var baseHasIn_default = baseHasIn;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_hasPath.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_hasPath.js
 function hasPath(object, path, hasFunc) {
   path = castPath_default(path, object);
   var index = -1, length = path.length, result = false;
@@ -7204,13 +7921,13 @@ function hasPath(object, path, hasFunc) {
 }
 var hasPath_default = hasPath;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/hasIn.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/hasIn.js
 function hasIn(object, path) {
   return object != null && hasPath_default(object, path, baseHasIn_default);
 }
 var hasIn_default = hasIn;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseMatchesProperty.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseMatchesProperty.js
 var COMPARE_PARTIAL_FLAG6 = 1;
 var COMPARE_UNORDERED_FLAG4 = 2;
 function baseMatchesProperty(path, srcValue) {
@@ -7224,7 +7941,7 @@ function baseMatchesProperty(path, srcValue) {
 }
 var baseMatchesProperty_default = baseMatchesProperty;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseProperty.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseProperty.js
 function baseProperty(key) {
   return function(object) {
     return object == null ? void 0 : object[key];
@@ -7232,7 +7949,7 @@ function baseProperty(key) {
 }
 var baseProperty_default = baseProperty;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_basePropertyDeep.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_basePropertyDeep.js
 function basePropertyDeep(path) {
   return function(object) {
     return baseGet_default(object, path);
@@ -7240,13 +7957,13 @@ function basePropertyDeep(path) {
 }
 var basePropertyDeep_default = basePropertyDeep;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/property.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/property.js
 function property(path) {
   return isKey_default(path) ? baseProperty_default(toKey_default(path)) : basePropertyDeep_default(path);
 }
 var property_default = property;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseIteratee.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseIteratee.js
 function baseIteratee(value) {
   if (typeof value == "function") {
     return value;
@@ -7261,7 +7978,7 @@ function baseIteratee(value) {
 }
 var baseIteratee_default = baseIteratee;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_arrayAggregator.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_arrayAggregator.js
 function arrayAggregator(array, setter, iteratee, accumulator) {
   var index = -1, length = array == null ? 0 : array.length;
   while (++index < length) {
@@ -7272,7 +7989,7 @@ function arrayAggregator(array, setter, iteratee, accumulator) {
 }
 var arrayAggregator_default = arrayAggregator;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_createBaseFor.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_createBaseFor.js
 function createBaseFor(fromRight) {
   return function(object, iteratee, keysFunc) {
     var index = -1, iterable = Object(object), props = keysFunc(object), length = props.length;
@@ -7287,17 +8004,17 @@ function createBaseFor(fromRight) {
 }
 var createBaseFor_default = createBaseFor;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseFor.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseFor.js
 var baseFor = createBaseFor_default();
 var baseFor_default = baseFor;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseForOwn.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseForOwn.js
 function baseForOwn(object, iteratee) {
   return object && baseFor_default(object, iteratee, keys_default);
 }
 var baseForOwn_default = baseForOwn;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_createBaseEach.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_createBaseEach.js
 function createBaseEach(eachFunc, fromRight) {
   return function(collection, iteratee) {
     if (collection == null) {
@@ -7317,11 +8034,11 @@ function createBaseEach(eachFunc, fromRight) {
 }
 var createBaseEach_default = createBaseEach;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseEach.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseEach.js
 var baseEach = createBaseEach_default(baseForOwn_default);
 var baseEach_default = baseEach;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseAggregator.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseAggregator.js
 function baseAggregator(collection, setter, iteratee, accumulator) {
   baseEach_default(collection, function(value, key, collection2) {
     setter(accumulator, value, iteratee(value), collection2);
@@ -7330,7 +8047,7 @@ function baseAggregator(collection, setter, iteratee, accumulator) {
 }
 var baseAggregator_default = baseAggregator;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_createAggregator.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_createAggregator.js
 function createAggregator(setter, initializer) {
   return function(collection, iteratee) {
     var func = isArray_default(collection) ? arrayAggregator_default : baseAggregator_default, accumulator = initializer ? initializer() : {};
@@ -7339,7 +8056,7 @@ function createAggregator(setter, initializer) {
 }
 var createAggregator_default = createAggregator;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/defaults.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/defaults.js
 var objectProto17 = Object.prototype;
 var hasOwnProperty14 = objectProto17.hasOwnProperty;
 var defaults = baseRest_default(function(object, sources) {
@@ -7367,13 +8084,13 @@ var defaults = baseRest_default(function(object, sources) {
 });
 var defaults_default = defaults;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isArrayLikeObject.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isArrayLikeObject.js
 function isArrayLikeObject(value) {
   return isObjectLike_default(value) && isArrayLike_default(value);
 }
 var isArrayLikeObject_default = isArrayLikeObject;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_arrayIncludesWith.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_arrayIncludesWith.js
 function arrayIncludesWith(array, value, comparator) {
   var index = -1, length = array == null ? 0 : array.length;
   while (++index < length) {
@@ -7385,7 +8102,7 @@ function arrayIncludesWith(array, value, comparator) {
 }
 var arrayIncludesWith_default = arrayIncludesWith;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseDifference.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseDifference.js
 var LARGE_ARRAY_SIZE2 = 200;
 function baseDifference(array, values2, iteratee, comparator) {
   var index = -1, includes2 = arrayIncludes_default, isCommon = true, length = array.length, result = [], valuesLength = values2.length;
@@ -7423,20 +8140,20 @@ function baseDifference(array, values2, iteratee, comparator) {
 }
 var baseDifference_default = baseDifference;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/difference.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/difference.js
 var difference = baseRest_default(function(array, values2) {
   return isArrayLikeObject_default(array) ? baseDifference_default(array, baseFlatten_default(values2, 1, isArrayLikeObject_default, true)) : [];
 });
 var difference_default = difference;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/last.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/last.js
 function last(array) {
   var length = array == null ? 0 : array.length;
   return length ? array[length - 1] : void 0;
 }
 var last_default = last;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/drop.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/drop.js
 function drop(array, n, guard) {
   var length = array == null ? 0 : array.length;
   if (!length) {
@@ -7447,7 +8164,7 @@ function drop(array, n, guard) {
 }
 var drop_default = drop;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/dropRight.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/dropRight.js
 function dropRight(array, n, guard) {
   var length = array == null ? 0 : array.length;
   if (!length) {
@@ -7459,20 +8176,20 @@ function dropRight(array, n, guard) {
 }
 var dropRight_default = dropRight;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_castFunction.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_castFunction.js
 function castFunction(value) {
   return typeof value == "function" ? value : identity_default;
 }
 var castFunction_default = castFunction;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/forEach.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/forEach.js
 function forEach(collection, iteratee) {
   var func = isArray_default(collection) ? arrayEach_default : baseEach_default;
   return func(collection, castFunction_default(iteratee));
 }
 var forEach_default = forEach;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_arrayEvery.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_arrayEvery.js
 function arrayEvery(array, predicate) {
   var index = -1, length = array == null ? 0 : array.length;
   while (++index < length) {
@@ -7484,7 +8201,7 @@ function arrayEvery(array, predicate) {
 }
 var arrayEvery_default = arrayEvery;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseEvery.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseEvery.js
 function baseEvery(collection, predicate) {
   var result = true;
   baseEach_default(collection, function(value, index, collection2) {
@@ -7495,7 +8212,7 @@ function baseEvery(collection, predicate) {
 }
 var baseEvery_default = baseEvery;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/every.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/every.js
 function every(collection, predicate, guard) {
   var func = isArray_default(collection) ? arrayEvery_default : baseEvery_default;
   if (guard && isIterateeCall_default(collection, predicate, guard)) {
@@ -7505,7 +8222,7 @@ function every(collection, predicate, guard) {
 }
 var every_default = every;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseFilter.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseFilter.js
 function baseFilter(collection, predicate) {
   var result = [];
   baseEach_default(collection, function(value, index, collection2) {
@@ -7517,14 +8234,14 @@ function baseFilter(collection, predicate) {
 }
 var baseFilter_default = baseFilter;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/filter.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/filter.js
 function filter(collection, predicate) {
   var func = isArray_default(collection) ? arrayFilter_default : baseFilter_default;
   return func(collection, baseIteratee_default(predicate, 3));
 }
 var filter_default = filter;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_createFind.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_createFind.js
 function createFind(findIndexFunc) {
   return function(collection, predicate, fromIndex) {
     var iterable = Object(collection);
@@ -7541,7 +8258,7 @@ function createFind(findIndexFunc) {
 }
 var createFind_default = createFind;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/findIndex.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/findIndex.js
 var nativeMax2 = Math.max;
 function findIndex(array, predicate, fromIndex) {
   var length = array == null ? 0 : array.length;
@@ -7556,17 +8273,17 @@ function findIndex(array, predicate, fromIndex) {
 }
 var findIndex_default = findIndex;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/find.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/find.js
 var find = createFind_default(findIndex_default);
 var find_default = find;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/head.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/head.js
 function head(array) {
   return array && array.length ? array[0] : void 0;
 }
 var head_default = head;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseMap.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseMap.js
 function baseMap(collection, iteratee) {
   var index = -1, result = isArrayLike_default(collection) ? Array(collection.length) : [];
   baseEach_default(collection, function(value, key, collection2) {
@@ -7576,20 +8293,20 @@ function baseMap(collection, iteratee) {
 }
 var baseMap_default = baseMap;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/map.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/map.js
 function map(collection, iteratee) {
   var func = isArray_default(collection) ? arrayMap_default : baseMap_default;
   return func(collection, baseIteratee_default(iteratee, 3));
 }
 var map_default = map;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/flatMap.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/flatMap.js
 function flatMap(collection, iteratee) {
   return baseFlatten_default(map_default(collection, iteratee), 1);
 }
 var flatMap_default = flatMap;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/groupBy.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/groupBy.js
 var objectProto18 = Object.prototype;
 var hasOwnProperty15 = objectProto18.hasOwnProperty;
 var groupBy = createAggregator_default(function(result, value, key) {
@@ -7601,7 +8318,7 @@ var groupBy = createAggregator_default(function(result, value, key) {
 });
 var groupBy_default = groupBy;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseHas.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseHas.js
 var objectProto19 = Object.prototype;
 var hasOwnProperty16 = objectProto19.hasOwnProperty;
 function baseHas(object, key) {
@@ -7609,20 +8326,20 @@ function baseHas(object, key) {
 }
 var baseHas_default = baseHas;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/has.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/has.js
 function has(object, path) {
   return object != null && hasPath_default(object, path, baseHas_default);
 }
 var has_default = has;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isString.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isString.js
 var stringTag5 = "[object String]";
 function isString(value) {
   return typeof value == "string" || !isArray_default(value) && isObjectLike_default(value) && baseGetTag_default(value) == stringTag5;
 }
 var isString_default = isString;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseValues.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseValues.js
 function baseValues(object, props) {
   return arrayMap_default(props, function(key) {
     return object[key];
@@ -7630,13 +8347,13 @@ function baseValues(object, props) {
 }
 var baseValues_default = baseValues;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/values.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/values.js
 function values(object) {
   return object == null ? [] : baseValues_default(object, keys_default(object));
 }
 var values_default = values;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/includes.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/includes.js
 var nativeMax3 = Math.max;
 function includes(collection, value, fromIndex, guard) {
   collection = isArrayLike_default(collection) ? collection : values_default(collection);
@@ -7649,7 +8366,7 @@ function includes(collection, value, fromIndex, guard) {
 }
 var includes_default = includes;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/indexOf.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/indexOf.js
 var nativeMax4 = Math.max;
 function indexOf(array, value, fromIndex) {
   var length = array == null ? 0 : array.length;
@@ -7664,7 +8381,7 @@ function indexOf(array, value, fromIndex) {
 }
 var indexOf_default = indexOf;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isEmpty.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isEmpty.js
 var mapTag7 = "[object Map]";
 var setTag7 = "[object Set]";
 var objectProto20 = Object.prototype;
@@ -7692,25 +8409,25 @@ function isEmpty(value) {
 }
 var isEmpty_default = isEmpty;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseIsRegExp.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseIsRegExp.js
 var regexpTag5 = "[object RegExp]";
 function baseIsRegExp(value) {
   return isObjectLike_default(value) && baseGetTag_default(value) == regexpTag5;
 }
 var baseIsRegExp_default = baseIsRegExp;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isRegExp.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isRegExp.js
 var nodeIsRegExp = nodeUtil_default && nodeUtil_default.isRegExp;
 var isRegExp = nodeIsRegExp ? baseUnary_default(nodeIsRegExp) : baseIsRegExp_default;
 var isRegExp_default = isRegExp;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isUndefined.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isUndefined.js
 function isUndefined(value) {
   return value === void 0;
 }
 var isUndefined_default = isUndefined;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/negate.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/negate.js
 var FUNC_ERROR_TEXT2 = "Expected a function";
 function negate(predicate) {
   if (typeof predicate != "function") {
@@ -7733,7 +8450,7 @@ function negate(predicate) {
 }
 var negate_default = negate;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseSet.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseSet.js
 function baseSet(object, path, value, customizer) {
   if (!isObject_default(object)) {
     return object;
@@ -7759,7 +8476,7 @@ function baseSet(object, path, value, customizer) {
 }
 var baseSet_default = baseSet;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_basePickBy.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_basePickBy.js
 function basePickBy(object, paths, predicate) {
   var index = -1, length = paths.length, result = {};
   while (++index < length) {
@@ -7772,7 +8489,7 @@ function basePickBy(object, paths, predicate) {
 }
 var basePickBy_default = basePickBy;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/pickBy.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/pickBy.js
 function pickBy(object, predicate) {
   if (object == null) {
     return {};
@@ -7787,7 +8504,7 @@ function pickBy(object, predicate) {
 }
 var pickBy_default = pickBy;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseReduce.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseReduce.js
 function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {
   eachFunc(collection, function(value, index, collection2) {
     accumulator = initAccum ? (initAccum = false, value) : iteratee(accumulator, value, index, collection2);
@@ -7796,21 +8513,21 @@ function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {
 }
 var baseReduce_default = baseReduce;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/reduce.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/reduce.js
 function reduce(collection, iteratee, accumulator) {
   var func = isArray_default(collection) ? arrayReduce_default : baseReduce_default, initAccum = arguments.length < 3;
   return func(collection, baseIteratee_default(iteratee, 4), accumulator, initAccum, baseEach_default);
 }
 var reduce_default = reduce;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/reject.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/reject.js
 function reject(collection, predicate) {
   var func = isArray_default(collection) ? arrayFilter_default : baseFilter_default;
   return func(collection, negate_default(baseIteratee_default(predicate, 3)));
 }
 var reject_default = reject;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseSome.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseSome.js
 function baseSome(collection, predicate) {
   var result;
   baseEach_default(collection, function(value, index, collection2) {
@@ -7821,7 +8538,7 @@ function baseSome(collection, predicate) {
 }
 var baseSome_default = baseSome;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/some.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/some.js
 function some(collection, predicate, guard) {
   var func = isArray_default(collection) ? arraySome_default : baseSome_default;
   if (guard && isIterateeCall_default(collection, predicate, guard)) {
@@ -7831,14 +8548,14 @@ function some(collection, predicate, guard) {
 }
 var some_default = some;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_createSet.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_createSet.js
 var INFINITY4 = 1 / 0;
 var createSet = !(Set_default && 1 / setToArray_default(new Set_default([, -0]))[1] == INFINITY4) ? noop_default : function(values2) {
   return new Set_default(values2);
 };
 var createSet_default = createSet;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseUniq.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseUniq.js
 var LARGE_ARRAY_SIZE3 = 200;
 function baseUniq(array, iteratee, comparator) {
   var index = -1, includes2 = arrayIncludes_default, length = array.length, isCommon = true, result = [], seen = result;
@@ -7882,13 +8599,13 @@ function baseUniq(array, iteratee, comparator) {
 }
 var baseUniq_default = baseUniq;
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/uniq.js
+// node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/uniq.js
 function uniq(array) {
   return array && array.length ? baseUniq_default(array) : [];
 }
 var uniq_default = uniq;
 
-// node_modules/.pnpm/@chevrotain+utils@11.1.0/node_modules/@chevrotain/utils/lib/src/print.js
+// node_modules/.pnpm/@chevrotain+utils@11.1.1/node_modules/@chevrotain/utils/lib/src/print.js
 function PRINT_ERROR(msg) {
   if (console && console.error) {
     console.error(`Error: ${msg}`);
@@ -7900,7 +8617,7 @@ function PRINT_WARNING(msg) {
   }
 }
 
-// node_modules/.pnpm/@chevrotain+utils@11.1.0/node_modules/@chevrotain/utils/lib/src/timer.js
+// node_modules/.pnpm/@chevrotain+utils@11.1.1/node_modules/@chevrotain/utils/lib/src/timer.js
 function timer(func) {
   const start = (/* @__PURE__ */ new Date()).getTime();
   const val = func();
@@ -7909,7 +8626,7 @@ function timer(func) {
   return { time: total, value: val };
 }
 
-// node_modules/.pnpm/@chevrotain+utils@11.1.0/node_modules/@chevrotain/utils/lib/src/to-fast-properties.js
+// node_modules/.pnpm/@chevrotain+utils@11.1.1/node_modules/@chevrotain/utils/lib/src/to-fast-properties.js
 function toFastProperties(toBecomeFast) {
   function FakeConstructor() {
   }
@@ -7925,7 +8642,7 @@ function toFastProperties(toBecomeFast) {
   (0, eval)(toBecomeFast);
 }
 
-// node_modules/.pnpm/@chevrotain+gast@11.1.0/node_modules/@chevrotain/gast/lib/src/model.js
+// node_modules/.pnpm/@chevrotain+gast@11.1.1/node_modules/@chevrotain/gast/lib/src/model.js
 function tokenLabel(tokType) {
   if (hasTokenLabel(tokType)) {
     return tokType.LABEL;
@@ -8131,7 +8848,7 @@ function serializeProduction(node) {
   }
 }
 
-// node_modules/.pnpm/@chevrotain+gast@11.1.0/node_modules/@chevrotain/gast/lib/src/visitor.js
+// node_modules/.pnpm/@chevrotain+gast@11.1.1/node_modules/@chevrotain/gast/lib/src/visitor.js
 var GAstVisitor = class {
   visit(node) {
     const nodeAny = node;
@@ -8193,7 +8910,7 @@ var GAstVisitor = class {
   }
 };
 
-// node_modules/.pnpm/@chevrotain+gast@11.1.0/node_modules/@chevrotain/gast/lib/src/helpers.js
+// node_modules/.pnpm/@chevrotain+gast@11.1.1/node_modules/@chevrotain/gast/lib/src/helpers.js
 function isSequenceProd(prod) {
   return prod instanceof Alternative || prod instanceof Option || prod instanceof Repetition || prod instanceof RepetitionMandatory || prod instanceof RepetitionMandatoryWithSeparator || prod instanceof RepetitionWithSeparator || prod instanceof Terminal || prod instanceof Rule;
 }
@@ -8244,7 +8961,7 @@ function getProductionDslName(prod) {
   }
 }
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/parse/grammar/rest.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/grammar/rest.js
 var RestWalker = class {
   walk(prod, prevRest = []) {
     forEach_default(prod.definition, (subProd, index) => {
@@ -8324,7 +9041,7 @@ function restForRepetitionWithSeparator(repSepProd, currRest, prevRest) {
   return fullRepSepRest;
 }
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/parse/grammar/first.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/grammar/first.js
 function first(prod) {
   if (prod instanceof NonTerminal) {
     return first(prod.referencedRule);
@@ -8364,10 +9081,10 @@ function firstForTerminal(terminal) {
   return [terminal.terminalType];
 }
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/parse/constants.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/constants.js
 var IN = "_~IN~_";
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/parse/grammar/follow.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/grammar/follow.js
 var ResyncFollowsWalker = class extends RestWalker {
   constructor(topProd) {
     super();
@@ -8400,7 +9117,7 @@ function buildBetweenProdsFollowPrefix(inner, occurenceInParent) {
   return inner.name + occurenceInParent + IN;
 }
 
-// node_modules/.pnpm/@chevrotain+regexp-to-ast@11.1.0/node_modules/@chevrotain/regexp-to-ast/lib/src/utils.js
+// node_modules/.pnpm/@chevrotain+regexp-to-ast@11.1.1/node_modules/@chevrotain/regexp-to-ast/lib/src/utils.js
 function cc(char) {
   return char.charCodeAt(0);
 }
@@ -8433,7 +9150,7 @@ function isCharacter(obj) {
   return obj["type"] === "Character";
 }
 
-// node_modules/.pnpm/@chevrotain+regexp-to-ast@11.1.0/node_modules/@chevrotain/regexp-to-ast/lib/src/character-classes.js
+// node_modules/.pnpm/@chevrotain+regexp-to-ast@11.1.1/node_modules/@chevrotain/regexp-to-ast/lib/src/character-classes.js
 var digitsCharCodes = [];
 for (let i = cc("0"); i <= cc("9"); i++) {
   digitsCharCodes.push(i);
@@ -8474,7 +9191,7 @@ var whitespaceCodes = [
   cc("\uFEFF")
 ];
 
-// node_modules/.pnpm/@chevrotain+regexp-to-ast@11.1.0/node_modules/@chevrotain/regexp-to-ast/lib/src/regexp-parser.js
+// node_modules/.pnpm/@chevrotain+regexp-to-ast@11.1.1/node_modules/@chevrotain/regexp-to-ast/lib/src/regexp-parser.js
 var hexDigitPattern = /[0-9a-fA-F]/;
 var decimalPattern = /[0-9]/;
 var decimalPatternNoZero = /[1-9]/;
@@ -9177,7 +9894,7 @@ var RegExpParser = class {
   }
 };
 
-// node_modules/.pnpm/@chevrotain+regexp-to-ast@11.1.0/node_modules/@chevrotain/regexp-to-ast/lib/src/base-regexp-visitor.js
+// node_modules/.pnpm/@chevrotain+regexp-to-ast@11.1.1/node_modules/@chevrotain/regexp-to-ast/lib/src/base-regexp-visitor.js
 var BaseRegExpVisitor = class {
   visitChildren(node) {
     for (const key in node) {
@@ -9287,7 +10004,7 @@ var BaseRegExpVisitor = class {
   }
 };
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/scan/reg_exp_parser.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/scan/reg_exp_parser.js
 var regExpAstCache = {};
 var regExpParser = new RegExpParser();
 function getRegExpAst(regExp) {
@@ -9304,7 +10021,7 @@ function clearRegExpParserCache() {
   regExpAstCache = {};
 }
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/scan/reg_exp.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/scan/reg_exp.js
 var complementErrorMessage = "Complement Sets are not supported for first char optimization";
 var failedOptimizationPrefixMsg = 'Unable to use "first char" lexer optimizations:\n';
 function getOptimizedStartCodesIndices(regExp, ensureOptimizations = false) {
@@ -9516,7 +10233,7 @@ function canMatchCharCode(charCodes, pattern) {
   }
 }
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/scan/lexer.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/scan/lexer.js
 var PATTERN = "PATTERN";
 var DEFAULT_MODE = "defaultMode";
 var MODES = "modes";
@@ -10209,7 +10926,7 @@ function initCharCodeToOptimizedIndexMap() {
   }
 }
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/scan/tokens.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/scan/tokens.js
 function tokenStructuredMatcher(tokInstance, tokConstructor) {
   const instanceType = tokInstance.tokenTypeIdx;
   if (instanceType === tokConstructor.tokenTypeIdx) {
@@ -10308,7 +11025,7 @@ function isTokenType(tokType) {
   return has_default(tokType, "tokenTypeIdx");
 }
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/scan/lexer_errors_public.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/scan/lexer_errors_public.js
 var defaultLexerErrorProvider = {
   buildUnableToPopLexerModeMessage(token) {
     return `Unable to pop Lexer Mode after encountering Token ->${token.image}<- The Mode Stack is empty`;
@@ -10318,7 +11035,7 @@ var defaultLexerErrorProvider = {
   }
 };
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/scan/lexer_public.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/scan/lexer_public.js
 var LexerDefinitionErrorType;
 (function(LexerDefinitionErrorType2) {
   LexerDefinitionErrorType2[LexerDefinitionErrorType2["MISSING_PATTERN"] = 0] = "MISSING_PATTERN";
@@ -10860,7 +11577,7 @@ var Lexer = class {
 Lexer.SKIPPED = "This marks a skipped Token pattern, this means each token identified by it will be consumed and then thrown into oblivion, this can be used to for example to completely ignore whitespace.";
 Lexer.NA = /NOT_APPLICABLE/;
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/scan/tokens_public.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/scan/tokens_public.js
 function tokenLabel2(tokType) {
   if (hasTokenLabel2(tokType)) {
     return tokType.LABEL;
@@ -10939,7 +11656,7 @@ function tokenMatcher(token, tokType) {
   return tokenStructuredMatcher(token, tokType);
 }
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/parse/errors_public.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/errors_public.js
 var defaultParserErrorProvider = {
   buildMismatchTokenMessage({ expected, actual, previous, ruleName }) {
     const hasLabel = hasTokenLabel2(expected);
@@ -11093,7 +11810,7 @@ see: https://en.wikipedia.org/wiki/LL_parser#Left_factoring.`;
   }
 };
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/parse/grammar/resolver.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/grammar/resolver.js
 function resolveGrammar(topLevels, errMsgProvider) {
   const refResolver = new GastRefResolverVisitor(topLevels, errMsgProvider);
   refResolver.resolveRefs();
@@ -11128,7 +11845,7 @@ var GastRefResolverVisitor = class extends GAstVisitor {
   }
 };
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/parse/grammar/interpreter.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/grammar/interpreter.js
 var AbstractNextPossibleTokensWalker = class extends RestWalker {
   constructor(topProd, path) {
     super();
@@ -11539,7 +12256,7 @@ function expandTopLevelRule(topRule, currIdx, currRuleStack, currOccurrenceStack
   };
 }
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/parse/grammar/lookahead.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/grammar/lookahead.js
 var PROD_TYPE;
 (function(PROD_TYPE2) {
   PROD_TYPE2[PROD_TYPE2["OPTION"] = 0] = "OPTION";
@@ -11898,7 +12615,7 @@ function areTokenCategoriesNotUsed(lookAheadPaths) {
   return every_default(lookAheadPaths, (singleAltPaths) => every_default(singleAltPaths, (singlePath) => every_default(singlePath, (token) => isEmpty_default(token.categoryMatches))));
 }
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/parse/grammar/checks.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/grammar/checks.js
 function validateLookahead(options) {
   const lookaheadValidationErrorMessages = options.lookaheadStrategy.validate({
     rules: options.rules,
@@ -12292,7 +13009,7 @@ function checkTerminalAndNoneTerminalsNameSpace(topLevels, tokenTypes, errMsgPro
   return errors;
 }
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/parse/grammar/gast/gast_resolver_public.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/grammar/gast/gast_resolver_public.js
 function resolveGrammar2(options) {
   const actualOptions = defaults_default(options, {
     errMsgProvider: defaultGrammarResolverErrorProvider
@@ -12310,7 +13027,7 @@ function validateGrammar2(options) {
   return validateGrammar(options.rules, options.tokenTypes, options.errMsgProvider, options.grammarName);
 }
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/parse/exceptions_public.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/exceptions_public.js
 var MISMATCHED_TOKEN_EXCEPTION = "MismatchedTokenException";
 var NO_VIABLE_ALT_EXCEPTION = "NoViableAltException";
 var EARLY_EXIT_EXCEPTION = "EarlyExitException";
@@ -12364,7 +13081,7 @@ var EarlyExitException = class extends RecognitionException {
   }
 };
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/parse/parser/traits/recoverable.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/parser/traits/recoverable.js
 var EOF_FOLLOW_KEY = {};
 var IN_RULE_RECOVERY_EXCEPTION = "InRuleRecoveryException";
 var InRuleRecoveryException = class extends Error {
@@ -12605,7 +13322,7 @@ function attemptInRepetitionRecovery(prodFunc, args, lookaheadFunc, dslMethodIdx
   }
 }
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/parse/grammar/keys.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/grammar/keys.js
 var BITS_FOR_METHOD_TYPE = 4;
 var BITS_FOR_OCCURRENCE_IDX = 8;
 var BITS_FOR_ALT_IDX = 8;
@@ -12620,7 +13337,7 @@ function getKeyForAutomaticLookahead(ruleIdx, dslMethodIdx, occurrence) {
 }
 var BITS_START_FOR_ALT_IDX = 32 - BITS_FOR_ALT_IDX;
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/parse/grammar/llk_lookahead.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/grammar/llk_lookahead.js
 var LLkLookaheadStrategy = class {
   constructor(options) {
     var _a;
@@ -12662,7 +13379,7 @@ var LLkLookaheadStrategy = class {
   }
 };
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/parse/parser/traits/looksahead.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/parser/traits/looksahead.js
 var LooksAhead = class {
   initLooksAhead(config) {
     this.dynamicTokensEnabled = has_default(config, "dynamicTokensEnabled") ? config.dynamicTokensEnabled : DEFAULT_PARSER_CONFIG.dynamicTokensEnabled;
@@ -12782,7 +13499,7 @@ function collectMethods(rule) {
   return dslMethods;
 }
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/parse/cst/cst.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/cst/cst.js
 function setNodeLocationOnlyOffset(currNodeLocation, newLocationInfo) {
   if (isNaN(currNodeLocation.startOffset) === true) {
     currNodeLocation.startOffset = newLocationInfo.startOffset;
@@ -12820,7 +13537,7 @@ function addNoneTerminalToCst(node, ruleName, ruleResult) {
   }
 }
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/lang/lang_extensions.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/lang/lang_extensions.js
 var NAME = "name";
 function defineNameProp(obj, nameValue) {
   Object.defineProperty(obj, NAME, {
@@ -12831,7 +13548,7 @@ function defineNameProp(obj, nameValue) {
   });
 }
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/parse/cst/cst_visitor.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/cst/cst_visitor.js
 function defaultVisit(ctx, param) {
   const childrenNames = keys_default(ctx);
   const childrenNamesLength = childrenNames.length;
@@ -12910,7 +13627,7 @@ function validateMissingCstMethods(visitorInstance, ruleNames) {
   return compact_default(errors);
 }
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/parse/parser/traits/tree_builder.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/parser/traits/tree_builder.js
 var TreeBuilder = class {
   initTreeBuilder(config) {
     this.CST_STACK = [];
@@ -13072,7 +13789,7 @@ var TreeBuilder = class {
   }
 };
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/parse/parser/traits/lexer_adapter.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/parser/traits/lexer_adapter.js
 var LexerAdapter = class {
   initLexerAdapter() {
     this.tokVector = [];
@@ -13129,7 +13846,7 @@ var LexerAdapter = class {
   }
 };
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/parse/parser/traits/recognizer_api.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/parser/traits/recognizer_api.js
 var RecognizerApi = class {
   ACTION(impl) {
     return impl.call(this);
@@ -13445,7 +14162,7 @@ var RecognizerApi = class {
   }
 };
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/parse/parser/traits/recognizer_engine.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/parser/traits/recognizer_engine.js
 var RecognizerEngine = class {
   initRecognizerEngine(tokenVocabulary, config) {
     this.className = this.constructor.name;
@@ -13869,7 +14586,7 @@ Make sure that all grammar rule definitions are done before 'performSelfAnalysis
   }
 };
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/parse/parser/traits/error_handler.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/parser/traits/error_handler.js
 var ErrorHandler = class {
   initErrorHandler(config) {
     this._errors = [];
@@ -13933,7 +14650,7 @@ var ErrorHandler = class {
   }
 };
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/parse/parser/traits/context_assist.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/parser/traits/context_assist.js
 var ContentAssist = class {
   initContentAssist() {
   }
@@ -13955,7 +14672,7 @@ var ContentAssist = class {
   }
 };
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/parse/parser/traits/gast_recorder.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/parser/traits/gast_recorder.js
 var RECORDING_NULL_OBJECT = {
   description: "This Object indicates the Parser is during Recording Phase"
 };
@@ -14217,7 +14934,7 @@ function assertMethodIdxIsValid(idx) {
   }
 }
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/parse/parser/traits/perf_tracer.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/parser/traits/perf_tracer.js
 var PerformanceTracer = class {
   initPerformanceTracer(config) {
     if (has_default(config, "traceInitPerf")) {
@@ -14251,7 +14968,7 @@ var PerformanceTracer = class {
   }
 };
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/parse/parser/utils/apply_mixins.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/parser/utils/apply_mixins.js
 function applyMixins(derivedCtor, baseCtors) {
   baseCtors.forEach((baseCtor) => {
     const baseProto = baseCtor.prototype;
@@ -14269,7 +14986,7 @@ function applyMixins(derivedCtor, baseCtors) {
   });
 }
 
-// node_modules/.pnpm/chevrotain@11.1.0/node_modules/chevrotain/lib/src/parse/parser/parser.js
+// node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/parser/parser.js
 var END_OF_FILE = createTokenInstance(EOF, "", NaN, NaN, NaN, NaN, NaN, NaN);
 Object.freeze(END_OF_FILE);
 var DEFAULT_PARSER_CONFIG = Object.freeze({
@@ -15317,7 +16034,7 @@ function parse(source, options = {}) {
 
 // packages/resolver/src/loader.ts
 import { readFile as readFile4 } from "fs/promises";
-import { resolve as resolve2, dirname as dirname3, isAbsolute } from "path";
+import { resolve as resolve2, dirname as dirname4, isAbsolute } from "path";
 var FileLoader = class {
   registryPath;
   localPath;
@@ -15378,7 +16095,7 @@ var FileLoader = class {
    */
   resolveRef(ref, fromFile) {
     if (ref.isRelative) {
-      const dir = dirname3(fromFile);
+      const dir = dirname4(fromFile);
       const rawPath = ref.raw.endsWith(".prs") ? ref.raw : `${ref.raw}.prs`;
       return resolve2(dir, rawPath);
     }
@@ -16040,7 +16757,7 @@ function uniqueConcat3(parent, child) {
 
 // packages/resolver/src/skills.ts
 import { readFile as readFile5, access } from "fs/promises";
-import { resolve as resolve3, dirname as dirname4 } from "path";
+import { resolve as resolve3, dirname as dirname5 } from "path";
 function parseSkillMd(content) {
   const lines = content.split("\n");
   let inFrontmatter = false;
@@ -16095,7 +16812,7 @@ async function resolveNativeSkills(ast, registryPath, sourceFile) {
   const skillsContent = skillsBlock.content;
   const updatedProperties = { ...skillsContent.properties };
   let hasUpdates = false;
-  const sourceDir = dirname4(sourceFile);
+  const sourceDir = dirname5(sourceFile);
   const isSkillsDir = sourceDir.includes("@skills");
   for (const [skillName, skillValue] of Object.entries(skillsContent.properties)) {
     if (typeof skillValue !== "object" || skillValue === null || Array.isArray(skillValue)) {
@@ -16323,7 +17040,7 @@ var Resolver = class {
 
 // packages/resolver/src/registry.ts
 import { existsSync as existsSync4, promises as fs } from "fs";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 var FileSystemRegistry = class {
   rootPath;
   constructor(options) {
@@ -16333,7 +17050,7 @@ var FileSystemRegistry = class {
    * Resolve a path relative to the registry root.
    */
   resolvePath(path) {
-    return join3(this.rootPath, path);
+    return join4(this.rootPath, path);
   }
   async fetch(path) {
     const fullPath = this.resolvePath(path);
@@ -16548,12 +17265,12 @@ function createHttpRegistry(options) {
 
 // packages/resolver/src/git-registry.ts
 import { existsSync as existsSync6, promises as fs3 } from "fs";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 import { simpleGit } from "simple-git";
 
 // packages/resolver/src/git-cache-manager.ts
 import { existsSync as existsSync5, promises as fs2 } from "fs";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import { homedir } from "os";
 
 // packages/resolver/src/git-url-utils.ts
@@ -16661,7 +17378,7 @@ function parseVersionedPath(path) {
 }
 
 // packages/resolver/src/git-cache-manager.ts
-var DEFAULT_CACHE_DIR = join4(homedir(), ".promptscript", ".cache", "git");
+var DEFAULT_CACHE_DIR = join5(homedir(), ".promptscript", ".cache", "git");
 var DEFAULT_TTL = 36e5;
 var METADATA_FILE = ".prs-cache-meta.json";
 var GitCacheManager = class {
@@ -16680,7 +17397,7 @@ var GitCacheManager = class {
    */
   getCachePath(url, ref) {
     const cacheKey = getCacheKey(url, ref);
-    return join4(this.cacheDir, cacheKey);
+    return join5(this.cacheDir, cacheKey);
   }
   /**
    * Check if a cache entry exists and is not stale.
@@ -16786,7 +17503,7 @@ var GitCacheManager = class {
       if (!dir.isDirectory()) {
         continue;
       }
-      const cachePath = join4(this.cacheDir, dir.name);
+      const cachePath = join5(this.cacheDir, dir.name);
       const metadata = await this.readMetadata(cachePath);
       if (metadata) {
         const isStale = Date.now() - metadata.lastUpdated > this.ttl;
@@ -16834,7 +17551,7 @@ var GitCacheManager = class {
     let size = 0;
     const entries = await fs2.readdir(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join4(dirPath, entry.name);
+      const fullPath = join5(dirPath, entry.name);
       if (entry.isDirectory()) {
         size += await this.calculateDirSize(fullPath);
       } else {
@@ -16848,7 +17565,7 @@ var GitCacheManager = class {
    * Read metadata from a cache directory.
    */
   async readMetadata(cachePath) {
-    const metadataPath = join4(cachePath, METADATA_FILE);
+    const metadataPath = join5(cachePath, METADATA_FILE);
     if (!existsSync5(metadataPath)) {
       return null;
     }
@@ -16863,7 +17580,7 @@ var GitCacheManager = class {
    * Write metadata to a cache directory.
    */
   async writeMetadata(cachePath, metadata) {
-    const metadataPath = join4(cachePath, METADATA_FILE);
+    const metadataPath = join5(cachePath, METADATA_FILE);
     await fs2.writeFile(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
   }
 };
@@ -17154,9 +17871,9 @@ var GitRegistry = class {
       cleanPath += ".prs";
     }
     if (this.subPath) {
-      return join5(repoPath, this.subPath, cleanPath);
+      return join6(repoPath, this.subPath, cleanPath);
     }
-    return join5(repoPath, cleanPath);
+    return join6(repoPath, cleanPath);
   }
   /**
    * Resolve a directory path within the repository.
@@ -17166,9 +17883,9 @@ var GitRegistry = class {
    */
   resolveDirectoryPath(repoPath, relativePath) {
     if (this.subPath) {
-      return join5(repoPath, this.subPath, relativePath);
+      return join6(repoPath, this.subPath, relativePath);
     }
-    return join5(repoPath, relativePath);
+    return join6(repoPath, relativePath);
   }
   /**
    * Check if an error is an authentication error.
@@ -17886,8 +18603,8 @@ var Compiler = class _Compiler {
    */
   async watch(entryPath, options = {}) {
     const { default: chokidar2 } = await import("chokidar");
-    const { dirname: dirname8, resolve: resolve9 } = await import("path");
-    const baseDir = dirname8(resolve9(entryPath));
+    const { dirname: dirname10, resolve: resolve9 } = await import("path");
+    const baseDir = dirname10(resolve9(entryPath));
     const includePatterns = options.include ?? ["**/*.prs"];
     const excludePatterns = options.exclude ?? ["**/node_modules/**"];
     const debounceMs = options.debounce ?? 300;
@@ -18107,6 +18824,69 @@ function createPager(enabled = true) {
   return new Pager(enabled);
 }
 
+// packages/cli/src/utils/registry-resolver.ts
+import { join as join7 } from "path";
+async function resolveRegistryPath(config) {
+  if (config.registry?.git) {
+    const gitConfig = config.registry.git;
+    const ref = gitConfig.ref ?? "main";
+    const cacheManager = new GitCacheManager({
+      ttl: config.registry.cache?.ttl
+    });
+    const normalizedUrl = normalizeGitUrl(gitConfig.url);
+    const cachePath = cacheManager.getCachePath(normalizedUrl, ref);
+    const isValid = await cacheManager.isValid(normalizedUrl, ref);
+    if (isValid) {
+      const subPath2 = gitConfig.path ?? "";
+      return {
+        path: subPath2 ? join7(cachePath, subPath2) : cachePath,
+        isRemote: true,
+        source: "git"
+      };
+    }
+    const registry = createGitRegistry({
+      url: gitConfig.url,
+      ref,
+      path: gitConfig.path,
+      auth: gitConfig.auth,
+      cache: {
+        enabled: config.registry.cache?.enabled ?? true,
+        ttl: config.registry.cache?.ttl
+      }
+    });
+    try {
+      await registry.fetch("registry-manifest.yaml");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (!message.includes("not found") && !message.includes("FileNotFoundError")) {
+        throw new Error(
+          `Failed to clone registry from ${gitConfig.url}: ${message}. Please check your network connection and registry configuration.`
+        );
+      }
+    }
+    const subPath = gitConfig.path ?? "";
+    return {
+      path: subPath ? join7(cachePath, subPath) : cachePath,
+      isRemote: true,
+      source: "git"
+    };
+  }
+  if (config.registry?.url) {
+    const localPath = config.registry?.path ?? "./registry";
+    return {
+      path: localPath,
+      isRemote: true,
+      source: "http"
+    };
+  }
+  const registryPath = config.registry?.path ?? "./registry";
+  return {
+    path: registryPath,
+    isRemote: false,
+    source: "local"
+  };
+}
+
 // packages/cli/src/commands/compile.ts
 var PROMPTSCRIPT_MARKERS = [
   "<!-- PromptScript",
@@ -18207,7 +18987,7 @@ async function writeOutputs(outputs, options, _config, services) {
       continue;
     }
     if (!fileExists2) {
-      await mkdir2(dirname5(outputPath), { recursive: true });
+      await mkdir2(dirname6(outputPath), { recursive: true });
       await writeFile2(outputPath, output.content, "utf-8");
       ConsoleOutput.success(outputPath);
       result.written.push(outputPath);
@@ -18223,14 +19003,14 @@ async function writeOutputs(outputs, options, _config, services) {
         result.unchanged.push(outputPath);
         continue;
       }
-      await mkdir2(dirname5(outputPath), { recursive: true });
+      await mkdir2(dirname6(outputPath), { recursive: true });
       await writeFile2(outputPath, output.content, "utf-8");
       ConsoleOutput.success(outputPath);
       result.written.push(outputPath);
       continue;
     }
     if (options.force || overwriteAll) {
-      await mkdir2(dirname5(outputPath), { recursive: true });
+      await mkdir2(dirname6(outputPath), { recursive: true });
       await writeFile2(outputPath, output.content, "utf-8");
       ConsoleOutput.success(outputPath);
       result.written.push(outputPath);
@@ -18243,7 +19023,7 @@ async function writeOutputs(outputs, options, _config, services) {
     const response = await promptForOverwrite(outputPath, services);
     switch (response) {
       case "yes":
-        await mkdir2(dirname5(outputPath), { recursive: true });
+        await mkdir2(dirname6(outputPath), { recursive: true });
         await writeFile2(outputPath, output.content, "utf-8");
         ConsoleOutput.success(outputPath);
         result.written.push(outputPath);
@@ -18254,7 +19034,7 @@ async function writeOutputs(outputs, options, _config, services) {
         break;
       case "all":
         overwriteAll = true;
-        await mkdir2(dirname5(outputPath), { recursive: true });
+        await mkdir2(dirname6(outputPath), { recursive: true });
         await writeFile2(outputPath, output.content, "utf-8");
         ConsoleOutput.success(outputPath);
         result.written.push(outputPath);
@@ -18293,10 +19073,20 @@ async function compileCommand(options, services = createDefaultServices()) {
   try {
     logger.verbose("Loading configuration...");
     const config = await loadConfig(options.config);
-    spinner.text = "Compiling...";
     const selectedTarget = options.target ?? options.format;
     const targets = selectedTarget ? [{ name: selectedTarget }] : parseTargets(config.targets);
-    const registryPath = options.registry ?? config.registry?.path ?? "./registry";
+    let registryPath;
+    if (options.registry) {
+      registryPath = options.registry;
+    } else {
+      spinner.text = "Resolving registry...";
+      const registry = await resolveRegistryPath(config);
+      registryPath = registry.path;
+      if (registry.isRemote) {
+        logger.verbose(`Using cached git registry: ${registryPath}`);
+      }
+    }
+    spinner.text = "Compiling...";
     logger.verbose(`Registry: ${registryPath}`);
     logger.debug(`Config: ${JSON.stringify(config, null, 2)}`);
     const prettierOptions = await resolvePrettierOptions(config, process.cwd());
@@ -18472,10 +19262,12 @@ async function validateCommand(options) {
   const spinner = isJsonFormat ? createSpinner("").stop() : createSpinner("Loading configuration...").start();
   try {
     const config = await loadConfig();
+    if (!isJsonFormat) spinner.text = "Resolving registry...";
+    const registry = await resolveRegistryPath(config);
     if (!isJsonFormat) spinner.text = "Validating...";
     const compiler = new Compiler({
       resolver: {
-        registryPath: config.registry?.path ?? "./registry",
+        registryPath: registry.path,
         localPath: "./.promptscript"
       },
       validator: config.validation,
@@ -18524,7 +19316,7 @@ function outputJsonResult(result) {
 // packages/cli/src/commands/pull.ts
 import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
 import { existsSync as existsSync9 } from "fs";
-import { resolve as resolve6, dirname as dirname6 } from "path";
+import { resolve as resolve6, dirname as dirname7 } from "path";
 async function pullCommand(options) {
   const spinner = createSpinner("Loading configuration...").start();
   try {
@@ -18563,7 +19355,7 @@ async function pullCommand(options) {
       }
       return;
     }
-    await mkdir3(dirname6(destPath), { recursive: true });
+    await mkdir3(dirname7(destPath), { recursive: true });
     await writeFile3(destPath, content, "utf-8");
     spinner.succeed("Pulled from registry");
     ConsoleOutput.success(destPath);
@@ -18719,11 +19511,13 @@ async function diffCommand(options) {
   const spinner = createSpinner("Loading configuration...").start();
   try {
     const config = await loadConfig();
+    spinner.text = "Resolving registry...";
+    const registry = await resolveRegistryPath(config);
     spinner.text = "Compiling...";
     const targets = options.target ? [{ name: options.target }] : parseTargets2(config.targets);
     const compiler = new Compiler({
       resolver: {
-        registryPath: config.registry?.path ?? "./registry",
+        registryPath: registry.path,
         localPath: "./.promptscript"
       },
       validator: config.validation,
@@ -18957,11 +19751,189 @@ function printResults(results) {
   }
 }
 
-// packages/cli/src/cli.ts
+// packages/cli/src/commands/update-check.ts
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname8 } from "path";
+
+// packages/cli/src/utils/version-check.ts
+import { homedir as homedir2 } from "os";
+import { join as join8 } from "path";
+import { existsSync as existsSync12, mkdirSync, readFileSync as readFileSync3, writeFileSync } from "fs";
+var NPM_REGISTRY_URL = "https://registry.npmjs.org/@promptscript/cli/latest";
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var FETCH_TIMEOUT_MS = 3e3;
+function getCacheDir() {
+  return join8(homedir2(), ".promptscript", ".cache");
+}
+function getCachePath() {
+  return join8(getCacheDir(), "version.json");
+}
+function readCache() {
+  try {
+    const cachePath = getCachePath();
+    if (!existsSync12(cachePath)) {
+      return null;
+    }
+    const content = readFileSync3(cachePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function writeCache(cache) {
+  try {
+    const cacheDir = getCacheDir();
+    if (!existsSync12(cacheDir)) {
+      mkdirSync(cacheDir, { recursive: true });
+    }
+    const cachePath = getCachePath();
+    writeFileSync(cachePath, JSON.stringify(cache, null, 2), "utf-8");
+  } catch {
+  }
+}
+function isCacheValid(cache) {
+  try {
+    const lastCheck = new Date(cache.lastCheck).getTime();
+    const now = Date.now();
+    return now - lastCheck < CACHE_TTL_MS;
+  } catch {
+    return false;
+  }
+}
+async function fetchLatestVersion() {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    const response = await fetch(NPM_REGISTRY_URL, {
+      signal: controller.signal,
+      headers: {
+        Accept: "application/json"
+      }
+    });
+    clearTimeout(timeout);
+    if (!response.ok) {
+      if (isVerbose()) {
+        ConsoleOutput.verbose(`Could not check for updates: HTTP ${response.status}`);
+      }
+      return null;
+    }
+    const data = await response.json();
+    return data.version ?? null;
+  } catch (error) {
+    if (isVerbose()) {
+      const code = error.code;
+      const message = error instanceof Error ? error.message : "Unknown error";
+      ConsoleOutput.verbose(`Could not check for updates: ${code ?? message}`);
+    }
+    return null;
+  }
+}
+function isNewerVersion(currentVersion, latestVersion) {
+  const cleanCurrent = currentVersion.replace(/^v/, "");
+  const cleanLatest = latestVersion.replace(/^v/, "");
+  const [currentBase, currentPrerelease] = cleanCurrent.split("-");
+  const [latestBase, latestPrerelease] = cleanLatest.split("-");
+  const currentParts = (currentBase ?? "").split(".").map((p) => parseInt(p, 10) || 0);
+  const latestParts = (latestBase ?? "").split(".").map((p) => parseInt(p, 10) || 0);
+  for (let i = 0; i < Math.max(currentParts.length, latestParts.length); i++) {
+    const c = currentParts[i] ?? 0;
+    const l = latestParts[i] ?? 0;
+    if (l > c) return true;
+    if (l < c) return false;
+  }
+  if (currentPrerelease && !latestPrerelease) {
+    return true;
+  }
+  return false;
+}
+async function checkForUpdates(currentVersion) {
+  if (process.env["PROMPTSCRIPT_NO_UPDATE_CHECK"]) {
+    return null;
+  }
+  if (isQuiet()) {
+    return null;
+  }
+  const cache = readCache();
+  if (cache && isCacheValid(cache) && cache.currentVersion === currentVersion) {
+    if (isNewerVersion(currentVersion, cache.latestVersion)) {
+      return {
+        currentVersion,
+        latestVersion: cache.latestVersion,
+        updateAvailable: true
+      };
+    }
+    return null;
+  }
+  const latestVersion = await fetchLatestVersion();
+  if (!latestVersion) {
+    return null;
+  }
+  writeCache({
+    lastCheck: (/* @__PURE__ */ new Date()).toISOString(),
+    latestVersion,
+    currentVersion
+  });
+  if (isNewerVersion(currentVersion, latestVersion)) {
+    return {
+      currentVersion,
+      latestVersion,
+      updateAvailable: true
+    };
+  }
+  return null;
+}
+async function forceCheckForUpdates(currentVersion) {
+  const latestVersion = await fetchLatestVersion();
+  if (!latestVersion) {
+    return { info: null, error: true };
+  }
+  writeCache({
+    lastCheck: (/* @__PURE__ */ new Date()).toISOString(),
+    latestVersion,
+    currentVersion
+  });
+  const updateAvailable = isNewerVersion(currentVersion, latestVersion);
+  return {
+    info: {
+      currentVersion,
+      latestVersion,
+      updateAvailable
+    },
+    error: false
+  };
+}
+function printUpdateNotification(info) {
+  console.log(
+    `Update available: ${info.currentVersion} \u2192 ${info.latestVersion} (npm i -g @promptscript/cli)`
+  );
+}
+
+// packages/cli/src/commands/update-check.ts
 var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = dirname7(__filename2);
+var __dirname2 = dirname8(__filename2);
+async function updateCheckCommand() {
+  const currentVersion = getPackageVersion(__dirname2, "../../package.json");
+  console.log(`@promptscript/cli v${currentVersion}`);
+  const { info, error } = await forceCheckForUpdates(currentVersion);
+  if (error) {
+    ConsoleOutput.error("Could not check for updates");
+    process.exitCode = 1;
+    return;
+  }
+  if (info?.updateAvailable) {
+    console.log(
+      `Update available: ${info.currentVersion} \u2192 ${info.latestVersion} (npm i -g @promptscript/cli)`
+    );
+  } else {
+    ConsoleOutput.success("Up to date");
+  }
+}
+
+// packages/cli/src/cli.ts
+var __filename3 = fileURLToPath3(import.meta.url);
+var __dirname3 = dirname9(__filename3);
 var program = new Command();
-program.name("prs").description("PromptScript CLI - Standardize AI instructions").version(getPackageVersion(__dirname2, "./package.json")).option("--verbose", "Enable verbose output").option("--debug", "Enable debug output (includes verbose)").option("--quiet", "Suppress non-error output").hook("preAction", (thisCommand) => {
+program.name("prs").description("PromptScript CLI - Standardize AI instructions").version(getPackageVersion(__dirname3, "../package.json")).option("--verbose", "Enable verbose output").option("--debug", "Enable debug output (includes verbose)").option("--quiet", "Suppress non-error output").hook("preAction", async (thisCommand, actionCommand) => {
   const opts = thisCommand.opts();
   if (opts["quiet"]) {
     setContext({ logLevel: 0 /* Quiet */ });
@@ -18975,13 +19947,22 @@ program.name("prs").description("PromptScript CLI - Standardize AI instructions"
   } else if (process.env["PROMPTSCRIPT_VERBOSE"] === "1" || process.env["PROMPTSCRIPT_VERBOSE"] === "true") {
     setContext({ logLevel: 2 /* Verbose */ });
   }
+  if (actionCommand.name() === "update-check") {
+    return;
+  }
+  const currentVersion = getPackageVersion(__dirname3, "../package.json");
+  const updateInfo = await checkForUpdates(currentVersion);
+  if (updateInfo) {
+    printUpdateNotification(updateInfo);
+  }
 });
 program.command("init").description("Initialize PromptScript in current directory").option("-n, --name <name>", "Project name (auto-detected from package.json, etc.)").option("-t, --team <team>", "Team namespace").option("--inherit <path>", "Inheritance path (e.g., @company/team)").option("--registry <path>", "Registry path").option("--targets <targets...>", "Target AI tools (github, claude, cursor)").option("-i, --interactive", "Force interactive mode").option("-y, --yes", "Skip prompts, use defaults").option("-f, --force", "Force reinitialize even if already initialized").option("-m, --migrate", "Install migration skill for AI-assisted migration").action((opts) => initCommand(opts));
 program.command("compile").description("Compile PromptScript to target formats").option("-t, --target <target>", "Specific target (github, claude, cursor)").option("-f, --format <format>", "Output format (alias for --target)").option("-a, --all", "All configured targets", true).option("-w, --watch", "Watch mode").option("-o, --output <dir>", "Output directory").option("--dry-run", "Preview changes").option("--registry <path>", "Registry path (overrides config)").option("-c, --config <path>", "Path to custom config file").option("--force", "Force overwrite existing files without prompts").action((opts) => compileCommand(opts));
 program.command("validate").description("Validate PromptScript files").option("--strict", "Treat warnings as errors").option("--format <format>", "Output format (text, json)", "text").action(validateCommand);
 program.command("pull").description("Pull updates from registry").option("-f, --force", "Force overwrite").option("--dry-run", "Preview changes without pulling").option("-b, --branch <name>", "Git branch to pull from").option("--tag <name>", "Git tag to pull from").option("--commit <hash>", "Git commit to pull from").option("--refresh", "Force re-fetch from remote (ignore cache)").action(pullCommand);
 program.command("diff").description("Show diff for compiled output").option("-t, --target <target>", "Specific target").option("-a, --all", "Show diff for all targets at once").option("--full", "Show full diff without truncation").option("--no-pager", "Disable pager output").option("--color", "Force colored output").option("--no-color", "Disable colored output").action(diffCommand);
-program.command("check").description("Check configuration and dependencies health").option("--fix", "Attempt to fix issues").action(checkCommand);
+program.command("check").description("Check configuration and dependencies health").action(checkCommand);
+program.command("update-check").description("Check for CLI updates").action(updateCheckCommand);
 function run(args = process.argv) {
   program.parse(args);
 }
@@ -18991,18 +19972,25 @@ export {
   ConsoleOutput,
   LogLevel,
   checkCommand,
+  checkForUpdates,
   compileCommand,
   createSpinner,
   diffCommand,
+  fetchLatestVersion,
   findConfigFile,
+  forceCheckForUpdates,
+  getCacheDir,
+  getCachePath,
   getContext,
   initCommand,
   isQuiet,
   isVerbose,
   loadConfig,
+  printUpdateNotification,
   pullCommand,
   run,
   setContext,
+  updateCheckCommand,
   validateCommand
 };
 /*! Bundled license information: