@gitruck/cli 0.2.15 → 0.2.17

package/dist/index.js

@@ -9318,6 +9318,724 @@ function namedFnBody(html, name) {
   return null;
 }
 var NOT_A_CALL = new Set(["if", "for", "while", "switch", "catch", "return", "function", "typeof", "new", "delete", "void", "in", "of", "do", "else"]);
+var MERGEABLE_PRIMITIVES = new Set(["line", "rect", "path", "polyline", "polygon"]);
+var PRIMITIVE_MERGE_MIN = 8;
+function maskHtmlComments(src) {
+  const out = src.split("");
+  for (let at = src.indexOf("<!--");at >= 0; at = src.indexOf("<!--", at)) {
+    const close = src.indexOf("-->", at + 4);
+    const end = close < 0 ? src.length : close + 3;
+    for (let i = at;i < end; i++)
+      if (out[i] !== "\r" && out[i] !== `
+`)
+        out[i] = " ";
+    at = end;
+  }
+  return out.join("");
+}
+function scriptBodiesOnly(src) {
+  const openRe = /<script\b[^>]*>/gi;
+  const first = openRe.exec(src);
+  if (!first)
+    return src;
+  const out = src.split("").map((c3) => c3 === "\r" || c3 === `
+` ? c3 : " ");
+  let open2 = first;
+  while (open2) {
+    const bodyStart = open2.index + open2[0].length;
+    const closeRe = /<\/script\s*>/gi;
+    closeRe.lastIndex = bodyStart;
+    const close = closeRe.exec(src);
+    const bodyEnd = close?.index ?? src.length;
+    for (let i = bodyStart;i < bodyEnd; i++)
+      out[i] = src[i];
+    openRe.lastIndex = close ? close.index + close[0].length : src.length;
+    open2 = openRe.exec(src);
+  }
+  return out.join("");
+}
+function maskJsComments(src) {
+  const out = src.split("");
+  const blank = (from, to) => {
+    for (let i = from;i < to; i++)
+      if (out[i] !== "\r" && out[i] !== `
+`)
+        out[i] = " ";
+  };
+  const canStartRegexAfter = new Set(["(", "[", "{", "=", ":", ",", ";", "!", "?", "&", "|", "+", "-", "*", "%", "^", "~", "<", ">"]);
+  const keywordBeforeRegex = new Set(["return", "case", "throw", "else", "do", "yield", "await"]);
+  const regexStartsAt = (at) => {
+    let prev = at - 1;
+    while (prev >= 0 && /\s/.test(out[prev]))
+      prev--;
+    if (prev < 0 || canStartRegexAfter.has(out[prev]))
+      return true;
+    if (!/[\w$]/.test(out[prev]))
+      return false;
+    let begin = prev;
+    while (begin > 0 && /[\w$]/.test(out[begin - 1]))
+      begin--;
+    return keywordBeforeRegex.has(out.slice(begin, prev + 1).join(""));
+  };
+  for (let i = 0;i < src.length; i++) {
+    const c3 = src[i];
+    if (c3 === '"' || c3 === "'" || c3 === "`") {
+      i = skipString(src, i);
+      continue;
+    }
+    if (src.startsWith("<!--", i)) {
+      const end2 = src.indexOf("-->", i + 4);
+      const to = end2 < 0 ? src.length : end2 + 3;
+      blank(i, to);
+      i = to - 1;
+      continue;
+    }
+    if (c3 === "/" && src[i + 1] === "/") {
+      const end2 = src.indexOf(`
+`, i + 2);
+      const to = end2 < 0 ? src.length : end2;
+      blank(i, to);
+      i = to - 1;
+      continue;
+    }
+    if (c3 === "/" && src[i + 1] === "*") {
+      const end2 = src.indexOf("*/", i + 2);
+      const to = end2 < 0 ? src.length : end2 + 2;
+      blank(i, to);
+      i = to - 1;
+      continue;
+    }
+    if (c3 !== "/" || src[i + 1] === "=" || !regexStartsAt(i))
+      continue;
+    let inClass = false;
+    let end = -1;
+    for (let j = i + 1;j < src.length; j++) {
+      if (src[j] === "\\") {
+        j++;
+        continue;
+      }
+      if (src[j] === "\r" || src[j] === `
+`)
+        break;
+      if (src[j] === "[")
+        inClass = true;
+      else if (src[j] === "]")
+        inClass = false;
+      else if (src[j] === "/" && !inClass) {
+        end = j + 1;
+        while (end < src.length && /[A-Za-z]/.test(src[end]))
+          end++;
+        break;
+      }
+    }
+    if (end < 0)
+      continue;
+    blank(i, end);
+    i = end - 1;
+  }
+  return out.join("");
+}
+function maskJsStrings(src) {
+  const out = src.split("");
+  for (let i = 0;i < src.length; i++) {
+    const c3 = src[i];
+    if (c3 !== '"' && c3 !== "'" && c3 !== "`")
+      continue;
+    const end = skipString(src, i);
+    for (let j = i;j <= end && j < out.length; j++)
+      if (out[j] !== "\r" && out[j] !== `
+`)
+        out[j] = " ";
+    i = end;
+  }
+  return out.join("");
+}
+function closeParen(src, open2) {
+  let depth = 0;
+  for (let i = open2;i < src.length; i++) {
+    const c3 = src[i];
+    if (c3 === '"' || c3 === "'" || c3 === "`") {
+      i = skipString(src, i);
+      continue;
+    }
+    if (c3 === "/" && src[i + 1] === "/") {
+      const nl = src.indexOf(`
+`, i);
+      i = nl < 0 ? src.length : nl;
+      continue;
+    }
+    if (c3 === "/" && src[i + 1] === "*") {
+      const e = src.indexOf("*/", i + 2);
+      i = e < 0 ? src.length : e + 1;
+      continue;
+    }
+    if (c3 === "(")
+      depth++;
+    else if (c3 === ")" && --depth === 0)
+      return i;
+  }
+  return -1;
+}
+function skipSpace(src, at) {
+  while (at < src.length && /\s/.test(src[at]))
+    at++;
+  return at;
+}
+function braceStatementEnd(src, open2) {
+  const body = braceBlock(src, open2);
+  const close = open2 + 1 + body.length;
+  return src[close] === "}" ? close + 1 : src.length;
+}
+function statementEnd(src, start) {
+  const at = skipSpace(src, start);
+  if (src[at] === "{")
+    return braceStatementEnd(src, at);
+  const keyword = /^([A-Za-z_$][\w$]*)\b/.exec(src.slice(at))?.[1] ?? "";
+  if (keyword === "if" || keyword === "for" || keyword === "while" || keyword === "with" || keyword === "switch") {
+    const open2 = src.indexOf("(", at + keyword.length);
+    const close = open2 < 0 ? -1 : closeParen(src, open2);
+    if (close < 0)
+      return src.length;
+    if (keyword === "switch") {
+      const block = skipSpace(src, close + 1);
+      return src[block] === "{" ? braceStatementEnd(src, block) : statementEnd(src, block);
+    }
+    const bodyEnd = statementEnd(src, close + 1);
+    if (keyword !== "if")
+      return bodyEnd;
+    const next = skipSpace(src, bodyEnd);
+    return /^else\b/.test(src.slice(next)) ? statementEnd(src, next + 4) : bodyEnd;
+  }
+  if (keyword === "do") {
+    const bodyEnd = statementEnd(src, at + 2);
+    const trailer = skipSpace(src, bodyEnd);
+    if (!/^while\b/.test(src.slice(trailer)))
+      return bodyEnd;
+    const open2 = src.indexOf("(", trailer + 5);
+    const close = open2 < 0 ? -1 : closeParen(src, open2);
+    if (close < 0)
+      return src.length;
+    const semi = skipSpace(src, close + 1);
+    return src[semi] === ";" ? semi + 1 : close + 1;
+  }
+  if (keyword === "try") {
+    let end = statementEnd(src, at + 3);
+    for (;; ) {
+      const next = skipSpace(src, end);
+      if (/^catch\b/.test(src.slice(next))) {
+        let body = skipSpace(src, next + 5);
+        if (src[body] === "(") {
+          const close = closeParen(src, body);
+          if (close < 0)
+            return src.length;
+          body = skipSpace(src, close + 1);
+        }
+        end = statementEnd(src, body);
+        continue;
+      }
+      if (/^finally\b/.test(src.slice(next))) {
+        end = statementEnd(src, next + 7);
+        continue;
+      }
+      return end;
+    }
+  }
+  let parens = 0;
+  let brackets = 0;
+  let braces = 0;
+  for (let i = at;i < src.length; i++) {
+    const c3 = src[i];
+    if (c3 === '"' || c3 === "'" || c3 === "`") {
+      i = skipString(src, i);
+      continue;
+    }
+    if (c3 === "(")
+      parens++;
+    else if (c3 === ")")
+      parens = Math.max(0, parens - 1);
+    else if (c3 === "[")
+      brackets++;
+    else if (c3 === "]")
+      brackets = Math.max(0, brackets - 1);
+    else if (c3 === "{")
+      braces++;
+    else if (c3 === "}") {
+      if (braces === 0 && parens === 0 && brackets === 0)
+        return i;
+      braces = Math.max(0, braces - 1);
+    } else if (c3 === ";" && parens === 0 && brackets === 0 && braces === 0)
+      return i + 1;
+    else if ((c3 === "\r" || c3 === `
+`) && parens === 0 && brackets === 0 && braces === 0) {
+      let prev = i - 1;
+      while (prev >= at && /\s/.test(src[prev]))
+        prev--;
+      let next = skipSpace(src, i + 1);
+      if (prev >= at && /[\w$)\]'"`}]/.test(src[prev]) && next < src.length && !/[.(\[`?+\-*/%&|^<>=,:]/.test(src[next]))
+        return i;
+    }
+  }
+  return src.length;
+}
+function numericForCount(header) {
+  const parts = header.split(";");
+  if (parts.length !== 3)
+    return null;
+  const init = /^(?:(?:var|let|const)\s+)?([A-Za-z_$][\w$]*)\s*=\s*(-?\d+(?:\.\d+)?)\s*$/.exec(parts[0].trim());
+  if (!init)
+    return null;
+  const name = init[1];
+  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const cond = new RegExp(`^${escaped}\\s*(<=|<|>=|>)\\s*(-?\\d+(?:\\.\\d+)?)\\s*$`).exec(parts[1].trim());
+  if (!cond)
+    return null;
+  const updateRaw = parts[2].trim();
+  let step = null;
+  if (new RegExp(`^(?:${escaped}\\s*\\+\\+|\\+\\+\\s*${escaped})$`).test(updateRaw))
+    step = 1;
+  else if (new RegExp(`^(?:${escaped}\\s*--|--\\s*${escaped})$`).test(updateRaw))
+    step = -1;
+  else {
+    const by = new RegExp(`^${escaped}\\s*([+-])=\\s*(-?\\d+(?:\\.\\d+)?)$`).exec(updateRaw);
+    if (by)
+      step = (by[1] === "+" ? 1 : -1) * Number(by[2]);
+  }
+  if (step === null || !Number.isFinite(step) || step === 0)
+    return null;
+  const from = Number(init[2]);
+  const to = Number(cond[2]);
+  const op = cond[1];
+  if (!Number.isFinite(from) || !Number.isFinite(to))
+    return null;
+  const compare = (value2) => op === "<" ? value2 < to : op === "<=" ? value2 <= to : op === ">" ? value2 > to : value2 >= to;
+  if (!compare(from))
+    return 0;
+  if (step > 0 && op.startsWith(">") || step < 0 && op.startsWith("<"))
+    return null;
+  if (Number.isSafeInteger(from) && Number.isSafeInteger(to) && Number.isSafeInteger(step)) {
+    const distance = step > 0 ? to - from : from - to;
+    if (!Number.isSafeInteger(distance) || distance < 0)
+      return null;
+    const stride = Math.abs(step);
+    const count2 = op === "<" || op === ">" ? Math.ceil(distance / stride) : Math.floor(distance / stride) + 1;
+    return Number.isSafeInteger(count2) ? count2 : null;
+  }
+  let value = from;
+  let count = 0;
+  while (compare(value)) {
+    if (++count > 1e6) {
+      const distance = step > 0 ? to - from : from - to;
+      const stride = Math.abs(step);
+      const estimated = op === "<" || op === ">" ? Math.ceil(distance / stride) : Math.floor(distance / stride) + 1;
+      return Number.isSafeInteger(estimated) && estimated >= 0 ? estimated : null;
+    }
+    const next = value + step;
+    if (Object.is(next, value) || !Number.isFinite(next))
+      return null;
+    value = next;
+  }
+  return count;
+}
+function loopSites(html) {
+  const out = [];
+  const doWhileTrailers = new Set;
+  const doRe = /\bdo\b/g;
+  let dm;
+  while (dm = doRe.exec(html)) {
+    const bodyEnd = statementEnd(html, dm.index + dm[0].length);
+    const trailer = skipSpace(html, bodyEnd);
+    if (/^while\b/.test(html.slice(trailer)))
+      doWhileTrailers.add(trailer);
+  }
+  const re = /\b(for|while)\s*\(/g;
+  let m;
+  while (m = re.exec(html)) {
+    if (m[1] === "while" && doWhileTrailers.has(m.index))
+      continue;
+    const open2 = m.index + m[0].lastIndexOf("(");
+    const close = closeParen(html, open2);
+    if (close < 0)
+      continue;
+    let at = close + 1;
+    while (at < html.length && /\s/.test(html[at]))
+      at++;
+    let bodyStart = at;
+    let bodyEnd;
+    if (html[at] === "{") {
+      const body = braceBlock(html, at);
+      bodyStart = at + 1;
+      bodyEnd = bodyStart + body.length;
+    } else
+      bodyEnd = statementEnd(html, at);
+    const kind = m[1];
+    const header = html.slice(open2 + 1, close);
+    out.push({
+      kind,
+      bodyStart,
+      bodyEnd,
+      count: kind === "for" ? numericForCount(header) : null,
+      header
+    });
+  }
+  return out;
+}
+function namedFunctionSites(code) {
+  const out = [];
+  const invocationAfter = (declStart, bodyEnd, expression) => {
+    let before = declStart - 1;
+    while (before >= 0 && /\s/.test(code[before]))
+      before--;
+    const expressionContext = expression || before >= 0 && /[(!=,:+\-~?]/.test(code[before]);
+    let after = bodyEnd + 1;
+    while (after < code.length && /\s/.test(code[after]))
+      after++;
+    if (code[after] === "(")
+      return expressionContext;
+    if (code[before] !== "(")
+      return false;
+    let groupingCount = 0;
+    let beforeOpen = before;
+    while (beforeOpen >= 0 && code[beforeOpen] === "(") {
+      groupingCount++;
+      beforeOpen--;
+      while (beforeOpen >= 0 && /\s/.test(code[beforeOpen]))
+        beforeOpen--;
+    }
+    if (beforeOpen >= 0 && /[\w$)\]]/.test(code[beforeOpen]))
+      return false;
+    for (let i = 0;i < groupingCount; i++) {
+      if (code[after] !== ")")
+        return false;
+      after = skipSpace(code, after + 1);
+    }
+    return expressionContext && code[after] === "(";
+  };
+  const patterns = [
+    {
+      re: /\b(?:var|let|const)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:(?:async\s+)?function\s*\*?\s*[\w$]*\s*\([^)]*\)|(?:async\s*)?(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>)\s*\{/g,
+      nameGroup: 1,
+      expression: true
+    },
+    {
+      re: /\b(?:async\s+)?function\s*\*?\s+([A-Za-z_$][\w$]*)\s*\([^)]*\)\s*\{/g,
+      nameGroup: 1,
+      expression: false
+    },
+    {
+      re: /\b(?:async\s+)?function\s*\*?\s*\([^)]*\)\s*\{/g,
+      nameGroup: null,
+      expression: true
+    },
+    {
+      re: /(?:async\s*)?(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>\s*\{/g,
+      nameGroup: null,
+      expression: true
+    }
+  ];
+  for (const { re, nameGroup, expression } of patterns) {
+    let m;
+    while (m = re.exec(code)) {
+      const open2 = m.index + m[0].lastIndexOf("{");
+      const paired = braceBlock(code, open2);
+      const bodyStart = open2 + 1;
+      const bodyEnd = bodyStart + paired.length;
+      if (out.some((fn) => fn.bodyStart === bodyStart))
+        continue;
+      const name = nameGroup === null ? null : m[nameGroup];
+      const signature = m[0].slice(0, m[0].lastIndexOf("{"));
+      const parenGroups = [...signature.matchAll(/\(([^()]*)\)/g)];
+      const singleArrow = /=\s*([A-Za-z_$][\w$]*)\s*=>\s*$/.exec(signature);
+      const rawParams = parenGroups.at(-1)?.[1] ?? singleArrow?.[1] ?? "";
+      const params = new Set(rawParams.split(",").map((part) => /^([A-Za-z_$][\w$]*)/.exec(part.trim())?.[1]).filter((name2) => Boolean(name2)));
+      out.push({
+        name,
+        declStart: m.index,
+        bodyStart,
+        bodyEnd,
+        body: paired,
+        params,
+        immediatelyInvoked: invocationAfter(m.index, bodyEnd, expression)
+      });
+    }
+  }
+  const functionRe = /\b(?:async\s+)?function\s*\*?\s*([A-Za-z_$][\w$]*)?\s*\(/g;
+  let fm;
+  while (fm = functionRe.exec(code)) {
+    const open2 = fm.index + fm[0].lastIndexOf("(");
+    const close = closeParen(code, open2);
+    if (close < 0)
+      continue;
+    let brace = close + 1;
+    while (brace < code.length && /\s/.test(code[brace]))
+      brace++;
+    if (code[brace] !== "{")
+      continue;
+    const paired = braceBlock(code, brace);
+    const bodyStart = brace + 1;
+    const bodyEnd = bodyStart + paired.length;
+    if (out.some((fn) => fn.bodyStart === bodyStart))
+      continue;
+    const prefix = code.slice(Math.max(0, fm.index - 160), fm.index);
+    const assigned = /\b(?:var|let|const)\s+([A-Za-z_$][\w$]*)\s*=\s*$/.exec(prefix);
+    const name = assigned?.[1] ?? fm[1] ?? null;
+    const params = new Set(code.slice(open2 + 1, close).split(",").map((part) => /^([A-Za-z_$][\w$]*)/.exec(part.trim())?.[1]).filter((param) => Boolean(param)));
+    out.push({
+      name,
+      declStart: fm.index,
+      bodyStart,
+      bodyEnd,
+      body: paired,
+      params,
+      immediatelyInvoked: invocationAfter(fm.index, bodyEnd, assigned !== null || fm[1] === undefined)
+    });
+  }
+  const arrowRe = /\b(?:var|let|const)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?\(/g;
+  let am;
+  while (am = arrowRe.exec(code)) {
+    const open2 = am.index + am[0].lastIndexOf("(");
+    const close = closeParen(code, open2);
+    if (close < 0)
+      continue;
+    let arrow = skipSpace(code, close + 1);
+    if (!code.startsWith("=>", arrow))
+      continue;
+    const brace = skipSpace(code, arrow + 2);
+    if (code[brace] !== "{")
+      continue;
+    const paired = braceBlock(code, brace);
+    const bodyStart = brace + 1;
+    const bodyEnd = bodyStart + paired.length;
+    if (out.some((fn) => fn.bodyStart === bodyStart))
+      continue;
+    const params = new Set(code.slice(open2 + 1, close).split(",").map((part) => /^([A-Za-z_$][\w$]*)/.exec(part.trim())?.[1]).filter((param) => Boolean(param)));
+    out.push({
+      name: am[1],
+      declStart: am.index,
+      bodyStart,
+      bodyEnd,
+      body: paired,
+      params,
+      immediatelyInvoked: invocationAfter(am.index, bodyEnd, true)
+    });
+  }
+  return out.sort((a, b) => a.declStart - b.declStart);
+}
+var CREATE_PRIMITIVE = /\b(?:(?:var|let|const)\s+)?([A-Za-z_$][\w$]*)\s*=(?!=)\s*document\s*\.\s*createElementNS\s*\(\s*[^,]+,\s*["']([A-Za-z][\w-]*)["']\s*\)/gi;
+function escapedIdent(name) {
+  return name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function appendedParent(body, elVar, baseAt, sameExecutionScope) {
+  const el = escapedIdent(elVar);
+  const appendRe = new RegExp(`\\b([A-Za-z_$][\\w$]*)\\s*\\.\\s*appendChild\\s*\\(\\s*${el}\\s*\\)`, "g");
+  let append;
+  while ((append = appendRe.exec(body)) && !sameExecutionScope(baseAt + append.index))
+    ;
+  if (!append)
+    return null;
+  const reassignRe = new RegExp(`\\b(?:(?:var|let|const)\\s+)?${el}\\s*=(?!=)`, "g");
+  let reassign;
+  while (reassign = reassignRe.exec(body)) {
+    if (reassign.index >= append.index)
+      break;
+    if (body[reassign.index - 1] === ".")
+      continue;
+    if (sameExecutionScope(baseAt + reassign.index))
+      return null;
+  }
+  return append[1];
+}
+function perElementDriven(html, body, elVar) {
+  const el = escapedIdent(elVar);
+  if (new RegExp(`\\bgsap\\s*\\.\\s*set\\s*\\(\\s*${el}\\b`).test(body))
+    return true;
+  if (new RegExp(`\\b[A-Za-z_$][\\w$]*\\s*\\.\\s*(?:to|from|fromTo)\\s*\\(\\s*${el}\\b`).test(body))
+    return true;
+  const pushes = new Set;
+  for (const pm of body.matchAll(new RegExp(`\\b([A-Za-z_$][\\w$]*)(?:\\s*\\[[^\\]]+\\])?\\s*\\.\\s*push\\s*\\(\\s*${el}\\s*\\)`, "g")))
+    pushes.add(pm[1]);
+  for (const arr of pushes) {
+    const a = escapedIdent(arr);
+    if (new RegExp(`\\b[A-Za-z_$][\\w$]*\\s*\\.\\s*(?:to|from|fromTo)\\s*\\(\\s*${a}(?:\\s*\\[[^\\]]+\\])?\\s*,`).test(html))
+      return true;
+  }
+  return false;
+}
+function detectPrimitiveLoops(html) {
+  const source = maskJsComments(scriptBodiesOnly(maskHtmlComments(html)));
+  const code = maskJsStrings(source);
+  const loops = loopSites(code);
+  const functions = namedFunctionSites(code);
+  const containingFunction = (at) => functions.filter((fn) => at >= fn.bodyStart && at < fn.bodyEnd).sort((a, b) => a.bodyEnd - a.bodyStart - (b.bodyEnd - b.bodyStart))[0] ?? null;
+  const functionOwner = (fn) => containingFunction(fn.declStart);
+  const hasOwnVariableBinding = (scope, name) => {
+    if (scope.params.has(name))
+      return true;
+    const re = new RegExp(`\\b(?:var|let|const|class)\\s+${escapedIdent(name)}\\b`, "g");
+    re.lastIndex = scope.bodyStart;
+    let binding;
+    while ((binding = re.exec(code)) && binding.index < scope.bodyEnd)
+      if (containingFunction(binding.index) === scope)
+        return true;
+    return false;
+  };
+  const resolveFunction = (name, at) => {
+    let scope = containingFunction(at);
+    while (scope) {
+      const local = functions.filter((fn) => fn.name === name && functionOwner(fn) === scope).sort((a, b) => b.declStart - a.declStart)[0];
+      if (local)
+        return local;
+      if (scope.name === name)
+        return scope;
+      if (hasOwnVariableBinding(scope, name))
+        return null;
+      scope = functionOwner(scope);
+    }
+    return functions.filter((fn) => fn.name === name && functionOwner(fn) === null).sort((a, b) => b.declStart - a.declStart)[0] ?? null;
+  };
+  const parentBindingScope = (fn, parent) => {
+    let scope = fn;
+    while (scope) {
+      if (hasOwnVariableBinding(scope, parent))
+        return scope;
+      scope = functionOwner(scope);
+    }
+    return null;
+  };
+  const freshParentDeclaration = (parent, before, scope) => {
+    const ident = escapedIdent(parent);
+    const re = new RegExp(`\\b(?:var|let|const)\\s+${ident}\\s*=\\s*(?:document\\s*\\.\\s*createElement(?:NS)?\\s*\\(|new\\b)`, "g");
+    re.lastIndex = scope?.bodyStart ?? 0;
+    let found = null;
+    let m;
+    while ((m = re.exec(code)) && m.index < before && (!scope || m.index < scope.bodyEnd))
+      if (containingFunction(m.index) === scope)
+        found = m.index;
+    return found;
+  };
+  const loopsForOneParent = (owned, freshAt) => freshAt === null ? owned : owned.filter((loop) => freshAt < loop.bodyStart || freshAt >= loop.bodyEnd);
+  const executionLoopsAt = (at) => {
+    const fn = containingFunction(at);
+    return loops.filter((loop) => {
+      if (at < loop.bodyStart || at >= loop.bodyEnd)
+        return false;
+      if (fn)
+        return loop.bodyStart >= fn.bodyStart && loop.bodyEnd <= fn.bodyEnd;
+      return containingFunction(loop.bodyStart) === null;
+    });
+  };
+  const loopProduct = (owned) => {
+    if (owned.some((loop) => loop.count === null))
+      return null;
+    let product = 1;
+    for (const loop of owned) {
+      product *= loop.count;
+      if (!Number.isSafeInteger(product))
+        return null;
+    }
+    return product;
+  };
+  const innermostLoopBody = (at, owned = executionLoopsAt(at)) => {
+    const loop = owned.sort((a, b) => a.bodyEnd - a.bodyStart - (b.bodyEnd - b.bodyStart))[0];
+    return loop ? code.slice(loop.bodyStart, loop.bodyEnd) : "";
+  };
+  const grouped = new Map;
+  const add = (tag, parent, count, driven, site, scope) => {
+    const key = `${scope}\x00${tag}\x00${parent}`;
+    const batch = grouped.get(key) ?? { tag, parent, count: 0, unknown: false, perElementDriven: false, sites: new Set };
+    if (count === null)
+      batch.unknown = true;
+    else {
+      batch.count += count;
+      if (!Number.isSafeInteger(batch.count))
+        batch.unknown = true;
+    }
+    batch.perElementDriven ||= driven;
+    batch.sites.add(site);
+    grouped.set(key, batch);
+  };
+  const creates = [];
+  CREATE_PRIMITIVE.lastIndex = 0;
+  let cm;
+  while (cm = CREATE_PRIMITIVE.exec(source)) {
+    if (!code[cm.index] || /\s/.test(code[cm.index]))
+      continue;
+    const tag = cm[2].toLowerCase();
+    if (!MERGEABLE_PRIMITIVES.has(tag))
+      continue;
+    const fn = containingFunction(cm.index);
+    const owned = executionLoopsAt(cm.index);
+    const nearest = owned.slice().sort((a, b) => a.bodyEnd - a.bodyStart - (b.bodyEnd - b.bodyStart))[0];
+    const bodyStart = nearest?.bodyStart ?? fn?.bodyStart ?? cm.index;
+    const body = nearest ? code.slice(nearest.bodyStart, nearest.bodyEnd) : fn?.body ?? "";
+    const tailStart = Math.max(0, cm.index - bodyStart) + cm[0].length;
+    const parent = appendedParent(body.slice(tailStart), cm[1], bodyStart + tailStart, (at) => containingFunction(at) === fn);
+    if (!parent)
+      continue;
+    creates.push({ at: cm.index, tag, elVar: cm[1], parent, fn, loops: owned });
+  }
+  const callsByFunction = new Map;
+  const pushCall = (fn, at) => {
+    const list = callsByFunction.get(fn.declStart) ?? [];
+    list.push({ at, loops: executionLoopsAt(at) });
+    callsByFunction.set(fn.declStart, list);
+  };
+  const functionNames = new Set(functions.map((fn) => fn.name).filter((name) => name !== null));
+  for (const call of code.matchAll(/\b([A-Za-z_$][\w$]*)\s*\(/g)) {
+    const name = call[1];
+    const at = call.index;
+    let before = at - 1;
+    while (before >= 0 && /\s/.test(code[before]))
+      before--;
+    if (NOT_A_CALL.has(name) || !functionNames.has(name) || code[before] === ".")
+      continue;
+    if (functions.some((fn) => fn.name === name && at >= fn.declStart && at < fn.bodyStart))
+      continue;
+    const target = resolveFunction(name, at);
+    if (target)
+      pushCall(target, at);
+  }
+  for (const fn of functions)
+    if (fn.immediatelyInvoked)
+      pushCall(fn, fn.bodyEnd);
+  for (const create of creates) {
+    if (!create.fn) {
+      if (create.loops.length === 0)
+        continue;
+      const nearest = create.loops.slice().sort((a, b) => a.bodyEnd - a.bodyStart - (b.bodyEnd - b.bodyStart))[0];
+      const body = innermostLoopBody(create.at, create.loops);
+      const freshAt = freshParentDeclaration(create.parent, create.at, null);
+      add(create.tag, create.parent, loopProduct(loopsForOneParent(create.loops, freshAt)), perElementDriven(code, body, create.elVar), `${nearest.kind} (${nearest.header.trim()})`, freshAt === null ? "shared-parent" : `fresh-parent:${freshAt}`);
+      continue;
+    }
+    const fnCalls = callsByFunction.get(create.fn.declStart) ?? [];
+    if (fnCalls.length === 0 && create.loops.length > 0) {
+      const nearest = create.loops.slice().sort((a, b) => a.bodyEnd - a.bodyStart - (b.bodyEnd - b.bodyStart))[0];
+      const boundParent = parentBindingScope(create.fn, create.parent);
+      const freshAt = freshParentDeclaration(create.parent, create.at, boundParent);
+      add(create.tag, create.parent, loopProduct(loopsForOneParent(create.loops, freshAt)), perElementDriven(code, innermostLoopBody(create.at, create.loops), create.elVar), `${nearest.kind} (${nearest.header.trim()})`, freshAt !== null ? `fresh-parent:${freshAt}` : boundParent ? `function:${boundParent.declStart}` : "shared-parent");
+    }
+    for (const call of fnCalls) {
+      if (create.loops.length === 0 && call.loops.length === 0)
+        continue;
+      const callerBody = innermostLoopBody(call.at, call.loops);
+      const boundParent = parentBindingScope(create.fn, create.parent);
+      const freshAt = freshParentDeclaration(create.parent, create.at, boundParent);
+      const oneParentInside = loopProduct(loopsForOneParent(create.loops, freshAt));
+      const oneParentOutside = loopProduct(loopsForOneParent(call.loops, freshAt));
+      const freshOwnedByFactory = freshAt !== null && boundParent === create.fn;
+      const count = freshOwnedByFactory ? oneParentInside : oneParentInside === null || oneParentOutside === null ? null : oneParentInside * oneParentOutside;
+      add(create.tag, create.parent, count, perElementDriven(code, `${create.fn.body}
+${callerBody}`, create.elVar), create.fn.name ? `factory ${create.fn.name}` : `IIFE @${create.fn.declStart}`, freshAt !== null ? `fresh-parent:${freshAt}` : boundParent ? `function:${boundParent.declStart}` : "shared-parent");
+    }
+  }
+  return [...grouped.values()].map((batch) => ({
+    tag: batch.tag,
+    parent: batch.parent,
+    count: batch.unknown ? null : batch.count,
+    perElementDriven: batch.perElementDriven,
+    site: [...batch.sites].join(" + ")
+  }));
+}
 function bodyWritesDom(html, body, hops, seen) {
   if (DOM_WRITE.test(body))
     return true;
@@ -9466,6 +10184,12 @@ function lintParticle(html, opts = {}) {
     else if (Number.isFinite(est) && est < slot)
       push("7-fill-slot", false, `时间线静态估长 ~${est}s，短于槽位包络 ${slot}s（铁律⑦：颗粒应占满坑位并终态驻留）——静态估算是**下界**（${skipped} 条调用因无法静态解析被跳过），仅供参考，最终以真渲染引擎逐帧为准`);
   }
+  for (const batch of detectPrimitiveLoops(html)) {
+    if (batch.perElementDriven || batch.count !== null && batch.count < PRIMITIVE_MERGE_MIN)
+      continue;
+    const amount = batch.count === null ? "条数未知（循环边界非数字字面量）" : `静态估算 ${batch.count} 个`;
+    push("8-primitive-merge", false, `${batch.site} 向同一父节点「${batch.parent}」循环生成 ${amount} <${batch.tag}>。` + "这里有一批可无损合并的重复图元：请按相同 stroke/fill 分档合并成单个 <path> 的多子路径；" + "合并后画面逐像素不变，属零成本改法。本项只提示写法形态，最终画面仍以真渲染出片为准");
+  }
   return { ok: !v.some((x) => x.fatal), violations: v, opaque, compositionId: cid };
 }