skilldrop-cli 0.16.36 → 0.16.37

package/packs/frontend/skills/bundle-size-review/scripts/bundle_stats.py

@@ -0,0 +1,1633 @@
+#!/usr/bin/env python3
+"""Size a JavaScript bundle from the bundler's stats file and say what pulls each module in. Stdlib only.
+
+Reads one of these, detected from its keys:
+  - webpack stats JSON (`webpack --json > stats.json`): assets, chunks (initial / entry),
+    modules with name, size, chunks and reasons, entrypoints. Multi-compiler output
+    (`children`) uses the first child.
+  - esbuild metafile (`--metafile=meta.json`): inputs with imports; outputs with bytes,
+    entryPoint, imports (import-statement / dynamic-import) and inputs[].bytesInOutput.
+  - rollup-plugin-visualizer raw data (`template: "raw-data"`, also what Vite uses):
+    tree, nodeParts (renderedLength, gzipLength, brotliLength) and nodeMetas
+    (id, moduleParts, imported, importedBy, isEntry).
+
+It prints, per entry, the initial JavaScript (what blocks first render) and the lazy chunks;
+the largest modules; packages by size; packages installed at more than one path, with what
+pulls each copy in; mechanical flags (whole-library CommonJS imports, locale bundles,
+polyfills, modules in several chunks); and, with --why, the import chain from an entry to a
+module or package. With --compare it diffs two stats files by entry, chunk, package and module.
+
+It also reads the project around the stats file (the first of the stats folder, its parent or
+grandparent that holds package.json, .browserslistrc or src/; or --root): package.json
+(dependency ranges, browserslist), .browserslistrc, the lockfile (installed versions and the
+range each dependent declares), bundler and TypeScript configs (target, existing budgets), and
+the source files on disk that import the bundled packages. It prints what it found and what is
+absent, and checks each bundled core-js polyfill against the browser targets.
+
+Every size is in bytes (kB = 1000 bytes), exactly as the stats give them. Compressed sizes are
+printed only when measured: "built-file" gzips the emitted files found under --dist (level 9);
+"visualizer" sums the plugin's per-module gzip/brotli lengths. Nothing is estimated.
+
+Usage:
+  python3 bundle_stats.py stats.json [--why lodash] [--budget main=170kB] [--dist dist/] [--root .]
+  python3 bundle_stats.py --compare before.json after.json [--budget main=200000] [--json]
+  cat stats.json | python3 bundle_stats.py - --json -o report.json
+
+A budget is ENTRY=SIZE on the entry's initial JavaScript in the stats' own size (bytes, or
+with a kB / KiB suffix), or ENTRY=gzip:SIZE when compressed sizes are measured.
+
+Exit codes: 0 report written; 1 a --budget was exceeded; 2 bad input.
+"""
+import argparse
+import gzip
+import json
+import os
+import re
+import sys
+from collections import defaultdict, deque
+
+KIB = 1024.0
+KB = 1000.0
+JS_EXT = (".js", ".mjs", ".cjs")
+CSS_EXT = (".css",)
+
+POLYFILL_PACKAGES = {
+    "core-js", "core-js-pure", "@babel/polyfill", "regenerator-runtime", "whatwg-fetch",
+    "promise-polyfill", "es6-promise", "intersection-observer", "resize-observer-polyfill",
+    "url-polyfill", "url-search-params-polyfill", "abortcontroller-polyfill",
+    "smoothscroll-polyfill", "formdata-polyfill", "element-closest", "custom-event-polyfill",
+    "@webcomponents/webcomponentsjs", "web-streams-polyfill", "unfetch", "isomorphic-fetch",
+}
+
+HASH_RE = re.compile(r"[.-]([A-Za-z0-9_-]{8,}|[0-9a-f]{6,})(?=\.(?:m?js|cjs|css)$)")
+PNPM_RE = re.compile(r"\.pnpm/(@[^/+]+\+[^/@]+|[^/@]+)@([0-9][^/_(]*)")
+YARN_RE = re.compile(r"([^/]+)-npm-([0-9][^/]*?)-[0-9a-f]{6,}-[0-9a-f]{6,}\.zip")
+CONCAT_RE = re.compile(r" \+ \d+ modules?$")
+
+
+class InputError(Exception):
+    pass
+
+
+# ---------------------------------------------------------------- helpers
+
+def kib(n):
+    """Exact bytes, one unit system throughout: 163,000 B."""
+    if n is None:
+        return "n/a"
+    return "{:,} B".format(int(round(n)))
+
+
+def bkb(n):
+    """Exact bytes with the kB (1000 bytes) figure: 163,000 B (163.0 kB)."""
+    if n is None:
+        return "not measured"
+    return "{:,} B ({:.1f} kB)".format(int(round(n)), n / KB)
+
+
+def clean_path(p):
+    if p is None:
+        return ""
+    p = str(p).replace("\\", "/")
+    p = p.lstrip("\0")
+    p = CONCAT_RE.sub("", p)
+    if "!" in p:
+        p = p.split("!")[-1]
+    p = p.split("?")[0]
+    while p.startswith("./"):
+        p = p[2:]
+    return p.lstrip("/")
+
+
+def strip_hash(name):
+    def repl(m):
+        h = m.group(1)
+        looks_hash = (any(c.isdigit() for c in h) or (h.lower() != h and h.upper() != h)
+                      or re.fullmatch(r"[0-9a-f]{6,}", h) is not None)
+        return "" if looks_hash else m.group(0)
+    return HASH_RE.sub(repl, name)
+
+
+def package_of(path):
+    """(name, install_path, version or None) for a node_modules path, else None."""
+    idx = path.rfind("node_modules/")
+    if idx < 0:
+        return None
+    rest = path[idx + len("node_modules/"):]
+    parts = rest.split("/")
+    if not parts or not parts[0] or parts[0].startswith("."):
+        return None
+    if parts[0].startswith("@") and len(parts) > 1:
+        name = parts[0] + "/" + parts[1]
+    else:
+        name = parts[0]
+    install = path[:idx] + "node_modules/" + name
+    prefix = path[:idx]
+    version = None
+    found = PNPM_RE.findall(prefix)
+    if found:
+        seg_name, seg_ver = found[-1]
+        if seg_name.replace("+", "/") == name:
+            version = seg_ver
+    if version is None:
+        found = YARN_RE.findall(prefix)
+        if found:
+            seg_name, seg_ver = found[-1]
+            if seg_name == name.replace("/", "-").lstrip("@") or seg_name == name.replace("/", "-"):
+                version = seg_ver
+    return name, install, version
+
+
+def owner_label(path):
+    pkg = package_of(path)
+    return pkg[0] if pkg else path
+
+
+def is_js(f):
+    return f.lower().endswith(JS_EXT)
+
+
+def is_css(f):
+    return f.lower().endswith(CSS_EXT)
+
+
+def stem(name):
+    base = os.path.basename(strip_hash(name))
+    return base.rsplit(".", 1)[0] if "." in base else base
+
+
+def new_bundle(fmt, tool):
+    return {"format": fmt, "tool": tool, "notes": [], "modules": {}, "edges": [],
+            "chunks": {}, "entries": {}, "entry_modules": set(), "cjs_paths": set(),
+            "raw_basis": "", "module_basis": ""}
+
+
+def add_module(b, key, size=0, chunk=None, source=None):
+    m = b["modules"].get(key)
+    if m is None:
+        m = {"path": key, "size": 0, "chunks": set(), "source": None, "cjs": False,
+             "chunk_sizes": defaultdict(int)}
+        b["modules"][key] = m
+    m["size"] += size
+    if chunk is not None:
+        m["chunks"].add(chunk)
+        m["chunk_sizes"][chunk] += size
+    if source is not None and m["source"] is None:
+        m["source"] = source
+    return m
+
+
+def new_chunk(b, key, name, files, initial, entry):
+    ch = {"key": key, "name": name, "files": list(files), "raw": 0, "css_raw": 0,
+          "initial": initial, "entry": entry, "loaded_from": [], "vis_gzip": None,
+          "vis_brotli": None, "raw_from_modules": False}
+    b["chunks"][key] = ch
+    return ch
+
+
+def unique_key(existing, key):
+    if key not in existing:
+        return key
+    i = 2
+    while "%s#%d" % (key, i) in existing:
+        i += 1
+    return "%s#%d" % (key, i)
+
+
+# ---------------------------------------------------------------- webpack
+
+def load_webpack(data):
+    if not data.get("modules") and not data.get("chunks") and isinstance(data.get("children"), list) and data["children"]:
+        child = data["children"][0]
+        b = load_webpack(child)
+        b["notes"].append("multi-compiler stats: only the first child (%s) is read"
+                          % (child.get("name") or "unnamed"))
+        return b
+    tool = "webpack %s" % data.get("version", "").strip() if data.get("version") else "webpack"
+    b = new_bundle("webpack", tool.strip())
+    assets = {}
+    for a in data.get("assets") or []:
+        if isinstance(a, dict) and a.get("name"):
+            assets[a["name"]] = a.get("size") or 0
+    id_to_key = {}
+    for c in data.get("chunks") or []:
+        names = c.get("names") or []
+        files = [f for f in (c.get("files") or []) if not f.endswith(".map") and ".hot-update." not in f]
+        if names:
+            key = names[0]
+        elif files:
+            key = strip_hash(files[0])
+        else:
+            key = "chunk %s" % c.get("id")
+        key = unique_key(b["chunks"], key)
+        id_to_key[c.get("id")] = key
+        ch = new_chunk(b, key, names[0] if names else key, files, bool(c.get("initial")), bool(c.get("entry")))
+        js_files = [f for f in files if is_js(f)]
+        if js_files and all(f in assets for f in js_files):
+            ch["raw"] = sum(assets[f] for f in js_files)
+        else:
+            ch["raw"] = c.get("size") or 0
+            ch["raw_from_modules"] = True
+        ch["css_raw"] = sum(assets.get(f, 0) for f in files if is_css(f))
+        for o in c.get("origins") or []:
+            mn = o.get("moduleName")
+            if mn and not ch["initial"]:
+                ch["loaded_from"].append(clean_path(mn))
+    raw_modules = list(data.get("modules") or [])
+    if not raw_modules:
+        for c in data.get("chunks") or []:
+            for m in c.get("modules") or []:
+                m = dict(m)
+                m.setdefault("chunks", [c.get("id")])
+                raw_modules.append(m)
+
+    def walk(m, inherited_chunks):
+        name = m.get("name") or m.get("identifier") or ""
+        mtype = m.get("moduleType") or ""
+        if mtype == "runtime" or name.startswith("webpack/runtime") or name.startswith("external "):
+            return
+        chunks = m.get("chunks")
+        if chunks is None:
+            chunks = inherited_chunks
+        nested = m.get("modules") or []
+        if nested:
+            for n in nested:
+                walk(n, chunks)
+            return
+        key = clean_path(name)
+        if not key:
+            return
+        size = m.get("size") or 0
+        ckeys = [id_to_key[c] for c in chunks if c in id_to_key] or [None]
+        for ck in ckeys:
+            add_module(b, key, size, ck, m.get("source") if isinstance(m.get("source"), str) else None)
+        mod = b["modules"][key]
+        mod["size"] = size  # a module in several chunks is one module; chunk_sizes holds the copies
+        bail = " ".join(m.get("optimizationBailout") or [])
+        if "not an ECMAScript module" in bail or mtype == "javascript/dynamic" or (
+                "providedExports" in m and m.get("providedExports") is None and mtype != "javascript/esm"
+                and key.endswith(JS_EXT)):
+            mod["cjs"] = True
+        for r in m.get("reasons") or []:
+            rtype = (r.get("type") or "").lower()
+            src = r.get("moduleName") or r.get("resolvedModule")
+            if "entry" in rtype or not src:
+                if "entry" in rtype:
+                    b["entry_modules"].add(key)
+                continue
+            kind = "dynamic" if "import()" in rtype or "dynamic" in rtype else "static"
+            if "cjs" in rtype or "require" in rtype:
+                kind = "static"
+            b["edges"].append((clean_path(src), key, kind, r.get("userRequest")))
+        if m.get("depth") == 0:
+            b["entry_modules"].add(key)
+
+    for m in raw_modules:
+        walk(m, [])
+
+    eps = data.get("entrypoints") or {}
+    if eps:
+        for name, ep in eps.items():
+            ckeys = [id_to_key[c] for c in (ep.get("chunks") or []) if c in id_to_key]
+            b["entries"][name] = {"chunks": ckeys}
+    else:
+        for ch in b["chunks"].values():
+            if ch["entry"]:
+                b["entries"][ch["name"]] = {"chunks": [ch["key"]]}
+    from_mods = [ch for ch in b["chunks"].values() if ch["raw_from_modules"]]
+    if from_mods and len(from_mods) == len(b["chunks"]):
+        b["raw_basis"] = "webpack chunk size = sum of module sizes, before minification (the stats have no assets)"
+    elif from_mods:
+        b["notes"].append("some chunks have no emitted-asset size in the stats; their size is the sum of module sizes before minification")
+        b["raw_basis"] = "emitted asset bytes (after minification) where the stats list the asset"
+    else:
+        b["raw_basis"] = "emitted asset bytes (after minification, before compression)"
+    b["module_basis"] = "webpack module size, before minification"
+    return b
+
+
+# ---------------------------------------------------------------- esbuild
+
+def load_esbuild(data):
+    b = new_bundle("esbuild", "esbuild metafile")
+    inputs = data.get("inputs") or {}
+    outputs = {k: v for k, v in (data.get("outputs") or {}).items() if not k.endswith(".map")}
+    dynamic_targets = set()
+    for ipath, inp in inputs.items():
+        src = clean_path(ipath)
+        if (inp.get("format") or "") == "cjs":
+            b["cjs_paths"].add(src)
+        for imp in inp.get("imports") or []:
+            if imp.get("external") or not imp.get("path"):
+                continue
+            kind = imp.get("kind") or ""
+            if kind in ("import-rule", "url-token", "composes-from"):
+                continue
+            k = "dynamic" if kind == "dynamic-import" else "static"
+            dst = clean_path(imp["path"])
+            if k == "dynamic":
+                dynamic_targets.add(dst)
+            b["edges"].append((src, dst, k, imp.get("original")))
+    out_key = {}
+    for oname, out in outputs.items():
+        if is_css(oname):
+            continue  # a CSS output is counted on the JS output that names it as cssBundle
+        ep = clean_path(out.get("entryPoint")) if out.get("entryPoint") else None
+        if ep:
+            key = ep
+        else:
+            biggest = max((out.get("inputs") or {}).items(), key=lambda kv: kv[1].get("bytesInOutput", 0), default=None)
+            key = "shared chunk: " + (owner_label(clean_path(biggest[0])) if biggest else strip_hash(oname))
+        key = unique_key(b["chunks"], key)
+        out_key[oname] = key
+        is_lazy = bool(ep) and ep in dynamic_targets
+        ch = new_chunk(b, key, os.path.basename(oname), [oname], False, bool(ep) and not is_lazy)
+        ch["raw"] = out.get("bytes") or 0
+        ch["dyn_entry"] = is_lazy
+        for ipath, info in (out.get("inputs") or {}).items():
+            add_module(b, clean_path(ipath), info.get("bytesInOutput") or 0, key)
+    for oname, out in outputs.items():
+        key = out_key.get(oname)
+        if key and out.get("cssBundle") and out["cssBundle"] in outputs:
+            b["chunks"][key]["css_raw"] = outputs[out["cssBundle"]].get("bytes") or 0
+    # initial closure per entry over static output imports
+    for oname, out in outputs.items():
+        key = out_key.get(oname)
+        if not key or not b["chunks"][key]["entry"] or is_css(oname):
+            continue
+        seen = [key]
+        stack = [oname]
+        while stack:
+            cur = stack.pop()
+            for imp in outputs.get(cur, {}).get("imports") or []:
+                if imp.get("external") or imp.get("kind") == "dynamic-import":
+                    continue
+                k2 = out_key.get(imp.get("path"))
+                if k2 and k2 not in seen:
+                    seen.append(k2)
+                    stack.append(imp["path"])
+        ep = clean_path(out["entryPoint"])
+        b["entries"][ep] = {"chunks": seen}
+        b["entry_modules"].add(ep)
+    initial = set(k for e in b["entries"].values() for k in e["chunks"])
+    for k, ch in b["chunks"].items():
+        ch["initial"] = k in initial
+    for src, dst, kind, _ in b["edges"]:
+        if kind == "dynamic":
+            for ch in b["chunks"].values():
+                if ch.get("dyn_entry") and ch["key"] == dst:
+                    ch["loaded_from"].append(src)
+    for p in b["cjs_paths"]:
+        if p in b["modules"]:
+            b["modules"][p]["cjs"] = True
+    b["raw_basis"] = "output file bytes (minified if --minify was on; before compression; .map files left out)"
+    b["module_basis"] = "esbuild bytesInOutput (bytes each input contributes to the output)"
+    return b
+
+
+# ---------------------------------------------------------------- rollup-plugin-visualizer
+
+def load_rollup(data):
+    if data.get("version") not in (None, 2, 3):
+        raise InputError("rollup-plugin-visualizer data version %r is not supported (expected 2)" % data.get("version"))
+    b = new_bundle("rollup-visualizer", "rollup-plugin-visualizer raw data")
+    env = data.get("env") or {}
+    if env.get("rollup"):
+        b["tool"] = "rollup %s (visualizer raw data)" % env["rollup"]
+    opts = data.get("options") or {}
+    parts = data.get("nodeParts") or {}
+    metas = data.get("nodeMetas") or {}
+    uid_to_key = {}
+    file_key = {}
+    files = []
+    for c in (data.get("tree") or {}).get("children") or []:
+        if c.get("name"):
+            files.append(c["name"])
+    for meta in metas.values():
+        for f in (meta.get("moduleParts") or {}):
+            if f not in files:
+                files.append(f)
+    for f in files:
+        key = unique_key(b["chunks"], strip_hash(f))
+        file_key[f] = key
+        new_chunk(b, key, f, [f], False, False)
+    gz_on = bool(opts.get("gzip"))
+    br_on = bool(opts.get("brotli"))
+    for uid, meta in metas.items():
+        raw_id = str(meta.get("id") or "")
+        key = clean_path(raw_id)
+        uid_to_key[uid] = key
+        if "?commonjs" in raw_id:
+            b["cjs_paths"].add(key)
+        if meta.get("isExternal"):
+            continue
+        if meta.get("isEntry"):
+            b["entry_modules"].add(key)
+        for f, puid in (meta.get("moduleParts") or {}).items():
+            part = parts.get(puid) or {}
+            ck = file_key.get(f)
+            mod = add_module(b, key, part.get("renderedLength") or 0, ck)
+            if gz_on:
+                mod["gzip"] = (mod.get("gzip") or 0) + (part.get("gzipLength") or 0)
+            ch = b["chunks"][ck]
+            ch["raw"] += part.get("renderedLength") or 0
+            if gz_on:
+                ch["vis_gzip"] = (ch["vis_gzip"] or 0) + (part.get("gzipLength") or 0)
+            if br_on:
+                ch["vis_brotli"] = (ch["vis_brotli"] or 0) + (part.get("brotliLength") or 0)
+    for uid, meta in metas.items():
+        src = uid_to_key[uid]
+        for imp in meta.get("imported") or []:
+            dst = uid_to_key.get(imp.get("uid"))
+            if dst is None or dst == src:
+                continue
+            if (metas.get(imp.get("uid")) or {}).get("isExternal"):
+                continue
+            b["edges"].append((src, dst, "dynamic" if imp.get("dynamic") else "static", None))
+    static_fwd = defaultdict(list)
+    for s, d, k, _ in b["edges"]:
+        if k == "static":
+            static_fwd[s].append(d)
+    dyn_targets = set(d for s, d, k, _ in b["edges"] if k == "dynamic")
+    for em in sorted(b["entry_modules"]):
+        if em in dyn_targets or em not in b["modules"]:
+            continue
+        seen = {em}
+        q = deque([em])
+        while q:
+            cur = q.popleft()
+            for d in static_fwd.get(cur, []):
+                if d not in seen:
+                    seen.add(d)
+                    q.append(d)
+        ckeys = []
+        for mk in seen:
+            for ck in (b["modules"].get(mk) or {}).get("chunks", ()):
+                if ck and ck not in ckeys:
+                    ckeys.append(ck)
+        own = sorted(b["modules"][em]["chunks"])
+        ckeys = own + sorted(c for c in ckeys if c not in own)
+        b["entries"][em] = {"chunks": ckeys}
+        for ck in own:
+            b["chunks"][ck]["entry"] = True
+    b["entry_modules"] -= dyn_targets
+    initial = set(k for e in b["entries"].values() for k in e["chunks"])
+    for k, ch in b["chunks"].items():
+        ch["initial"] = k in initial
+        if not ch["initial"]:
+            members = set(mk for mk, m in b["modules"].items() if k in m["chunks"])
+            for s, d, kind, _ in b["edges"]:
+                if kind == "dynamic" and d in members and s not in members and s not in ch["loaded_from"]:
+                    ch["loaded_from"].append(s)
+    for p in b["cjs_paths"]:
+        if p in b["modules"]:
+            b["modules"][p]["cjs"] = True
+    b["raw_basis"] = "rendered length (after tree-shaking; before minification unless the visualizer runs after the minifier)"
+    b["module_basis"] = "rendered length per module"
+    if not gz_on:
+        b["notes"].append("the visualizer was run without gzipSize, so no compressed sizes are available")
+    return b
+
+
+# ---------------------------------------------------------------- load
+
+def load(path):
+    try:
+        if path == "-":
+            text = sys.stdin.read()
+        else:
+            with open(path, "r", encoding="utf-8-sig") as fh:
+                text = fh.read()
+    except OSError as e:
+        raise InputError("cannot read %s: %s" % (path, e))
+    if not text.strip():
+        raise InputError("%s is empty" % path)
+    try:
+        data = json.loads(text)
+    except ValueError as e:
+        raise InputError("%s is not JSON (%s). webpack prints build logs before the JSON unless run with --json > stats.json" % (path, e))
+    if not isinstance(data, dict):
+        raise InputError("%s is JSON but not an object" % path)
+    if "lighthouseVersion" in data:
+        raise InputError("%s is a Lighthouse report, not bundler stats" % path)
+    if "nodeMetas" in data and "nodeParts" in data:
+        b = load_rollup(data)
+    elif isinstance(data.get("inputs"), dict) and isinstance(data.get("outputs"), dict):
+        b = load_esbuild(data)
+    elif any(k in data for k in ("modules", "chunks", "assets", "entrypoints")) or isinstance(data.get("children"), list):
+        b = load_webpack(data)
+    else:
+        raise InputError("%s is not a webpack stats file, an esbuild metafile or rollup-plugin-visualizer raw data" % path)
+    if not b["modules"] and not b["chunks"]:
+        raise InputError("%s has no modules or chunks to size" % path)
+    rev = defaultdict(list)
+    for s, d, k, r in b["edges"]:
+        if s != d:
+            rev[d].append((s, k, r))
+    b["rev"] = rev
+    for ch in b["chunks"].values():
+        if ch["initial"] or ch["loaded_from"]:
+            continue
+        members = set(mk for mk, m in b["modules"].items() if ch["key"] in m["chunks"])
+        for s, d, k, _ in b["edges"]:
+            if k == "dynamic" and d in members and s not in members and s not in ch["loaded_from"]:
+                ch["loaded_from"].append(s)
+    if not b["entry_modules"]:
+        b["entry_modules"] = set(mk for mk in b["modules"] if mk not in rev)
+        b["notes"].append("no entry modules are marked; chains start at modules nothing imports")
+    return b
+
+
+# ---------------------------------------------------------------- analysis
+
+def compress_chunk(b, ch, dist):
+    js_files = [f for f in ch["files"] if is_js(f)]
+    if dist and js_files:
+        total = 0
+        ok = True
+        for f in js_files:
+            cand = [os.path.join(dist, f), os.path.join(dist, os.path.basename(f))]
+            hit = next((c for c in cand if os.path.isfile(c)), None)
+            if not hit:
+                ok = False
+                break
+            with open(hit, "rb") as fh:
+                total += len(gzip.compress(fh.read(), compresslevel=9))
+        if ok:
+            return total, "built-file", None, None
+    if ch["vis_gzip"] is not None:
+        br = ch["vis_brotli"]
+        return ch["vis_gzip"], "visualizer", br, ("visualizer" if br is not None else None)
+    return None, None, None, None
+
+
+def sum_known(vals):
+    vals = list(vals)
+    return sum(vals) if vals and all(v is not None for v in vals) else None
+
+
+def basis_of(bases):
+    s = sorted(set(x for x in bases if x))
+    if not s or None in bases:
+        return None
+    return s[0] if len(s) == 1 else "mixed: " + ", ".join(s)
+
+
+def find_chain(b, target, allow_dynamic):
+    entries = b["entry_modules"]
+    if target in entries:
+        return [{"module": target}]
+    prev = {target: None}
+    q = deque([target])
+    while q:
+        cur = q.popleft()
+        for src, kind, req in b["rev"].get(cur, []):
+            if src in prev or (kind == "dynamic" and not allow_dynamic):
+                continue
+            prev[src] = (cur, kind, req)
+            if src in entries:
+                path = [{"module": src}]
+                node = src
+                while prev[node] is not None:
+                    nxt, k, r = prev[node]
+                    step = {"module": nxt, "via": k}
+                    if r:
+                        step["request"] = r
+                    path.append(step)
+                    node = nxt
+                return path
+            q.append(src)
+    return None
+
+
+def chain_for(b, target):
+    c = find_chain(b, target, False)
+    return c if c is not None else find_chain(b, target, True)
+
+
+def analyze(b, dist=None, top=10, why=None):
+    chunks = b["chunks"]
+    for ch in chunks.values():
+        ch["gzip"], ch["gzip_basis"], ch["brotli"], ch["brotli_basis"] = compress_chunk(b, ch, dist)
+    initial_keys = set(k for e in b["entries"].values() for k in e["chunks"])
+    mods = b["modules"]
+    for m in mods.values():
+        m["initial"] = any(c in initial_keys for c in m["chunks"])
+        m["pkg"] = package_of(m["path"])
+    res = {"format": b["format"], "tool": b["tool"], "raw_basis": b["raw_basis"],
+           "module_basis": b["module_basis"], "notes": list(b["notes"]), "entries": [],
+           "lazy_chunks": [], "largest_modules": [], "packages": [], "duplicates": [],
+           "in_several_chunks": [], "flags": []}
+    for name, e in b["entries"].items():
+        cl = [chunks[k] for k in e["chunks"] if k in chunks]
+        res["entries"].append({
+            "name": name,
+            "js_raw": sum(c["raw"] for c in cl),
+            "gzip": sum_known(c["gzip"] for c in cl),
+            "gzip_basis": basis_of([c["gzip_basis"] for c in cl]) if cl else None,
+            "brotli": sum_known(c["brotli"] for c in cl),
+            "brotli_basis": basis_of([c["brotli_basis"] for c in cl]) if cl else None,
+            "css_raw": sum(c["css_raw"] for c in cl),
+            "chunks": [{"key": c["key"], "files": c["files"], "raw": c["raw"], "gzip": c["gzip"],
+                        "gzip_basis": c["gzip_basis"]} for c in cl],
+        })
+    res["entries"].sort(key=lambda e: -e["js_raw"])
+
+    def chunk_contents(key, n=3):
+        agg = defaultdict(int)
+        for m in mods.values():
+            if key in m["chunks"]:
+                agg[owner_label(m["path"])] += m["chunk_sizes"].get(key, m["size"])
+        return [{"owner": o, "size": s} for o, s in sorted(agg.items(), key=lambda kv: -kv[1])[:n]]
+
+    for ch in sorted(chunks.values(), key=lambda c: -c["raw"]):
+        if ch["key"] in initial_keys:
+            continue
+        res["lazy_chunks"].append({"key": ch["key"], "files": ch["files"], "raw": ch["raw"], "gzip": ch["gzip"],
+                                   "gzip_basis": ch["gzip_basis"], "loaded_from": sorted(set(ch["loaded_from"])),
+                                   "mostly": chunk_contents(ch["key"])})
+    for m in sorted(mods.values(), key=lambda m: -m["size"])[:top]:
+        res["largest_modules"].append({"path": m["path"], "package": m["pkg"][0] if m["pkg"] else None,
+                                       "size": m["size"], "initial": m["initial"], "chunks": sorted(c for c in m["chunks"] if c)})
+    pkgs = {}
+    for m in mods.values():
+        if not m["pkg"]:
+            continue
+        name, install, version = m["pkg"]
+        p = pkgs.setdefault(name, {"name": name, "size": 0, "initial_size": 0, "lazy_size": 0, "modules": 0,
+                                   "installs": {}, "cjs": False, "gzip": 0, "gzip_known": True})
+        p["size"] += m["size"]
+        if m.get("gzip") is None:
+            p["gzip_known"] = False
+        else:
+            p["gzip"] += m["gzip"]
+        p["modules"] += 1
+        if m["initial"]:
+            p["initial_size"] += m["size"]
+        else:
+            p["lazy_size"] += m["size"]
+        p["cjs"] = p["cjs"] or m["cjs"]
+        inst = p["installs"].setdefault(install, {"install": install, "version": version, "size": 0,
+                                                  "initial_size": 0, "modules": []})
+        inst["size"] += m["size"]
+        if m["initial"]:
+            inst["initial_size"] += m["size"]
+        inst["modules"].append(m["path"])
+    plist = sorted(pkgs.values(), key=lambda p: -p["size"])
+    for p in plist:
+        res["packages"].append({"name": p["name"], "size": p["size"], "initial_size": p["initial_size"],
+                                "lazy_size": p["lazy_size"], "modules": p["modules"],
+                                "installs": len(p["installs"]), "commonjs": p["cjs"],
+                                "gzip": p["gzip"] if p["gzip_known"] else None})
+    # duplicates
+    for p in plist:
+        if len(p["installs"]) < 2:
+            continue
+        dup = {"package": p["name"], "installs": []}
+        for inst in sorted(p["installs"].values(), key=lambda i: -i["size"]):
+            members = set(inst["modules"])
+            pulled = []
+            for mk in inst["modules"]:
+                for src, kind, req in b["rev"].get(mk, []):
+                    if src in members:
+                        continue
+                    label = owner_label(src)
+                    item = "%s (%s)" % (label, req) if req else label
+                    if item not in pulled:
+                        pulled.append(item)
+            first = None
+            for mk in inst["modules"]:
+                c = chain_for(b, mk)
+                if c and (first is None or len(c) < len(first)):
+                    first = c
+            dup["installs"].append({"install": inst["install"], "version": inst["version"],
+                                    "size": inst["size"], "initial_size": inst["initial_size"],
+                                    "pulled_in_by": pulled, "chain": first})
+        res["duplicates"].append(dup)
+    # modules copied into several chunks
+    several = defaultdict(lambda: {"size": 0, "extra": 0, "chunks": set(), "modules": 0})
+    for m in mods.values():
+        real = [c for c in m["chunks"] if c]
+        if len(real) > 1:
+            s = several[owner_label(m["path"])]
+            s["size"] += m["size"]
+            s["extra"] += m["size"] * (len(real) - 1)
+            s["chunks"].update(real)
+            s["modules"] += 1
+    for owner, s in sorted(several.items(), key=lambda kv: -kv[1]["extra"]):
+        if s["extra"] >= 1024:
+            res["in_several_chunks"].append({"owner": owner, "size": s["size"], "extra_copies_size": s["extra"],
+                                             "chunks": sorted(s["chunks"]), "modules": s["modules"]})
+    # flags, per install path so two copies of one package are judged separately
+    for p in plist:
+        name = p["name"]
+        several_installs = len(p["installs"]) > 1
+        for inst in p["installs"].values():
+            members = set(inst["modules"])
+            label = inst["install"] if several_installs else name
+            size = inst["size"]
+            initial = inst["initial_size"] > 0
+            cjs = any(mods[mk]["cjs"] for mk in members)
+            prebuilt = all(".production.min." in mk or mk.endswith(".min.js") for mk in members)
+            bare = []
+            for mk in inst["modules"]:
+                for src, kind, req in b["rev"].get(mk, []):
+                    if src not in members and req == name:
+                        lbl = owner_label(src)
+                        if lbl not in bare:
+                            bare.append(lbl)
+            if bare and cjs and size >= 10 * KIB:
+                res["flags"].append({"kind": "whole-library-commonjs", "package": label, "size": size, "initial": initial,
+                                     "detail": "imported by its bare name \"%s\" from %s; this copy is CommonJS, so nothing in it is tree-shaken" % (name, ", ".join(bare))})
+            elif bare and len(members) >= 20:
+                res["flags"].append({"kind": "barrel-import", "package": label, "size": size, "initial": initial,
+                                     "detail": "%d modules included through the bare import \"%s\" from %s; check whether it is shaken" % (len(members), name, ", ".join(bare))})
+            elif cjs and inst["initial_size"] >= 10 * KIB and not prebuilt:
+                res["flags"].append({"kind": "commonjs-in-initial", "package": label, "size": inst["initial_size"], "initial": True,
+                                     "detail": "CommonJS, so it cannot be tree-shaken"})
+            locale = [mk for mk in inst["modules"] if re.search(r"/(locale|locales|i18n)/", mk) or "with-locales" in mk]
+            if len(locale) >= 5 or any("with-locales" in mk for mk in locale):
+                res["flags"].append({"kind": "locales", "package": label, "size": sum(mods[mk]["size"] for mk in locale),
+                                     "initial": any(mods[mk]["initial"] for mk in locale),
+                                     "detail": "%d locale module(s) included: %s" % (len(locale), ", ".join(sorted(locale)[:3]))})
+            if name in POLYFILL_PACKAGES or name.endswith("-polyfill"):
+                feats = [mk for mk in inst["modules"] if "/modules/" in mk] or list(inst["modules"])
+                sample = sorted(set(os.path.basename(mk).rsplit(".", 1)[0] for mk in feats))
+                res["flags"].append({"kind": "polyfill", "package": label, "size": size, "initial": initial,
+                                     "detail": "%d module(s) in total; features: %s%s" % (len(members), ", ".join(sample[:16]), ", ..." if len(sample) > 16 else "")})
+    if why:
+        res["why"] = [why_one(b, q) for q in why]
+    return res
+
+
+def why_one(b, query):
+    mods = b["modules"]
+    targets = []
+    pk_installs = defaultdict(list)
+    for mk, m in mods.items():
+        p = package_of(mk)
+        if p and p[0] == query:
+            pk_installs[p[1]].append(mk)
+    if pk_installs:
+        for install, members in sorted(pk_installs.items()):
+            best = None
+            for mk in members:
+                c = chain_for(b, mk)
+                if c and (best is None or len(c) < len(best[1])):
+                    best = (mk, c)
+            targets.append({"install": install, "module": best[0] if best else members[0],
+                            "chain": best[1] if best else None})
+    else:
+        hits = [mk for mk in mods if mk == query or mk.endswith("/" + query) or query in mk]
+        hits.sort(key=lambda mk: (mk != query, -mods[mk]["size"]))
+        for mk in hits[:3]:
+            targets.append({"module": mk, "chain": chain_for(b, mk)})
+    for t in targets:
+        t["importers"] = sorted(set("%s (%s)" % (s, r) if r else s for s, k, r in b["rev"].get(t["module"], [])))[:8]
+        t["initial"] = mods[t["module"]].get("initial", False)
+    return {"query": query, "matches": targets}
+
+
+# ---------------------------------------------------------------- budgets and compare
+
+SIZE_RE = re.compile(r"^\s*([0-9]+(?:\.[0-9]+)?)\s*(b|kb|kib|mb|mib)?\s*$", re.I)
+UNIT = {None: 1, "b": 1, "kb": 1000, "kib": 1024, "mb": 1000000, "mib": 1048576}
+
+
+def parse_budgets(items):
+    out = []
+    for it in items or []:
+        if "=" not in it:
+            raise InputError("--budget takes ENTRY=SIZE, e.g. main=170000, main=170kB or main=gzip:60kB; got %r" % it)
+        k, v = it.split("=", 1)
+        kind = "raw"
+        if v.lower().startswith("gzip:"):
+            kind, v = "gzip", v[5:]
+        m = SIZE_RE.match(v)
+        if not m:
+            raise InputError("--budget size must be bytes or a number with kB / KiB: %r" % it)
+        out.append((k.strip(), kind, float(m.group(1)) * UNIT[(m.group(2) or "").lower() or None]))
+    return out
+
+
+def check_budgets(res, budgets):
+    rows = []
+    for key, kind, limit in budgets:
+        for e in res["entries"]:
+            if key in ("*", e["name"], stem(e["name"])):
+                val = e["js_raw"] if kind == "raw" else e["gzip"]
+                row = {"entry": e["name"], "kind": kind, "limit": int(limit), "value": val,
+                       "basis": res["raw_basis"] if kind == "raw" else e["gzip_basis"],
+                       "pass": None if val is None else val <= limit}
+                if val is None:
+                    row["note"] = "compressed size not measured; pass --dist with the built files"
+                rows.append(row)
+        if key != "*" and not any(r["entry"] == key or stem(r["entry"]) == key for r in rows):
+            rows.append({"entry": key, "kind": kind, "limit": int(limit), "value": None, "basis": None, "pass": None,
+                         "note": "no entry by this name"})
+    return rows
+
+
+def compare(b1, b2, r1, r2, top):
+    out = {"before": {"tool": r1["tool"]}, "after": {"tool": r2["tool"]}, "entries": [], "chunks": [],
+           "packages": [], "modules_added": [], "modules_removed": [], "modules_changed": [],
+           "moved_to_initial": [], "moved_to_lazy": []}
+    e1 = {e["name"]: e for e in r1["entries"]}
+    e2 = {e["name"]: e for e in r2["entries"]}
+    for name in list(e1) + [n for n in e2 if n not in e1]:
+        a, c = e1.get(name), e2.get(name)
+        out["entries"].append({"name": name, "raw_before": a["js_raw"] if a else 0, "raw_after": c["js_raw"] if c else 0,
+                               "gzip_before": a["gzip"] if a else 0, "gzip_after": c["gzip"] if c else 0,
+                               "gzip_basis": basis_of([x["gzip_basis"] for x in (a, c) if x])})
+    for e in out["entries"]:
+        e["raw_delta"] = e["raw_after"] - e["raw_before"]
+        e["gzip_delta"] = (e["gzip_after"] - e["gzip_before"]
+                           if e["gzip_after"] is not None and e["gzip_before"] is not None else None)
+    for key in list(b1["chunks"]) + [k for k in b2["chunks"] if k not in b1["chunks"]]:
+        a, c = b1["chunks"].get(key), b2["chunks"].get(key)
+        d = (c["raw"] if c else 0) - (a["raw"] if a else 0)
+        out["chunks"].append({"key": key, "initial_before": a["initial"] if a else None,
+                              "initial_after": c["initial"] if c else None,
+                              "raw_before": a["raw"] if a else 0, "raw_after": c["raw"] if c else 0, "raw_delta": d,
+                              "loaded_from": sorted(set((c or a)["loaded_from"])),
+                              "status": "added" if not a else "removed" if not c else "changed" if d else "same"})
+    out["chunks"].sort(key=lambda x: -abs(x["raw_delta"]))
+    out["chunks"] = [c for c in out["chunks"] if c["status"] != "same"]
+    p1 = {p["name"]: p for p in r1["packages"]}
+    p2 = {p["name"]: p for p in r2["packages"]}
+    for name in set(p1) | set(p2):
+        a, c = p1.get(name), p2.get(name)
+        row = {"name": name, "size_before": a["size"] if a else 0, "size_after": c["size"] if c else 0,
+               "initial_before": a["initial_size"] if a else 0, "initial_after": c["initial_size"] if c else 0,
+               "status": "added" if not a else "removed" if not c else "changed"}
+        row["delta"] = row["size_after"] - row["size_before"]
+        row["initial_delta"] = row["initial_after"] - row["initial_before"]
+        if row["delta"] or row["initial_delta"]:
+            if c:
+                mk = next((m for m in sorted(b2["modules"]) if (package_of(m) or ("",))[0] == name), None)
+                row["chain_after"] = chain_for(b2, mk) if mk else None
+            out["packages"].append(row)
+        if a and c and a["initial_size"] == 0 and c["initial_size"] > 0:
+            out["moved_to_initial"].append(name)
+        if a and c and a["initial_size"] > 0 and c["initial_size"] == 0:
+            out["moved_to_lazy"].append(name)
+    out["packages"].sort(key=lambda x: (-abs(x["initial_delta"]), -abs(x["delta"])))
+    m1, m2 = b1["modules"], b2["modules"]
+    added = sorted((k for k in m2 if k not in m1), key=lambda k: -m2[k]["size"])
+    for k in added[:top]:
+        out["modules_added"].append({"path": k, "size": m2[k]["size"], "initial": m2[k]["initial"],
+                                     "chain": chain_for(b2, k) if m2[k]["initial"] else None})
+    out["modules_added_total"] = {"count": len(added), "size": sum(m2[k]["size"] for k in added),
+                                  "initial_size": sum(m2[k]["size"] for k in added if m2[k]["initial"])}
+    removed = sorted((k for k in m1 if k not in m2), key=lambda k: -m1[k]["size"])
+    for k in removed[:top]:
+        out["modules_removed"].append({"path": k, "size": m1[k]["size"], "initial_before": m1[k]["initial"]})
+    changed = sorted((k for k in m1 if k in m2 and m1[k]["size"] != m2[k]["size"]),
+                     key=lambda k: -abs(m2[k]["size"] - m1[k]["size"]))
+    moved = [k for k in m1 if k in m2 and not m1[k]["initial"] and m2[k]["initial"]]
+    out["modules_moved_to_initial"] = {"count": len(moved), "size": sum(m2[k]["size"] for k in moved),
+                                       "modules": [{"path": k, "size": m2[k]["size"]} for k in
+                                                   sorted(moved, key=lambda k: -m2[k]["size"])[:top]]}
+    def totals(b):
+        init = sum(c["raw"] for c in b["chunks"].values() if c["initial"])
+        return init, sum(c["raw"] for c in b["chunks"].values()) - init
+    i1, l1 = totals(b1)
+    i2, l2 = totals(b2)
+    out["totals"] = {"all_before": i1 + l1, "all_after": i2 + l2, "initial_before": i1, "initial_after": i2,
+                     "lazy_before": l1, "lazy_after": l2}
+    for k in changed[:top]:
+        out["modules_changed"].append({"path": k, "size_before": m1[k]["size"], "size_after": m2[k]["size"],
+                                       "initial_before": m1[k]["initial"], "initial_after": m2[k]["initial"]})
+    return out
+
+
+# ---------------------------------------------------------------- project files around the stats
+
+# First browser version with the feature native (MDN browser-compat data). core-js can keep a
+# polyfill a little longer to patch spec bugs, so a rebuild confirms the removal.
+POLYFILL_FEATURES = {
+    "es.promise": ("Promise", r"\bPromise\b", {"chrome": "67", "edge": "79", "firefox": "69", "safari": "11"}),
+    "es.promise.all-settled": ("Promise.allSettled", r"\bPromise\.allSettled\b", {"chrome": "76", "edge": "79", "firefox": "71", "safari": "13"}),
+    "es.promise.any": ("Promise.any", r"\bPromise\.any\b", {"chrome": "85", "edge": "85", "firefox": "79", "safari": "14"}),
+    "es.promise.with-resolvers": ("Promise.withResolvers", r"\bPromise\.withResolvers\b", {"chrome": "119", "edge": "119", "firefox": "121", "safari": "17.4"}),
+    "es.global-this": ("globalThis", r"\bglobalThis\b", {"chrome": "71", "edge": "79", "firefox": "65", "safari": "12.1"}),
+    "es.array.flat": ("Array.prototype.flat", r"\.flat\(", {"chrome": "69", "edge": "79", "firefox": "62", "safari": "12"}),
+    "es.array.flat-map": ("Array.prototype.flatMap", r"\.flatMap\(", {"chrome": "69", "edge": "79", "firefox": "62", "safari": "12"}),
+    "es.array.includes": ("Array.prototype.includes", r"\.includes\(", {"chrome": "47", "edge": "14", "firefox": "43", "safari": "9"}),
+    "es.array.at": ("Array.prototype.at", r"\.at\(", {"chrome": "92", "edge": "92", "firefox": "90", "safari": "15.4"}),
+    "es.string.at-alternative": ("String.prototype.at", r"\.at\(", {"chrome": "92", "edge": "92", "firefox": "90", "safari": "15.4"}),
+    "es.array.find-last": ("Array.prototype.findLast", r"\.findLast\(", {"chrome": "97", "edge": "97", "firefox": "104", "safari": "15.4"}),
+    "es.array.find-last-index": ("Array.prototype.findLastIndex", r"\.findLastIndex\(", {"chrome": "97", "edge": "97", "firefox": "104", "safari": "15.4"}),
+    "es.array.to-sorted": ("Array.prototype.toSorted", r"\.toSorted\(", {"chrome": "110", "edge": "110", "firefox": "115", "safari": "16"}),
+    "es.array.to-reversed": ("Array.prototype.toReversed", r"\.toReversed\(", {"chrome": "110", "edge": "110", "firefox": "115", "safari": "16"}),
+    "es.array.to-spliced": ("Array.prototype.toSpliced", r"\.toSpliced\(", {"chrome": "110", "edge": "110", "firefox": "115", "safari": "16"}),
+    "es.array.with": ("Array.prototype.with", r"\.with\(", {"chrome": "110", "edge": "110", "firefox": "115", "safari": "16"}),
+    "es.array.from-async": ("Array.fromAsync", r"\bArray\.fromAsync\b", {"chrome": "121", "edge": "121", "firefox": "115", "safari": "16.4"}),
+    "es.object.from-entries": ("Object.fromEntries", r"\bObject\.fromEntries\b", {"chrome": "73", "edge": "79", "firefox": "63", "safari": "12.1"}),
+    "es.object.has-own": ("Object.hasOwn", r"\bObject\.hasOwn\b", {"chrome": "93", "edge": "93", "firefox": "92", "safari": "15.4"}),
+    "es.object.group-by": ("Object.groupBy", r"\bObject\.groupBy\b", {"chrome": "117", "edge": "117", "firefox": "119", "safari": "17.4"}),
+    "es.map.group-by": ("Map.groupBy", r"\bMap\.groupBy\b", {"chrome": "117", "edge": "117", "firefox": "119", "safari": "17.4"}),
+    "es.string.replace-all": ("String.prototype.replaceAll", r"\.replaceAll\(", {"chrome": "85", "edge": "85", "firefox": "77", "safari": "13.1"}),
+    "es.string.is-well-formed": ("String.prototype.isWellFormed", r"\.isWellFormed\(", {"chrome": "111", "edge": "111", "firefox": "119", "safari": "16.4"}),
+    "es.set.union.v2": ("Set.prototype.union and the other Set methods", r"\.(union|intersection|difference|symmetricDifference|isSubsetOf|isSupersetOf|isDisjointFrom)\(", {"chrome": "122", "edge": "122", "firefox": "127", "safari": "17"}),
+    "es.symbol": ("Symbol", r"\bSymbol\b", {"chrome": "49", "edge": "15", "firefox": "51", "safari": "10"}),
+    "es.array.iterator": ("Array iterators", r"\bfor\s*\(.+\bof\b|\.(entries|keys|values)\(", {"chrome": "66", "edge": "79", "firefox": "60", "safari": "15.4"}),
+    "es.map": ("Map", r"\bnew\s+Map\b", {"chrome": "51", "edge": "15", "firefox": "53", "safari": "10"}),
+    "es.set": ("Set", r"\bnew\s+Set\b", {"chrome": "51", "edge": "15", "firefox": "53", "safari": "10"}),
+    "es.object.assign": ("Object.assign", r"\bObject\.assign\b", {"chrome": "49", "edge": "79", "firefox": "36", "safari": "9"}),
+    "es.object.entries": ("Object.entries", r"\bObject\.entries\b", {"chrome": "54", "edge": "14", "firefox": "47", "safari": "10.1"}),
+    "es.object.values": ("Object.values", r"\bObject\.values\b", {"chrome": "54", "edge": "14", "firefox": "47", "safari": "10.1"}),
+    "es.promise.finally": ("Promise.prototype.finally", r"\.finally\(", {"chrome": "67", "edge": "79", "firefox": "69", "safari": "13.1"}),
+    "es.string.pad-start": ("String.prototype.padStart", r"\.padStart\(", {"chrome": "57", "edge": "15", "firefox": "48", "safari": "15.4"}),
+    "es.string.pad-end": ("String.prototype.padEnd", r"\.padEnd\(", {"chrome": "57", "edge": "15", "firefox": "48", "safari": "15.4"}),
+    "es.string.includes": ("String.prototype.includes", r"\.includes\(", {"chrome": "51", "edge": "15", "firefox": "40", "safari": "10"}),
+    "web.url": ("URL", r"\bnew\s+URL\b", {"chrome": "67", "edge": "79", "firefox": "57", "safari": "14.1"}),
+    "web.url-search-params": ("URLSearchParams", r"\bURLSearchParams\b", {"chrome": "67", "edge": "79", "firefox": "57", "safari": "14.1"}),
+    "web.structured-clone": ("structuredClone", r"\bstructuredClone\(", {"chrome": "98", "edge": "98", "firefox": "94", "safari": "15.4"}),
+}
+BROWSER_ALIAS = {"chrome": "chrome", "edge": "edge", "firefox": "firefox", "ff": "firefox", "safari": "safari",
+                 "ios_saf": "safari", "ios": "safari"}
+SKIP_DIRS = {"node_modules", ".git", "dist", "build", "out", "coverage", ".next", ".nuxt", ".svelte-kit", ".cache", ".turbo"}
+SRC_EXT = (".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".vue", ".svelte")
+CONFIG_RE = re.compile(r"^((webpack|vite|rollup|esbuild|rspack|rsbuild|tsup|next|nuxt|astro|svelte|craco|babel)\.config(\.[\w-]+)?\.[cm]?[jt]s"
+                       r"|build\.[cm]?[jt]s|tsconfig(\.[\w-]+)?\.json|\.babelrc(\.json)?|\.size-limit(\.json|\.[cm]?js)?)$")
+SPEC_RES = [("static", re.compile(r"""\bfrom\s*['"]([^'"]+)['"]""")),
+            ("side-effect", re.compile(r"""(?m)^\s*import\s*['"]([^'"]+)['"]""")),
+            ("dynamic", re.compile(r"""\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)""")),
+            ("require", re.compile(r"""\brequire\s*\(\s*['"]([^'"]+)['"]\s*\)"""))]
+NS_RE = re.compile(r"""\bimport\s+\*\s+as\s+([\w$]+)\s+from\s*['"]([^'"]+)['"]""")
+
+
+def ver_tuple(v):
+    out = []
+    for part in str(v).split("."):
+        if not part.isdigit():
+            break
+        out.append(int(part))
+    return tuple(out) or (0,)
+
+
+def bare_package(spec):
+    if not spec or spec.startswith((".", "/")) or ":" in spec.split("/")[0]:
+        return None
+    parts = spec.split("/")
+    return "/".join(parts[:2]) if spec.startswith("@") and len(parts) > 1 else parts[0]
+
+
+def read_text(path, limit=1000000):
+    try:
+        if os.path.getsize(path) > limit:
+            return None
+        with open(path, "r", encoding="utf-8", errors="replace") as fh:
+            return fh.read()
+    except OSError:
+        return None
+
+
+def read_json(path):
+    t = read_text(path, 20000000)
+    if t is None:
+        return None
+    try:
+        return json.loads(t)
+    except ValueError:
+        return None
+
+
+def find_root(stats_path, root):
+    if root:
+        return os.path.abspath(root)
+    if not stats_path or stats_path == "-":
+        return None
+    d = os.path.dirname(os.path.abspath(stats_path))
+    cands = [d, os.path.dirname(d), os.path.dirname(os.path.dirname(d))]
+    for c in cands:
+        if any(os.path.exists(os.path.join(c, f)) for f in ("package.json", ".browserslistrc")):
+            return c
+    for c in cands:
+        if os.path.isdir(os.path.join(c, "src")):
+            return c
+    return d
+
+
+def parse_browserslist(queries):
+    """{browser: min version tuple} when every query is a plain version query, else None."""
+    targets = {}
+    for q in queries:
+        q = q.strip().lower()
+        if not q:
+            continue
+        m = re.fullmatch(r"([a-z_]+)\s*(>=|>)\s*([0-9.]+)", q) or re.fullmatch(r"([a-z_]+)\s+([0-9.]+)(?:\s*-\s*[0-9.]+)?", q)
+        if not m or m.group(1) not in BROWSER_ALIAS:
+            return None
+        if len(m.groups()) == 3:
+            v = ver_tuple(m.group(3))
+            if m.group(2) == ">":
+                v = (v[0] + 1,)
+        else:
+            v = ver_tuple(m.group(2))
+        b = BROWSER_ALIAS[m.group(1)]
+        targets[b] = min(targets.get(b, v), v)
+    return targets or None
+
+
+def browserslist_queries(raw):
+    lines = []
+    section = None
+    prod = []
+    for line in raw.splitlines():
+        line = line.split("#", 1)[0].strip()
+        if not line:
+            continue
+        if line.startswith("[") and line.endswith("]"):
+            section = line[1:-1].strip().lower()
+            continue
+        for q in line.split(","):
+            (prod if section == "production" else lines if section is None else []).append(q.strip())
+    return prod or lines
+
+
+def build_targets(text):
+    toks = []
+    for m in re.finditer(r"""\btarget\s*:\s*(\[[^\]]*\]|['"][^'"]+['"])""", text):
+        toks += re.findall(r"""['"]([^'"]+)['"]""", m.group(1))
+    for m in re.finditer(r"""--target=([^\s'"]+)""", text):
+        toks += m.group(1).split(",")
+    out = []
+    for t in toks:
+        out += [x.strip() for x in t.split(",") if x.strip()]
+    return out
+
+
+def esbuild_style_targets(tokens):
+    targets = {}
+    for t in tokens:
+        m = re.fullmatch(r"(chrome|edge|firefox|safari|ios)([0-9][0-9.]*)", t.lower())
+        if m:
+            b = BROWSER_ALIAS[m.group(1)]
+            v = ver_tuple(m.group(2))
+            targets[b] = min(targets.get(b, v), v)
+    return targets or None
+
+
+def lock_index(root):
+    for name in ("package-lock.json", "npm-shrinkwrap.json"):
+        data = read_json(os.path.join(root, name))
+        if not isinstance(data, dict):
+            continue
+        pk = data.get("packages")
+        if isinstance(pk, dict):
+            return name, pk
+        deps = data.get("dependencies")
+        if isinstance(deps, dict):  # lockfile v1: nested dependencies
+            flat = {}
+            def walk(d, prefix):
+                for n, info in d.items():
+                    path = prefix + "node_modules/" + n
+                    flat[path] = {"version": info.get("version"), "dependencies": info.get("requires") or {}}
+                    if isinstance(info.get("dependencies"), dict):
+                        walk(info["dependencies"], path + "/")
+            walk(deps, "")
+            return name, flat
+    return None, None
+
+
+def project_context(root, res, b):
+    if not root or not os.path.isdir(root):
+        return None
+    ctx = {"root": root, "found": [], "absent": [], "browserslist": None, "build_targets": [], "ts_target": None,
+           "targets": None, "targets_from": None, "budgets": [], "versions": {}, "lockfile": None,
+           "dependents": {}, "sources_on_disk": [], "bundle_sources_absent": [], "importers": {}, "namespace": [],
+           "polyfills": []}
+    pkg = read_json(os.path.join(root, "package.json"))
+    (ctx["found"] if isinstance(pkg, dict) else ctx["absent"]).append("package.json")
+    queries, where = None, None
+    rc = read_text(os.path.join(root, ".browserslistrc"))
+    if rc is not None:
+        ctx["found"].append(".browserslistrc")
+        queries, where = browserslist_queries(rc), ".browserslistrc"
+    else:
+        ctx["absent"].append(".browserslistrc")
+    if isinstance(pkg, dict):
+        bl = pkg.get("browserslist")
+        if isinstance(bl, dict):
+            bl = bl.get("production") or bl.get("defaults")
+        if isinstance(bl, str):
+            bl = [bl]
+        if isinstance(bl, list):
+            if queries is None:
+                queries, where = [str(x) for x in bl], "package.json browserslist"
+            else:
+                ctx["notes"] = ["package.json also has a browserslist field; browserslist refuses to run with both"]
+        elif rc is None:
+            ctx["absent"].append("package.json browserslist field")
+        sl = pkg.get("size-limit") or pkg.get("bundlesize")
+        if sl:
+            ctx["budgets"].append("package.json %s: %s" % ("size-limit" if pkg.get("size-limit") else "bundlesize", json.dumps(sl)[:200]))
+    if queries is not None:
+        ctx["browserslist"] = {"from": where, "queries": queries}
+    configs = []
+    for d in (root, os.path.join(root, "config"), os.path.join(root, "scripts")):
+        try:
+            names = sorted(os.listdir(d))
+        except OSError:
+            continue
+        for n in names:
+            if CONFIG_RE.match(n) and os.path.isfile(os.path.join(d, n)):
+                configs.append(os.path.relpath(os.path.join(d, n), root))
+    if configs:
+        ctx["found"] += configs
+    else:
+        ctx["absent"].append("bundler config (webpack/vite/rollup/esbuild config, build.mjs)")
+    for rel in configs:
+        text = read_text(os.path.join(root, rel)) or ""
+        if rel.startswith("tsconfig") or "tsconfig" in rel:
+            m = re.search(r'"target"\s*:\s*"([^"]+)"', text)
+            if m:
+                ctx["ts_target"] = {"from": rel, "target": m.group(1)}
+            continue
+        toks = build_targets(text)
+        if toks:
+            ctx["build_targets"].append({"from": rel, "target": toks})
+        for key in ("maxEntrypointSize", "maxAssetSize", "hints"):
+            for m in re.finditer(r"\b%s\s*:\s*([^,}\n]+)" % key, text):
+                ctx["budgets"].append("%s %s: %s" % (rel, key, m.group(1).strip()))
+        if os.path.basename(rel).startswith(".size-limit"):
+            ctx["budgets"].append("%s: %s" % (rel, " ".join(text.split())[:200]))
+    if queries is not None:
+        ctx["targets"] = parse_browserslist(queries)
+        ctx["targets_from"] = where if ctx["targets"] else None
+    if ctx["targets"] is None and ctx["build_targets"]:
+        toks = [t for bt in ctx["build_targets"] for t in bt["target"]]
+        ctx["targets"] = esbuild_style_targets(toks)
+        ctx["targets_from"] = ctx["build_targets"][0]["from"] + " target" if ctx["targets"] else None
+    # versions: lockfile installed versions and declared ranges
+    lname, lock = lock_index(root)
+    if lname:
+        ctx["found"].append(lname)
+        ctx["lockfile"] = lname
+    else:
+        other = [n for n in ("yarn.lock", "pnpm-lock.yaml", "bun.lockb") if os.path.exists(os.path.join(root, n))]
+        if other:
+            ctx["found"] += other
+            ctx["lockfile"] = other[0] + " (not parsed; read versions with yarn why / pnpm why)"
+        else:
+            ctx["absent"].append("lockfile")
+    declared = {}
+    if isinstance(pkg, dict):
+        for sec in ("dependencies", "devDependencies", "peerDependencies", "optionalDependencies"):
+            for n, r in (pkg.get(sec) or {}).items():
+                declared.setdefault(n, r)
+    names = [p["name"] for p in res["packages"][:20]] + [d["package"] for d in res["duplicates"]]
+    for n in dict.fromkeys(names):
+        row = {"declared": declared.get(n)}
+        if lock:
+            row["installed"] = (lock.get("node_modules/" + n) or {}).get("version")
+        ctx["versions"][n] = row
+    for d in res["duplicates"]:
+        for inst in d["installs"]:
+            if lock and inst.get("version") is None:
+                v = (lock.get(inst["install"]) or {}).get("version")
+                if v:
+                    inst["version"] = v
+                    inst["version_from"] = lname
+        if lock:
+            wants = []
+            if d["package"] in declared:
+                wants.append("the app (package.json) %s" % declared[d["package"]])
+            for path, info in sorted(lock.items()):
+                if not path or not isinstance(info, dict):
+                    continue
+                r = (info.get("dependencies") or {}).get(d["package"]) or (info.get("peerDependencies") or {}).get(d["package"])
+                if r:
+                    owner = path.rsplit("node_modules/", 1)[-1]
+                    wants.append("%s@%s %s" % (owner, info.get("version") or "?", r))
+            ctx["dependents"][d["package"]] = wants
+    # source files on disk
+    files = []
+    for dp, dns, fns in os.walk(root):
+        dns[:] = [x for x in dns if x not in SKIP_DIRS and not x.startswith(".")]
+        for fn in fns:
+            if fn.endswith(SRC_EXT) and not CONFIG_RE.match(fn):
+                files.append(os.path.relpath(os.path.join(dp, fn), root).replace("\\", "/"))
+        if len(files) > 3000:
+            break
+    files.sort()
+    ctx["sources_on_disk"] = files
+    on_disk = set(files)
+    bundle_src = sorted(m for m in b["modules"] if "node_modules/" not in m and m.endswith(SRC_EXT))
+    ctx["bundle_sources_absent"] = [m for m in bundle_src if m not in on_disk]
+    bundled = set(p["name"] for p in res["packages"])
+    texts = {}
+    for f in files:
+        t = read_text(os.path.join(root, f))
+        if t is None:
+            continue
+        texts[f] = t
+        for kind, rx in SPEC_RES:
+            for spec in rx.findall(t):
+                pk = bare_package(spec)
+                if pk in bundled:
+                    ctx["importers"].setdefault(pk, [])
+                    item = (f, kind, spec)
+                    if item not in ctx["importers"][pk]:
+                        ctx["importers"][pk].append(item)
+        for ns, spec in NS_RE.findall(t):
+            pk = bare_package(spec)
+            if pk and re.search(r"\b%s\s*\[" % re.escape(ns), t):
+                ctx["namespace"].append({"file": f, "package": pk, "name": ns})
+    # polyfills against the targets
+    for m in sorted(b["modules"]):
+        pk = package_of(m)
+        if not pk or pk[0] not in ("core-js", "core-js-pure") or "/modules/" not in m:
+            continue
+        feat = os.path.basename(m).rsplit(".", 1)[0]
+        key = feat.replace("esnext.", "es.", 1)
+        row = {"module": feat, "size": b["modules"][m]["size"], "imported_by": [], "used_in": []}
+        for f, t in texts.items():
+            if re.search(r"""['"]core-js(-pure)?/(modules|stable|actual|es|features)/%s['"]""" % re.escape(feat), t):
+                row["imported_by"].append(f)
+        info = POLYFILL_FEATURES.get(key)
+        tg = ctx["targets"]
+        if not info:
+            row["verdict"] = "not in this script's table; check against the targets by hand"
+        elif not tg:
+            row["feature"] = info[0]
+            row["verdict"] = "browser targets unknown"
+        else:
+            row["feature"] = info[0]
+            short = []
+            unknown = []
+            for br, minv in sorted(tg.items()):
+                nat = info[2].get(br)
+                if nat is None:
+                    unknown.append(br)
+                elif minv < ver_tuple(nat):
+                    short.append("%s %s < %s" % (br, ".".join(map(str, minv)), nat))
+            if short:
+                row["verdict"] = "NEEDED: native only from %s" % ", ".join(short)
+                rx = re.compile(info[1])
+                row["used_in"] = sorted(f for f, t in texts.items() if rx.search(t) and f not in row["imported_by"])
+            elif unknown:
+                row["verdict"] = "unknown for %s" % ", ".join(unknown)
+            else:
+                row["verdict"] = "not needed: native in every target (%s)" % ", ".join(
+                    "%s %s" % (br, info[2][br]) for br in sorted(tg))
+        ctx["polyfills"].append(row)
+    return ctx
+
+
+# ---------------------------------------------------------------- text output
+
+def fmt_chain(chain):
+    if not chain:
+        return "(no chain from an entry found in the stats)"
+    s = chain[0]["module"]
+    for step in chain[1:]:
+        arrow = " -import()-> " if step.get("via") == "dynamic" else " > "
+        s += arrow + step["module"]
+    return s
+
+
+def gz_label(basis):
+    return {"built-file": "measured from the built files, gzip -9", "visualizer": "from the visualizer's per-module figures"}.get(basis, basis or "not measured")
+
+
+def comp_line(gzip_v, gzip_b, br_v=None, br_b=None):
+    if gzip_v is None:
+        return "compressed: not measured"
+    s = "gzip %s [%s]" % (bkb(gzip_v), gz_label(gzip_b))
+    if br_v is not None:
+        s += ", brotli %s [%s]" % (bkb(br_v), gz_label(br_b))
+    return s
+
+
+def header(res):
+    L = ["Bundle: %s. All sizes in bytes as the stats give them (kB = 1000 bytes)." % res["tool"],
+         "Chunk sizes: %s." % res["raw_basis"],
+         "Module and package sizes: %s." % res["module_basis"]]
+    if not any(e["gzip"] is not None for e in res["entries"]):
+        L.append("Compressed sizes: not measured; no built files were read (pass --dist DIR after a build).")
+    for n in res["notes"]:
+        L.append("Note: %s." % n)
+    return L
+
+
+def render_project(ctx):
+    L = [""]
+    if ctx is None:
+        L.append("Project files: none read (stats from stdin and no --root)")
+        return L
+    rel = os.path.relpath(ctx["root"])
+    L.append("Project files (root: %s)" % (rel if not rel.startswith("..") else ctx["root"]))
+    L.append("  found: %s" % (", ".join(ctx["found"]) or "(none)"))
+    L.append("  absent: %s" % (", ".join(ctx["absent"]) or "(none)"))
+    for n in ctx.get("notes", []):
+        L.append("  note: %s" % n)
+    bl = ctx["browserslist"]
+    if bl:
+        L.append("  browserslist (%s): %s" % (bl["from"], ", ".join(bl["queries"])))
+    for bt in ctx["build_targets"]:
+        L.append("  build target (%s): %s" % (bt["from"], ", ".join(bt["target"])))
+    if ctx["ts_target"]:
+        L.append("  TypeScript target (%s): %s (syntax only; does not decide polyfills)" % (ctx["ts_target"]["from"], ctx["ts_target"]["target"]))
+    if ctx["targets"]:
+        L.append("  browser targets used for the polyfill check (%s): %s" % (
+            ctx["targets_from"], ", ".join("%s >= %s" % (k, ".".join(map(str, v))) for k, v in sorted(ctx["targets"].items()))))
+    elif bl:
+        L.append("  browser targets: the queries are not plain version queries; resolve them with: npx --no browserslist")
+    else:
+        L.append("  browser targets: none found in the project files")
+    L.append("  existing size budgets: %s" % ("; ".join(ctx["budgets"]) if ctx["budgets"] else "none found"))
+    if ctx["lockfile"] and not ctx["lockfile"].endswith("not parsed; read versions with yarn why / pnpm why)"):
+        vers = ["%s %s%s" % (n, v.get("installed") or "not in lockfile",
+                             (" (declared %s)" % v["declared"]) if v.get("declared") else " (not a direct dependency)")
+                for n, v in ctx["versions"].items()]
+        if vers:
+            L.append("  installed versions (%s; declared range from package.json): %s" % (ctx["lockfile"], "; ".join(vers)))
+    else:
+        vers = ["%s %s" % (n, v["declared"]) for n, v in ctx["versions"].items() if v.get("declared")]
+        if vers:
+            L.append("  declared ranges in package.json (installed versions unknown without a lockfile): %s" % "; ".join(vers))
+    for pk, wants in ctx["dependents"].items():
+        if wants:
+            L.append("  who asks for %s: %s" % (pk, "; ".join(wants)))
+    L.append("  source files on disk: %d%s" % (len(ctx["sources_on_disk"]),
+             (": " + ", ".join(ctx["sources_on_disk"][:12]) + (" ..." if len(ctx["sources_on_disk"]) > 12 else "")) if ctx["sources_on_disk"] else ""))
+    if ctx["bundle_sources_absent"]:
+        a = ctx["bundle_sources_absent"]
+        L.append("  bundled source files not on disk here (%d): %s%s" % (len(a), ", ".join(a[:10]), " ..." if len(a) > 10 else ""))
+    for pk, imps in sorted(ctx["importers"].items()):
+        per = {}
+        for f, kind, spec in imps:
+            per.setdefault(f, []).append((kind, spec))
+        parts = []
+        for f, items in per.items():
+            if len(items) > 2:
+                parts.append("%s (%d imports, e.g. '%s')" % (f, len(items), items[0][1]))
+            else:
+                parts.append("%s (%s)" % (f, ", ".join("%s '%s'" % it for it in items)))
+        L.append("  %s imported in: %s" % (pk, "; ".join(parts[:8])))
+    for n in ctx["namespace"]:
+        L.append("  namespace import with a computed lookup: %s does import * as %s from '%s' and reads %s[...], so every export stays in the bundle"
+                 % (n["file"], n["name"], n["package"], n["name"]))
+    if ctx["polyfills"]:
+        L.append("")
+        L.append("Polyfills against the browser targets (first native version per MDN browser-compat data; a rebuild confirms each removal)")
+        for p in ctx["polyfills"]:
+            extra = ""
+            if p["imported_by"]:
+                extra += "; imported in %s" % ", ".join(p["imported_by"])
+            if p["used_in"]:
+                extra += "; feature used in %s" % ", ".join(p["used_in"])
+            L.append("  %-28s %10s  %s%s%s" % (p["module"], kib(p["size"]), ("%s: " % p["feature"]) if p.get("feature") else "",
+                                               p["verdict"], extra))
+        removable = [p for p in ctx["polyfills"] if p["verdict"].startswith("not needed")]
+        if removable:
+            L.append("  not needed by the targets: %d module(s), %s in total" % (len(removable), kib(sum(p["size"] for p in removable))))
+    return L
+
+
+def render_budgets(rows, title):
+    L = ["", title]
+    for r in rows:
+        if r["pass"] is None:
+            L.append("  %s: budget %s %s; %s" % (r["entry"], r["kind"], kib(r["limit"]), r.get("note")))
+        else:
+            L.append("  %s: %s vs budget %s (%s) -> %s" % (r["entry"], kib(r["value"]), kib(r["limit"]), r["kind"],
+                                                         "PASS" if r["pass"] else "OVER"))
+    return L
+
+
+def render_why(why):
+    L = []
+    for w in why or []:
+        L.append("")
+        L.append("Why is %s in the bundle?" % w["query"])
+        if not w["matches"]:
+            L.append("  no module or package by that name in the stats")
+        for t in w["matches"]:
+            head = t.get("install") or t["module"]
+            L.append("  %s (%s)" % (head, "initial" if t["initial"] else "lazy"))
+            L.append("    chain: %s" % fmt_chain(t["chain"]))
+            if t["importers"]:
+                L.append("    imported by: %s" % ", ".join(t["importers"]))
+    return L
+
+
+def render_single(res, budgets_rows):
+    L = header(res)
+    L.append("")
+    L.append("Initial JS per entry (loaded before first render)")
+    if not res["entries"]:
+        L.append("  (no entries found)")
+    for e in res["entries"]:
+        L.append("  %s: %s%s%s" % (e["name"], bkb(e["js_raw"]),
+                                   ("; " + comp_line(e["gzip"], e["gzip_basis"], e["brotli"], e["brotli_basis"])) if e["gzip"] is not None else "",
+                                   ("; CSS %s" % kib(e["css_raw"])) if e["css_raw"] else ""))
+        for c in e["chunks"]:
+            L.append("    %-28s %14s  %s" % (c["key"], kib(c["raw"]), ", ".join(c["files"])))
+    L.append("")
+    L.append("Lazy chunks (loaded on demand, not on first render)")
+    if not res["lazy_chunks"]:
+        L.append("  (none)")
+    for c in res["lazy_chunks"]:
+        mostly = ", ".join("%s %s" % (x["owner"], kib(x["size"])) for x in c["mostly"])
+        frm = ("; loaded from " + ", ".join(c["loaded_from"])) if c["loaded_from"] else ""
+        L.append("  %s: %s%s; files %s%s; largest: %s" % (c["key"], kib(c["raw"]),
+                 (", gzip %s" % kib(c["gzip"])) if c["gzip"] is not None else "", ", ".join(c["files"]), frm, mostly))
+    L.append("")
+    L.append("Largest modules (%s)" % res["module_basis"])
+    for m in res["largest_modules"]:
+        L.append("  %14s  %-8s %s  [%s]" % (kib(m["size"]), "initial" if m["initial"] else "lazy", m["path"], ", ".join(m["chunks"])))
+    L.append("")
+    L.append("Packages by size")
+    for p in res["packages"][:15]:
+        where = "initial %s" % kib(p["initial_size"]) if p["initial_size"] else "lazy only"
+        if p["initial_size"] and p["lazy_size"]:
+            where += ", lazy %s" % kib(p["lazy_size"])
+        extra = []
+        if p["installs"] > 1:
+            extra.append("%d install paths" % p["installs"])
+        if p["commonjs"]:
+            extra.append("CommonJS")
+        if p.get("gzip") is not None:
+            extra.insert(0, "%s gzip [visualizer]" % kib(p["gzip"]))
+        L.append("  %14s  %-28s %s; %d module(s)%s" % (kib(p["size"]), p["name"], where, p["modules"],
+                                                     ("; " + ", ".join(extra)) if extra else ""))
+    L.append("")
+    L.append("Packages installed at more than one path")
+    if not res["duplicates"]:
+        L.append("  (none)")
+    for d in res["duplicates"]:
+        L.append("  %s: %d copies" % (d["package"], len(d["installs"])))
+        for i in d["installs"]:
+            ver = i["version"] or "version not in stats or lockfile (read it with npm ls %s)" % d["package"]
+            if i.get("version_from"):
+                ver = "%s (from %s)" % (i["version"], i["version_from"])
+            L.append("    %s  %s  %s (%s)" % (i["install"], ver, kib(i["size"]), "initial" if i["initial_size"] else "lazy"))
+            L.append("      pulled in by: %s" % (", ".join(i["pulled_in_by"]) or "(no importer in stats)"))
+            L.append("      chain: %s" % fmt_chain(i["chain"]))
+    if res["in_several_chunks"]:
+        L.append("")
+        L.append("Modules copied into more than one chunk")
+        for s in res["in_several_chunks"]:
+            L.append("  %s: %d module(s), %s each copy, %s extra, in %s" % (s["owner"], s["modules"], kib(s["size"]),
+                                                                       kib(s["extra_copies_size"]), ", ".join(s["chunks"])))
+    L.append("")
+    L.append("Flags")
+    if not res["flags"]:
+        L.append("  (none)")
+    for f in res["flags"]:
+        L.append("  %s: %s, %s, %s; %s" % (f["kind"], f["package"], kib(f["size"]), "initial" if f["initial"] else "lazy", f["detail"]))
+    L.extend(render_project(res.get("project")))
+    if budgets_rows:
+        L.extend(render_budgets(budgets_rows, "Budgets on each entry's initial JS"))
+    L.extend(render_why(res.get("why")))
+    return "\n".join(L) + "\n"
+
+
+def signed(n):
+    if n is None:
+        return "n/a"
+    return ("+" if n > 0 else "") + kib(n)
+
+
+def render_compare(cmp_, r1, r2, budgets_before, budgets_after):
+    L = ["Before: %s. After: %s." % (cmp_["before"]["tool"], cmp_["after"]["tool"])] + header(r2)[1:] + [""]
+    t = cmp_["totals"]
+    L.append("All JS chunks: %s -> %s (%s); initial %s, lazy %s" % (
+        bkb(t["all_before"]), bkb(t["all_after"]), signed(t["all_after"] - t["all_before"]),
+        signed(t["initial_after"] - t["initial_before"]), signed(t["lazy_after"] - t["lazy_before"])))
+    L.append("")
+    L.append("Initial JS per entry")
+    for e in cmp_["entries"]:
+        gz = ""
+        if e["gzip_before"] is not None and e["gzip_after"] is not None:
+            gz = "; gzip %s -> %s (%s) [%s]" % (kib(e["gzip_before"]), kib(e["gzip_after"]), signed(e["gzip_delta"]), gz_label(e["gzip_basis"]))
+        L.append("  %s: %s -> %s (%s)%s" % (e["name"], bkb(e["raw_before"]), bkb(e["raw_after"]), signed(e["raw_delta"]), gz))
+    L.append("")
+    L.append("Chunks that changed")
+    for c in cmp_["chunks"][:15]:
+        kind = "initial" if (c["initial_after"] if c["initial_after"] is not None else c["initial_before"]) else "lazy"
+        if c["initial_before"] is not None and c["initial_after"] is not None and c["initial_before"] != c["initial_after"]:
+            kind = "lazy -> initial" if c["initial_after"] else "initial -> lazy"
+        L.append("  %-30s %-15s %12s -> %12s (%s) %s%s" % (c["key"], kind, kib(c["raw_before"]), kib(c["raw_after"]),
+                                                         signed(c["raw_delta"]), c["status"],
+                                                         ("; loaded with import() from " + ", ".join(c["loaded_from"])) if c["loaded_from"] and kind != "initial" else ""))
+    L.append("")
+    L.append("Packages that changed (sorted by change in initial size)")
+    for p in cmp_["packages"][:15]:
+        L.append("  %-28s total %s -> %s (%s); initial %s -> %s (%s) %s" % (
+            p["name"], kib(p["size_before"]), kib(p["size_after"]), signed(p["delta"]),
+            kib(p["initial_before"]), kib(p["initial_after"]), signed(p["initial_delta"]), p["status"]))
+        if p.get("chain_after") and p["initial_delta"] > 0:
+            L.append("      chain: %s" % fmt_chain(p["chain_after"]))
+    if cmp_["moved_to_initial"]:
+        L.append("  moved from lazy to initial: %s" % ", ".join(cmp_["moved_to_initial"]))
+    if cmp_["moved_to_lazy"]:
+        L.append("  moved from initial to lazy: %s" % ", ".join(cmp_["moved_to_lazy"]))
+    t = cmp_["modules_added_total"]
+    L.append("")
+    L.append("Modules added: %d, %s, of which %s in initial chunks" % (t["count"], kib(t["size"]), kib(t["initial_size"])))
+    for m in cmp_["modules_added"]:
+        L.append("  %12s  %-8s %s" % (kib(m["size"]), "initial" if m["initial"] else "lazy", m["path"]))
+        if m["chain"]:
+            L.append("      chain: %s" % fmt_chain(m["chain"]))
+    mv = cmp_["modules_moved_to_initial"]
+    if mv["count"]:
+        L.append("Modules moved from lazy to initial chunks: %d, %s" % (mv["count"], kib(mv["size"])))
+        for m in mv["modules"]:
+            L.append("  %12s  %s" % (kib(m["size"]), m["path"]))
+    if cmp_["modules_changed"]:
+        L.append("Modules that changed size")
+        for m in cmp_["modules_changed"]:
+            mvs = ""
+            if m["initial_before"] != m["initial_after"]:
+                mvs = " lazy -> initial" if m["initial_after"] else " initial -> lazy"
+            L.append("  %s: %s -> %s%s" % (m["path"], kib(m["size_before"]), kib(m["size_after"]), mvs))
+    if cmp_["modules_removed"]:
+        L.append("Modules removed")
+        for m in cmp_["modules_removed"]:
+            L.append("  %12s  %s" % (kib(m["size"]), m["path"]))
+    L.extend(render_project(r2.get("project")))
+    if budgets_after:
+        bmap = {(r["entry"], r["kind"], r["limit"]): r for r in budgets_before}
+        L += ["", "Budgets on each entry's initial JS, before -> after"]
+        for r in budgets_after:
+            rb = bmap.get((r["entry"], r["kind"], r["limit"]))
+            if r["pass"] is None:
+                L.append("  %s: budget %s %s; %s" % (r["entry"], r["kind"], kib(r["limit"]), r.get("note")))
+                continue
+            L.append("  %s: budget %s (%s); before %s (%s), after %s (%s)" % (
+                r["entry"], kib(r["limit"]), r["kind"], kib(rb["value"]) if rb else "n/a",
+                ("PASS" if rb["pass"] else "OVER") if rb and rb["pass"] is not None else "n/a",
+                kib(r["value"]), "PASS" if r["pass"] else "OVER"))
+    return "\n".join(L) + "\n"
+
+
+# ---------------------------------------------------------------- main
+
+def to_jsonable(o):
+    if isinstance(o, (set, tuple)):
+        return sorted(o) if isinstance(o, set) else list(o)
+    raise TypeError(type(o))
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(description="Size a JS bundle from webpack stats, an esbuild metafile or rollup-plugin-visualizer raw data, and read the project files around it.")
+    ap.add_argument("stats", nargs="?", help="stats file, or - for stdin")
+    ap.add_argument("--compare", nargs=2, metavar=("BEFORE", "AFTER"), help="diff two stats files")
+    ap.add_argument("--why", action="append", metavar="MODULE_OR_PACKAGE", help="print the import chain from an entry (repeatable)")
+    ap.add_argument("--budget", action="append", metavar="ENTRY=SIZE",
+                    help="budget on an entry's initial JS: bytes or kB/KiB (main=170kB), or gzip:SIZE when measured; * for every entry (repeatable)")
+    ap.add_argument("--dist", metavar="DIR", help="build output folder; gzip the real emitted files when found")
+    ap.add_argument("--root", metavar="DIR", help="project folder to read package.json, .browserslistrc, lockfile, configs and sources from (default: found next to the stats file)")
+    ap.add_argument("--top", type=int, default=10, help="rows in the largest-module lists (default 10)")
+    ap.add_argument("--json", action="store_true", help="print JSON instead of text")
+    ap.add_argument("-o", "--output", metavar="PATH", help="write the report to PATH instead of stdout")
+    args = ap.parse_args(argv)
+    try:
+        budgets = parse_budgets(args.budget)
+        over = False
+        if args.compare:
+            if args.stats:
+                raise InputError("give either one stats file or --compare BEFORE AFTER, not both")
+            b1, b2 = load(args.compare[0]), load(args.compare[1])
+            r1 = analyze(b1, None, args.top)
+            r2 = analyze(b2, args.dist, args.top, args.why)
+            r2["project"] = project_context(find_root(args.compare[1], args.root), r2, b2)
+            cmp_ = compare(b1, b2, r1, r2, args.top)
+            bb, ba = check_budgets(r1, budgets), check_budgets(r2, budgets)
+            over = any(r["pass"] is False for r in ba)
+            if args.json:
+                payload = {"compare": cmp_, "budgets_before": bb, "budgets_after": ba, "why": r2.get("why"),
+                           "project": r2["project"]}
+                text = json.dumps(payload, indent=2, default=to_jsonable) + "\n"
+            else:
+                text = render_compare(cmp_, r1, r2, bb, ba)
+                if r2.get("why"):
+                    text += "\n".join(render_why(r2["why"])) + "\n"
+        else:
+            if not args.stats:
+                raise InputError("give a stats file path, - for stdin, or --compare BEFORE AFTER")
+            b = load(args.stats)
+            res = analyze(b, args.dist, args.top, args.why)
+            res["project"] = project_context(find_root(args.stats, args.root), res, b)
+            rows = check_budgets(res, budgets)
+            res["budgets"] = rows
+            over = any(r["pass"] is False for r in rows)
+            text = json.dumps(res, indent=2, default=to_jsonable) + "\n" if args.json else render_single(res, rows)
+    except InputError as e:
+        sys.stderr.write("bundle_stats: %s\n" % e)
+        return 2
+    if args.output:
+        with open(args.output, "w", encoding="utf-8") as fh:
+            fh.write(text)
+    else:
+        sys.stdout.write(text)
+    return 1 if over else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())