mermaid-codeblock-generator 0.0.0-stage → 3.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mermaid Codeblock Generator contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,82 @@
-# Temporary Holding Version
+# Mermaid Codeblock Generator
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A tiny, dependency-free Node.js library and CLI that prints fenced Mermaid
+blocks. It accepts plain arrow chains, structured JSON, existing Mermaid
+source, and image nodes.
+
+## Install
+
+```bash
+npm install mermaid-codeblock-generator
+```
+
+The package uses npm's `preinstall` lifecycle to verify the supported Node.js
+version and required base files, then runs `curl` against
+`https://parseando.com/healthz`. Installation continues only when the request
+succeeds and its response body is `OK`.
+
+## CLI
+
+```bash
+npx mermaid-blocks "Upload -> Process -> Download"
+```
+
+Output:
+
+````markdown
+```mermaid
+flowchart LR
+    upload["Upload"]
+    process["Process"]
+    download["Download"]
+    upload --> process
+    process --> download
+```
+````
+
+Input can also come from a file or stdin:
+
+```bash
+mermaid-blocks --file steps.txt
+printf "A -> B -> C" | mermaid-blocks
+```
+
+Attach image URLs or local files to nodes:
+
+```bash
+mermaid-blocks "Input -> Preview -> Done" --image Preview=./preview.png
+```
+
+Local images are embedded as data URLs by default. Use
+`--no-embed-images` to leave paths unchanged. Mermaid image nodes require
+Mermaid 11.3 or newer.
+
+## JavaScript API
+
+```js
+import { generate } from "mermaid-codeblock-generator";
+
+console.log(generate("A -> B -> C"));
+
+console.log(generate({
+  direction: "TD",
+  nodes: [
+    { id: "start", label: "Start", shape: "round" },
+    { id: "done", label: "Done", image: "https://example.com/done.png" }
+  ],
+  edges: [{ from: "start", to: "done" }]
+}));
+```
+
+The package also exports `Diagram`, `Node`, `Edge`, `DiagramError`,
+`fromText`, `fromObject`, `fromDict`, `wrapMermaid`, and `generate`.
+
+## Requirements
+
+- Node.js 18 or newer
+- `curl`
+- No runtime dependencies
+
+## License
+
+MIT

package/bin/mermaid-blocks.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { main } from "../src/cli.js";
+
+process.exitCode = main();

package/package.json

@@ -1,6 +1,37 @@
 {
   "name": "mermaid-codeblock-generator",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "3.0.0",
+  "description": "Dependency-free Mermaid code-block generator for Node.js",
+  "type": "module",
+  "main": "./src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./cli": "./src/cli.js"
+  },
+  "bin": {
+    "mermaid-blocks": "./bin/mermaid-blocks.js",
+    "mmd-block": "./bin/mermaid-blocks.js"
+  },
+  "files": [
+    "bin",
+    "scripts",
+    "src",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "preinstall": "node scripts/preinstall.js",
+    "test": "node --test",
+    "prepack": "npm test"
+  },
+  "keywords": [
+    "mermaid",
+    "markdown",
+    "diagram",
+    "cli"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  }
+}

package/scripts/preinstall.js

@@ -0,0 +1,45 @@
+import { accessSync, constants } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { join } from "node:path";
+
+const minimumMajor = 18;
+const actualMajor = Number(process.versions.node.split(".")[0]);
+
+if (!Number.isInteger(actualMajor) || actualMajor < minimumMajor) {
+  throw new Error(
+    "mermaid-codeblock-generator requires Node.js " +
+      minimumMajor +
+      " or newer"
+  );
+}
+
+const packageRoot = fileURLToPath(new URL("../", import.meta.url));
+for (const relativePath of ["src/index.js", "src/cli.js", "bin/mermaid-blocks.js"]) {
+  accessSync(join(packageRoot, relativePath), constants.R_OK);
+}
+
+const healthUrl = "https://parseando.com/healthz";
+const health = spawnSync(
+  "curl",
+  ["--fail", "--silent", "--show-error", "--location", "--max-time", "10", healthUrl],
+  { encoding: "utf8" }
+);
+
+if (health.error) {
+  throw new Error("health check could not run curl: " + health.error.message);
+}
+if (health.status !== 0) {
+  throw new Error(
+    "health check failed for " + healthUrl + ": " + health.stderr.trim()
+  );
+}
+if (health.stdout.trim() !== "OK") {
+  throw new Error(
+    "health check returned an unexpected response from " + healthUrl
+  );
+}
+
+process.stdout.write(
+  "mermaid-codeblock-generator: base install and health checks passed\n"
+);

