blume 2.0.1 → 2.0.3

package/src/translate/work-list.ts

@@ -1,9 +1,10 @@
-import { existsSync } from "node:fs";
+import { existsSync, readdirSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 
-import { dirname, extname, join, relative } from "pathe";
+import { extname, join, relative } from "pathe";
 
 import { localeCodes, localeTargetPath } from "../core/i18n.ts";
+import { scanProject } from "../core/project-graph.ts";
 import type { BlumeProject } from "../core/project-graph.ts";
 import type { Diagnostic, PageRecord } from "../core/types.ts";
 import { hashSource } from "./ledger.ts";
@@ -34,7 +35,11 @@ export interface PageWorkItem {
   /** POSIX root-relative source path — the ledger key. */
   sourceRel: string;
   status: WorkStatus;
-  /** Absolute canonical target path (`localeTargetPath`). */
+  /**
+   * Absolute target path: an existing translation's own file (which can sit
+   * at a non-canonical name, like a hand-written `fr/guide.md` for
+   * `guide.mdx`), otherwise the canonical `localeTargetPath`.
+   */
   targetPath: string;
   /** POSIX root-relative target path, for display. */
   targetRel: string;
@@ -48,7 +53,7 @@ export interface PageWorkItem {
 export interface MetaWorkEntry {
   meta: TranslatableMeta;
   status: WorkStatus;
-  /** Absolute path of the generated per-locale `meta.ts`. */
+  /** Absolute path of the per-locale meta module (see `metaTargetPath`). */
   targetPath: string;
 }
 
@@ -84,6 +89,36 @@ export interface TranslateWorkList {
 
 const PAGE_EXTENSIONS = new Set([".md", ".mdx"]);
 
+/**
+ * The names in each content root, read once per root: a locale folder authored
+ * in another casing (`pt-br/` for `pt-BR`) is where `localeTargetPath` puts
+ * that locale's translations.
+ */
+const rootFolders = (): ((contentRoot: string) => string[]) => {
+  const read = new Map<string, string[]>();
+  return (contentRoot) => {
+    const cached = read.get(contentRoot);
+    if (cached) {
+      return cached;
+    }
+    const names = readdirSync(contentRoot);
+    read.set(contentRoot, names);
+    return names;
+  };
+};
+
+/**
+ * Scan the project for a translation run: drafts included. A production
+ * (`build`) scan drops them, so a hand-written translation marked
+ * `draft: true` would look missing and be overwritten, and a source page
+ * drafted for a while would lose its ledger stamps — its outdated
+ * translations then reading as current once it's published again. A dev scan
+ * keeps drafts and differs only in reusing cached remote content, which
+ * translation never reads.
+ */
+export const scanForTranslation = (root: string): Promise<BlumeProject> =>
+  scanProject(root, { mode: "dev" });
+
 /**
  * The translatable page universe: filesystem-backed default-locale pages.
  * Remote/staged sources have no writable path; fallback records are padding;
@@ -201,6 +236,7 @@ const partialWorkItems = async (
       page.sourcePath ? [page.sourcePath] : []
     )
   );
+  const folders = rootFolders();
   const partials = new Map<string, string>();
   for (const { page, contentRoot } of universe) {
     for (const partial of page.includes ?? []) {
@@ -220,7 +256,7 @@ const partialWorkItems = async (
     for (const locale of targetLocales) {
       const targetPath = join(
         contentRoot,
-        localeTargetPath(contentRel, ext, locale, i18n)
+        localeTargetPath(contentRel, ext, locale, i18n, folders(contentRoot))
       );
       const item = (status: WorkStatus): PageWorkItem => {
         const partialItem: PageWorkItem = {
@@ -251,6 +287,37 @@ const partialWorkItems = async (
   return work;
 };
 
+/**
+ * Every existing translation, keyed by `translationKey` and locale, with the
+ * file it was read from when that file is on disk in a filesystem source. A
+ * retranslation writes there: an adopted hand-written `fr/guide.md` for a
+ * `guide.mdx` source is replaced in place, never joined by a canonical
+ * `fr/guide.mdx` that would publish the route twice.
+ */
+const existingTranslations = (
+  project: BlumeProject
+): Map<string, string | undefined> => {
+  const writableSources = new Set(
+    project.sources.flatMap((source) =>
+      source.staged || !source.contentRoot ? [] : [source.name]
+    )
+  );
+  const translated = new Map<string, string | undefined>();
+  for (const page of project.graph.pages) {
+    const key = `${page.translationKey}\0${page.locale}`;
+    if (page.fallback || translated.has(key)) {
+      continue;
+    }
+    translated.set(
+      key,
+      page.sourcePath && writableSources.has(page.source.name)
+        ? page.sourcePath
+        : undefined
+    );
+  }
+  return translated;
+};
+
 /**
  * Compute the run's work: which (source, locale) pairs are missing or stale,
  * which existing translations to adopt, and what's already up to date.
@@ -278,11 +345,7 @@ export const computeWorkList = async (
       (options.locales === undefined || options.locales.includes(code))
   );
 
-  const translated = new Set(
-    project.graph.pages.flatMap((page) =>
-      page.fallback ? [] : [`${page.translationKey}${page.locale}`]
-    )
-  );
+  const translated = existingTranslations(project);
 
   const { root } = project.context;
   const knownSources = new Set<string>();
@@ -291,6 +354,7 @@ export const computeWorkList = async (
   let upToDate = 0;
 
   const universe = translatablePages(project, i18n);
+  const folders = rootFolders();
 
   for (const { page, contentRoot, ext, sourcePath } of universe) {
     const sourceRel = relative(root, sourcePath);
@@ -300,10 +364,13 @@ export const computeWorkList = async (
     const contentRel = relative(contentRoot, sourcePath);
 
     for (const locale of targetLocales) {
-      const targetPath = join(
-        contentRoot,
-        localeTargetPath(contentRel, ext, locale, i18n)
-      );
+      const key = `${page.translationKey}\0${locale}`;
+      const targetPath =
+        translated.get(key) ??
+        join(
+          contentRoot,
+          localeTargetPath(contentRel, ext, locale, i18n, folders(contentRoot))
+        );
       const item = (status: WorkStatus): PageWorkItem => ({
         kind: "page",
         locale,
@@ -313,7 +380,7 @@ export const computeWorkList = async (
         targetPath,
         targetRel: relative(root, targetPath),
       });
-      const exists = translated.has(`${page.translationKey}${locale}`);
+      const exists = translated.has(key);
       const stamp = ledger.files[sourceRel]?.[locale];
       const outcome = classifyPair(exists, stamp, hash, options.force === true);
       if (outcome === "untracked") {
@@ -347,16 +414,21 @@ export const computeWorkList = async (
     const entries: MetaWorkEntry[] = [];
     for (const source of meta.metas) {
       knownSources.add(source.sourceRel);
-      const targetDir = dirname(metaTargetPath(source, locale));
-      const exists = ["meta.ts", "meta.js", "meta.mjs"].some((name) =>
-        existsSync(join(targetDir, name))
+      // The locale folder's existing meta module when there is one, so a
+      // retranslation rewrites it instead of adding a `meta.ts` beside it.
+      const targetPath = metaTargetPath(
+        source,
+        locale,
+        i18n,
+        folders(source.contentRoot)
       );
+      const exists = existsSync(targetPath);
       const hash = hashSource(source.raw);
       const stamp = ledger.files[source.sourceRel]?.[locale];
       const entry = (status: WorkStatus): MetaWorkEntry => ({
         meta: source,
         status,
-        targetPath: metaTargetPath(source, locale),
+        targetPath,
       });
       const outcome = classifyPair(exists, stamp, hash, options.force === true);
       if (outcome === "untracked") {

package/src/upgrade/upgrade.ts

@@ -47,6 +47,7 @@ export type DependencyBump =
       to: string;
     }
   | { range: string; status: "current" }
+  | { range: string; status: "manual" }
   | { status: "missing" };
 
 type DependencyField = "dependencies" | "devDependencies";
@@ -73,6 +74,28 @@ export const rangeMajor = (range: string): number | null => {
   return major === undefined ? null : Number(major);
 };
 
+// Ranges whose version lives somewhere the bump doesn't rewrite: a pnpm
+// catalog in pnpm-workspace.yaml, or the `range` of an `npm:name@range` alias.
+const CATALOG_RANGE = /^catalog:(?<name>.*)$/u;
+const NPM_ALIAS = /^npm:.+@(?<range>[^@]*)$/u;
+
+/**
+ * What to change by hand for a `blume` range the bump can't rewrite (a
+ * `manual` {@link DependencyBump}): the pnpm catalog entry it points at, or
+ * the version inside its `npm:` alias.
+ */
+export const manualBumpAdvice = (range: string, version: string): string => {
+  const catalog = CATALOG_RANGE.exec(range)?.groups?.name;
+  if (catalog === undefined) {
+    return `package.json installs blume through the alias \`${range}\`, which \`blume upgrade\` doesn't rewrite: set the alias's version to ^${version}, then reinstall.`;
+  }
+  const entry =
+    catalog === "" || catalog === "default"
+      ? "`catalog`"
+      : `\`catalogs.${catalog}\``;
+  return `package.json takes blume from the pnpm catalog (\`${range}\`), which \`blume upgrade\` can't bump: set blume to ^${version} under ${entry} in pnpm-workspace.yaml if it isn't already, then reinstall.`;
+};
+
 // The file's own indentation (two spaces, four, or a tab), so a fallback
 // rewrite doesn't reformat a package.json the user keeps differently.
 const INDENT = /^(?<indent>[ \t]+)"/mu;
@@ -106,9 +129,11 @@ const replaceRange = (
 /**
  * Point `package.json`'s `blume` dependency at `^version` when it pins an
  * older major. A range already on this major, or one that names no version
- * (`workspace:*`, `latest`), is reported as current and left alone; a
- * project with no `package.json`, or none that lists `blume`, is `missing`.
- * Only the range changes: the rest of the file is kept byte for byte.
+ * (`workspace:*`, `latest`), is reported as current and left alone; one whose
+ * version lives elsewhere (`catalog:`, an `npm:` alias of an older major) is
+ * `manual`, for the user to change; a project with no `package.json`, or none
+ * that lists `blume`, is `missing`. Only the range changes: the rest of the
+ * file is kept byte for byte.
  */
 export const bumpBlumeDependency = async (
   root: string,
@@ -129,11 +154,18 @@ export const bumpBlumeDependency = async (
   if (!(field && from)) {
     return { status: "missing" };
   }
-  const current = rangeMajor(from);
+  if (CATALOG_RANGE.test(from)) {
+    return { range: from, status: "manual" };
+  }
+  const aliased = NPM_ALIAS.exec(from)?.groups?.range;
+  const current = rangeMajor(aliased ?? from);
   const target = rangeMajor(version);
   if (current === null || target === null || current >= target) {
     return { range: from, status: "current" };
   }
+  if (aliased !== undefined) {
+    return { range: from, status: "manual" };
+  }
   const to = `^${version}`;
   const indent = INDENT.exec(text)?.groups?.indent ?? "  ";
   const updated = { ...pkg, [field]: { ...pkg[field], blume: to } };

package/dist/cli/chunk-27g6wdth.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/cli/dev-lock.ts"],
-  "sourcesContent": [
-    "import {\n  existsSync,\n  mkdirSync,\n  readFileSync,\n  rmSync,\n  writeFileSync,\n} from \"node:fs\";\n\nimport { join } from \"pathe\";\n\nimport { resolveRuntimeDir } from \"../core/project.ts\";\nimport { logger } from \"./log.ts\";\n\n/**\n * A best-effort PID lock in the shared `.blume/` runtime dir. `blume dev`\n * regenerates and serves `.blume` continuously, so a concurrent `build`,\n * `eject`, or second `dev` that regenerates or deletes it out from under the\n * running Vite server corrupts the dev session. The lock lets those commands\n * detect a live dev server and refuse — and, because it records the server's\n * port, point the caller (often an agent that just tried to start its own\n * server) at the URL to reuse instead.\n */\n\nexport interface DevLockInfo {\n  pid: number;\n  /** Port the dev server is bound to, when known. */\n  port?: number;\n}\n\nconst lockPath = (outDir: string): string => join(outDir, \"dev.lock\");\n\n/** What `JSON.parse` can yield for a lock file body. */\ntype LockFileValue =\n  | string\n  | number\n  | boolean\n  | null\n  | LockFileValue[]\n  | { [key: string]: LockFileValue };\n\nconst isValidPid = (pid: LockFileValue | undefined): pid is number =>\n  typeof pid === \"number\" && Number.isInteger(pid) && pid > 0;\n\nconst isPortNumber = (port: LockFileValue | undefined): port is number =>\n  typeof port === \"number\";\n\nconst isLockRecord = (\n  data: LockFileValue\n): data is { pid?: LockFileValue; port?: LockFileValue } =>\n  typeof data === \"object\" && data !== null;\n\n/**\n * Parse a lock file body. Current locks are JSON (`{\"pid\":123,\"port\":3001}`);\n * a bare integer (the pre-port format) still parses as a pid-only lock.\n */\nconst parseLock = (raw: string): DevLockInfo | null => {\n  let data: LockFileValue;\n  try {\n    data = JSON.parse(raw.trim());\n  } catch {\n    return null;\n  }\n  if (isValidPid(data)) {\n    return { pid: data };\n  }\n  if (isLockRecord(data)) {\n    const { pid, port } = data;\n    if (isValidPid(pid)) {\n      return isPortNumber(port) ? { pid, port } : { pid };\n    }\n  }\n  return null;\n};\n\nconst isProcessAlive = (pid: number): boolean => {\n  try {\n    // Signal 0 probes liveness without actually signaling the process.\n    process.kill(pid, 0);\n    return true;\n  } catch (error) {\n    // EPERM means the process exists but belongs to another user — still\n    // live, so the lock must hold (only ESRCH proves it's gone).\n    // SAFETY: `process.kill` failures are errno exceptions.\n    return (error as NodeJS.ErrnoException).code === \"EPERM\";\n  }\n};\n\n/**\n * Read the lock on `outDir` held by a live `blume dev`, or null. A lock left\n * by a process that has since exited (stale) is treated as absent.\n */\nexport const readDevLock = (outDir: string): DevLockInfo | null => {\n  const path = lockPath(outDir);\n  if (!existsSync(path)) {\n    return null;\n  }\n  const lock = parseLock(readFileSync(path, \"utf-8\"));\n  return lock && isProcessAlive(lock.pid) ? lock : null;\n};\n\n/** Whether another live `blume dev` holds the lock on `outDir`. */\nexport const isDevLocked = (outDir: string): boolean =>\n  readDevLock(outDir) !== null;\n\nconst lockPayload = (port?: number): string => {\n  const info: DevLockInfo = { pid: process.pid };\n  if (port !== undefined) {\n    info.port = port;\n  }\n  return JSON.stringify(info);\n};\n\nconst writeLock = (outDir: string, port?: number): void => {\n  writeFileSync(lockPath(outDir), lockPayload(port));\n};\n\n/** Thrown when another live `blume dev` already holds the lock. */\nexport class DevLockHeldError extends Error {\n  readonly lock: DevLockInfo;\n\n  constructor(lock: DevLockInfo) {\n    super(`A blume dev server (pid ${lock.pid}) already holds the lock.`);\n    this.name = \"DevLockHeldError\";\n    this.lock = lock;\n  }\n}\n\nconst ownsLock = (outDir: string): boolean => {\n  const path = lockPath(outDir);\n  if (!existsSync(path)) {\n    return false;\n  }\n  try {\n    return parseLock(readFileSync(path, \"utf-8\"))?.pid === process.pid;\n  } catch {\n    return false;\n  }\n};\n\n/**\n * One atomic claim attempt. Returns `true` when this process wins the `wx`\n * write, `false` when the dir held a stale or our-own leftover lock (now\n * cleared, so the caller should retry). Throws {@link DevLockHeldError} when a\n * live foreign holder owns the dir.\n */\nconst tryClaimLock = (outDir: string, port?: number): boolean => {\n  try {\n    writeFileSync(lockPath(outDir), lockPayload(port), { flag: \"wx\" });\n    return true;\n  } catch (error) {\n    // SAFETY: `writeFileSync` failures are errno exceptions.\n    if ((error as NodeJS.ErrnoException).code !== \"EEXIST\") {\n      throw error;\n    }\n    const existing = readDevLock(outDir);\n    if (existing && existing.pid !== process.pid) {\n      throw new DevLockHeldError(existing);\n    }\n    // Stale or our own leftover: clear it and race for the claim again.\n    rmSync(lockPath(outDir), { force: true });\n    return false;\n  }\n};\n\n/**\n * Write the current process's dev lock into `outDir` and return a release\n * function. The claim is atomic (`wx`): two `blume dev` processes racing the\n * same dir can't both pass a check-then-write — the loser gets a\n * {@link DevLockHeldError} naming the live holder. A stale lock (dead pid) or\n * this process's own leftover is cleared and re-claimed. The release only\n * removes the file if it's still ours, so a newer dev server's lock is never\n * clobbered.\n */\nexport const acquireDevLock = (outDir: string, port?: number): (() => void) => {\n  mkdirSync(outDir, { recursive: true });\n  while (!tryClaimLock(outDir, port)) {\n    // Retry until we win the claim or a live holder makes us throw.\n  }\n  let released = false;\n  return () => {\n    if (released) {\n      return;\n    }\n    released = true;\n    try {\n      if (ownsLock(outDir)) {\n        rmSync(lockPath(outDir), { force: true });\n      }\n    } catch {\n      // Best-effort cleanup; a stale lock is handled by the liveness check.\n    }\n  };\n};\n\n/**\n * Rewrite this process's lock with the port the server actually bound (the\n * lock is acquired before the server starts, and Vite may bump a busy port).\n * A lock owned by another process is left alone.\n */\nexport const updateDevLockPort = (outDir: string, port: number): void => {\n  if (ownsLock(outDir)) {\n    writeLock(outDir, port);\n  }\n};\n\n/** Human-readable location of a locked dev server, e.g. \" at http://localhost:3001\". */\nexport const describeDevLock = (lock: DevLockInfo): string =>\n  lock.port === undefined ? \"\" : ` at http://localhost:${lock.port}`;\n\n/**\n * Exit with an error when a live `blume dev` owns the runtime dir under `root`.\n * `action` names the operation being refused (e.g. \"building\"). `runtimeDir`\n * relocates the checked dir: an isolated verify (`.blume-verify`) targets a dir\n * dev never locks, so it proceeds; a default or `--runtime-dir .blume` run still\n * refuses. Only commands that actually accept `--isolated` (build, check) should\n * set `isolatedHint`, so the refusal never suggests a flag the command ignores.\n */\nexport const refuseIfDevRunning = (\n  root: string,\n  action: string,\n  options: { runtimeDir?: string; isolatedHint?: boolean } = {}\n): void => {\n  const lock = readDevLock(resolveRuntimeDir(root, options.runtimeDir));\n  if (lock) {\n    const remedies = options.isolatedHint\n      ? \"Reuse that server, stop it first, or re-run with --isolated to build/verify against .blume-verify without touching it.\"\n      : \"Reuse that server or stop it first.\";\n    logger.error(\n      `A \\`blume dev\\` server is running${describeDevLock(lock)}; ${action} would corrupt its .blume runtime. ${remedies}`\n    );\n    process.exit(1);\n  }\n};\n"
-  ],
-  "mappings": ";;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA;AAqBA,IAAM,WAAW,CAAC,WAA2B,KAAK,QAAQ,UAAU;AAWpE,IAAM,aAAa,CAAC,QAClB,OAAO,QAAQ,YAAY,OAAO,UAAU,GAAG,KAAK,MAAM;AAE5D,IAAM,eAAe,CAAC,SACpB,OAAO,SAAS;AAElB,IAAM,eAAe,CACnB,SAEA,OAAO,SAAS,YAAY,SAAS;AAMvC,IAAM,YAAY,CAAC,QAAoC;AAAA,EACrD,IAAI;AAAA,EACJ,IAAI;AAAA,IACF,OAAO,KAAK,MAAM,IAAI,KAAK,CAAC;AAAA,IAC5B,MAAM;AAAA,IACN,OAAO;AAAA;AAAA,EAET,IAAI,WAAW,IAAI,GAAG;AAAA,IACpB,OAAO,EAAE,KAAK,KAAK;AAAA,EACrB;AAAA,EACA,IAAI,aAAa,IAAI,GAAG;AAAA,IACtB,QAAQ,KAAK,SAAS;AAAA,IACtB,IAAI,WAAW,GAAG,GAAG;AAAA,MACnB,OAAO,aAAa,IAAI,IAAI,EAAE,KAAK,KAAK,IAAI,EAAE,IAAI;AAAA,IACpD;AAAA,EACF;AAAA,EACA,OAAO;AAAA;AAGT,IAAM,iBAAiB,CAAC,QAAyB;AAAA,EAC/C,IAAI;AAAA,IAEF,QAAQ,KAAK,KAAK,CAAC;AAAA,IACnB,OAAO;AAAA,IACP,OAAO,OAAO;AAAA,IAId,OAAQ,MAAgC,SAAS;AAAA;AAAA;AAQ9C,IAAM,cAAc,CAAC,WAAuC;AAAA,EACjE,MAAM,OAAO,SAAS,MAAM;AAAA,EAC5B,IAAI,CAAC,WAAW,IAAI,GAAG;AAAA,IACrB,OAAO;AAAA,EACT;AAAA,EACA,MAAM,OAAO,UAAU,aAAa,MAAM,OAAO,CAAC;AAAA,EAClD,OAAO,QAAQ,eAAe,KAAK,GAAG,IAAI,OAAO;AAAA;AAOnD,IAAM,cAAc,CAAC,SAA0B;AAAA,EAC7C,MAAM,OAAoB,EAAE,KAAK,QAAQ,IAAI;AAAA,EAC7C,IAAI,SAAS,WAAW;AAAA,IACtB,KAAK,OAAO;AAAA,EACd;AAAA,EACA,OAAO,KAAK,UAAU,IAAI;AAAA;AAG5B,IAAM,YAAY,CAAC,QAAgB,SAAwB;AAAA,EACzD,cAAc,SAAS,MAAM,GAAG,YAAY,IAAI,CAAC;AAAA;AAAA;AAI5C,MAAM,yBAAyB,MAAM;AAAA,EACjC;AAAA,EAET,WAAW,CAAC,MAAmB;AAAA,IAC7B,MAAM,2BAA2B,KAAK,8BAA8B;AAAA,IACpE,KAAK,OAAO;AAAA,IACZ,KAAK,OAAO;AAAA;AAEhB;AAEA,IAAM,WAAW,CAAC,WAA4B;AAAA,EAC5C,MAAM,OAAO,SAAS,MAAM;AAAA,EAC5B,IAAI,CAAC,WAAW,IAAI,GAAG;AAAA,IACrB,OAAO;AAAA,EACT;AAAA,EACA,IAAI;AAAA,IACF,OAAO,UAAU,aAAa,MAAM,OAAO,CAAC,GAAG,QAAQ,QAAQ;AAAA,IAC/D,MAAM;AAAA,IACN,OAAO;AAAA;AAAA;AAUX,IAAM,eAAe,CAAC,QAAgB,SAA2B;AAAA,EAC/D,IAAI;AAAA,IACF,cAAc,SAAS,MAAM,GAAG,YAAY,IAAI,GAAG,EAAE,MAAM,KAAK,CAAC;AAAA,IACjE,OAAO;AAAA,IACP,OAAO,OAAO;AAAA,IAEd,IAAK,MAAgC,SAAS,UAAU;AAAA,MACtD,MAAM;AAAA,IACR;AAAA,IACA,MAAM,WAAW,YAAY,MAAM;AAAA,IACnC,IAAI,YAAY,SAAS,QAAQ,QAAQ,KAAK;AAAA,MAC5C,MAAM,IAAI,iBAAiB,QAAQ;AAAA,IACrC;AAAA,IAEA,OAAO,SAAS,MAAM,GAAG,EAAE,OAAO,KAAK,CAAC;AAAA,IACxC,OAAO;AAAA;AAAA;AAaJ,IAAM,iBAAiB,CAAC,QAAgB,SAAgC;AAAA,EAC7E,UAAU,QAAQ,EAAE,WAAW,KAAK,CAAC;AAAA,EACrC,OAAO,CAAC,aAAa,QAAQ,IAAI,GAAG,CAEpC;AAAA,EACA,IAAI,WAAW;AAAA,EACf,OAAO,MAAM;AAAA,IACX,IAAI,UAAU;AAAA,MACZ;AAAA,IACF;AAAA,IACA,WAAW;AAAA,IACX,IAAI;AAAA,MACF,IAAI,SAAS,MAAM,GAAG;AAAA,QACpB,OAAO,SAAS,MAAM,GAAG,EAAE,OAAO,KAAK,CAAC;AAAA,MAC1C;AAAA,MACA,MAAM;AAAA;AAAA;AAWL,IAAM,oBAAoB,CAAC,QAAgB,SAAuB;AAAA,EACvE,IAAI,SAAS,MAAM,GAAG;AAAA,IACpB,UAAU,QAAQ,IAAI;AAAA,EACxB;AAAA;AAIK,IAAM,kBAAkB,CAAC,SAC9B,KAAK,SAAS,YAAY,KAAK,wBAAwB,KAAK;AAUvD,IAAM,qBAAqB,CAChC,MACA,QACA,UAA2D,CAAC,MACnD;AAAA,EACT,MAAM,OAAO,YAAY,kBAAkB,MAAM,QAAQ,UAAU,CAAC;AAAA,EACpE,IAAI,MAAM;AAAA,IACR,MAAM,WAAW,QAAQ,eACrB,2HACA;AAAA,IACJ,OAAO,MACL,oCAAoC,gBAAgB,IAAI,MAAM,4CAA4C,UAC5G;AAAA,IACA,QAAQ,KAAK,CAAC;AAAA,EAChB;AAAA;",
-  "debugId": "1007843429DAE30664756E2164756E21",
-  "names": []
-}