domflax 0.1.2 → 0.2.0

package/README.md

@@ -2,9 +2,9 @@
 
 > Compile-time DOM flattener and semantic CSS compressor — fewer DOM nodes, smaller class sets, **identical rendered UI**.
 
-`domflax` analyzes your JSX at build time and rewrites it to a smaller equivalent:
+`domflax` analyzes your JSX **and HTML** at build time and rewrites it to a smaller equivalent:
 
-1. **Compress** — collapses verbose class sets into their shortest equivalents (`px-4 py-4 mt-2 mb-2` → `p-4 my-2`, `h-10 w-10` → `size-10`).
+1. **Compress** — a general engine rewrites each element's classes to the **shortest set that produces the same computed style** (`px-4 py-4 mt-2 mb-2` → `p-4 my-2`, `h-10 w-10` → `size-10`). One algorithm across **Tailwind v3, Tailwind v4, and custom CSS** — no per-utility patterns.
 2. **Flatten** — removes wrapper elements that are *provably inert* (they add no layout and paint nothing).
 
 Matching happens on **computed styles**, not raw class names — so the rules work across Tailwind, custom CSS, and (later) other providers, and a Tailwind class and an equivalent custom class compress the same way.
@@ -24,10 +24,10 @@ It rewrites only the **static shape** of your markup. Dynamic class lists (`clas
 **Safety model — conservative by default, no browser involved.**
 
 - **Compression is always safe.** It only re-serializes an element's *own* class list, so a `ref`, an event handler, a `{dynamic}` child, or `dangerouslySetInnerHTML` never blocks it — only a *dynamic* className (or a class a CSS selector depends on) is left alone.
-- **Flattening is conservative.** A wrapper is removed only when removal is *provably* render-neutral — it establishes no layout context and has no style to reproduce on its child. It never drops a style it can't reproduce, and never touches a wrapper a CSS selector depends on (`.list > .item h3`).
+- **Flattening is conservative.** A wrapper is removed only when removal is *provably* render-neutral — it establishes no layout context and has no style to reproduce on its child. A `flex`/`grid` **centering** wrapper is removed only when its parent is statically `display:grid` (so `place-self:center` is provably equivalent — Chromium-verified); a flex/block/unknown parent leaves it preserved. It never drops a style it can't reproduce, and never touches a wrapper a CSS selector depends on (`.list > .item h3`).
 - domflax runs as a **purely static** source transform. It never launches a browser, so builds stay fast and deterministic.
 
-> **Status: v0.1.2.** Works end-to-end on real `.jsx`/`.tsx` — in component-return position **and inside `.map()` / expressions (list rows)** — via Vite, Next.js (webpack), and the CLI, with Tailwind and custom-CSS providers. 22 patterns. Wrappers that establish a layout context (e.g. `flex`/`grid` centering) are **conservatively preserved** — proving those render-identical needs context a static pass can't see; recovering them safely is on the Roadmap. APIs may change before 1.0.
+> **Status: v0.2.0.** Optimizes real `.jsx`/`.tsx` **and `.html`** — component-return, inside `.map()`/expressions, and whole static-HTML sites — via Vite, Next.js (webpack), and the CLI. **Compression is one general engine** that emits the shortest class set reproducing each element's computed style, uniformly across **Tailwind v3, Tailwind v4, and custom CSS** (it re-resolves the result and verifies it's identical before emitting). **Flattening** is a lean set of provably-safe structural patterns (inert wrappers + grid-parent centering). **Static-only — never launches a browser** during a build; a Tailwind project it can't resolve is left untouched, never broken. The CLI batches large sites across CPU cores (`--max-memory`, never OOM) and auto-detects each HTML page's own `<link>` stylesheets; the Vite/Next plugins print a build-end optimization summary. APIs may change before 1.0.
 
 ## Install
 
@@ -67,9 +67,21 @@ module.exports = {
 
 > domflax runs as a **source transform** on your `.jsx`/`.tsx` files via the bundler — it never touches a framework's shipped `index.html`. Use `next build` (webpack); **Turbopack is not supported yet** (it doesn't accept arbitrary webpack loaders).
 
+At the end of the build both plugins print a one-box summary of what domflax did:
+
+```
+  ▲ domflax
+  ────────────────────────────────
+   files optimized     42
+   DOM nodes removed   318
+   classes compressed  1,204
+   size saved          18.7 KB
+  ────────────────────────────────
+```
+
 ### Tailwind (auto-detected)
 
-When `tailwindcss` is present, `provider: 'auto'` resolves classes through the real Tailwind engine and emits the shortest equivalent Tailwind classes back. `tailwindcss` is an optional peer, loaded from your project only when used.
+When `tailwindcss` is present, `provider: 'auto'` resolves classes through your project's real Tailwind engine — **Tailwind v3 and v4 are both supported** — and emits the shortest equivalent classes back. `tailwindcss` is an optional peer, loaded from your project only when used. A Tailwind version domflax can't resolve is left untouched (never broken).
 
 ### Custom CSS files
 
@@ -96,32 +108,55 @@ npx domflax ./src --out ./domflax-out
 | `<path>` | Folder (auto-scanned) or glob of files. |
 | `--out <dir>` | Write optimized output here (mirrors input structure). |
 | `--provider <name>` | `auto` (default), `tailwind`, or `custom`. |
-| `--css <files...>` | Stylesheets when `--provider custom`. |
+| `--css <files...>` | **Global** stylesheets (`--provider custom`); each `.html` page's own `<link>` imports are auto-detected on top. |
+| `--max-memory <MB>` | Cap total RAM — and thus worker parallelism. Default ≈ 70% of free RAM; low values run slower but never OOM. |
+| `--concurrency <N>` | Cap worker count (memory always wins). |
 | `--dry-run` | Preview changes, write nothing. |
+| `--details` | Print per-file optimization stats (nodes / classes / bytes). |
 | `--dangerously-overwrite-source` | Allow in-place source rewrite (needs clean git). |
 
+### HTML & static sites
+
+domflax optimizes `.html`/`.htm` too (parse5), so you can run it over a **built static site** (`dist/`):
+
+```bash
+npx domflax ./dist --provider custom --out ./dist-optimized
+```
+
+- **Per-page CSS, automatically.** Each HTML file resolves against the stylesheets *it* links (`<link rel="stylesheet">`, relative + local) plus any global `--css` — so you usually don't select CSS at all, and selector-safety is accurate per page.
+- **Centering actually flattens here.** In HTML the parent is statically known, so a `grid`-parent centering wrapper is provably removable (Chromium-verified) — real node removal, not just compression.
+- **Big sites, safely parallel.** Large batches run across CPU cores with a memory-bounded worker pool: `--max-memory` caps RAM (and parallelism); a bad or huge file fails just that file (reported), never crashing or OOM-ing the run.
+- **Byte-for-byte outside edits** — doctype, comments, whitespace, scripts, and attribute order are preserved; only changed `class` values and unwrapped tags are touched.
+
 ## Writing a pattern
 
-Patterns are how domflax knows what's safe to rewrite. Each is a **single declarative file** — the definition and its tests live in one `definePattern` call, with no separate test file and no manual registration:
+Compression is a general engine — there are **no per-utility compress patterns**. Patterns are for **flattening**: each is a single declarative file whose definition and tests live in one `definePattern` call, auto-discovered, with no manual registration:
 
 ```ts
-import { definePattern } from 'domflax/pattern-kit'
+import { definePattern, not, hasDynamicClasses } from 'domflax/pattern-kit'
 
 export default definePattern({
-  name: 'padding-shorthand',
-  category: 'compress/padding-shorthand',
-  safety: 1,
-  doc: { summary: 'Equal/paired padding longhands collapse to the shortest shorthand.' },
-  // a compress recipe rewrites only the element's own class list (declines with null otherwise)
-  rewrite: { rewriteClasses: (computed) => foldPadding(computed) },
+  name: 'display-contents-wrapper',
+  category: 'flatten/wrapper/display-contents-wrapper',
+  safety: 2,
+  doc: { summary: 'A display:contents wrapper generates no box — unwrap it into its sole child.' },
+  match: {
+    tag: 'div',
+    style: { display: 'contents' },
+    onlyChild: 'element',
+    paintsNothing: true,
+    where: [not(hasDynamicClasses)],
+  },
+  rewrite: { flattenInto: 'child' },
   test: {
-    cases:   [{ before: '<div className="px-4 py-4">{x}</div>', after: '<div className="p-4">{x}</div>' }],
-    noMatch: ['<div className="pt-2 pr-4 pb-8 pl-4">box</div>'],
+    cases:   [{ before: '<div className="contents"><a className="text-blue-500">L</a></div>',
+                after:  '<a className="text-blue-500">L</a>' }],
+    noMatch: ['<div className="contents" ref={r}><a>L</a></div>'],
   },
 })
 ```
 
-Drop the file under `src/library/**` as `*.pattern.ts` and it's **auto-discovered**. The generic harness runs every pattern's `test` cases through the *real* transform, plus an automatic invariant suite (purity, opacity-barrier safety, id-preservation, fixpoint termination) — so a new pattern is wired, tested, and proven sound with zero boilerplate. Flatten patterns auto-receive the opacity + selector-safety guards; compress patterns are gated only on dynamic / selector-bound classes.
+Drop the file under `src/library/**` as `*.pattern.ts` and it's **auto-discovered**. The generic harness runs its `test` cases through the *real* transform, plus an automatic invariant suite (purity, opacity-barrier safety, id-preservation, fixpoint termination). Every `flatten/*` pattern auto-receives the opacity + selector-safety guards, and the conservative safety gate only commits a removal it can *prove* is render-neutral — so a pattern can never produce unsafe output.
 
 ## Advanced entry points
 
@@ -134,23 +169,23 @@ The transform itself is static and never launches a browser. `domflax/verify` is
 
 ## Examples
 
-Runnable examples live in [`examples/`](./examples): `vite-react-tailwind`, `vite-custom-css` (custom provider + selector-safety), and `next-tailwind`.
+Runnable examples live in [`examples/`](./examples): `vite-react-tailwind`, `vite-custom-css` (custom provider + selector-safety), `next-tailwind`, and `static-html` (CLI optimizing a plain `.html` page with per-page `<link>` CSS auto-detection).
 
 ## Roadmap
 
-- [x] Monorepo + single bundled package
-- [x] Core engine (IR, pass manager, surgical full-module codegen)
-- [x] Declarative `definePattern({ …, test })` + auto-discovery; 22 flatten/compress patterns
-- [x] Real Tailwind engine + custom-CSS resolvers
-- [x] CSS selector-safety + residual-skip (don't break `div div h1`; never drop un-reproducible styles)
-- [x] Compression across dynamic content (refs / handlers / `{expr}` children)
-- [x] Optimize JSX inside `.map()` / expressions (list rows)
-- [x] Vite + Next.js (webpack) adapters + CLI (folders, wizard, output-safety)
-- [x] Standalone equivalence verifier (Playwright, opt-in)
-- [ ] Context-aware (or opt-in-verified) flatten for `flex`/`grid` centering wrappers
-- [ ] HTML frontend (plain `.html` / Astro static)
-- [ ] `domflax/runtime` — optimize dynamic HTML strings before `innerHTML`
-- [ ] More providers; `templatize` (plain-HTML cloneNode)
+Done so far: monorepo + single bundled package · core IR/pass engine with surgical codegen · declarative `definePattern` + auto-discovery · the general compress **engine** (Tailwind v3 + v4 + custom CSS) · Tailwind v4 support + fail-safe · selector-safety & residual-skip · compression across dynamic content and inside `.map()` rows · Vite + Next.js adapters with a build-end summary · HTML frontend with per-page `<link>` CSS auto-detection · grid-parent centering flatten (Chromium-verified) · memory-bounded parallel CLI.
+
+Where it's going — each release adds the engine capability that unlocks its next validated pattern batch (full details in [`docs/ROADMAP.md`](./docs/ROADMAP.md)):
+
+| Version | Theme | Patterns |
+| --- | --- | --- |
+| **0.3.0** | **Reach** — `cn()`/template-literal static extraction, arbitrary-value + variant-aware compression, deeper static layout reasoning (margin-collapse, item sizing) | ~25 |
+| **0.4.0** | **Verified tier** — opt-in render-verified flattening for static HTML (real pages, pixel-identical or rejected); unlocks animation-wrapper class-transfer, multi-child unwraps, merges | ~60 |
+| **0.5.0** | **More frontends** — Astro static + Vue SFC frontends, Turbopack, Bootstrap/other providers for the compress engine | ~100 |
+| **0.6.0** | **Perf & ecosystem** — incremental/watch caching, `domflax/runtime`, `templatize` (cloneNode), community `domflax-pattern-*` packages | ~140 |
+| **1.0.0** | **Stable** — frozen API, semver guarantees, docs site, published benchmarks | **200+** |
+
+Every pattern that ships must *uniquely fire on real code* and be proven render-neutral (statically or via the verified tier) — the count grows from new capability surface, never from padding.
 
 ## License
 

package/dist/chunk-EYQXQQQH.js

@@ -0,0 +1,336 @@
+import {
+  builtinPatterns,
+  createCssResolver,
+  createHtmlBackend,
+  createHtmlFrontend,
+  createJsxBackend,
+  createJsxFrontend,
+  createTailwindResolver
+} from "./chunk-FPT4EJ6Q.js";
+import {
+  buildSelectorIndex,
+  createSyntheticSink,
+  normalizer,
+  runPasses,
+  syncClassesFromComputed
+} from "./chunk-TTJEXWAC.js";
+import {
+  init_esm_shims
+} from "./chunk-U5GOONKV.js";
+
+// ../cli/src/safety.ts
+init_esm_shims();
+import { execFileSync } from "child_process";
+import * as path from "path";
+var DISPOSABLE_DIRS = /* @__PURE__ */ new Set(["dist", "build", "out", ".next"]);
+function isDisposablePath(file) {
+  return path.resolve(file).split(path.sep).some((seg) => DISPOSABLE_DIRS.has(seg));
+}
+function isGitClean(cwd) {
+  try {
+    const out = execFileSync("git", ["status", "--porcelain"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return out.trim().length === 0;
+  } catch {
+    return false;
+  }
+}
+function planWrites(options, gitClean) {
+  if (options.dangerouslyOverwriteSource) {
+    if (!options.noGitCheck && !gitClean) {
+      return {
+        ok: false,
+        error: "refusing --dangerously-overwrite-source: git working tree is not clean. Commit or stash first, or pass --no-git-check to override."
+      };
+    }
+    return { ok: true, value: { mode: "overwrite-source", outDir: null } };
+  }
+  const outDir = path.resolve(options.out ?? "domflax-out");
+  return { ok: true, value: { mode: "out-dir", outDir } };
+}
+function destinationFor(file, inputRoot, plan) {
+  const absFile = path.resolve(file);
+  if (plan.mode === "overwrite-source") {
+    return { ok: true, value: absFile };
+  }
+  const outDir = plan.outDir;
+  const rel = path.relative(inputRoot, absFile);
+  const safeRel = rel === "" || rel.startsWith("..") || path.isAbsolute(rel) ? path.basename(absFile) : rel;
+  const dest = path.join(outDir, safeRel);
+  if (path.resolve(dest) === absFile && !isDisposablePath(absFile)) {
+    return {
+      ok: false,
+      error: `refusing to overwrite source file ${absFile}: the output path resolves onto the source. Choose a different --out, or pass --dangerously-overwrite-source (with a clean git tree).`
+    };
+  }
+  return { ok: true, value: dest };
+}
+
+// ../cli/src/transform.ts
+init_esm_shims();
+import * as path3 from "path";
+
+// ../cli/src/html-css.ts
+init_esm_shims();
+import { createHash } from "crypto";
+import { existsSync } from "fs";
+import * as path2 from "path";
+function isRemoteHref(href) {
+  const h = href.trim();
+  return h.startsWith("//") || /^[a-z][a-z0-9+.-]*:/i.test(h);
+}
+function attrValue(tag, name) {
+  const re = new RegExp(`\\b${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s"'>]+))`, "i");
+  const m = re.exec(tag);
+  if (!m) return null;
+  return (m[1] ?? m[2] ?? m[3] ?? "").trim();
+}
+function extractLinkHrefs(html) {
+  const out = [];
+  const linkRe = /<link\b[^>]*>/gi;
+  let m;
+  while ((m = linkRe.exec(html)) !== null) {
+    const tag = m[0];
+    const rel = attrValue(tag, "rel");
+    if (rel === null || !/(?:^|\s)stylesheet(?:\s|$)/i.test(rel)) continue;
+    const href = attrValue(tag, "href");
+    if (href) out.push(href);
+  }
+  return out;
+}
+function extractInlineStyles(html) {
+  const out = [];
+  const styleRe = /<style\b([^>]*)>([\s\S]*?)<\/style>/gi;
+  let m;
+  while ((m = styleRe.exec(html)) !== null) {
+    const type = attrValue(`<style ${m[1] ?? ""}>`, "type")?.toLowerCase();
+    if (type && type !== "text/css" && type !== "css") continue;
+    const css = m[2] ?? "";
+    if (css.trim().length > 0) out.push(css);
+  }
+  return out;
+}
+function extractHtmlStylesheets(htmlCode, htmlAbsPath) {
+  const dir = path2.dirname(path2.resolve(htmlAbsPath));
+  const files = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const rawHref of extractLinkHrefs(htmlCode)) {
+    const href = (rawHref.split(/[?#]/, 1)[0] ?? "").trim();
+    if (!href || isRemoteHref(href)) continue;
+    const abs = path2.resolve(dir, href);
+    if (seen.has(abs)) continue;
+    seen.add(abs);
+    if (existsSync(abs)) files.push(abs);
+  }
+  return { files, inline: extractInlineStyles(htmlCode) };
+}
+function cssSetKey(sortedResolvedPaths, inline) {
+  const h = createHash("sha1");
+  h.update(sortedResolvedPaths.join("\n"));
+  h.update("\0inline\0");
+  for (const block of inline) {
+    h.update(block);
+    h.update("\0");
+  }
+  return h.digest("hex");
+}
+
+// ../cli/src/transform.ts
+function buildResolver(provider, css, projectRoot) {
+  if (provider === "custom") {
+    return createCssResolver([], { files: css, projectRoot });
+  }
+  return createTailwindResolver({ projectRoot });
+}
+function buildPasses(patterns) {
+  const byPhase = /* @__PURE__ */ new Map();
+  for (const p of patterns) {
+    const phase = p.category.split("/", 1)[0] ?? "flatten";
+    let bucket = byPhase.get(phase);
+    if (!bucket) {
+      bucket = [];
+      byPhase.set(phase, bucket);
+    }
+    bucket.push(p);
+  }
+  const passes = [];
+  for (const [phase, pats] of byPhase) {
+    passes.push({ phase, category: `${phase}/builtin`, patterns: pats });
+  }
+  return passes;
+}
+function selectPatterns(names) {
+  if (names === null) return builtinPatterns;
+  const set = new Set(names);
+  return builtinPatterns.filter((p) => set.has(p.name));
+}
+function jsxKindOf(id) {
+  const clean = id.split("?", 1)[0] ?? id;
+  const lower = clean.toLowerCase();
+  if (lower.endsWith(".tsx")) return "tsx";
+  if (lower.endsWith(".jsx")) return "jsx";
+  return null;
+}
+function htmlKindOf(id) {
+  const lower = (id.split("?", 1)[0] ?? id).toLowerCase();
+  if (lower.endsWith(".html") || lower.endsWith(".htm")) return "html";
+  return null;
+}
+function countClassTokens(code) {
+  let total = 0;
+  const re = /\b(?:className|class)\s*=\s*"([^"]*)"/g;
+  let m;
+  while ((m = re.exec(code)) !== null) {
+    total += m[1].split(/\s+/).filter((t) => t.length > 0).length;
+  }
+  return total;
+}
+function bytes(s) {
+  return Buffer.byteLength(s, "utf8");
+}
+function passthroughResult(code) {
+  return {
+    code,
+    changed: false,
+    passthrough: true,
+    stats: {
+      nodesIn: 0,
+      nodesOut: 0,
+      nodesRemoved: 0,
+      classesBefore: 0,
+      classesAfter: 0,
+      classesSaved: 0,
+      bytesBefore: bytes(code),
+      bytesAfter: bytes(code),
+      bytesSaved: 0
+    }
+  };
+}
+function createTransform(options) {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const globalResolver = buildResolver(options.provider, options.css, projectRoot);
+  const patterns = selectPatterns(options.passes);
+  const resolverCache = /* @__PURE__ */ new Map();
+  function resolverFor(code, id) {
+    if (options.provider !== "custom" || htmlKindOf(id) === null) return globalResolver;
+    const { files: localFiles, inline } = extractHtmlStylesheets(code, id);
+    if (localFiles.length === 0 && inline.length === 0) return globalResolver;
+    const globalPaths = options.css.map((p) => path3.resolve(p));
+    const sortedPaths = [.../* @__PURE__ */ new Set([...globalPaths, ...localFiles])].sort();
+    const key = cssSetKey(sortedPaths, inline);
+    let resolver = resolverCache.get(key);
+    if (!resolver) {
+      const inlineFiles = inline.map((css, i) => ({ id: `${id}#inline-${i}`, css }));
+      resolver = createCssResolver(inlineFiles, { files: sortedPaths, projectRoot });
+      resolverCache.set(key, resolver);
+    }
+    return resolver;
+  }
+  function prepare(code, id, kind, gate, resolver) {
+    const parsed = createJsxFrontend().parse(code, {
+      id,
+      kind,
+      resolver,
+      normalizer,
+      config: {},
+      onDiagnostic: () => {
+      }
+    });
+    const doc = parsed.doc;
+    const nodesIn = doc.nodes.size;
+    for (const node of doc.nodes.values()) node.meta.safetyFloor = 3;
+    const ctx = {
+      doc,
+      safetyCeiling: options.safety,
+      normalizer,
+      // Real CSS-selector-safety index from the active resolver (custom-CSS reports combinator /
+      // structural-pseudo coupling; Tailwind has none → null index, behaviour unchanged).
+      selectors: buildSelectorIndex(doc, resolver),
+      resolver,
+      gate
+    };
+    return { doc, ctx, passes: buildPasses(patterns), nodesIn };
+  }
+  function prepareHtml(code, id, gate, resolver) {
+    const parsed = createHtmlFrontend().parse(code, {
+      id,
+      kind: "html",
+      resolver,
+      normalizer,
+      config: {},
+      onDiagnostic: () => {
+      }
+    });
+    const doc = parsed.doc;
+    const nodesIn = doc.nodes.size;
+    const ctx = {
+      doc,
+      safetyCeiling: options.safety,
+      normalizer,
+      selectors: buildSelectorIndex(doc, resolver),
+      resolver,
+      gate
+    };
+    return { doc, ctx, passes: buildPasses(patterns), nodesIn };
+  }
+  function finish(code, optimized, id, nodesIn, resolver, backend = "jsx") {
+    syncClassesFromComputed(optimized, resolver, normalizer);
+    const print = backend === "html" ? createHtmlBackend().print : createJsxBackend().print;
+    const printed = print(
+      optimized,
+      { moduleId: id, ops: [], provenance: /* @__PURE__ */ new Map() },
+      { normalizer, resolver, sink: createSyntheticSink(), eol: "\n", onDiagnostic: () => {
+      } }
+    );
+    const out = printed.code;
+    const nodesOut = optimized.nodes.size;
+    const classesBefore = countClassTokens(code);
+    const classesAfter = countClassTokens(out);
+    return {
+      code: out,
+      changed: out !== code,
+      passthrough: false,
+      stats: {
+        nodesIn,
+        nodesOut,
+        nodesRemoved: Math.max(0, nodesIn - nodesOut),
+        classesBefore,
+        classesAfter,
+        classesSaved: Math.max(0, classesBefore - classesAfter),
+        bytesBefore: bytes(code),
+        bytesAfter: bytes(out),
+        bytesSaved: bytes(code) - bytes(out)
+      }
+    };
+  }
+  return {
+    resolver: globalResolver,
+    transformFile(code, id) {
+      const kind = jsxKindOf(id);
+      if (kind !== null) {
+        const resolver = resolverFor(code, id);
+        const { doc, ctx, passes, nodesIn } = prepare(code, id, kind, "provably-safe", resolver);
+        const { doc: optimized } = runPasses(doc, passes, ctx);
+        return finish(code, optimized, id, nodesIn, resolver);
+      }
+      if (htmlKindOf(id) !== null) {
+        const resolver = resolverFor(code, id);
+        const { doc, ctx, passes, nodesIn } = prepareHtml(code, id, "provably-safe", resolver);
+        const { doc: optimized } = runPasses(doc, passes, ctx);
+        return finish(code, optimized, id, nodesIn, resolver, "html");
+      }
+      return passthroughResult(code);
+    }
+  };
+}
+
+export {
+  isGitClean,
+  planWrites,
+  destinationFor,
+  createTransform
+};
+//# sourceMappingURL=chunk-EYQXQQQH.js.map

package/dist/chunk-EYQXQQQH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../cli/src/safety.ts","../../cli/src/transform.ts","../../cli/src/html-css.ts"],"sourcesContent":["/**\n * @domflax/cli — OUTPUT SAFETY (DESIGN-DECISIONS Q16, ARCHITECTURE §16.10).\n *\n * Source is READ-ONLY by default. Writes land in `--out`/`./domflax-out` (mirroring structure), or in\n * place ONLY inside disposable build dirs (dist/build/out/.next). Overwriting real source in place\n * requires `--dangerously-overwrite-source` AND a clean git tree (skippable with `--no-git-check`).\n * `--dry-run` writes nothing.\n */\n\nimport { execFileSync } from 'node:child_process';\nimport * as path from 'node:path';\n\nimport type { CliOptions } from './options';\n\n/** Disposable build directories where in-place overwrite is always safe (they are regenerated). */\nconst DISPOSABLE_DIRS: ReadonlySet<string> = new Set(['dist', 'build', 'out', '.next']);\n\n/** True when any path segment is a disposable build dir, so the file is a regenerable artifact. */\nexport function isDisposablePath(file: string): boolean {\n  return path\n    .resolve(file)\n    .split(path.sep)\n    .some((seg) => DISPOSABLE_DIRS.has(seg));\n}\n\nexport type WriteMode = 'out-dir' | 'overwrite-source';\n\n/** Invocation-level write plan shared by every file. */\nexport interface WritePlan {\n  readonly mode: WriteMode;\n  /** Resolved absolute output dir for `out-dir` mode; `null` when overwriting source in place. */\n  readonly outDir: string | null;\n}\n\nexport type Result<T> = { readonly ok: true; readonly value: T } | { readonly ok: false; readonly error: string };\n\n/** Run `git status --porcelain`; clean ⇒ true. A non-repo / missing git ⇒ false (fail safe). */\nexport function isGitClean(cwd: string): boolean {\n  try {\n    const out = execFileSync('git', ['status', '--porcelain'], {\n      cwd,\n      encoding: 'utf8',\n      stdio: ['ignore', 'pipe', 'ignore'],\n    });\n    return out.trim().length === 0;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Resolve the invocation-level {@link WritePlan}. In-place source overwrite is refused unless the\n * danger flag is set and (the git tree is clean OR the git check is waived).\n */\nexport function planWrites(options: CliOptions, gitClean: boolean): Result<WritePlan> {\n  if (options.dangerouslyOverwriteSource) {\n    if (!options.noGitCheck && !gitClean) {\n      return {\n        ok: false,\n        error:\n          'refusing --dangerously-overwrite-source: git working tree is not clean. ' +\n          'Commit or stash first, or pass --no-git-check to override.',\n      };\n    }\n    return { ok: true, value: { mode: 'overwrite-source', outDir: null } };\n  }\n  const outDir = path.resolve(options.out ?? 'domflax-out');\n  return { ok: true, value: { mode: 'out-dir', outDir } };\n}\n\n/**\n * Compute the destination path for one source file under a {@link WritePlan}. Refuses when an\n * `out-dir` destination resolves onto the source file itself and that file is NOT a disposable build\n * artifact — that would be an unsanctioned in-place source overwrite (the Q16 guard).\n */\nexport function destinationFor(file: string, inputRoot: string, plan: WritePlan): Result<string> {\n  const absFile = path.resolve(file);\n\n  if (plan.mode === 'overwrite-source') {\n    // Already gated by planWrites (danger flag + clean-git / waiver).\n    return { ok: true, value: absFile };\n  }\n\n  const outDir = plan.outDir!;\n  const rel = path.relative(inputRoot, absFile);\n  // Inputs outside the mirror root collapse to their basename so we never escape outDir with `..`.\n  const safeRel = rel === '' || rel.startsWith('..') || path.isAbsolute(rel) ? path.basename(absFile) : rel;\n  const dest = path.join(outDir, safeRel);\n\n  if (path.resolve(dest) === absFile && !isDisposablePath(absFile)) {\n    return {\n      ok: false,\n      error:\n        `refusing to overwrite source file ${absFile}: the output path resolves onto the source. ` +\n        'Choose a different --out, or pass --dangerously-overwrite-source (with a clean git tree).',\n    };\n  }\n  return { ok: true, value: dest };\n}\n","/**\n * @domflax/cli — the single-file transform engine.\n *\n * Built directly from the LOWER packages (core + frontend-jsx + resolver-tailwind/resolver-css +\n * patterns + pattern-kit). It deliberately does NOT import the `domflax` meta package: domflax's bin\n * imports `@domflax/cli`, so importing domflax here would form a dependency cycle. The pipeline\n * mirrors domflax's own:  parse (JSX→IR, resolving each element's static classes through the chosen\n * resolver) → runPasses(builtinPatterns) → reverse-emit computed styles back to class tokens → print.\n *\n * `.jsx`/`.tsx` route to `@domflax/frontend-jsx` (Babel); `.html`/`.htm` route to\n * `@domflax/frontend-html` (parse5). Every other file passes through unchanged.\n */\n\nimport {\n  buildSelectorIndex,\n  createSyntheticSink,\n  runPasses,\n  syncClassesFromComputed,\n} from '@domflax/core';\nimport type {\n  ApplyContext,\n  FileKind,\n  FlattenGate,\n  IRDocument,\n  Pass,\n  PassCategory,\n  PassPhase,\n  Pattern,\n  SafetyLevel,\n  StyleResolver,\n} from '@domflax/core';\nimport { createHtmlBackend, createHtmlFrontend } from '@domflax/frontend-html';\nimport { createJsxBackend, createJsxFrontend } from '@domflax/frontend-jsx';\nimport { normalizer } from '@domflax/pattern-kit';\nimport { builtinPatterns } from '@domflax/patterns';\nimport { createCssResolver } from '@domflax/resolver-css';\nimport { createTailwindResolver } from '@domflax/resolver-tailwind';\n\nimport * as path from 'node:path';\n\nimport { cssSetKey, extractHtmlStylesheets } from './html-css';\nimport type { CliOptions, ProviderOption } from './options';\n\n/* ───────────────────────── per-file result + stats ───────────────────────── */\n\nexport interface FileStats {\n  readonly nodesIn: number;\n  readonly nodesOut: number;\n  readonly nodesRemoved: number;\n  readonly classesBefore: number;\n  readonly classesAfter: number;\n  readonly classesSaved: number;\n  readonly bytesBefore: number;\n  readonly bytesAfter: number;\n  readonly bytesSaved: number;\n}\n\nexport interface FileResult {\n  readonly code: string;\n  readonly changed: boolean;\n  readonly passthrough: boolean;\n  readonly stats: FileStats;\n}\n\n/** A configured transform — holds the resolver (and its cached engine) across files. */\nexport interface Transform {\n  readonly resolver: StyleResolver;\n  /**\n   * SYNC transform — fully static (gate `'provably-safe'`); never changes rendering and never launches\n   * a browser. Only provably layout-neutral flattens are applied.\n   */\n  transformFile(code: string, id: string): FileResult;\n}\n\n/* ───────────────────────── resolver wiring ───────────────────────── */\n\n/**\n * Build the {@link StyleResolver} for the chosen provider. The heavy engine each wraps (Tailwind v3 /\n * postcss) is loaded LAZILY at construction and resolved from the user's PROJECT via the factories'\n * `projectRoot` option — never from where the CLI bundle happens to live.\n */\nexport function buildResolver(provider: ProviderOption, css: readonly string[], projectRoot: string): StyleResolver {\n  if (provider === 'custom') {\n    return createCssResolver([], { files: css, projectRoot });\n  }\n  // 'auto' and 'tailwind' both resolve against the project's Tailwind engine.\n  return createTailwindResolver({ projectRoot });\n}\n\n/* ───────────────────────── pass assembly ───────────────────────── */\n\n/** Group the flat pattern list into one {@link Pass} per {@link PassPhase} (derived from category). */\nfunction buildPasses(patterns: readonly Pattern[]): Pass[] {\n  const byPhase = new Map<PassPhase, Pattern[]>();\n  for (const p of patterns) {\n    const phase = (p.category.split('/', 1)[0] ?? 'flatten') as PassPhase;\n    let bucket = byPhase.get(phase);\n    if (!bucket) {\n      bucket = [];\n      byPhase.set(phase, bucket);\n    }\n    bucket.push(p);\n  }\n  const passes: Pass[] = [];\n  for (const [phase, pats] of byPhase) {\n    passes.push({ phase, category: `${phase}/builtin` as PassCategory, patterns: pats });\n  }\n  return passes;\n}\n\n/** Select the active patterns: every built-in unless the caller narrowed by name (the wizard does). */\nfunction selectPatterns(names: readonly string[] | null): readonly Pattern[] {\n  if (names === null) return builtinPatterns;\n  const set = new Set(names);\n  return builtinPatterns.filter((p) => set.has(p.name));\n}\n\n/* ───────────────────────── file kind + token counting ───────────────────────── */\n\n/** `.tsx`/`.jsx` ⇒ the matching {@link FileKind}; anything else ⇒ null (no JSX frontend). */\nfunction jsxKindOf(id: string): FileKind | null {\n  const clean = id.split('?', 1)[0] ?? id;\n  const lower = clean.toLowerCase();\n  if (lower.endsWith('.tsx')) return 'tsx';\n  if (lower.endsWith('.jsx')) return 'jsx';\n  return null;\n}\n\n/** `.html`/`.htm` ⇒ `'html'`; anything else ⇒ null (no HTML frontend). */\nfunction htmlKindOf(id: string): FileKind | null {\n  const lower = (id.split('?', 1)[0] ?? id).toLowerCase();\n  if (lower.endsWith('.html') || lower.endsWith('.htm')) return 'html';\n  return null;\n}\n\n/** Rough class-token count for the `--report` summary (provider-independent, string-level). */\nfunction countClassTokens(code: string): number {\n  let total = 0;\n  const re = /\\b(?:className|class)\\s*=\\s*\"([^\"]*)\"/g;\n  let m: RegExpExecArray | null;\n  while ((m = re.exec(code)) !== null) {\n    total += m[1]!.split(/\\s+/).filter((t) => t.length > 0).length;\n  }\n  return total;\n}\n\nfunction bytes(s: string): number {\n  return Buffer.byteLength(s, 'utf8');\n}\n\nfunction passthroughResult(code: string): FileResult {\n  return {\n    code,\n    changed: false,\n    passthrough: true,\n    stats: {\n      nodesIn: 0,\n      nodesOut: 0,\n      nodesRemoved: 0,\n      classesBefore: 0,\n      classesAfter: 0,\n      classesSaved: 0,\n      bytesBefore: bytes(code),\n      bytesAfter: bytes(code),\n      bytesSaved: 0,\n    },\n  };\n}\n\n/* ───────────────────────── the transform ───────────────────────── */\n\n/**\n * Construct a transform for the given options. The resolver (and its engine) is built once and reused\n * across every file. With `provider: 'tailwind'|'auto'`, if Tailwind cannot be resolved from the\n * project the resolver degrades to resolving nothing — transforms then pass through unchanged.\n */\n/** Parsed + authorized doc and the apply context, shared by the sync + async transform paths. */\ninterface PreparedFile {\n  readonly doc: IRDocument;\n  readonly ctx: ApplyContext;\n  readonly passes: readonly Pass[];\n  readonly nodesIn: number;\n}\n\nexport function createTransform(options: CliOptions): Transform {\n  const projectRoot = options.projectRoot ?? process.cwd();\n  const globalResolver = buildResolver(options.provider, options.css, projectRoot);\n  const patterns = selectPatterns(options.passes);\n\n  // FEATURE A — per-file resolver cache, keyed by the exact CSS set (sorted paths + inline hash), so\n  // pages that share stylesheet imports reuse one resolver (and its parsed engine).\n  const resolverCache = new Map<string, StyleResolver>();\n\n  /**\n   * Choose the resolver for one file. `.jsx`/`.tsx` and every non-custom provider use the single\n   * GLOBAL resolver. An `.html`/`.htm` file under the CUSTOM provider resolves against the GLOBAL set\n   * (`options.css`, applied to every file) PLUS its own `<link>` imports and inline `<style>` blocks.\n   */\n  function resolverFor(code: string, id: string): StyleResolver {\n    if (options.provider !== 'custom' || htmlKindOf(id) === null) return globalResolver;\n    const { files: localFiles, inline } = extractHtmlStylesheets(code, id);\n    if (localFiles.length === 0 && inline.length === 0) return globalResolver;\n\n    // Canonicalize: global stylesheets first (base cascade), then the file's own imports. The cache\n    // key — and the resolver's own file order — are the sorted, resolved paths, so identical import\n    // sets always hit the same cache entry regardless of source ordering.\n    const globalPaths = options.css.map((p) => path.resolve(p));\n    const sortedPaths = [...new Set([...globalPaths, ...localFiles])].sort();\n    const key = cssSetKey(sortedPaths, inline);\n\n    let resolver = resolverCache.get(key);\n    if (!resolver) {\n      const inlineFiles = inline.map((css, i) => ({ id: `${id}#inline-${i}`, css }));\n      resolver = createCssResolver(inlineFiles, { files: sortedPaths, projectRoot });\n      resolverCache.set(key, resolver);\n    }\n    return resolver;\n  }\n\n  /** PARSE (JSX → IR, classes onto `computed`) + AUTHORIZE + build the apply context for `gate`. */\n  function prepare(\n    code: string,\n    id: string,\n    kind: FileKind,\n    gate: FlattenGate,\n    resolver: StyleResolver,\n  ): PreparedFile {\n    const parsed = createJsxFrontend().parse(code, {\n      id,\n      kind,\n      resolver,\n      normalizer,\n      config: {},\n      onDiagnostic: () => {},\n    });\n    const doc = parsed.doc;\n    const nodesIn = doc.nodes.size;\n    for (const node of doc.nodes.values()) node.meta.safetyFloor = 3;\n    const ctx: ApplyContext = {\n      doc,\n      safetyCeiling: options.safety as SafetyLevel,\n      normalizer,\n      // Real CSS-selector-safety index from the active resolver (custom-CSS reports combinator /\n      // structural-pseudo coupling; Tailwind has none → null index, behaviour unchanged).\n      selectors: buildSelectorIndex(doc, resolver),\n      resolver,\n      gate,\n    };\n    return { doc, ctx, passes: buildPasses(patterns), nodesIn };\n  }\n\n  /**\n   * PARSE (HTML → IR, classes onto `computed`) for `.html`/`.htm`. The HTML frontend sets per-node\n   * safety floors itself (opaque nodes → 0), so — unlike the JSX prepare — we must NOT blanket-open\n   * every node to floor 3.\n   */\n  function prepareHtml(code: string, id: string, gate: FlattenGate, resolver: StyleResolver): PreparedFile {\n    const parsed = createHtmlFrontend().parse(code, {\n      id,\n      kind: 'html',\n      resolver,\n      normalizer,\n      config: {},\n      onDiagnostic: () => {},\n    });\n    const doc = parsed.doc;\n    const nodesIn = doc.nodes.size;\n    const ctx: ApplyContext = {\n      doc,\n      safetyCeiling: options.safety as SafetyLevel,\n      normalizer,\n      selectors: buildSelectorIndex(doc, resolver),\n      resolver,\n      gate,\n    };\n    return { doc, ctx, passes: buildPasses(patterns), nodesIn };\n  }\n\n  /** REVERSE-EMIT + PRINT the optimized doc, then assemble the per-file result + stats. */\n  function finish(\n    code: string,\n    optimized: IRDocument,\n    id: string,\n    nodesIn: number,\n    resolver: StyleResolver,\n    backend: 'jsx' | 'html' = 'jsx',\n  ): FileResult {\n    syncClassesFromComputed(optimized, resolver, normalizer);\n    const print = backend === 'html' ? createHtmlBackend().print : createJsxBackend().print;\n    const printed = print(\n      optimized,\n      { moduleId: id, ops: [], provenance: new Map() },\n      { normalizer, resolver, sink: createSyntheticSink(), eol: '\\n', onDiagnostic: () => {} },\n    );\n    const out = printed.code;\n    const nodesOut = optimized.nodes.size;\n    const classesBefore = countClassTokens(code);\n    const classesAfter = countClassTokens(out);\n    return {\n      code: out,\n      changed: out !== code,\n      passthrough: false,\n      stats: {\n        nodesIn,\n        nodesOut,\n        nodesRemoved: Math.max(0, nodesIn - nodesOut),\n        classesBefore,\n        classesAfter,\n        classesSaved: Math.max(0, classesBefore - classesAfter),\n        bytesBefore: bytes(code),\n        bytesAfter: bytes(out),\n        bytesSaved: bytes(code) - bytes(out),\n      },\n    };\n  }\n\n  return {\n    resolver: globalResolver,\n    transformFile(code: string, id: string): FileResult {\n      const kind = jsxKindOf(id);\n      if (kind !== null) {\n        const resolver = resolverFor(code, id);\n        const { doc, ctx, passes, nodesIn } = prepare(code, id, kind, 'provably-safe', resolver);\n        const { doc: optimized } = runPasses(doc, passes, ctx);\n        return finish(code, optimized, id, nodesIn, resolver);\n      }\n      if (htmlKindOf(id) !== null) {\n        const resolver = resolverFor(code, id);\n        const { doc, ctx, passes, nodesIn } = prepareHtml(code, id, 'provably-safe', resolver);\n        const { doc: optimized } = runPasses(doc, passes, ctx);\n        return finish(code, optimized, id, nodesIn, resolver, 'html');\n      }\n      return passthroughResult(code);\n    },\n  };\n}\n\n/** The names of every built-in pattern, for the wizard's multiselect. */\nexport function builtinPatternNames(): readonly string[] {\n  return builtinPatterns.map((p) => p.name);\n}\n","/**\n * @domflax/cli — per-file CSS discovery for HTML inputs (FEATURE A).\n *\n * Each HTML page links its OWN stylesheets, so resolving every file against one hand-picked global\n * `--css` set is wrong for HTML. {@link extractHtmlStylesheets} lifts a file's own local stylesheets\n * (`<link rel=\"stylesheet\" href>`, resolved RELATIVE to the html file's directory) plus its inline\n * `<style>` blocks straight out of the markup. Remote (`http:`/`https:`/`data:`/protocol-relative)\n * and missing hrefs are skipped, so only real, on-disk stylesheets feed the resolver.\n *\n * The scan is a lightweight, dependency-free `<link>`/`<style>` sweep (no parse5): it runs per file and\n * inside every worker, so keeping it self-contained avoids pulling the HTML frontend into the hot path.\n * {@link cssSetKey} keys the transform's resolver cache so pages sharing imports reuse one resolver.\n */\n\nimport { createHash } from 'node:crypto';\nimport { existsSync } from 'node:fs';\nimport * as path from 'node:path';\n\n/** The stylesheets a single HTML file pulls in beyond the global set. */\nexport interface HtmlStylesheets {\n  /** Absolute paths of local `<link rel=\"stylesheet\">` targets that exist on disk. */\n  readonly files: readonly string[];\n  /** Verbatim contents of the file's inline `<style>` blocks (source order). */\n  readonly inline: readonly string[];\n}\n\n/** True for any href we must NOT treat as a local file: it has a URI scheme or is protocol-relative. */\nfunction isRemoteHref(href: string): boolean {\n  const h = href.trim();\n  // A leading scheme (`http:`, `https:`, `data:`, `file:`…) or `//host` protocol-relative form.\n  return h.startsWith('//') || /^[a-z][a-z0-9+.-]*:/i.test(h);\n}\n\n/**\n * Read one attribute's value out of a start-tag string. Handles double-, single-, and unquoted forms;\n * returns `null` when the attribute is absent (an empty value returns `''`).\n */\nfunction attrValue(tag: string, name: string): string | null {\n  const re = new RegExp(`\\\\b${name}\\\\s*=\\\\s*(?:\"([^\"]*)\"|'([^']*)'|([^\\\\s\"'>]+))`, 'i');\n  const m = re.exec(tag);\n  if (!m) return null;\n  return (m[1] ?? m[2] ?? m[3] ?? '').trim();\n}\n\n/** Collect the `href` of every `<link>` whose `rel` includes the `stylesheet` keyword. */\nfunction extractLinkHrefs(html: string): string[] {\n  const out: string[] = [];\n  const linkRe = /<link\\b[^>]*>/gi;\n  let m: RegExpExecArray | null;\n  while ((m = linkRe.exec(html)) !== null) {\n    const tag = m[0];\n    const rel = attrValue(tag, 'rel');\n    if (rel === null || !/(?:^|\\s)stylesheet(?:\\s|$)/i.test(rel)) continue;\n    const href = attrValue(tag, 'href');\n    if (href) out.push(href);\n  }\n  return out;\n}\n\n/** Collect the text of every inline `<style>` block (skipping any explicitly non-CSS `type`). */\nfunction extractInlineStyles(html: string): string[] {\n  const out: string[] = [];\n  const styleRe = /<style\\b([^>]*)>([\\s\\S]*?)<\\/style>/gi;\n  let m: RegExpExecArray | null;\n  while ((m = styleRe.exec(html)) !== null) {\n    const type = attrValue(`<style ${m[1] ?? ''}>`, 'type')?.toLowerCase();\n    // Only plain CSS counts — a typed island like text/scss or text/template is not a stylesheet.\n    if (type && type !== 'text/css' && type !== 'css') continue;\n    const css = m[2] ?? '';\n    if (css.trim().length > 0) out.push(css);\n  }\n  return out;\n}\n\n/**\n * Extract an HTML file's own local stylesheets + inline styles. `href`s are resolved RELATIVE to the\n * html file's directory; remote/protocol-relative/`data:` hrefs and files that don't exist on disk are\n * dropped. Query/hash suffixes (`style.css?v=2`) are stripped before resolution.\n */\nexport function extractHtmlStylesheets(htmlCode: string, htmlAbsPath: string): HtmlStylesheets {\n  const dir = path.dirname(path.resolve(htmlAbsPath));\n  const files: string[] = [];\n  const seen = new Set<string>();\n  for (const rawHref of extractLinkHrefs(htmlCode)) {\n    const href = (rawHref.split(/[?#]/, 1)[0] ?? '').trim();\n    if (!href || isRemoteHref(href)) continue;\n    const abs = path.resolve(dir, href);\n    if (seen.has(abs)) continue;\n    seen.add(abs);\n    if (existsSync(abs)) files.push(abs);\n  }\n  return { files, inline: extractInlineStyles(htmlCode) };\n}\n\n/**\n * A stable cache key for a CSS set: the sorted, resolved stylesheet paths plus a hash of the inline\n * blocks. Two HTML files that pull in the same imports (and inline the same styles) produce the same\n * key, so the transform reuses one resolver for both — hundreds of pages stay fast.\n */\nexport function cssSetKey(sortedResolvedPaths: readonly string[], inline: readonly string[]): string {\n  const h = createHash('sha1');\n  h.update(sortedResolvedPaths.join('\\n'));\n  h.update('\u0000inline\u0000');\n  for (const block of inline) {\n    h.update(block);\n    h.update('\u0000');\n  }\n  return h.digest('hex');\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;AASA,SAAS,oBAAoB;AAC7B,YAAY,UAAU;AAKtB,IAAM,kBAAuC,oBAAI,IAAI,CAAC,QAAQ,SAAS,OAAO,OAAO,CAAC;AAG/E,SAAS,iBAAiB,MAAuB;AACtD,SACG,aAAQ,IAAI,EACZ,MAAW,QAAG,EACd,KAAK,CAAC,QAAQ,gBAAgB,IAAI,GAAG,CAAC;AAC3C;AAcO,SAAS,WAAW,KAAsB;AAC/C,MAAI;AACF,UAAM,MAAM,aAAa,OAAO,CAAC,UAAU,aAAa,GAAG;AAAA,MACzD;AAAA,MACA,UAAU;AAAA,MACV,OAAO,CAAC,UAAU,QAAQ,QAAQ;AAAA,IACpC,CAAC;AACD,WAAO,IAAI,KAAK,EAAE,WAAW;AAAA,EAC/B,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAMO,SAAS,WAAW,SAAqB,UAAsC;AACpF,MAAI,QAAQ,4BAA4B;AACtC,QAAI,CAAC,QAAQ,cAAc,CAAC,UAAU;AACpC,aAAO;AAAA,QACL,IAAI;AAAA,QACJ,OACE;AAAA,MAEJ;AAAA,IACF;AACA,WAAO,EAAE,IAAI,MAAM,OAAO,EAAE,MAAM,oBAAoB,QAAQ,KAAK,EAAE;AAAA,EACvE;AACA,QAAM,SAAc,aAAQ,QAAQ,OAAO,aAAa;AACxD,SAAO,EAAE,IAAI,MAAM,OAAO,EAAE,MAAM,WAAW,OAAO,EAAE;AACxD;AAOO,SAAS,eAAe,MAAc,WAAmB,MAAiC;AAC/F,QAAM,UAAe,aAAQ,IAAI;AAEjC,MAAI,KAAK,SAAS,oBAAoB;AAEpC,WAAO,EAAE,IAAI,MAAM,OAAO,QAAQ;AAAA,EACpC;AAEA,QAAM,SAAS,KAAK;AACpB,QAAM,MAAW,cAAS,WAAW,OAAO;AAE5C,QAAM,UAAU,QAAQ,MAAM,IAAI,WAAW,IAAI,KAAU,gBAAW,GAAG,IAAS,cAAS,OAAO,IAAI;AACtG,QAAM,OAAY,UAAK,QAAQ,OAAO;AAEtC,MAAS,aAAQ,IAAI,MAAM,WAAW,CAAC,iBAAiB,OAAO,GAAG;AAChE,WAAO;AAAA,MACL,IAAI;AAAA,MACJ,OACE,qCAAqC,OAAO;AAAA,IAEhD;AAAA,EACF;AACA,SAAO,EAAE,IAAI,MAAM,OAAO,KAAK;AACjC;;;AClGA;AAsCA,YAAYA,WAAU;;;ACtCtB;AAcA,SAAS,kBAAkB;AAC3B,SAAS,kBAAkB;AAC3B,YAAYC,WAAU;AAWtB,SAAS,aAAa,MAAuB;AAC3C,QAAM,IAAI,KAAK,KAAK;AAEpB,SAAO,EAAE,WAAW,IAAI,KAAK,uBAAuB,KAAK,CAAC;AAC5D;AAMA,SAAS,UAAU,KAAa,MAA6B;AAC3D,QAAM,KAAK,IAAI,OAAO,MAAM,IAAI,iDAAiD,GAAG;AACpF,QAAM,IAAI,GAAG,KAAK,GAAG;AACrB,MAAI,CAAC,EAAG,QAAO;AACf,UAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,KAAK;AAC3C;AAGA,SAAS,iBAAiB,MAAwB;AAChD,QAAM,MAAgB,CAAC;AACvB,QAAM,SAAS;AACf,MAAI;AACJ,UAAQ,IAAI,OAAO,KAAK,IAAI,OAAO,MAAM;AACvC,UAAM,MAAM,EAAE,CAAC;AACf,UAAM,MAAM,UAAU,KAAK,KAAK;AAChC,QAAI,QAAQ,QAAQ,CAAC,8BAA8B,KAAK,GAAG,EAAG;AAC9D,UAAM,OAAO,UAAU,KAAK,MAAM;AAClC,QAAI,KAAM,KAAI,KAAK,IAAI;AAAA,EACzB;AACA,SAAO;AACT;AAGA,SAAS,oBAAoB,MAAwB;AACnD,QAAM,MAAgB,CAAC;AACvB,QAAM,UAAU;AAChB,MAAI;AACJ,UAAQ,IAAI,QAAQ,KAAK,IAAI,OAAO,MAAM;AACxC,UAAM,OAAO,UAAU,UAAU,EAAE,CAAC,KAAK,EAAE,KAAK,MAAM,GAAG,YAAY;AAErE,QAAI,QAAQ,SAAS,cAAc,SAAS,MAAO;AACnD,UAAM,MAAM,EAAE,CAAC,KAAK;AACpB,QAAI,IAAI,KAAK,EAAE,SAAS,EAAG,KAAI,KAAK,GAAG;AAAA,EACzC;AACA,SAAO;AACT;AAOO,SAAS,uBAAuB,UAAkB,aAAsC;AAC7F,QAAM,MAAW,cAAa,cAAQ,WAAW,CAAC;AAClD,QAAM,QAAkB,CAAC;AACzB,QAAM,OAAO,oBAAI,IAAY;AAC7B,aAAW,WAAW,iBAAiB,QAAQ,GAAG;AAChD,UAAM,QAAQ,QAAQ,MAAM,QAAQ,CAAC,EAAE,CAAC,KAAK,IAAI,KAAK;AACtD,QAAI,CAAC,QAAQ,aAAa,IAAI,EAAG;AACjC,UAAM,MAAW,cAAQ,KAAK,IAAI;AAClC,QAAI,KAAK,IAAI,GAAG,EAAG;AACnB,SAAK,IAAI,GAAG;AACZ,QAAI,WAAW,GAAG,EAAG,OAAM,KAAK,GAAG;AAAA,EACrC;AACA,SAAO,EAAE,OAAO,QAAQ,oBAAoB,QAAQ,EAAE;AACxD;AAOO,SAAS,UAAU,qBAAwC,QAAmC;AACnG,QAAM,IAAI,WAAW,MAAM;AAC3B,IAAE,OAAO,oBAAoB,KAAK,IAAI,CAAC;AACvC,IAAE,OAAO,YAAU;AACnB,aAAW,SAAS,QAAQ;AAC1B,MAAE,OAAO,KAAK;AACd,MAAE,OAAO,IAAG;AAAA,EACd;AACA,SAAO,EAAE,OAAO,KAAK;AACvB;;;AD3BO,SAAS,cAAc,UAA0B,KAAwB,aAAoC;AAClH,MAAI,aAAa,UAAU;AACzB,WAAO,kBAAkB,CAAC,GAAG,EAAE,OAAO,KAAK,YAAY,CAAC;AAAA,EAC1D;AAEA,SAAO,uBAAuB,EAAE,YAAY,CAAC;AAC/C;AAKA,SAAS,YAAY,UAAsC;AACzD,QAAM,UAAU,oBAAI,IAA0B;AAC9C,aAAW,KAAK,UAAU;AACxB,UAAM,QAAS,EAAE,SAAS,MAAM,KAAK,CAAC,EAAE,CAAC,KAAK;AAC9C,QAAI,SAAS,QAAQ,IAAI,KAAK;AAC9B,QAAI,CAAC,QAAQ;AACX,eAAS,CAAC;AACV,cAAQ,IAAI,OAAO,MAAM;AAAA,IAC3B;AACA,WAAO,KAAK,CAAC;AAAA,EACf;AACA,QAAM,SAAiB,CAAC;AACxB,aAAW,CAAC,OAAO,IAAI,KAAK,SAAS;AACnC,WAAO,KAAK,EAAE,OAAO,UAAU,GAAG,KAAK,YAA4B,UAAU,KAAK,CAAC;AAAA,EACrF;AACA,SAAO;AACT;AAGA,SAAS,eAAe,OAAqD;AAC3E,MAAI,UAAU,KAAM,QAAO;AAC3B,QAAM,MAAM,IAAI,IAAI,KAAK;AACzB,SAAO,gBAAgB,OAAO,CAAC,MAAM,IAAI,IAAI,EAAE,IAAI,CAAC;AACtD;AAKA,SAAS,UAAU,IAA6B;AAC9C,QAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,EAAE,CAAC,KAAK;AACrC,QAAM,QAAQ,MAAM,YAAY;AAChC,MAAI,MAAM,SAAS,MAAM,EAAG,QAAO;AACnC,MAAI,MAAM,SAAS,MAAM,EAAG,QAAO;AACnC,SAAO;AACT;AAGA,SAAS,WAAW,IAA6B;AAC/C,QAAM,SAAS,GAAG,MAAM,KAAK,CAAC,EAAE,CAAC,KAAK,IAAI,YAAY;AACtD,MAAI,MAAM,SAAS,OAAO,KAAK,MAAM,SAAS,MAAM,EAAG,QAAO;AAC9D,SAAO;AACT;AAGA,SAAS,iBAAiB,MAAsB;AAC9C,MAAI,QAAQ;AACZ,QAAM,KAAK;AACX,MAAI;AACJ,UAAQ,IAAI,GAAG,KAAK,IAAI,OAAO,MAAM;AACnC,aAAS,EAAE,CAAC,EAAG,MAAM,KAAK,EAAE,OAAO,CAAC,MAAM,EAAE,SAAS,CAAC,EAAE;AAAA,EAC1D;AACA,SAAO;AACT;AAEA,SAAS,MAAM,GAAmB;AAChC,SAAO,OAAO,WAAW,GAAG,MAAM;AACpC;AAEA,SAAS,kBAAkB,MAA0B;AACnD,SAAO;AAAA,IACL;AAAA,IACA,SAAS;AAAA,IACT,aAAa;AAAA,IACb,OAAO;AAAA,MACL,SAAS;AAAA,MACT,UAAU;AAAA,MACV,cAAc;AAAA,MACd,eAAe;AAAA,MACf,cAAc;AAAA,MACd,cAAc;AAAA,MACd,aAAa,MAAM,IAAI;AAAA,MACvB,YAAY,MAAM,IAAI;AAAA,MACtB,YAAY;AAAA,IACd;AAAA,EACF;AACF;AAiBO,SAAS,gBAAgB,SAAgC;AAC9D,QAAM,cAAc,QAAQ,eAAe,QAAQ,IAAI;AACvD,QAAM,iBAAiB,cAAc,QAAQ,UAAU,QAAQ,KAAK,WAAW;AAC/E,QAAM,WAAW,eAAe,QAAQ,MAAM;AAI9C,QAAM,gBAAgB,oBAAI,IAA2B;AAOrD,WAAS,YAAY,MAAc,IAA2B;AAC5D,QAAI,QAAQ,aAAa,YAAY,WAAW,EAAE,MAAM,KAAM,QAAO;AACrE,UAAM,EAAE,OAAO,YAAY,OAAO,IAAI,uBAAuB,MAAM,EAAE;AACrE,QAAI,WAAW,WAAW,KAAK,OAAO,WAAW,EAAG,QAAO;AAK3D,UAAM,cAAc,QAAQ,IAAI,IAAI,CAAC,MAAW,cAAQ,CAAC,CAAC;AAC1D,UAAM,cAAc,CAAC,GAAG,oBAAI,IAAI,CAAC,GAAG,aAAa,GAAG,UAAU,CAAC,CAAC,EAAE,KAAK;AACvE,UAAM,MAAM,UAAU,aAAa,MAAM;AAEzC,QAAI,WAAW,cAAc,IAAI,GAAG;AACpC,QAAI,CAAC,UAAU;AACb,YAAM,cAAc,OAAO,IAAI,CAAC,KAAK,OAAO,EAAE,IAAI,GAAG,EAAE,WAAW,CAAC,IAAI,IAAI,EAAE;AAC7E,iBAAW,kBAAkB,aAAa,EAAE,OAAO,aAAa,YAAY,CAAC;AAC7E,oBAAc,IAAI,KAAK,QAAQ;AAAA,IACjC;AACA,WAAO;AAAA,EACT;AAGA,WAAS,QACP,MACA,IACA,MACA,MACA,UACc;AACd,UAAM,SAAS,kBAAkB,EAAE,MAAM,MAAM;AAAA,MAC7C;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,QAAQ,CAAC;AAAA,MACT,cAAc,MAAM;AAAA,MAAC;AAAA,IACvB,CAAC;AACD,UAAM,MAAM,OAAO;AACnB,UAAM,UAAU,IAAI,MAAM;AAC1B,eAAW,QAAQ,IAAI,MAAM,OAAO,EAAG,MAAK,KAAK,cAAc;AAC/D,UAAM,MAAoB;AAAA,MACxB;AAAA,MACA,eAAe,QAAQ;AAAA,MACvB;AAAA;AAAA;AAAA,MAGA,WAAW,mBAAmB,KAAK,QAAQ;AAAA,MAC3C;AAAA,MACA;AAAA,IACF;AACA,WAAO,EAAE,KAAK,KAAK,QAAQ,YAAY,QAAQ,GAAG,QAAQ;AAAA,EAC5D;AAOA,WAAS,YAAY,MAAc,IAAY,MAAmB,UAAuC;AACvG,UAAM,SAAS,mBAAmB,EAAE,MAAM,MAAM;AAAA,MAC9C;AAAA,MACA,MAAM;AAAA,MACN;AAAA,MACA;AAAA,MACA,QAAQ,CAAC;AAAA,MACT,cAAc,MAAM;AAAA,MAAC;AAAA,IACvB,CAAC;AACD,UAAM,MAAM,OAAO;AACnB,UAAM,UAAU,IAAI,MAAM;AAC1B,UAAM,MAAoB;AAAA,MACxB;AAAA,MACA,eAAe,QAAQ;AAAA,MACvB;AAAA,MACA,WAAW,mBAAmB,KAAK,QAAQ;AAAA,MAC3C;AAAA,MACA;AAAA,IACF;AACA,WAAO,EAAE,KAAK,KAAK,QAAQ,YAAY,QAAQ,GAAG,QAAQ;AAAA,EAC5D;AAGA,WAAS,OACP,MACA,WACA,IACA,SACA,UACA,UAA0B,OACd;AACZ,4BAAwB,WAAW,UAAU,UAAU;AACvD,UAAM,QAAQ,YAAY,SAAS,kBAAkB,EAAE,QAAQ,iBAAiB,EAAE;AAClF,UAAM,UAAU;AAAA,MACd;AAAA,MACA,EAAE,UAAU,IAAI,KAAK,CAAC,GAAG,YAAY,oBAAI,IAAI,EAAE;AAAA,MAC/C,EAAE,YAAY,UAAU,MAAM,oBAAoB,GAAG,KAAK,MAAM,cAAc,MAAM;AAAA,MAAC,EAAE;AAAA,IACzF;AACA,UAAM,MAAM,QAAQ;AACpB,UAAM,WAAW,UAAU,MAAM;AACjC,UAAM,gBAAgB,iBAAiB,IAAI;AAC3C,UAAM,eAAe,iBAAiB,GAAG;AACzC,WAAO;AAAA,MACL,MAAM;AAAA,MACN,SAAS,QAAQ;AAAA,MACjB,aAAa;AAAA,MACb,OAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA,cAAc,KAAK,IAAI,GAAG,UAAU,QAAQ;AAAA,QAC5C;AAAA,QACA;AAAA,QACA,cAAc,KAAK,IAAI,GAAG,gBAAgB,YAAY;AAAA,QACtD,aAAa,MAAM,IAAI;AAAA,QACvB,YAAY,MAAM,GAAG;AAAA,QACrB,YAAY,MAAM,IAAI,IAAI,MAAM,GAAG;AAAA,MACrC;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AAAA,IACL,UAAU;AAAA,IACV,cAAc,MAAc,IAAwB;AAClD,YAAM,OAAO,UAAU,EAAE;AACzB,UAAI,SAAS,MAAM;AACjB,cAAM,WAAW,YAAY,MAAM,EAAE;AACrC,cAAM,EAAE,KAAK,KAAK,QAAQ,QAAQ,IAAI,QAAQ,MAAM,IAAI,MAAM,iBAAiB,QAAQ;AACvF,cAAM,EAAE,KAAK,UAAU,IAAI,UAAU,KAAK,QAAQ,GAAG;AACrD,eAAO,OAAO,MAAM,WAAW,IAAI,SAAS,QAAQ;AAAA,MACtD;AACA,UAAI,WAAW,EAAE,MAAM,MAAM;AAC3B,cAAM,WAAW,YAAY,MAAM,EAAE;AACrC,cAAM,EAAE,KAAK,KAAK,QAAQ,QAAQ,IAAI,YAAY,MAAM,IAAI,iBAAiB,QAAQ;AACrF,cAAM,EAAE,KAAK,UAAU,IAAI,UAAU,KAAK,QAAQ,GAAG;AACrD,eAAO,OAAO,MAAM,WAAW,IAAI,SAAS,UAAU,MAAM;AAAA,MAC9D;AACA,aAAO,kBAAkB,IAAI;AAAA,IAC/B;AAAA,EACF;AACF;","names":["path","path"]}