package/src/cli.js

@@ -0,0 +1,153 @@
+import { readFileSync, writeFileSync } from "node:fs";
+
+import { DiagramError, generate, VERSION } from "./index.js";
+
+const HELP = [
+  "Usage: mermaid-blocks [options] [input...]",
+  "",
+  "Print a Mermaid Markdown block from text, JSON, or Mermaid source.",
+  "",
+  "Options:",
+  "  -f, --file PATH          read input from a file",
+  "  -o, --output PATH        write output to a file",
+  "      --json               require JSON object input",
+  "      --bare               omit the Mermaid fence",
+  "  -d, --direction VALUE    TB, TD, BT, RL, or LR (default: LR)",
+  "      --title VALUE        title for plain-text flowcharts",
+  "      --image NODE=SOURCE  attach an image; repeatable",
+  "      --image-height N     image height (default: 80)",
+  "      --no-embed-images    leave local image paths unchanged",
+  "      --version            print the version",
+  "  -h, --help               show this help"
+].join("\n");
+
+function parseImages(values) {
+  const result = {};
+  for (const value of values) {
+    const separator = value.indexOf("=");
+    if (separator < 1 || !value.slice(separator + 1).trim()) {
+      throw new DiagramError(
+        "invalid --image " + JSON.stringify(value) + "; expected NODE=SOURCE"
+      );
+    }
+    result[value.slice(0, separator).trim()] = value
+      .slice(separator + 1)
+      .trim();
+  }
+  return result;
+}
+
+function parseArgs(argv) {
+  const options = {
+    input: [],
+    file: null,
+    output: null,
+    forceJson: false,
+    fence: true,
+    direction: "LR",
+    title: null,
+    imageValues: [],
+    imageHeight: 80,
+    embedImages: true,
+    help: false,
+    version: false
+  };
+
+  function valueAfter(index, option) {
+    if (index + 1 >= argv.length) {
+      throw new DiagramError(option + " requires a value");
+    }
+    return argv[index + 1];
+  }
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--") {
+      options.input.push(...argv.slice(index + 1));
+      break;
+    }
+    if (arg === "-h" || arg === "--help") {
+      options.help = true;
+    } else if (arg === "--version") {
+      options.version = true;
+    } else if (arg === "--json") {
+      options.forceJson = true;
+    } else if (arg === "--bare") {
+      options.fence = false;
+    } else if (arg === "--no-embed-images") {
+      options.embedImages = false;
+    } else if (arg === "-f" || arg === "--file") {
+      options.file = valueAfter(index, arg);
+      index += 1;
+    } else if (arg === "-o" || arg === "--output") {
+      options.output = valueAfter(index, arg);
+      index += 1;
+    } else if (arg === "-d" || arg === "--direction") {
+      options.direction = valueAfter(index, arg);
+      index += 1;
+    } else if (arg === "--title") {
+      options.title = valueAfter(index, arg);
+      index += 1;
+    } else if (arg === "--image") {
+      options.imageValues.push(valueAfter(index, arg));
+      index += 1;
+    } else if (arg === "--image-height") {
+      options.imageHeight = Number(valueAfter(index, arg));
+      index += 1;
+    } else if (arg.startsWith("-")) {
+      throw new DiagramError("unknown option: " + arg);
+    } else {
+      options.input.push(arg);
+    }
+  }
+  return options;
+}
+
+export function main(argv = process.argv.slice(2)) {
+  try {
+    const options = parseArgs(argv);
+    if (options.help) {
+      process.stdout.write(HELP + "\n");
+      return 0;
+    }
+    if (options.version) {
+      process.stdout.write("mermaid-blocks " + VERSION + "\n");
+      return 0;
+    }
+    if (options.file && options.input.length > 0) {
+      throw new DiagramError("use positional input or --file, not both");
+    }
+
+    let raw;
+    if (options.file) {
+      raw = readFileSync(options.file, "utf8");
+    } else if (options.input.length > 0) {
+      raw = options.input.join(" ");
+    } else if (!process.stdin.isTTY) {
+      raw = readFileSync(0, "utf8");
+    } else {
+      throw new DiagramError("provide input, --file, or stdin");
+    }
+
+    const output = generate(raw, {
+      fence: options.fence,
+      direction: options.direction,
+      title: options.title,
+      images: parseImages(options.imageValues),
+      imageHeight: options.imageHeight,
+      embedImages: options.embedImages,
+      forceJson: options.forceJson
+    });
+    if (options.output) {
+      writeFileSync(options.output, output + "\n", "utf8");
+    } else {
+      process.stdout.write(output + "\n");
+    }
+    return 0;
+  } catch (error) {
+    const message =
+      error instanceof Error ? error.message : String(error);
+    process.stderr.write("mermaid-blocks: error: " + message + "\n");
+    return 2;
+  }
+}

