@hawkeyexl/manni 4.3.1 → 4.4.0

package/dist/chunk-H6FZ66XR.js

@@ -0,0 +1,634 @@
+#!/usr/bin/env node
+import {
+  URI_BASE_ID,
+  artifactLocation,
+  fileUri,
+  normalizeRoot
+} from "./chunk-GLP5PSXB.js";
+import {
+  LintError,
+  matchSections,
+  occurrenceRange
+} from "./chunk-CK7SKVHR.js";
+import {
+  REPORT_FORMAT_LIST,
+  renderJunit
+} from "./chunk-C6OH6CNF.js";
+import {
+  isErrorSeverity
+} from "./chunk-JVTNMVYU.js";
+import {
+  palette
+} from "./chunk-RNVYGWIC.js";
+import {
+  escapeWorkflowCommandMessage,
+  escapeWorkflowCommandProperty
+} from "./chunk-MNH7QO4Z.js";
+import {
+  package_default
+} from "./chunk-UZC7LDAQ.js";
+
+// src/lint/core/rule-id.ts
+var RULE_ID_PREFIX = "manni:lint";
+var TOOL_NAME = "manni";
+var STRUCTURE_JOB = "structure";
+function ruleName(type) {
+  return type.replace(/_error$/, "").replace(/_/g, "-");
+}
+function ruleId(type, job = STRUCTURE_JOB) {
+  return `${RULE_ID_PREFIX}/${job}/${ruleName(type)}`;
+}
+
+// src/lint/reporters/junit.ts
+var JUNIT_CLASSNAME = "manni.lint";
+function toFieldError(finding) {
+  return {
+    schema: RULE_ID_PREFIX,
+    instancePath: "",
+    message: finding.heading != null ? `${finding.heading}: ${finding.message}` : finding.message,
+    keyword: `${STRUCTURE_JOB}/${ruleName(finding.type)}`,
+    severity: finding.severity,
+    line: finding.position.start.line,
+    col: finding.position.start.column
+  };
+}
+function toValidationResults(run) {
+  return run.results.filter((result) => result.skipped == null).map((result) => ({
+    file: result.file,
+    // meta's `format` is the extractor that read the file. A lint result does
+    // not carry the parser that produced its tree, and no reporter reached
+    // through here reads the field, so it names the domain rather than
+    // inventing a format the run never recorded.
+    format: "lint",
+    // meta's invariant, not a count: `ok` is "no error-severity finding".
+    // Read as "no findings at all", a file whose only finding is a warning
+    // renders as a `✗` through meta's own pretty reporter - which is a
+    // legitimate consumer, since this function is exported - while lint's
+    // exit code says the run passed.
+    ok: !result.findings.some(isErrorSeverity),
+    schemas: [RULE_ID_PREFIX],
+    errors: result.findings.map(toFieldError)
+  }));
+}
+function renderJunit2(run) {
+  return renderJunit(toValidationResults(run), {
+    classname: JUNIT_CLASSNAME
+  });
+}
+
+// src/lint/reporters/sarif.ts
+var SARIF_VERSION = "2.1.0";
+var SARIF_SCHEMA = "https://docs.oasis-open.org/sarif/sarif/v2.1.0/errata01/os/schemas/sarif-schema-2.1.0.json";
+var INFORMATION_URI = "https://github.com/hawkeyexl/manni";
+var LEVELS = {
+  notice: "note",
+  warning: "warning",
+  error: "error"
+};
+var SKIP_DESCRIPTIONS = {
+  "no-template": "File was not linted: no template resolved for it.",
+  "unsupported-format": "File was not linted: no parser handles its format.",
+  unreadable: "File was not linted: it could not be read."
+};
+function region(position) {
+  return {
+    startLine: position.start.line,
+    startColumn: position.start.column,
+    endLine: position.end.line,
+    endColumn: position.end.column
+  };
+}
+function location(file, root, position) {
+  return {
+    physicalLocation: {
+      artifactLocation: artifactLocation(file, root),
+      region: position ? region(position) : void 0
+    }
+  };
+}
+function messageText(finding) {
+  return finding.heading != null ? `${finding.heading}: ${finding.message}` : finding.message;
+}
+function words(id) {
+  return id.split(/[^A-Za-z0-9]+/).filter(Boolean);
+}
+function pascalCase(id) {
+  return words(id).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+}
+function humanize(id) {
+  const text = words(id).join(" ");
+  return text.charAt(0).toUpperCase() + text.slice(1);
+}
+function buildRules(run) {
+  const indexOf = /* @__PURE__ */ new Map();
+  const order = [];
+  const severities = /* @__PURE__ */ new Map();
+  for (const result of run.results) {
+    for (const finding of result.findings) {
+      let seen = severities.get(finding.type);
+      if (!seen) {
+        seen = /* @__PURE__ */ new Set();
+        severities.set(finding.type, seen);
+        indexOf.set(finding.type, order.length);
+        order.push(finding.type);
+      }
+      seen.add(finding.severity);
+    }
+  }
+  const descriptors = order.map((type) => {
+    const rule = ruleName(type);
+    const descriptor = {
+      id: ruleId(type),
+      name: pascalCase(rule),
+      shortDescription: { text: humanize(rule) }
+    };
+    const [only, ...rest] = [...severities.get(type) ?? []];
+    if (only !== void 0 && rest.length === 0) {
+      descriptor.defaultConfiguration = { level: LEVELS[only] };
+    }
+    return descriptor;
+  });
+  return { descriptors, indexOf };
+}
+function toResult(finding, file, rules, root) {
+  return {
+    ruleId: ruleId(finding.type),
+    // Always populated in practice, since the index is built from these same
+    // findings. Omitted rather than faked if it ever is not: a wrong index
+    // points the alert at somebody else's rule, which is worse than none.
+    ruleIndex: rules.indexOf.get(finding.type),
+    level: LEVELS[finding.severity],
+    message: { text: messageText(finding) },
+    locations: [location(file, root, finding.position)],
+    properties: finding.heading != null ? { heading: finding.heading } : void 0
+  };
+}
+function buildSkips(run, root) {
+  const indexOf = /* @__PURE__ */ new Map();
+  const descriptors = [];
+  const notifications = [];
+  for (const result of run.results) {
+    const reason = result.skipped;
+    if (reason == null) continue;
+    let index = indexOf.get(reason);
+    if (index === void 0) {
+      index = descriptors.length;
+      indexOf.set(reason, index);
+      descriptors.push({
+        id: reason,
+        name: pascalCase(reason),
+        shortDescription: { text: SKIP_DESCRIPTIONS[reason] }
+      });
+    }
+    notifications.push({
+      // Declared in `tool.driver.notifications` and referenced by id *and*
+      // index, for the same reason results reference their rules both ways.
+      descriptor: { id: reason, index },
+      level: "note",
+      message: { text: skipMessage(result, reason) },
+      locations: [location(result.file, root)]
+    });
+  }
+  return { descriptors, notifications };
+}
+function skipMessage(result, reason) {
+  return result.reason ?? SKIP_DESCRIPTIONS[reason];
+}
+function renderSarif(run, opts = {}) {
+  const root = normalizeRoot(opts.root ?? process.cwd());
+  const rules = buildRules(run);
+  const skips = buildSkips(run, root);
+  const results = run.results.flatMap(
+    (result) => result.findings.map(
+      (finding) => toResult(finding, result.file, rules, root)
+    )
+  );
+  const driver = {
+    name: "manni-lint",
+    informationUri: INFORMATION_URI,
+    version: package_default.version,
+    // Emitted even when empty: results point into this array, so a consumer
+    // always looks here, and a stable shape is cheaper than a special case.
+    rules: rules.descriptors,
+    notifications: skips.descriptors.length > 0 ? skips.descriptors : void 0
+  };
+  const invocation = {
+    // Findings are the tool doing its job, not failing at it. This would only
+    // be false if manni lint itself could not run, and that path exits 2
+    // before any report is rendered.
+    executionSuccessful: true,
+    toolExecutionNotifications: skips.notifications.length > 0 ? skips.notifications : void 0
+  };
+  const log = {
+    $schema: SARIF_SCHEMA,
+    version: SARIF_VERSION,
+    runs: [
+      {
+        tool: { driver },
+        // Declared unconditionally: it is what makes every relative `uri` in
+        // this report mean anything, and a reader should not have to infer the
+        // base from whether some result happened to use it.
+        originalUriBaseIds: { [URI_BASE_ID]: { uri: fileUri(root) } },
+        invocations: [invocation],
+        results
+      }
+    ]
+  };
+  return JSON.stringify(log, null, 2);
+}
+
+// src/lint/reporters/alignment.ts
+var LABEL_WIDTH = 22;
+var ARROW = "\u2190";
+var ELLIPSIS = "\u2026";
+var TIMES = "\xD7";
+function pad(label) {
+  return label.length >= LABEL_WIDTH ? `${label} ` : label.padEnd(LABEL_WIDTH + 1);
+}
+function titleText(title) {
+  return title === null ? "(no heading)" : `"${title}"`;
+}
+function ruleLabel(rule) {
+  if (rule.id !== void 0) return rule.id;
+  if (typeof rule.heading === "string") return rule.heading;
+  return "(any)";
+}
+function pageHeading(tree) {
+  const [only] = tree.sections;
+  if (tree.sections.length === 1 && only && only.level <= 1) {
+    const text2 = only.title || null;
+    if (text2 === null) return { text: null, note: "no heading" };
+    const synthesized = only.titlePosition !== null && tree.frontmatterPosition !== null && only.titlePosition.start.offset === tree.frontmatterPosition.start.offset && only.titlePosition.end.offset === tree.frontmatterPosition.end.offset;
+    return { text: text2, note: synthesized ? "synthesized from frontmatter" : null };
+  }
+  const raw = tree.frontmatter?.["title"];
+  const text = typeof raw === "string" && raw !== "" ? raw : null;
+  return { text, note: text === null ? "no heading" : "synthesized from frontmatter" };
+}
+function pageSections(tree) {
+  const [only] = tree.sections;
+  if (tree.sections.length === 1 && only && only.level <= 1) return only.sections;
+  return tree.sections;
+}
+function matchedRow(depth, run) {
+  const head = run[0];
+  if (!head) return { depth, text: `${pad("(empty run)")}${ARROW} (missing)` };
+  const rule = head.rule;
+  const first = head.section;
+  const last = (run[run.length - 1] ?? head).section;
+  const label = run.length === 1 ? ruleLabel(rule) : `${ruleLabel(rule)} ${TIMES}${run.length}`;
+  const coerced = run.length === 1 && head.coerced ? " (coerced)" : "";
+  const arrow = run.length === 1 ? `${titleText(first.title || null)}${coerced}` : `${titleText(first.title || null)} ${ELLIPSIS} ${titleText(last.title || null)}`;
+  return { depth, text: `${pad(label)}${ARROW} ${arrow}` };
+}
+function absentLabel(rule) {
+  return occurrenceRange(rule).min > 0 ? "(missing)" : "(none)";
+}
+function missingRows(depth, rule) {
+  if (!rule.repeat) {
+    return [{ depth, text: `${pad(ruleLabel(rule))}${ARROW} ${absentLabel(rule)}` }];
+  }
+  const label = absentLabel(rule);
+  const rows = [{ depth, text: pad(rule.id ?? "(repeat)").trimEnd() }];
+  for (const member of rule.repeat) {
+    rows.push({ depth: depth + 1, text: `${pad(ruleLabel(member))}${ARROW} ${label}` });
+  }
+  return rows;
+}
+function insertMissing(matched, missing) {
+  const out = [];
+  let mi = 0;
+  for (const entry of matched) {
+    while (mi < missing.length) {
+      const next = missing[mi];
+      if (!next || entry.index !== null && next.index >= entry.index) break;
+      out.push(...next.rows);
+      mi++;
+    }
+    out.push(...entry.rows);
+  }
+  while (mi < missing.length) {
+    const next = missing[mi];
+    if (!next) break;
+    out.push(...next.rows);
+    mi++;
+  }
+  return out;
+}
+function alignLevel(rules, sections, parent, depth) {
+  if (rules === void 0) return [];
+  const { matches } = matchSections(sections, rules, { parent });
+  const ruleIndex = new Map(rules.map((r, i2) => [r, i2]));
+  const rootOf = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    if (rule.repeat) for (const member of rule.repeat) rootOf.set(member, rule);
+    else rootOf.set(rule, rule);
+  }
+  const rootOfRule = (rule) => rootOf.get(rule) ?? rule;
+  const matchedRoots = new Set(matches.map((m) => rootOfRule(m.rule)));
+  const bySection = new Map(matches.map((m) => [m.section, m]));
+  const matched = [];
+  let i = 0;
+  while (i < sections.length) {
+    const section = sections[i];
+    if (!section) break;
+    const match = bySection.get(section);
+    if (!match) {
+      matched.push({
+        index: null,
+        rows: [{ depth, text: `(unexpected) ${titleText(section.title || null)}` }]
+      });
+      i++;
+      continue;
+    }
+    const root = rootOfRule(match.rule);
+    if (root.repeat) {
+      const taken = [];
+      while (i < sections.length) {
+        const here = sections[i];
+        if (!here) break;
+        const next = bySection.get(here);
+        if (!next || rootOfRule(next.rule) !== root) break;
+        taken.push(next);
+        i++;
+      }
+      const rows2 = [{ depth, text: pad(root.id ?? "(repeat)").trimEnd() }];
+      let run2 = [];
+      const flushMember = () => {
+        if (run2.length === 0) return;
+        rows2.push(matchedRow(depth + 1, run2));
+        for (const m of run2) {
+          rows2.push(...alignLevel(m.rule.sections, m.section.sections, m.section, depth + 2));
+        }
+        run2 = [];
+      };
+      for (const m of taken) {
+        const first = run2[0];
+        if (first && first.rule !== m.rule) flushMember();
+        run2.push(m);
+      }
+      flushMember();
+      const takenMembers = new Set(taken.map((m) => m.rule));
+      for (const member of root.repeat) {
+        if (takenMembers.has(member)) continue;
+        rows2.push({ depth: depth + 1, text: `${pad(ruleLabel(member))}${ARROW} (missing)` });
+      }
+      matched.push({ index: ruleIndex.get(root) ?? null, rows: rows2 });
+      continue;
+    }
+    const run = [match];
+    i++;
+    while (i < sections.length) {
+      const here = sections[i];
+      if (!here) break;
+      const next = bySection.get(here);
+      if (!next || next.rule !== match.rule) break;
+      run.push(next);
+      i++;
+    }
+    const rows = [matchedRow(depth, run)];
+    for (const m of run) {
+      rows.push(...alignLevel(m.rule.sections, m.section.sections, m.section, depth + 1));
+    }
+    matched.push({ index: ruleIndex.get(match.rule) ?? null, rows });
+  }
+  const missing = rules.filter((rule) => !matchedRoots.has(rule)).map((rule) => {
+    const index = ruleIndex.get(rule);
+    if (index === void 0) {
+      throw new LintError("alignLevel: rule missing from its own index");
+    }
+    return { index, rows: missingRows(depth, rule) };
+  });
+  return insertMissing(matched, missing);
+}
+function explainAlignment(tree, template) {
+  const heading = pageHeading(tree);
+  const arrow = heading.text !== null ? `${titleText(heading.text)}${heading.note ? ` (${heading.note})` : ""}` : `(${heading.note ?? "no heading"})`;
+  const rows = [{ depth: 0, text: `${pad("(page)")}${ARROW} ${arrow}` }];
+  rows.push(...alignLevel(template.sections, pageSections(tree), null, 1));
+  return rows;
+}
+function formatAlignment(rows) {
+  return rows.map((row) => `${"  ".repeat(row.depth)}${row.text}`);
+}
+
+// src/lint/reporters/index.ts
+function plural(n, word) {
+  return `${n} ${word}${n === 1 ? "" : "s"}`;
+}
+function locate(finding) {
+  return `${finding.position.start.line}:${finding.position.start.column}`;
+}
+function describeFinding(finding) {
+  return finding.heading != null ? `${finding.heading}: ${finding.message}` : finding.message;
+}
+function levelPrefix(c, severity) {
+  if (severity === "error") return "";
+  return `${severity === "notice" ? c.dim("notice") : c.yellow("warning")} `;
+}
+function renderPretty(run, opts = {}) {
+  const c = palette(opts.color ?? false);
+  const lines = [];
+  let warnings = 0;
+  let notices = 0;
+  for (const result of run.results) {
+    if (result.skipped != null) {
+      const why = result.reason ?? result.skipped;
+      lines.push(`${c.yellow("-")} ${result.file}  ${c.dim(`skipped: ${why}`)}`);
+      continue;
+    }
+    if (result.success && result.findings.length === 0) {
+      lines.push(`${c.green("\u2713")} ${result.file}`);
+      continue;
+    }
+    const mark = result.success ? c.yellow("\u26A0") : c.red("\u2717");
+    lines.push(`${mark} ${result.file}`);
+    for (const finding of result.findings) {
+      if (finding.severity === "warning") warnings++;
+      else if (finding.severity === "notice") notices++;
+      lines.push(
+        `    ${c.dim(locate(finding))}  ${c.cyan(ruleId(finding.type))}  ${levelPrefix(c, finding.severity)}${describeFinding(finding)}`
+      );
+    }
+  }
+  const { checked, passed, failed, skipped } = run.summary;
+  const warningsText = warnings > 0 ? `, ${plural(warnings, "warning")}` : "";
+  const noticesText = notices > 0 ? `, ${plural(notices, "notice")}` : "";
+  const summary = `${plural(checked, "file")} checked, ${passed} passed, ${failed} failed, ${skipped} skipped${warningsText}${noticesText}`;
+  if (lines.length > 0) lines.push("");
+  lines.push(failed > 0 ? c.red(summary) : c.green(summary));
+  return lines.join("\n");
+}
+function renderJson(run) {
+  const results = run.results.map((result) => ({
+    file: result.file,
+    success: result.success,
+    errors: result.findings.map((finding) => ({
+      type: finding.type,
+      // Additive, and deliberately beside `type` rather than instead of it.
+      // `ruleId` is the family id every other reporter files this finding
+      // under; `tool` names which tool produced it, the question a second
+      // lint job makes worth asking.
+      ruleId: ruleId(finding.type),
+      tool: TOOL_NAME,
+      heading: finding.heading,
+      message: finding.message,
+      position: finding.position,
+      // Additive too, and the reason it has to be: `success: true` beside a
+      // non-empty `errors` array is exactly what a warning-only file looks
+      // like now that `success` means "no error-severity finding" rather than
+      // "no findings". Without this key a consumer has no way to tell that
+      // apart from an error the JSON shape simply forgot to fail on.
+      severity: finding.severity
+    })),
+    // Additive, and the one thing this shape could not say. A skipped file is
+    // `{success: false, errors: []}`, which is also what a failure whose
+    // finding vanished looks like - so a consumer counting failures counted a
+    // file nothing read as a file that was read and found wanting. Null rather
+    // than absent, because a key that comes and goes makes "not skipped" and
+    // "an older manni" the same observation. The prose `reason` stays off the
+    // wire; it is a diagnostic for the pretty and SARIF reports.
+    skipped: result.skipped ?? null
+  }));
+  return JSON.stringify(results, null, 2);
+}
+function renderGithub(run) {
+  const lines = [];
+  for (const result of run.results) {
+    for (const finding of result.findings) {
+      const params = [
+        `file=${escapeWorkflowCommandProperty(result.file)}`,
+        `line=${finding.position.start.line}`,
+        `col=${finding.position.start.column}`,
+        `title=${escapeWorkflowCommandProperty(ruleId(finding.type))}`
+      ];
+      const message = escapeWorkflowCommandMessage(describeFinding(finding));
+      lines.push(`::${finding.severity} ${params.join(",")}::${message}`);
+    }
+  }
+  return lines.join("\n");
+}
+function alignmentFor(result) {
+  const source = result.alignment;
+  if (!source) return null;
+  return formatAlignment(explainAlignment(source.tree, source.template));
+}
+function renderExplain(run, opts = {}) {
+  const c = palette(opts.color ?? false);
+  const lines = [];
+  for (const result of run.results) {
+    const chosen = result.template;
+    lines.push(`${chosen ? c.cyan("\u25B8") : c.dim("-")} ${c.bold(result.file)}`);
+    const steps = result.resolution?.steps ?? [];
+    if (steps.length === 0) {
+      lines.push(`    ${c.dim("(no resolution recorded)")}`);
+    }
+    for (const step of steps) {
+      const mark = step.ref ? c.green("\u2192") : c.dim("\xB7");
+      const label = step.ref ? c.bold(step.ref) : c.dim(step.detail);
+      const suffix = step.ref ? `  ${c.dim(step.detail)}` : "";
+      lines.push(`    ${mark} ${step.stage.padEnd(20)} ${label}${suffix}`);
+    }
+    const alignment = chosen ? alignmentFor(result) : null;
+    if (alignment && alignment.length > 0) {
+      lines.push(`    ${c.dim("alignment")}`);
+      for (const row of alignment) lines.push(`      ${row}`);
+    }
+    const cause = result.resolution?.cause;
+    if (cause === "unknown-type") {
+      const type = result.resolution?.unknownType ?? "(none recorded)";
+      const near = result.resolution?.suggestions ?? [];
+      const known = result.resolution?.knownTypes ?? [];
+      const hint = near.length ? `; did you mean ${near.join(", ")}?` : known.length ? `; known doctypes: ${known.join(", ")}` : "";
+      lines.push(`    ${c.red("\u2717")} no template serves type "${type}"${hint}`);
+    } else if (cause === "no-type") {
+      lines.push(`    ${c.dim("skipped: the page declares no type")}`);
+    }
+    lines.push("");
+  }
+  const routed = run.results.filter((r) => r.template != null).length;
+  lines.push(
+    `${run.results.length} file${run.results.length === 1 ? "" : "s"}, ${routed} routed, ${run.results.length - routed} unrouted`
+  );
+  return lines.join("\n");
+}
+function render(run, format, opts = {}) {
+  switch (format) {
+    case "json":
+      return renderJson(run);
+    case "github":
+      return renderGithub(run);
+    case "sarif":
+      return renderSarif(run, opts.root === void 0 ? {} : { root: opts.root });
+    case "junit":
+      return renderJunit2(run);
+    case "explain":
+      return renderExplain(run, opts);
+    case "pretty":
+      return renderPretty(run, opts);
+    default: {
+      const unreachable = format;
+      throw new LintError(
+        `Unknown report format ${JSON.stringify(unreachable)}. Use ${REPORT_FORMAT_LIST}.`
+      );
+    }
+  }
+}
+function templateLine(c, entry) {
+  const title = entry.title !== "" ? `  ${c.dim("\u2014")}  ${entry.title}` : "";
+  const types = entry.types.length > 0 ? entry.types.join(", ") : "(no types declared)";
+  return `  ${c.cyan(entry.id)}${title}  ${c.dim(`types: ${types}`)}  ${c.dim(`[${entry.source}]`)}`;
+}
+function renderTemplates(info, format, opts = {}) {
+  if (format === "json") return JSON.stringify(info, null, 2);
+  const c = palette(opts.color ?? false);
+  const lines = [c.bold("Templates:")];
+  if (info.templates.length === 0) {
+    lines.push(c.dim("  (none)"));
+  } else {
+    for (const entry of info.templates) lines.push(templateLine(c, entry));
+  }
+  return lines.join("\n");
+}
+function formatLine(c, entry) {
+  const head = `      ${c.cyan(entry.name)}  ${entry.label} (${entry.extensions.join(", ")})`;
+  if (entry.kinds.length === 0) return head;
+  return `${head}  ${c.dim(`kinds: ${entry.kinds.join(", ")}`)}`;
+}
+function renderTools(tools, format, opts = {}) {
+  if (format === "json") return JSON.stringify(tools, null, 2);
+  const c = palette(opts.color ?? false);
+  const lines = [c.bold("Jobs:")];
+  for (const entry of tools) {
+    const state = [
+      entry.configured ? "configured" : "not configured",
+      entry.available ? "available" : "unavailable"
+    ].join(", ");
+    const version = entry.version ?? "\u2014";
+    lines.push(
+      `  ${c.cyan(entry.job)}  tool: ${c.bold(entry.tool)} ${version}  [${state}]`
+    );
+    lines.push(`    config: ${c.dim(entry.config)}`);
+    lines.push(`    ${c.dim("formats:")}`);
+    for (const info of entry.formats) lines.push(formatLine(c, info));
+  }
+  return lines.join("\n");
+}
+
+export {
+  RULE_ID_PREFIX,
+  TOOL_NAME,
+  ruleName,
+  ruleId,
+  toValidationResults,
+  renderJunit2 as renderJunit,
+  renderSarif,
+  renderPretty,
+  renderJson,
+  renderGithub,
+  renderExplain,
+  render,
+  renderTemplates,
+  renderTools
+};
+//# sourceMappingURL=chunk-H6FZ66XR.js.map