stitchkit 0.107.0 → 0.108.0

package/dist/entrypoints/bin/upgrade-cli.js

@@ -1,11 +1,175 @@
 #!/usr/bin/env node
 
 // src/entrypoints/bin/upgrade-cli.ts
-import { readFileSync, realpathSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
+import { readdirSync, readFileSync, realpathSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
+// src/internal/upgrade-affects.ts
+var AFFECTS_LINE = /^\s*\*\*Affects:\*\*\s*(.*)$/;
+var FENCE = /^\s*(`{3,}|~{3,})/;
+var ENTRYPOINT = /^`(stitchkit(?:\/[a-z0-9][a-z0-9-]*)*)`/;
+var SYMBOL = /^([A-Za-z_$][\w$]*)(?:\(([^()]+)\))?$/;
+
+class UpgradeAffectsError extends Error {
+  name = "UpgradeAffectsError";
+}
+function breakingItems(section) {
+  const items = [];
+  let fenced = false;
+  let current;
+  const flush = () => {
+    if (current)
+      items.push({ markdown: current.join(`
+`).trimEnd() });
+    current = undefined;
+  };
+  for (const line of section.split(`
+`)) {
+    if (FENCE.test(line)) {
+      fenced = !fenced;
+      current?.push(line);
+      continue;
+    }
+    if (fenced) {
+      current?.push(line);
+      continue;
+    }
+    if (/^[-*+] /.test(line)) {
+      flush();
+      current = [line];
+    } else if (current && /^\S/.test(line)) {
+      flush();
+    } else {
+      current?.push(line);
+    }
+  }
+  flush();
+  return items;
+}
+function affectsLineOf(itemMarkdown) {
+  let fenced = false;
+  const lines = [];
+  for (const line of itemMarkdown.split(`
+`)) {
+    if (FENCE.test(line)) {
+      fenced = !fenced;
+      continue;
+    }
+    if (fenced)
+      continue;
+    const match = AFFECTS_LINE.exec(line);
+    if (match)
+      lines.push((match[1] ?? "").trim());
+  }
+  if (lines.length > 1)
+    throw new UpgradeAffectsError(`the item carries ${lines.length} "**Affects:**" lines; join their targets with "; " on one line`);
+  return lines[0];
+}
+function splitTopLevel(text, separator) {
+  const parts = [];
+  let depth = 0;
+  let start = 0;
+  for (let index = 0;index < text.length; index++) {
+    const char = text[index];
+    if (char === "(")
+      depth++;
+    else if (char === ")")
+      depth--;
+    else if (depth === 0 && text.startsWith(separator, index)) {
+      parts.push(text.slice(start, index));
+      start = index + separator.length;
+      index += separator.length - 1;
+    }
+  }
+  parts.push(text.slice(start));
+  return parts;
+}
+function parseTarget(text) {
+  let rest = text.trim();
+  const entrypoints = [];
+  for (;; ) {
+    const match = ENTRYPOINT.exec(rest);
+    const name = match?.[1];
+    if (!match || name === undefined)
+      break;
+    entrypoints.push(name);
+    rest = rest.slice(match[0].length);
+    if (!rest.startsWith(", `"))
+      break;
+    rest = rest.slice(2);
+  }
+  if (entrypoints.length === 0)
+    throw new UpgradeAffectsError(`"${text.trim()}" does not start with a backticked stitchkit entrypoint`);
+  if (!rest.startsWith(" "))
+    throw new UpgradeAffectsError(`"${text.trim()}" names no export, \`behaviour\` or \`*\``);
+  const what = rest.trim();
+  if (what === "behaviour")
+    return entrypoints.map((entrypoint) => ({ entrypoint, kind: "behaviour" }));
+  if (what === "*")
+    return entrypoints.map((entrypoint) => ({ entrypoint, kind: "any-import" }));
+  const symbols = splitTopLevel(what, ", ").map((part) => {
+    const match = SYMBOL.exec(part.trim());
+    const name = match?.[1];
+    if (!match || name === undefined)
+      throw new UpgradeAffectsError(`"${part.trim()}" is not an export name with an optional (qualifier)`);
+    const qualifier = match[2]?.trim();
+    return qualifier ? { name, qualifier } : { name };
+  });
+  return entrypoints.map((entrypoint) => ({ entrypoint, kind: "symbols", symbols }));
+}
+function parseAffectsLine(line) {
+  if (line.trim() === "")
+    throw new UpgradeAffectsError("the line names nothing");
+  return splitTopLevel(line, "; ").flatMap(parseTarget);
+}
+
 // src/internal/upgrade-plan.ts
+var BREAKING_HEADING = /^### \s*⚠️?\s*Breaking changes[^\n]*$/m;
+var NOT_DECLARED = "Not declared in this legacy changelog section.";
+function leadingEntrypoints(item) {
+  let rest = item.replace(/^[-*+] /, "").replace(/^\*\*/, "");
+  const names = [];
+  for (;; ) {
+    const match = /^`(stitchkit(?:\/[a-z0-9][a-z0-9-]*)*)`/.exec(rest);
+    const name = match?.[1];
+    if (!match || name === undefined)
+      break;
+    names.push(name);
+    rest = rest.slice(match[0].length);
+    const separator = /^(?:, and |, | and | \+ )/.exec(rest);
+    if (!separator)
+      break;
+    rest = rest.slice(separator[0].length);
+  }
+  return names;
+}
+function itemTitle(item) {
+  const flat = item.replace(/\s+/g, " ").trim();
+  const bold = /\*\*(.+?)\*\*/.exec(flat)?.[1];
+  if (bold !== undefined && !bold.startsWith("Who must act") && !bold.startsWith("Affects"))
+    return bold.replace(/\.$/, "");
+  const first = flat.replace(/^[-*+] /, "");
+  return first.length > 100 ? `${first.slice(0, 99)}…` : first;
+}
+function itemAudience(item) {
+  const flat = item.replace(/\s+/g, " ");
+  const who = /\*\*Who must act:\*\*\s*(.*?)(?=\s+See \[|\s+→|\s+\*\*Affects:\*\*|$)/.exec(flat)?.[1];
+  return who?.trim() || undefined;
+}
+function sectionItems(version, markdown, sectionAudience) {
+  return breakingItems(markdown).map(({ markdown: item }) => {
+    const line = affectsLineOf(item);
+    return {
+      version,
+      entrypoints: leadingEntrypoints(item),
+      title: itemTitle(item),
+      affects: line === undefined ? undefined : parseAffectsLine(line),
+      whoMustAct: itemAudience(item) ?? sectionAudience,
+      markdown: item
+    };
+  });
+}
 function semverParts(version) {
   const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(version);
   if (!match)
@@ -43,7 +207,7 @@ function planUpgrade(changelog, from, to) {
     const bodyStart = (release.index ?? 0) + release[0].length;
     const bodyEnd = releases[index + 1]?.index ?? changelog.length;
     const body = changelog.slice(bodyStart, bodyEnd);
-    const breakingHeader = /^### ⚠️ Breaking changes\s*$/m.exec(body);
+    const breakingHeader = BREAKING_HEADING.exec(body);
     if (!breakingHeader)
       continue;
     const breakingStart = (breakingHeader.index ?? 0) + breakingHeader[0].length;
@@ -51,10 +215,12 @@ function planUpgrade(changelog, from, to) {
     const nextSection = /^### /m.exec(afterHeader);
     const markdown = afterHeader.slice(0, nextSection?.index ?? afterHeader.length).trim();
     const who = /^\*\*Who must act:\*\*\s*([\s\S]*?)(?=\n\s*\n|\n[-*] )/m.exec(markdown);
+    const whoMustAct = who?.[1]?.replace(/\s+/g, " ").trim() ?? NOT_DECLARED;
     changes.push({
       version,
-      whoMustAct: who?.[1]?.replace(/\s+/g, " ").trim() ?? "Not declared in this legacy changelog section.",
-      markdown
+      whoMustAct,
+      markdown,
+      items: sectionItems(version, markdown, whoMustAct)
     });
   }
   return changes.sort((left, right) => compareSemver(left.version, right.version));
@@ -78,6 +244,206 @@ ${change.markdown.replace(/^\*\*Who must act:\*\*[\s\S]*?(?=\n\s*\n|\n[-*] )/m,
 `;
 }
 
+// src/internal/upgrade-usage.ts
+var SPECIFIER = /^stitchkit(?:\/[A-Za-z0-9._-]+)*$/;
+function masked(text) {
+  const strings = new Map;
+  const blank = (part) => part.replace(/[^\n]/g, " ");
+  let code = "";
+  let index = 0;
+  while (index < text.length) {
+    const char = text[index] ?? "";
+    const next = text[index + 1];
+    if (char === '"' || char === "'" || char === "`") {
+      let end = index + 1;
+      let value = "";
+      while (end < text.length && text[end] !== char) {
+        if (text[end] === "\\") {
+          value += text.slice(end, end + 2);
+          end += 2;
+          continue;
+        }
+        if (char !== "`" && text[end] === `
+`)
+          break;
+        value += text[end];
+        end++;
+      }
+      if (char !== "`")
+        strings.set(index, value);
+      code += `${char}${blank(text.slice(index + 1, end))}${text[end] === char ? char : ""}`;
+      index = text[end] === char ? end + 1 : end;
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      const end = text.indexOf(`
+`, index);
+      const stop = end === -1 ? text.length : end;
+      code += blank(text.slice(index, stop));
+      index = stop;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      const end = text.indexOf("*/", index + 2);
+      const stop = end === -1 ? text.length : end + 2;
+      code += blank(text.slice(index, stop));
+      index = stop;
+      continue;
+    }
+    code += char;
+    index++;
+  }
+  return { code, strings };
+}
+function scriptBlocks(text) {
+  let out = "";
+  let at = 0;
+  for (const match of text.matchAll(/(<script\b[^>]*>)([\s\S]*?)<\/script\s*>/gi)) {
+    const start = (match.index ?? 0) + (match[1]?.length ?? 0);
+    out += text.slice(at, start).replace(/[^\n]/g, " ") + (match[2] ?? "");
+    at = start + (match[2]?.length ?? 0);
+  }
+  return out + text.slice(at).replace(/[^\n]/g, " ");
+}
+function lineLocator(text) {
+  const starts = [0];
+  for (let index = text.indexOf(`
+`);index !== -1; index = text.indexOf(`
+`, index + 1))
+    starts.push(index + 1);
+  return (offset) => {
+    let low = 0;
+    let high = starts.length - 1;
+    while (low < high) {
+      const middle = low + high + 1 >> 1;
+      if ((starts[middle] ?? 0) <= offset)
+        low = middle;
+      else
+        high = middle - 1;
+    }
+    return low + 1;
+  };
+}
+function clauseNames(clause) {
+  const names = [];
+  const braces = /\{([^}]*)\}/.exec(clause);
+  if (braces?.[1] !== undefined) {
+    let at = (braces.index ?? 0) + 1;
+    for (const part of braces[1].split(",")) {
+      const match = /^(\s*)(?:type\s+)?([A-Za-z_$][\w$]*)/.exec(part);
+      if (match?.[2])
+        names.push({ name: match[2], at: at + (match[1]?.length ?? 0) });
+      at += part.length + 1;
+    }
+  }
+  const star = /\*/.exec(clause.replace(/\{[^}]*\}/, (block) => " ".repeat(block.length)));
+  if (star)
+    names.push({ name: "*", at: star.index ?? 0 });
+  const head = /^\s*(?:type\s+)?([A-Za-z_$][\w$]*)\s*(?:,|$)/.exec(clause);
+  if (head?.[1] && head[1] !== "type")
+    names.push({ name: "*", at: head.index ?? 0 });
+  return names;
+}
+var IDENTIFIER = "[A-Za-z_$][\\w$]*";
+var CLAUSE = `(?:${IDENTIFIER}\\s*,\\s*)?(?:\\{[^{}'"\`;]*\\}|\\*(?:\\s+as\\s+${IDENTIFIER})?)|${IDENTIFIER}`;
+var DECLARATION = new RegExp(`(?:^|[;}])[ \\t]*(import|export)(\\s+type)?(\\s+(?:${CLAUSE})\\s*|\\s*\\{[^{}'"\`;]*\\}\\s*|\\s*\\*(?:\\s+as\\s+${IDENTIFIER})?\\s*)from\\s*(['"])`, "gm");
+var BARE = /(?:^|[;}])[ \t]*import\s*(['"])/gm;
+var DYNAMIC = /\b(?:import|require)\s*\(\s*(['"])/g;
+var quoteAt = (match) => (match.index ?? 0) + match[0].length - 1;
+function scanStitchkitImports(sources) {
+  const found = [];
+  for (const { path, text: raw } of sources) {
+    const text = raw.charCodeAt(0) === 65279 ? raw.slice(1) : raw;
+    const source = /\.(?:vue|svelte)$/.test(path) ? scriptBlocks(text) : text;
+    const { code, strings } = masked(source);
+    const lineAt = lineLocator(code);
+    const specifierAt = (match) => {
+      const specifier = strings.get(quoteAt(match));
+      return specifier !== undefined && SPECIFIER.test(specifier) ? specifier : undefined;
+    };
+    for (const match of code.matchAll(DECLARATION)) {
+      const entrypoint = specifierAt(match);
+      if (entrypoint === undefined)
+        continue;
+      const clause = match[3] ?? "";
+      const clauseStart = (match.index ?? 0) + match[0].lastIndexOf("from") - clause.length;
+      for (const { name, at } of clauseNames(clause))
+        found.push({ path, line: lineAt(clauseStart + at), entrypoint, name });
+    }
+    for (const pattern of [BARE, DYNAMIC])
+      for (const match of code.matchAll(pattern)) {
+        const entrypoint = specifierAt(match);
+        if (entrypoint !== undefined)
+          found.push({ path, line: lineAt(quoteAt(match)), entrypoint, name: "*" });
+      }
+  }
+  return found.sort((left, right) => left.path === right.path ? left.line - right.line : left.path < right.path ? -1 : 1);
+}
+var filesImporting = (imports, entrypoints) => [
+  ...new Set(imports.filter((use) => entrypoints.includes(use.entrypoint)).map((use) => use.path))
+].sort();
+function usesOf(target, imports) {
+  if (target.kind === "behaviour")
+    return [];
+  const names = target.kind === "symbols" ? new Set(target.symbols.map((symbol) => symbol.name)) : undefined;
+  return imports.filter((use) => use.entrypoint === target.entrypoint && (names === undefined || use.name === "*" || names.has(use.name)));
+}
+function upgradeVerdicts(items, imports) {
+  return items.map((item) => {
+    if (item.affects === undefined)
+      return {
+        item,
+        verdict: { kind: "not-declared", files: filesImporting(imports, item.entrypoints) }
+      };
+    const uses = item.affects.flatMap((target) => usesOf(target, imports));
+    if (uses.length > 0)
+      return { item, verdict: { kind: "affects", uses } };
+    const behavioural = item.affects.filter((target) => target.kind === "behaviour");
+    const files = filesImporting(imports, behavioural.map((target) => target.entrypoint));
+    if (files.length > 0)
+      return { item, verdict: { kind: "behavioural", files } };
+    return { item, verdict: { kind: "not-used" } };
+  });
+}
+var VERDICT_TEXT = {
+  affects: "affects this project",
+  "not-used": "not used here",
+  behavioural: "behavioural — check by hand",
+  "not-declared": "not declared — check by hand"
+};
+function renderUpgradeVerdicts(verdicts) {
+  if (verdicts.length === 0)
+    return "";
+  const lines = ["## Does it touch this project?", ""];
+  for (const { item, verdict } of verdicts) {
+    const where = item.entrypoints.length > 0 ? ` ${item.entrypoints.map((name) => `\`${name}\``).join(", ")}` : "";
+    lines.push(`- **${item.version}**${where} — ${item.title}: **${VERDICT_TEXT[verdict.kind]}**`);
+    if (verdict.kind === "affects")
+      for (const use of verdict.uses)
+        lines.push(`  - ${use.path}:${use.line} ${use.name === "*" ? `every import of \`${use.entrypoint}\`` : `\`${use.name}\``}`);
+    if (verdict.kind === "behavioural" || verdict.kind === "not-declared")
+      for (const file of verdict.files)
+        lines.push(`  - ${file}`);
+  }
+  return `${lines.join(`
+`)}
+`;
+}
+function upgradeVerdictsJson(verdicts) {
+  return verdicts.map(({ item, verdict }) => ({
+    version: item.version,
+    entrypoints: item.entrypoints,
+    title: item.title,
+    whoMustAct: item.whoMustAct,
+    affects: item.affects ?? null,
+    verdict: verdict.kind,
+    ...verdict.kind === "affects" && { uses: verdict.uses },
+    ...(verdict.kind === "behavioural" || verdict.kind === "not-declared") && {
+      files: verdict.files
+    }
+  }));
+}
+
 // src/entrypoints/bin/upgrade-cli.ts
 var USAGE = `stitchkit upgrade — print every breaking change between the installed version and this one
 
@@ -87,9 +453,59 @@ var USAGE = `stitchkit upgrade — print every breaking change between the insta
 Options
   --from <version>     installed version (default: the stitchkit in ./node_modules)
   --to <version>       target version (default: the version of this package)
-  --cwd <dir>          project to read the installed version from (default: .)
+  --cwd <dir>          project to read the installed version and imports from (default: .)
   --changelog <path>   changelog to plan from (default: the one in this package)
+  --json               print the breaking items and their verdicts as JSON
+
+Each breaking item is matched against what the project imports from stitchkit:
+"affects this project" (with file:line), "not used here", "behavioural — check
+by hand" or, for an item written before machine lines, "not declared — check by hand".
 `;
+var SKIPPED_DIRECTORIES = new Set(["node_modules", ".git", ".next", ".turbo", ".cache"]);
+var OUTPUT_DIRECTORIES = new Set(["dist", "build", "out", "coverage"]);
+var SOURCE_FILE = /\.(?:[cm]?[jt]sx?|vue|svelte)$/;
+var DENIED = new Set(["EACCES", "EPERM"]);
+function deniedCode(error) {
+  const code = typeof error === "object" && error !== null ? Reflect.get(error, "code") : undefined;
+  return typeof code === "string" && DENIED.has(code) ? code : undefined;
+}
+function projectSources(root, io = {
+  readdir: (path) => readdirSync(path, { withFileTypes: true }),
+  readFile: (path) => readFileSync(path, "utf8")
+}) {
+  const sources = [];
+  const unscanned = [];
+  const attempt = (path, read) => {
+    try {
+      return read();
+    } catch (error) {
+      const code = deniedCode(error);
+      if (code === undefined)
+        throw error;
+      unscanned.push({ path: relative(root, path) || ".", code });
+      return;
+    }
+  };
+  const walk = (directory) => {
+    const entries = attempt(directory, () => io.readdir(directory));
+    const packageRoot = directory === root || (entries ?? []).some((entry) => entry.name === "package.json");
+    for (const entry of entries ?? []) {
+      const path = join(directory, entry.name);
+      if (entry.isDirectory()) {
+        const skipped = SKIPPED_DIRECTORIES.has(entry.name) || packageRoot && OUTPUT_DIRECTORIES.has(entry.name);
+        if (!skipped)
+          walk(path);
+      } else if (entry.isFile() && SOURCE_FILE.test(entry.name)) {
+        const text = attempt(path, () => io.readFile(path));
+        if (text !== undefined)
+          sources.push({ path: relative(root, path), text });
+      }
+    }
+  };
+  walk(root);
+  unscanned.sort((left, right) => left.path < right.path ? -1 : 1);
+  return { sources, unscanned };
+}
 function option(argv, name) {
   const index = argv.indexOf(`--${name}`);
   if (index < 0)
@@ -136,8 +552,13 @@ ${USAGE}`, code: 1 };
   if (from === undefined) {
     throw new Error(`No stitchkit found in ${join(cwd, "node_modules")} — run this in the project that depends on it, or pass --from <installed version>`);
   }
+  const json = argv.includes("--json");
   if (from === to) {
-    return { output: `Already on ${to}. Nothing to upgrade.
+    return json ? {
+      output: `${JSON.stringify({ from, to, items: [], unscanned: [] }, null, 2)}
+`,
+      code: 0
+    } : { output: `Already on ${to}. Nothing to upgrade.
 `, code: 0 };
   }
   const changelogPath = option(argv, "changelog") ?? join(root, "CHANGELOG.md");
@@ -147,7 +568,28 @@ ${USAGE}`, code: 1 };
   } catch {
     throw new Error(`Cannot read the changelog at ${changelogPath}`);
   }
-  return { output: renderUpgradePlan(planUpgrade(changelog, from, to), from, to), code: 0 };
+  const plan = planUpgrade(changelog, from, to);
+  const { sources, unscanned } = projectSources(cwd);
+  const verdicts = upgradeVerdicts(plan.flatMap((change) => change.items), scanStitchkitImports(sources));
+  if (json) {
+    const document = { from, to, items: upgradeVerdictsJson(verdicts), unscanned };
+    return { output: `${JSON.stringify(document, null, 2)}
+`, code: 0 };
+  }
+  const usage = renderUpgradeVerdicts(verdicts);
+  const skipped = unscanned.length === 0 ? "" : `
+## Not scanned
+
+The verdicts above do not include these paths (no permission to read them):
+
+${unscanned.map((entry) => `- ${entry.path} (${entry.code})`).join(`
+`)}
+`;
+  return {
+    output: `${renderUpgradePlan(plan, from, to)}${usage ? `
+${usage}` : ""}${skipped}`,
+    code: 0
+  };
 }
 function isDirectInvocation(invoked, self) {
   if (invoked === undefined)
@@ -173,5 +615,6 @@ if (isDirectInvocation(process.argv[1], fileURLToPath(import.meta.url))) {
 }
 export {
   isDirectInvocation,
+  projectSources,
   runUpgradeCli
 };

package/dist/entrypoints/cli/publish.js

@@ -1,7 +1,7 @@
 import"../../index-xqhede6x.js";
 import"../../index-2kbysk9s.js";
-import"../../index-7r74re56.js";
-import"../../index-bnf8s6v3.js";
+import"../../index-bh2ht9y5.js";
+import"../../index-t2bsd0hm.js";
 import {
   signCliManifest2,
   verifyCliManifest2,
@@ -18,7 +18,7 @@ import {
 } from "../../index-ktjmgq9p.js";
 import {
   withExclusiveLock2
-} from "../../index-4f37d3bg.js";
+} from "../../index-w9mqgnz9.js";
 import {
   ManagedFileError2,
   createManagedFileBoundary2

package/dist/entrypoints/files/packaging.d.ts

@@ -1,3 +1,5 @@
-export type { NativePackagingAsset, NativePackagingEmbeddedAsset, NativePackagingEmbeddedOptions, NativePackagingEmbeddedResult, NativePackagingOptions, NativePackagingPlugin, NativePackagingResult, } from '../../files/native-packaging.js';
+export { inspectNativeArtifact, type NativeArtifactLoader } from '../../files/native-artifact.js';
+export type { NativePackagingAsset, NativePackagingEmbeddedAsset, NativePackagingEmbeddedOptions, NativePackagingEmbeddedResult, NativePackagingOptions, NativePackagingResult, } from '../../files/native-packaging.js';
 export { createNativePackaging } from '../../files/native-packaging.js';
+export type { NativePackagingPlugin } from '../../files/native-packaging-plugin.js';
 //# sourceMappingURL=packaging.d.ts.map

package/dist/entrypoints/files/packaging.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"packaging.d.ts","sourceRoot":"","sources":["../../../src/entrypoints/files/packaging.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,oBAAoB,EACpB,4BAA4B,EAC5B,8BAA8B,EAC9B,6BAA6B,EAC7B,sBAAsB,EACtB,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC"}
+{"version":3,"file":"packaging.d.ts","sourceRoot":"","sources":["../../../src/entrypoints/files/packaging.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,KAAK,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAC/F,YAAY,EACV,oBAAoB,EACpB,4BAA4B,EAC5B,8BAA8B,EAC9B,6BAA6B,EAC7B,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,YAAY,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAC"}