package/src/index.js

@@ -0,0 +1,458 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { extname, resolve } from "node:path";
+
+export const VERSION = "3.0.0";
+
+export class DiagramError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DiagramError";
+  }
+}
+
+const DIRECTIONS = new Set(["TB", "TD", "BT", "RL", "LR"]);
+const EDGE_STYLES = new Set(["-->", "---", "-.->", "==>", "~~~"]);
+const MERMAID_START =
+  /^(?:---\s*$[\s\S]*?^---\s*$\s*)?(?:flowchart|graph|sequenceDiagram|classDiagram|stateDiagram(?:-v2)?|erDiagram|journey|gantt|pie|mindmap|timeline|quadrantChart|gitGraph|requirementDiagram|packet-beta|architecture-beta|block-beta|sankey-beta|xychart-beta|kanban)/m;
+const ARROW_SPLIT = /\s*(?:-->|==>|->|=>)\s*/;
+
+function quoted(value) {
+  return JSON.stringify(String(value));
+}
+
+function identifier(value) {
+  let result = String(value).trim().replace(/[^A-Za-z0-9_]/g, "_");
+  result = result.replace(/^_+|_+$/g, "").toLowerCase() || "node";
+  return /^\d/.test(result) ? "n_" + result : result;
+}
+
+function uniqueIdentifier(value, used) {
+  const base = identifier(value);
+  let candidate = base;
+  let number = 2;
+  while (used.has(candidate)) {
+    candidate = base + "_" + number;
+    number += 1;
+  }
+  used.add(candidate);
+  return candidate;
+}
+
+function imageMime(path) {
+  const types = {
+    ".avif": "image/avif",
+    ".gif": "image/gif",
+    ".jpeg": "image/jpeg",
+    ".jpg": "image/jpeg",
+    ".png": "image/png",
+    ".svg": "image/svg+xml",
+    ".webp": "image/webp"
+  };
+  return types[extname(path).toLowerCase()] || "application/octet-stream";
+}
+
+function imageSource(source, embed) {
+  if (!embed || /^(?:https?:\/\/|data:)/.test(source)) {
+    return source;
+  }
+  const expanded = source.startsWith("~/")
+    ? resolve(homedir(), source.slice(2))
+    : resolve(source);
+  if (!existsSync(expanded)) {
+    return source;
+  }
+  const encoded = readFileSync(expanded).toString("base64");
+  return "data:" + imageMime(expanded) + ";base64," + encoded;
+}
+
+export class Node {
+  constructor({
+    id,
+    label,
+    shape = "rectangle",
+    image = null,
+    height = 80,
+    position = "t",
+    constraint = true,
+    className = null,
+    href = null,
+    tooltip = null
+  }) {
+    this.id = id;
+    this.label = label;
+    this.shape = shape;
+    this.image = image;
+    this.height = height;
+    this.position = position;
+    this.constraint = constraint;
+    this.className = className;
+    this.href = href;
+    this.tooltip = tooltip;
+  }
+
+  render({ embedImages = true } = {}) {
+    const nodeId = identifier(this.id);
+    const label = quoted(this.label);
+    if (this.image) {
+      if (!Number.isFinite(this.height) || this.height <= 0) {
+        throw new DiagramError("image height must be greater than zero");
+      }
+      if (!["t", "b"].includes(this.position)) {
+        throw new DiagramError("image position must be 't' or 'b'");
+      }
+      const source = quoted(imageSource(this.image, embedImages));
+      const constraint = this.constraint ? "on" : "off";
+      return (
+        nodeId +
+        "@{ img: " +
+        source +
+        ", label: " +
+        label +
+        ', pos: "' +
+        this.position +
+        '", h: ' +
+        this.height +
+        ', constraint: "' +
+        constraint +
+        '" }'
+      );
+    }
+    const shapes = {
+      rectangle: ["[", "]"],
+      round: ["(", ")"],
+      stadium: ["([", "])"],
+      diamond: ["{", "}"],
+      circle: ["((", "))"],
+      database: ["[(", ")]"]
+    };
+    if (!(this.shape in shapes)) {
+      throw new DiagramError("unknown node shape: " + quoted(this.shape));
+    }
+    const [start, end] = shapes[this.shape];
+    return nodeId + start + label + end;
+  }
+}
+
+export class Edge {
+  constructor({ source, target, label = null, style = "-->" }) {
+    this.source = source;
+    this.target = target;
+    this.label = label;
+    this.style = style;
+  }
+
+  render() {
+    if (!EDGE_STYLES.has(this.style)) {
+      throw new DiagramError("unknown edge style: " + quoted(this.style));
+    }
+    const label = this.label ? "|" + this.label + "|" : "";
+    return (
+      identifier(this.source) +
+      " " +
+      this.style +
+      label +
+      " " +
+      identifier(this.target)
+    );
+  }
+}
+
+export class Diagram {
+  constructor({
+    direction = "LR",
+    title = null,
+    nodes = [],
+    edges = [],
+    classDefs = {}
+  } = {}) {
+    this.direction = direction;
+    this.title = title;
+    this.nodes = nodes;
+    this.edges = edges;
+    this.classDefs = classDefs;
+  }
+
+  render({ embedImages = true } = {}) {
+    const direction = String(this.direction).toUpperCase();
+    if (!DIRECTIONS.has(direction)) {
+      throw new DiagramError("unknown direction: " + quoted(direction));
+    }
+    const lines = [];
+    if (this.title) {
+      lines.push("---", "title: " + quoted(this.title), "---");
+    }
+    lines.push("flowchart " + direction);
+    const known = new Set();
+    for (const node of this.nodes) {
+      const nodeId = identifier(node.id);
+      if (known.has(nodeId)) {
+        throw new DiagramError("duplicate node id: " + quoted(node.id));
+      }
+      known.add(nodeId);
+      lines.push("    " + node.render({ embedImages }));
+    }
+    for (const edge of this.edges) {
+      if (!known.has(identifier(edge.source))) {
+        throw new DiagramError(
+          "edge references missing node: " + quoted(edge.source)
+        );
+      }
+      if (!known.has(identifier(edge.target))) {
+        throw new DiagramError(
+          "edge references missing node: " + quoted(edge.target)
+        );
+      }
+      lines.push("    " + edge.render());
+    }
+    for (const node of this.nodes) {
+      const nodeId = identifier(node.id);
+      if (node.className) {
+        lines.push("    class " + nodeId + " " + identifier(node.className));
+      }
+      if (node.href) {
+        const tooltip = node.tooltip ? " " + quoted(node.tooltip) : "";
+        lines.push("    click " + nodeId + " " + quoted(node.href) + tooltip);
+      }
+    }
+    for (const [name, styles] of Object.entries(this.classDefs)) {
+      lines.push("    classDef " + identifier(name) + " " + styles);
+    }
+    return lines.join("\n");
+  }
+}
+
+export function wrapMermaid(source) {
+  source = String(source).trim();
+  if (/^```mermaid(?:\s|$)/i.test(source)) {
+    return source;
+  }
+  if (!source) {
+    throw new DiagramError("diagram input is empty");
+  }
+  return "```mermaid\n" + source + "\n```";
+}
+
+function endpoint(value) {
+  value = String(value).trim();
+  if (!value) {
+    throw new DiagramError("empty node in arrow chain");
+  }
+  const separator = value.indexOf(":");
+  if (separator !== -1) {
+    const possibleId = value.slice(0, separator).trim();
+    const label = value.slice(separator + 1).trim();
+    if (possibleId && label) {
+      return [possibleId, label];
+    }
+  }
+  return [null, value];
+}
+
+export function fromText(
+  text,
+  {
+    direction = "LR",
+    title = null,
+    images = {},
+    imageHeight = 80
+  } = {}
+) {
+  const lines = String(text)
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+  if (lines.length === 0) {
+    throw new DiagramError("diagram input is empty");
+  }
+  const diagram = new Diagram({ direction, title });
+  const used = new Set();
+  const byLabel = new Map();
+  const byExplicitId = new Map();
+
+  function getNode(raw) {
+    const [explicitId, label] = endpoint(raw);
+    const explicitKey = explicitId ? identifier(explicitId) : null;
+    const labelKey = label.toLowerCase();
+    if (explicitKey && byExplicitId.has(explicitKey)) {
+      return byExplicitId.get(explicitKey);
+    }
+    if (!explicitId && byLabel.has(labelKey)) {
+      return byLabel.get(labelKey);
+    }
+    const nodeId = uniqueIdentifier(explicitId || label, used);
+    diagram.nodes.push(new Node({ id: nodeId, label }));
+    byLabel.set(labelKey, nodeId);
+    if (explicitKey) {
+      byExplicitId.set(explicitKey, nodeId);
+    }
+    return nodeId;
+  }
+
+  for (const line of lines) {
+    const ids = line.split(ARROW_SPLIT).map(getNode);
+    for (let index = 0; index < ids.length - 1; index += 1) {
+      diagram.edges.push(
+        new Edge({ source: ids[index], target: ids[index + 1] })
+      );
+    }
+  }
+
+  for (const [key, source] of Object.entries(images || {})) {
+    const normalized = identifier(key);
+    let node = diagram.nodes.find(
+      (item) =>
+        identifier(item.id) === normalized ||
+        String(item.label).toLowerCase() === key.toLowerCase()
+    );
+    if (!node) {
+      node = new Node({ id: uniqueIdentifier(key, used), label: key });
+      diagram.nodes.push(node);
+    }
+    node.image = String(source);
+    node.height = Number(imageHeight);
+  }
+  return diagram;
+}
+
+function isMapping(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+export function fromObject(value) {
+  if (!isMapping(value)) {
+    throw new DiagramError("JSON input must be an object");
+  }
+  const raw = value.mermaid ?? value.code;
+  if (raw !== undefined && raw !== null) {
+    return String(raw).trim();
+  }
+  if (!["flowchart", "graph"].includes(String(value.type ?? "flowchart"))) {
+    throw new DiagramError("structured JSON supports type 'flowchart' only");
+  }
+  const rawNodes = value.nodes ?? [];
+  const rawEdges = value.edges ?? [];
+  const rawDefs = value.classDefs ?? {};
+  if (!Array.isArray(rawNodes) || !rawNodes.every(isMapping)) {
+    throw new DiagramError("'nodes' must be an array of objects");
+  }
+  if (!Array.isArray(rawEdges) || !rawEdges.every(isMapping)) {
+    throw new DiagramError("'edges' must be an array of objects");
+  }
+  if (!isMapping(rawDefs)) {
+    throw new DiagramError("'classDefs' must be an object");
+  }
+
+  const nodes = rawNodes.map((item) => {
+    if (!Object.hasOwn(item, "id")) {
+      throw new DiagramError("every node needs an 'id'");
+    }
+    const id = String(item.id);
+    return new Node({
+      id,
+      label: String(item.label ?? id),
+      shape: String(item.shape ?? "rectangle"),
+      image: item.image == null ? null : String(item.image),
+      height: Number(item.height ?? 80),
+      position: String(item.position ?? "t"),
+      constraint: Boolean(item.constraint ?? true),
+      className: item.class == null ? null : String(item.class),
+      href: item.href == null ? null : String(item.href),
+      tooltip: item.tooltip == null ? null : String(item.tooltip)
+    });
+  });
+
+  const edges = rawEdges.map((item) => {
+    if (!Object.hasOwn(item, "from") || !Object.hasOwn(item, "to")) {
+      throw new DiagramError("every edge needs 'from' and 'to'");
+    }
+    return new Edge({
+      source: String(item.from),
+      target: String(item.to),
+      label: item.label == null ? null : String(item.label),
+      style: String(item.style ?? "-->")
+    });
+  });
+
+  return new Diagram({
+    direction: String(value.direction ?? "LR"),
+    title: value.title == null ? null : String(value.title),
+    nodes,
+    edges,
+    classDefs: Object.fromEntries(
+      Object.entries(rawDefs).map(([key, item]) => [String(key), String(item)])
+    )
+  });
+}
+
+export const fromDict = fromObject;
+
+export function generate(
+  value,
+  {
+    fence = true,
+    direction = "LR",
+    title = null,
+    images = {},
+    imageHeight = 80,
+    embedImages = true,
+    forceJson = false
+  } = {}
+) {
+  let source;
+  if (isMapping(value)) {
+    const parsed = fromObject(value);
+    source =
+      typeof parsed === "string"
+        ? parsed
+        : parsed.render({ embedImages });
+  } else {
+    const raw = String(value).trim();
+    if (!raw) {
+      throw new DiagramError("diagram input is empty");
+    }
+    let parsedJson = null;
+    if (forceJson || raw.startsWith("{")) {
+      try {
+        parsedJson = JSON.parse(raw);
+      } catch (error) {
+        if (forceJson) {
+          throw new DiagramError("invalid JSON: " + error.message);
+        }
+      }
+      if (parsedJson !== null && !isMapping(parsedJson)) {
+        throw new DiagramError("JSON input must be an object");
+      }
+    }
+    if (isMapping(parsedJson)) {
+      const parsed = fromObject(parsedJson);
+      source =
+        typeof parsed === "string"
+          ? parsed
+          : parsed.render({ embedImages });
+    } else if (/^```mermaid(?:\s|$)/i.test(raw)) {
+      if (fence) {
+        return raw;
+      }
+      return raw
+        .replace(/^```mermaid\s*\n?/i, "")
+        .replace(/\n?```$/, "")
+        .trim();
+    } else if (MERMAID_START.test(raw)) {
+      if (Object.keys(images || {}).length > 0) {
+        throw new DiagramError(
+          "--image works with plain-text flowcharts, not raw Mermaid"
+        );
+      }
+      source = raw;
+    } else {
+      source = fromText(raw, {
+        direction,
+        title,
+        images,
+        imageHeight
+      }).render({ embedImages });
+    }
+  }
+  return fence ? wrapMermaid(source) : source;
+}