agentic-mermaid 0.4.1 → 0.5.3

package/dist/chunk-IVD4NXNE.js

@@ -1,615 +0,0 @@
-import {
-  BUILTIN_RESOURCE_MEDIA_TYPES,
-  RESOURCE_MANIFEST,
-  applyPngColorProfile,
-  graphemes,
-  inlineFontVarForRaster,
-  inspectPngDimensions,
-  omitPngOutputOptions,
-  pngNapiRuntimeProvenance,
-  prepareRenderInput,
-  prepareSvgForPngRasterization,
-  projectNativePngOutputPolicyInput,
-  renderPngGraphicalProjection,
-  snapshotHostBackendPolicy,
-  snapshotResourceManifest
-} from "./chunk-LCGBT32P.js";
-
-// src/agent/png.ts
-import { fileURLToPath } from "url";
-import { tmpdir as tmpdir2 } from "os";
-import { basename, dirname as dirname2, join as join4 } from "path";
-import { existsSync, mkdtempSync as mkdtempSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
-import { Resvg } from "@resvg/resvg-js";
-
-// src/agent/font-coverage.ts
-import { readdirSync, readFileSync, statSync } from "fs";
-import { join } from "path";
-
-// src/agent/font-coverage-core.ts
-import { decodeXML } from "entities";
-var CMAP = 1668112752;
-var TTCF = 1953784678;
-var OTTO = 1330926671;
-var TRUE = 1953658213;
-function parseFont(bytes) {
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  try {
-    if (view.getUint32(0) === TTCF) {
-      const faces = [];
-      for (let i = 0; i < view.getUint32(8); i++) faces.push(parseSfnt(view, view.getUint32(12 + i * 4)));
-      return faces.filter((face2) => face2.length > 0);
-    }
-    const face = parseSfnt(view, 0);
-    return face.length > 0 ? [face] : [];
-  } catch {
-    return [];
-  }
-}
-function parseSfnt(view, base) {
-  const version = view.getUint32(base);
-  if (version !== 65536 && version !== OTTO && version !== TRUE) return [];
-  const tables = view.getUint16(base + 4);
-  for (let i = 0; i < tables; i++) {
-    const record = base + 12 + i * 16;
-    if (view.getUint32(record) === CMAP) return parseCmap(view, view.getUint32(record + 8));
-  }
-  return [];
-}
-function parseCmap(view, offset) {
-  const lookups = [];
-  const count = view.getUint16(offset + 2);
-  for (let i = 0; i < count; i++) {
-    const record = offset + 4 + i * 8;
-    const platform = view.getUint16(record);
-    const encoding = view.getUint16(record + 2);
-    if (!(platform === 0 || platform === 3 && (encoding === 1 || encoding === 10))) continue;
-    const subtable = offset + view.getUint32(record + 4);
-    const format = view.getUint16(subtable);
-    if (format === 4) lookups.push(format4(view, subtable));
-    else if (format === 12) lookups.push(format12(view, subtable));
-    else if (format === 6) lookups.push(format6(view, subtable));
-    else if (format === 0) lookups.push(format0(view, subtable));
-  }
-  return lookups;
-}
-function format4(view, subtable) {
-  const count = view.getUint16(subtable + 6) / 2;
-  const ends = subtable + 14;
-  const starts = ends + count * 2 + 2;
-  const deltas = starts + count * 2;
-  const offsets = deltas + count * 2;
-  return { has(codepoint) {
-    if (codepoint > 65535) return false;
-    let low = 0, high = count - 1;
-    while (low < high) {
-      const mid = low + high >> 1;
-      if (view.getUint16(ends + mid * 2) < codepoint) low = mid + 1;
-      else high = mid;
-    }
-    if (view.getUint16(starts + low * 2) > codepoint || codepoint === 65535) return false;
-    const rangeOffset = view.getUint16(offsets + low * 2);
-    if (rangeOffset === 0) return (codepoint + view.getInt16(deltas + low * 2) & 65535) !== 0;
-    const glyphOffset = offsets + low * 2 + rangeOffset + (codepoint - view.getUint16(starts + low * 2)) * 2;
-    if (glyphOffset + 2 > view.byteLength) return false;
-    const glyph = view.getUint16(glyphOffset);
-    return glyph !== 0 && (glyph + view.getInt16(deltas + low * 2) & 65535) !== 0;
-  } };
-}
-function format12(view, subtable) {
-  const count = view.getUint32(subtable + 12);
-  const groups = subtable + 16;
-  return { has(codepoint) {
-    let low = 0, high = count - 1;
-    while (low <= high) {
-      const mid = low + high >> 1;
-      const at = groups + mid * 12;
-      if (codepoint < view.getUint32(at)) high = mid - 1;
-      else if (codepoint > view.getUint32(at + 4)) low = mid + 1;
-      else return view.getUint32(at + 8) + codepoint - view.getUint32(at) !== 0;
-    }
-    return false;
-  } };
-}
-function format6(view, subtable) {
-  const first = view.getUint16(subtable + 6);
-  const count = view.getUint16(subtable + 8);
-  return { has: (codepoint) => codepoint >= first && codepoint < first + count && view.getUint16(subtable + 10 + (codepoint - first) * 2) !== 0 };
-}
-function format0(view, subtable) {
-  return { has: (codepoint) => codepoint < 256 && view.getUint8(subtable + 6 + codepoint) !== 0 };
-}
-function extractSvgTextContent(svg) {
-  let text = "";
-  for (const match of svg.matchAll(/<text\b[^>]*>([\s\S]*?)<\/text>/g)) text += match[1].replace(/<[^>]*>/g, "");
-  return decodeXML(text);
-}
-function ignorable(codepoint) {
-  return codepoint <= 32 || codepoint === 127 || codepoint >= 8203 && codepoint <= 8207 || codepoint === 8232 || codepoint === 8233 || codepoint >= 65024 && codepoint <= 65039 || codepoint === 65279;
-}
-function script(codepoint) {
-  if (codepoint >= 11904 && codepoint <= 40959 || codepoint >= 44032 && codepoint <= 55295 || codepoint >= 63744 && codepoint <= 64255 || codepoint >= 131072 && codepoint <= 262143) return "CJK";
-  if (codepoint >= 9728 && codepoint <= 10175 || codepoint >= 126976 && codepoint <= 129791) return "emoji";
-  if (codepoint >= 1424 && codepoint <= 1535) return "Hebrew";
-  if (codepoint >= 1536 && codepoint <= 1919) return "Arabic";
-  if (codepoint >= 2304 && codepoint <= 2431) return "Devanagari";
-  return "other";
-}
-function findUncoveredScriptsFromBuffers(svg, fontBuffers) {
-  const faces = fontBuffers.flatMap(parseFont);
-  const byScript = /* @__PURE__ */ new Map();
-  for (const cluster of graphemes(extractSvgTextContent(svg))) {
-    const codepoints = [...cluster].map((char) => char.codePointAt(0)).filter((codepoint) => !ignorable(codepoint));
-    if (codepoints.length === 0) continue;
-    const oneFaceCovers = faces.some((face) => codepoints.every((codepoint) => face.some((lookup) => lookup.has(codepoint))));
-    const shapingUncertain = cluster.includes("\u200D") || /\p{Mark}/u.test(cluster);
-    if (oneFaceCovers && !shapingUncertain) continue;
-    for (const codepoint of codepoints) {
-      const bucket = byScript.get(script(codepoint)) ?? /* @__PURE__ */ new Set();
-      bucket.add(codepoint);
-      byScript.set(script(codepoint), bucket);
-    }
-  }
-  return [...byScript].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([name, values]) => ({
-    script: name,
-    chars: [...values].sort((a, b) => a - b).map((codepoint) => String.fromCodePoint(codepoint))
-  }));
-}
-
-// src/agent/font-coverage.ts
-var FONT_EXT = /\.(ttf|otf|ttc|otc)$/i;
-function fontFilesUnder(directory, depth = 4) {
-  if (depth < 0) return [];
-  let entries;
-  try {
-    entries = readdirSync(directory).sort();
-  } catch {
-    return [];
-  }
-  const files = [];
-  for (const entry of entries) {
-    const path = join(directory, entry);
-    try {
-      const stat = statSync(path);
-      if (stat.isDirectory()) files.push(...fontFilesUnder(path, depth - 1));
-      else if (FONT_EXT.test(entry)) files.push(path);
-    } catch {
-    }
-  }
-  return files;
-}
-function fontBuffersUnder(directories) {
-  const buffers = [];
-  for (const directory of directories) {
-    for (const file of fontFilesUnder(directory)) {
-      try {
-        buffers.push(new Uint8Array(readFileSync(file)));
-      } catch {
-      }
-    }
-  }
-  return buffers;
-}
-function findUncoveredScripts(svg, callerFontDirectories, verifiedFontBuffers) {
-  return findUncoveredScriptsFromBuffers(svg, [
-    ...verifiedFontBuffers,
-    ...fontBuffersUnder(callerFontDirectories)
-  ]);
-}
-
-// src/shared/png-font-warnings.ts
-function buildPngFontWarnings(uncovered, options = {}) {
-  return uncovered.map(({ script: script2, chars }) => {
-    const examples = chars.slice(0, 5).join(" ");
-    const uncertainty = options.systemFontsMayCover ? " They are absent from bundled/caller-provided fonts; an installed system font may cover them, so final shaping is machine-dependent." : " They may draw as tofu or fail to shape as one grapheme.";
-    return {
-      code: "PNG_FONT_COVERAGE",
-      script: script2,
-      chars: [...chars],
-      message: `no known loaded face covers ${chars.length} ${script2} character${chars.length === 1 ? "" : "s"} (${examples}) in one grapheme cluster.${uncertainty} Supply fontDirs (CLI: --font-dirs <dir>) with a face that covers the cluster.`
-    };
-  });
-}
-
-// src/node-resource-resolver.ts
-import { createHash } from "crypto";
-import {
-  closeSync,
-  constants as fsConstants,
-  fstatSync,
-  lstatSync,
-  openSync,
-  readSync,
-  realpathSync
-} from "fs";
-import { isAbsolute, join as join2, relative, sep } from "path";
-var ResourceResolutionError = class extends Error {
-  code;
-  resourceId;
-  constructor(code, resourceId, message) {
-    super(`${code}: ${message}`);
-    this.name = "ResourceResolutionError";
-    this.code = code;
-    this.resourceId = resourceId;
-  }
-};
-function errnoCode(error) {
-  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
-}
-function sha256(bytes) {
-  return createHash("sha256").update(bytes).digest("hex");
-}
-function openedResourceDescriptorPath(platform, fd) {
-  if (platform === "linux") return `/proc/self/fd/${fd}`;
-  if (platform === "darwin") return `/dev/fd/${fd}`;
-  return void 0;
-}
-var NodeResourceResolver = class {
-  #root;
-  #manifest;
-  #maxResourceBytes;
-  #mediaTypes;
-  #byId;
-  constructor(packageRoot, manifest, options = {}) {
-    let manifestSnapshot;
-    try {
-      manifestSnapshot = snapshotResourceManifest(manifest);
-    } catch (error) {
-      const detail = error instanceof Error ? error.message.replace(/^INVALID_RESOURCE_MANIFEST:\s*/, "") : String(error);
-      throw new ResourceResolutionError("INVALID_RESOURCE_MANIFEST", "resource-manifest", detail);
-    }
-    const maxResourceBytes = options.maxResourceBytes ?? 16 * 1024 * 1024;
-    if (!Number.isSafeInteger(maxResourceBytes) || maxResourceBytes <= 0) {
-      throw new ResourceResolutionError("INVALID_RESOURCE_MANIFEST", "resource-manifest", "maxResourceBytes must be a positive safe integer");
-    }
-    try {
-      this.#root = realpathSync(packageRoot);
-    } catch {
-      throw new ResourceResolutionError("RESOURCE_MISSING", "resource-manifest", `package root does not exist: ${packageRoot}`);
-    }
-    this.#manifest = manifestSnapshot;
-    this.#maxResourceBytes = maxResourceBytes;
-    this.#mediaTypes = Object.freeze({ ...options.mediaTypes ?? BUILTIN_RESOURCE_MEDIA_TYPES });
-    this.#byId = new Map(this.#manifest.resources.map((entry) => [entry.identity.id, entry]));
-  }
-  list() {
-    return this.#manifest.resources;
-  }
-  #securePath(entry, declaredPath, missingCode) {
-    const segments = declaredPath.split("/");
-    let candidate = this.#root;
-    for (const segment of segments) {
-      candidate = join2(candidate, segment);
-      let stat;
-      try {
-        stat = lstatSync(candidate);
-      } catch (error) {
-        if (errnoCode(error) === "ENOENT") {
-          throw new ResourceResolutionError(missingCode, entry.identity.id, `declared path is missing: ${declaredPath}`);
-        }
-        throw error;
-      }
-      if (stat.isSymbolicLink()) {
-        throw new ResourceResolutionError("RESOURCE_SYMLINK_REJECTED", entry.identity.id, `symlink component is forbidden: ${declaredPath}`);
-      }
-    }
-    const escaped = relative(this.#root, candidate);
-    if (escaped === ".." || escaped.startsWith(`..${sep}`) || isAbsolute(escaped)) {
-      throw new ResourceResolutionError("RESOURCE_PATH_ESCAPE", entry.identity.id, `path escapes package root: ${declaredPath}`);
-    }
-    return candidate;
-  }
-  #openSecureFile(entry, declaredPath, missingCode) {
-    const absolutePath = this.#securePath(entry, declaredPath, missingCode);
-    let fd;
-    try {
-      fd = openSync(absolutePath, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
-    } catch (error) {
-      const code = errnoCode(error);
-      if (code === "ENOENT") throw new ResourceResolutionError(missingCode, entry.identity.id, `declared path is missing: ${declaredPath}`);
-      if (code === "ELOOP") throw new ResourceResolutionError("RESOURCE_SYMLINK_REJECTED", entry.identity.id, `symlink component is forbidden: ${declaredPath}`);
-      throw error;
-    }
-    try {
-      const openedStat = fstatSync(fd);
-      if (!openedStat.isFile()) {
-        throw new ResourceResolutionError("RESOURCE_NOT_REGULAR", entry.identity.id, `resource is not a regular file: ${declaredPath}`);
-      }
-      const descriptorPath = openedResourceDescriptorPath(process.platform, fd);
-      if (descriptorPath) {
-        const openedPath = realpathSync(descriptorPath);
-        if (openedPath !== descriptorPath && !openedPath.startsWith(`${descriptorPath}${sep}`)) {
-          const escaped = relative(this.#root, openedPath);
-          if (escaped === ".." || escaped.startsWith(`..${sep}`) || isAbsolute(escaped)) {
-            throw new ResourceResolutionError("RESOURCE_PATH_ESCAPE", entry.identity.id, `opened file escapes package root: ${declaredPath}`);
-          }
-        }
-      }
-      const rootedPath = this.#securePath(entry, declaredPath, missingCode);
-      const rootedStat = lstatSync(rootedPath);
-      if (!rootedStat.isFile()) {
-        throw new ResourceResolutionError("RESOURCE_NOT_REGULAR", entry.identity.id, `resource is not a regular file: ${declaredPath}`);
-      }
-      if (openedStat.dev !== rootedStat.dev || openedStat.ino !== rootedStat.ino) {
-        throw new ResourceResolutionError("RESOURCE_PATH_ESCAPE", entry.identity.id, `opened file identity no longer matches the rooted path: ${declaredPath}`);
-      }
-      return fd;
-    } catch (error) {
-      closeSync(fd);
-      throw error;
-    }
-  }
-  resolve(resourceId) {
-    const entry = this.#byId.get(resourceId);
-    if (!entry) throw new ResourceResolutionError("UNKNOWN_RESOURCE", resourceId, `resource is not installed: ${resourceId}`);
-    if (entry.bytes > this.#maxResourceBytes) {
-      throw new ResourceResolutionError("RESOURCE_SIZE_LIMIT", resourceId, `${entry.bytes} exceeds the ${this.#maxResourceBytes}-byte host limit`);
-    }
-    const licenseFd = this.#openSecureFile(entry, entry.license.noticePath, "RESOURCE_LICENSE_NOTICE_MISSING");
-    closeSync(licenseFd);
-    const fd = this.#openSecureFile(entry, entry.path, "RESOURCE_MISSING");
-    let bytes;
-    try {
-      const before = fstatSync(fd);
-      if (before.size !== entry.bytes) {
-        throw new ResourceResolutionError("RESOURCE_SIZE_MISMATCH", resourceId, `declared ${entry.bytes} bytes but found ${before.size}`);
-      }
-      const bounded = new Uint8Array(entry.bytes + 1);
-      let read = 0;
-      while (read < bounded.byteLength) {
-        const count = readSync(fd, bounded, read, bounded.byteLength - read, null);
-        if (count === 0) break;
-        read += count;
-      }
-      const after = fstatSync(fd);
-      if (read !== entry.bytes || after.size !== entry.bytes) {
-        throw new ResourceResolutionError("RESOURCE_SIZE_MISMATCH", resourceId, `declared ${entry.bytes} bytes but securely read ${read}`);
-      }
-      bytes = bounded.slice(0, read);
-    } finally {
-      closeSync(fd);
-    }
-    const mediaType = this.#mediaTypes[entry.mediaType];
-    if (!mediaType || !mediaType(bytes)) {
-      throw new ResourceResolutionError("RESOURCE_MEDIA_TYPE_MISMATCH", resourceId, `resource bytes do not match ${entry.mediaType}`);
-    }
-    const actualDigest = sha256(bytes);
-    if (actualDigest !== entry.sha256) {
-      throw new ResourceResolutionError("RESOURCE_DIGEST_MISMATCH", resourceId, `expected ${entry.sha256}, received ${actualDigest}`);
-    }
-    const snapshot = bytes.slice();
-    return Object.freeze({
-      entry,
-      readBytes: () => snapshot.slice()
-    });
-  }
-  verifyInstalled() {
-    const resources = [];
-    const diagnostics = [];
-    for (const entry of this.#manifest.resources) {
-      try {
-        resources.push(this.resolve(entry.identity.id));
-      } catch (error) {
-        if (!entry.required && error instanceof ResourceResolutionError && error.code === "RESOURCE_MISSING") {
-          diagnostics.push(Object.freeze({
-            code: "OPTIONAL_RESOURCE_MISSING",
-            resourceId: entry.identity.id,
-            message: error.message
-          }));
-          continue;
-        }
-        throw error;
-      }
-    }
-    return Object.freeze({
-      resources: Object.freeze(resources),
-      diagnostics: Object.freeze(diagnostics)
-    });
-  }
-};
-
-// src/agent/embedded-font-resources.ts
-import { tmpdir } from "os";
-import { dirname, join as join3 } from "path";
-import { mkdirSync, mkdtempSync, readFileSync as readFileSync2, rmSync, writeFileSync } from "fs";
-var registeredFiles;
-function verifyEmbeddedFontResourceFiles(manifest, files) {
-  const snapshot = snapshotResourceManifest(manifest);
-  const pathOwners = /* @__PURE__ */ new Map();
-  for (const entry of snapshot.resources) {
-    pathOwners.set(entry.path, { resourceId: entry.identity.id, missingCode: "RESOURCE_MISSING" });
-    if (!pathOwners.has(entry.license.noticePath)) {
-      pathOwners.set(entry.license.noticePath, {
-        resourceId: entry.identity.id,
-        missingCode: "RESOURCE_LICENSE_NOTICE_MISSING"
-      });
-    }
-  }
-  const root = mkdtempSync(join3(tmpdir(), "agentic-mermaid-embedded-resources-"));
-  try {
-    const materialized = /* @__PURE__ */ new Set();
-    for (const file of files) {
-      const owner = pathOwners.get(file.manifestPath);
-      if (!owner) {
-        throw new ResourceResolutionError(
-          "UNKNOWN_RESOURCE",
-          file.manifestPath,
-          `embedded path is not declared by the font resource manifest: ${file.manifestPath}`
-        );
-      }
-      if (materialized.has(file.manifestPath)) {
-        throw new ResourceResolutionError(
-          "INVALID_RESOURCE_MANIFEST",
-          owner.resourceId,
-          `duplicate embedded path: ${file.manifestPath}`
-        );
-      }
-      let bytes;
-      try {
-        bytes = readFileSync2(file.embeddedPath);
-      } catch {
-        throw new ResourceResolutionError(
-          owner.missingCode,
-          owner.resourceId,
-          `embedded source is unavailable for declared path: ${file.manifestPath}`
-        );
-      }
-      const target = join3(root, file.manifestPath);
-      mkdirSync(dirname(target), { recursive: true, mode: 448 });
-      writeFileSync(target, bytes, { flag: "wx", mode: 256 });
-      materialized.add(file.manifestPath);
-    }
-    return new NodeResourceResolver(root, snapshot).verifyInstalled();
-  } finally {
-    try {
-      rmSync(root, { recursive: true, force: true });
-    } catch {
-    }
-  }
-}
-function verifyRegisteredEmbeddedFontResources(manifest) {
-  return registeredFiles ? verifyEmbeddedFontResourceFiles(manifest, registeredFiles) : void 0;
-}
-
-// src/agent/png.ts
-var cachedBundledFonts;
-var cleanupRegistered = false;
-function materializeVerifiedFontSnapshot(resources) {
-  const snapshotDirectory = mkdtempSync2(join4(tmpdir2(), "agentic-mermaid-fonts-"));
-  try {
-    const buffers = resources.map((resource) => resource.readBytes());
-    const files = buffers.map((bytes, index) => {
-      const file = join4(snapshotDirectory, `${index}-${basename(resources[index].entry.path)}`);
-      writeFileSync2(file, bytes, { flag: "wx", mode: 256 });
-      return file;
-    });
-    return Object.freeze({
-      snapshotDirectory,
-      buffers: Object.freeze(buffers),
-      files: Object.freeze(files)
-    });
-  } catch (error) {
-    try {
-      rmSync2(snapshotDirectory, { recursive: true, force: true });
-    } catch {
-    }
-    throw error;
-  }
-}
-function resolveBundledFonts() {
-  if (cachedBundledFonts) return cachedBundledFonts;
-  const here = typeof import.meta.url === "string" ? fileURLToPath(import.meta.url) : __filename;
-  let dir = dirname2(here);
-  for (let i = 0; i < 6; i++) {
-    const candidate = join4(dir, "assets", "fonts");
-    if (existsSync(candidate)) {
-      const verified = new NodeResourceResolver(dir, RESOURCE_MANIFEST).verifyInstalled();
-      cachedBundledFonts = materializeVerifiedFontSnapshot(verified.resources);
-      break;
-    }
-    const parent = dirname2(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  if (!cachedBundledFonts) {
-    const embedded = verifyRegisteredEmbeddedFontResources(RESOURCE_MANIFEST);
-    if (embedded) cachedBundledFonts = materializeVerifiedFontSnapshot(embedded.resources);
-  }
-  if (!cachedBundledFonts) throw new Error("RESOURCE_MISSING: required bundled font manifest could not be located");
-  if (!cleanupRegistered) {
-    cleanupRegistered = true;
-    process.once("exit", () => {
-      try {
-        if (cachedBundledFonts) rmSync2(cachedBundledFonts.snapshotDirectory, { recursive: true, force: true });
-      } catch {
-      }
-    });
-  }
-  return cachedBundledFonts;
-}
-function renderMermaidPNG(input, opts = {}) {
-  return renderMermaidPNGWithReceipt(input, opts).png;
-}
-function renderMermaidPNGWithReceipt(input, opts = {}) {
-  return renderMermaidPNGWithReceiptForHost(input, opts, {});
-}
-function createMermaidPNGRenderer(hostOptions = {}) {
-  const backendPolicy = snapshotHostBackendPolicy(hostOptions.backendPolicy);
-  const host = Object.freeze({ ...backendPolicy ? { backendPolicy } : {} });
-  return Object.freeze({
-    renderMermaidPNG(input, opts = {}) {
-      return renderMermaidPNGWithReceiptForHost(input, opts, host).png;
-    },
-    renderMermaidPNGWithReceipt(input, opts = {}) {
-      return renderMermaidPNGWithReceiptForHost(input, opts, host);
-    }
-  });
-}
-function renderMermaidPNGWithReceiptForHost(input, opts, hostOptions) {
-  const preparedInput = prepareRenderInput(input);
-  const source = preparedInput.source;
-  const onWarning = opts.onWarning;
-  if (onWarning !== void 0 && typeof onWarning !== "function") {
-    throw new TypeError("PNG onWarning must be a function");
-  }
-  const outputOptions = projectNativePngOutputPolicyInput(opts);
-  const renderOptions = omitPngOutputOptions(opts);
-  const graphical = renderPngGraphicalProjection(
-    source,
-    renderOptions,
-    outputOptions,
-    { backendPolicy: hostOptions.backendPolicy, expectedFamilyId: preparedInput.expectedFamilyId }
-  );
-  const outputPolicy = graphical.outputPolicy;
-  const svg = prepareSvgForPngRasterization(
-    inlineFontVarForRaster(graphical.svg),
-    graphical.rasterDimensions
-  );
-  const bundledFonts = resolveBundledFonts();
-  const emit = onWarning ?? ((w) => process.stderr.write(`agentic-mermaid renderMermaidPNG: warning ${w.code}: ${w.message}
-`));
-  for (const warning of buildPngFontWarnings(findUncoveredScripts(
-    svg,
-    outputPolicy.fonts.callerDirectories,
-    bundledFonts.buffers
-  ), { systemFontsMayCover: outputPolicy.fonts.loadSystemFonts })) emit(warning);
-  const resvgOpts = {
-    background: graphical.rasterBackground,
-    // The shared contract already projected and pinned exact integer root
-    // dimensions. Rendering at zoom 1 avoids resvg-specific ratio rounding.
-    fitTo: { mode: "zoom", value: 1 },
-    font: {
-      loadSystemFonts: outputPolicy.fonts.loadSystemFonts,
-      // These private files were materialized from the exact verified byte
-      // snapshots. Explicit caller directories remain a host-controlled input.
-      fontFiles: [...bundledFonts.files],
-      fontDirs: [...outputPolicy.fonts.callerDirectories],
-      // Inter is the metrics font: src/text-metrics.ts is calibrated for it
-      // and the SVG @import requests it, so rasterizing with anything else
-      // (DejaVu is ~14% wider) pushes long labels outside their measured
-      // boxes. resvg falls back per-glyph across every loaded font, so
-      // DejaVu still covers glyphs Inter lacks (arrows, math, Armenian, …).
-      defaultFontFamily: outputPolicy.fonts.defaultFamily
-    }
-  };
-  const resvg = new Resvg(svg, resvgOpts);
-  const png = applyPngColorProfile(resvg.render().asPng());
-  const actualDimensions = inspectPngDimensions(png);
-  if (actualDimensions.width !== graphical.rasterDimensions.width || actualDimensions.height !== graphical.rasterDimensions.height) {
-    throw new Error(
-      `native PNG rasterizer returned ${actualDimensions.width}\xD7${actualDimensions.height}; expected ${graphical.rasterDimensions.width}\xD7${graphical.rasterDimensions.height}`
-    );
-  }
-  return {
-    png: new Uint8Array(png.buffer, png.byteOffset, png.byteLength),
-    receipt: graphical.receipt,
-    runtime: pngNapiRuntimeProvenance(outputPolicy.fonts)
-  };
-}
-
-export {
-  renderMermaidPNG,
-  renderMermaidPNGWithReceipt,
-  createMermaidPNGRenderer
-};
-//# sourceMappingURL=chunk-IVD4NXNE.js.map

package/dist/chunk-JDMRPUAG.js

@@ -1,37 +0,0 @@
-import {
-  AsciiWidthError,
-  MermaidFamilyDetectionError
-} from "./chunk-LCGBT32P.js";
-
-// src/render-error-diagnostic.ts
-function projectKnownRenderErrorDiagnostic(error) {
-  if (error instanceof MermaidFamilyDetectionError) {
-    return {
-      code: error.code,
-      message: error.message,
-      line: error.line,
-      preservation: error.preservation,
-      help: error.help
-    };
-  }
-  if (error instanceof AsciiWidthError) {
-    return {
-      code: error.code,
-      message: error.message,
-      requestedWidth: error.requestedWidth,
-      requiredWidth: error.requiredWidth,
-      family: error.family,
-      reason: error.reason
-    };
-  }
-  return void 0;
-}
-function projectRenderErrorDiagnostic(error) {
-  return projectKnownRenderErrorDiagnostic(error) ?? { code: "RENDER_FAILED", message: "Rendering failed" };
-}
-
-export {
-  projectKnownRenderErrorDiagnostic,
-  projectRenderErrorDiagnostic
-};
-//# sourceMappingURL=chunk-JDMRPUAG.js.map