ranui/dist/mermaid-parser.core-uIDZYuBu.js

A framework-agnostic Web Components UI library built on native custom elements, with TypeScript types, light/dark theming, SSR and PWA support.

import { C as c, S as l, _ as P, a as B, b, c as M, d as G, f as A, g as N, h as I, i as f, l as x, m as _, n as p, o as d, p as L, r as W, s as O, t as v, u, v as $, w as i, x as t, y as D } from "./chunk-KEIR6QF5-B2Op7cFH.js";
var F = class extends v {
  static {
    t(this, "ArchitectureTokenBuilder");
  }
  constructor() {
    super(["architecture"]);
  }
}, U = class extends p {
  static {
    t(this, "ArchitectureValueConverter");
  }
  runCustomConverter(r, e, a) {
    if (r.name === "ARCH_ICON") return e.replace(/[()]/g, "").trim();
    if (r.name === "ARCH_TEXT_ICON") return e.replace(/["()]/g, "");
    if (r.name === "ARCH_TITLE") {
      let n = e.replace(/^\[|]$/g, "").trim();
      return (n.startsWith('"') && n.endsWith('"') || n.startsWith("'") && n.endsWith("'")) && (n = n.slice(1, -1), n = n.replace(/\\"/g, '"').replace(/\\'/g, "'")), n.trim();
    }
  }
}, Y = { parser: {
  TokenBuilder: /* @__PURE__ */ t(() => new F(), "TokenBuilder"),
  ValueConverter: /* @__PURE__ */ t(() => new U(), "ValueConverter")
} };
function j(r = d) {
  const e = i(c(r), u), a = i(l({ shared: e }), W, Y);
  return e.ServiceRegistry.register(a), {
    shared: e,
    Architecture: a
  };
}
t(j, "createArchitectureServices");
var z = class extends v {
  static {
    t(this, "CynefinTokenBuilder");
  }
  constructor() {
    super(["cynefin-beta"]);
  }
}, H = { parser: {
  TokenBuilder: /* @__PURE__ */ t(() => new z(), "TokenBuilder"),
  ValueConverter: /* @__PURE__ */ t(() => new f(), "ValueConverter")
} };
function Q(r = d) {
  const e = i(c(r), u), a = i(l({ shared: e }), B, H);
  return e.ServiceRegistry.register(a), {
    shared: e,
    Cynefin: a
  };
}
t(Q, "createCynefinServices");
var K = class extends v {
  static {
    t(this, "EventModelingTokenBuilder");
  }
  constructor() {
    super(["eventmodeling"]);
  }
}, T = /* @__PURE__ */ new Set(["cmd", "command"]), S = /* @__PURE__ */ new Set(["evt", "event"]), g = /* @__PURE__ */ new Set(["rmo", "readmodel"]), C = /* @__PURE__ */ new Set(["pcr", "processor"]), k = /* @__PURE__ */ new Set(["ui"]);
function w(r) {
  const e = r.validation.EventModelingValidator, a = r.validation.ValidationRegistry;
  if (a) {
    const n = {
      EmTimeFrame: e.checkSourceFrameTypes.bind(e),
      EmResetFrame: e.checkSourceFrameTypes.bind(e)
    };
    a.register(n, e);
  }
}
t(w, "registerValidationChecks");
var X = class {
  static {
    t(this, "EventModelingValidator");
  }
  checkSourceFrameTypes(r, e) {
    r.sourceFrames.length !== 0 && (T.has(r.modelEntityType) ? this.validateSources(r, /* @__PURE__ */ new Set([...k, ...C]), "command", "ui or processor", e) : S.has(r.modelEntityType) ? this.validateSources(r, T, "event", "command", e) : g.has(r.modelEntityType) ? this.validateSources(r, S, "read model", "event", e) : C.has(r.modelEntityType) ? this.validateSources(r, g, "processor", "read model", e) : k.has(r.modelEntityType) && this.validateSources(r, g, "ui", "read model", e));
  }
  validateSources(r, e, a, n, s) {
    for (const m of r.sourceFrames) {
      const h = m.ref;
      h !== void 0 && !e.has(h.modelEntityType) && s("error", `A ${a} can only receive input from a ${n}, not from '${h.modelEntityType}'.`, {
        node: r,
        property: "sourceFrames"
      });
    }
  }
}, Z = {
  parser: {
    TokenBuilder: /* @__PURE__ */ t(() => new K(), "TokenBuilder"),
    ValueConverter: /* @__PURE__ */ t(() => new f(), "ValueConverter")
  },
  validation: { EventModelingValidator: /* @__PURE__ */ t(() => new X(), "EventModelingValidator") }
};
function q(r = d) {
  const e = i(c(r), u), a = i(l({ shared: e }), O, Z);
  return e.ServiceRegistry.register(a), w(a), {
    shared: e,
    EventModel: a
  };
}
t(q, "createEventModelingServices");
var J = class extends v {
  static {
    t(this, "GitGraphTokenBuilder");
  }
  constructor() {
    super(["gitGraph"]);
  }
}, ee = { parser: {
  TokenBuilder: /* @__PURE__ */ t(() => new J(), "TokenBuilder"),
  ValueConverter: /* @__PURE__ */ t(() => new f(), "ValueConverter")
} };
function re(r = d) {
  const e = i(c(r), u), a = i(l({ shared: e }), M, ee);
  return e.ServiceRegistry.register(a), {
    shared: e,
    GitGraph: a
  };
}
t(re, "createGitGraphServices");
var ae = class extends v {
  static {
    t(this, "InfoTokenBuilder");
  }
  constructor() {
    super(["info", "showInfo"]);
  }
}, te = { parser: {
  TokenBuilder: /* @__PURE__ */ t(() => new ae(), "TokenBuilder"),
  ValueConverter: /* @__PURE__ */ t(() => new f(), "ValueConverter")
} };
function ne(r = d) {
  const e = i(c(r), u), a = i(l({ shared: e }), x, te);
  return e.ServiceRegistry.register(a), {
    shared: e,
    Info: a
  };
}
t(ne, "createInfoServices");
var se = class extends v {
  static {
    t(this, "PacketTokenBuilder");
  }
  constructor() {
    super(["packet"]);
  }
}, ie = { parser: {
  TokenBuilder: /* @__PURE__ */ t(() => new se(), "TokenBuilder"),
  ValueConverter: /* @__PURE__ */ t(() => new f(), "ValueConverter")
} };
function oe(r = d) {
  const e = i(c(r), u), a = i(l({ shared: e }), G, ie);
  return e.ServiceRegistry.register(a), {
    shared: e,
    Packet: a
  };
}
t(oe, "createPacketServices");
var ce = class extends v {
  static {
    t(this, "PieTokenBuilder");
  }
  constructor() {
    super(["pie", "showData"]);
  }
}, le = class extends p {
  static {
    t(this, "PieValueConverter");
  }
  runCustomConverter(r, e, a) {
    if (r.name === "PIE_SECTION_LABEL")
      return e.replace(/"/g, "").trim();
  }
}, de = { parser: {
  TokenBuilder: /* @__PURE__ */ t(() => new ce(), "TokenBuilder"),
  ValueConverter: /* @__PURE__ */ t(() => new le(), "ValueConverter")
} };
function ue(r = d) {
  const e = i(c(r), u), a = i(l({ shared: e }), A, de);
  return e.ServiceRegistry.register(a), {
    shared: e,
    Pie: a
  };
}
t(ue, "createPieServices");
var ve = class extends v {
  static {
    t(this, "RadarTokenBuilder");
  }
  constructor() {
    super(["radar-beta"]);
  }
}, me = { parser: {
  TokenBuilder: /* @__PURE__ */ t(() => new ve(), "TokenBuilder"),
  ValueConverter: /* @__PURE__ */ t(() => new f(), "ValueConverter")
} };
function pe(r = d) {
  const e = i(c(r), u), a = i(l({ shared: e }), L, me);
  return e.ServiceRegistry.register(a), {
    shared: e,
    Radar: a
  };
}
t(pe, "createRadarServices");
var fe = class extends v {
  static {
    t(this, "RailroadTokenBuilder");
  }
  constructor() {
    super(["railroad-beta"]);
  }
}, R = /* @__PURE__ */ t((r) => {
  const e = r.slice(1, -1);
  let a = "";
  for (let n = 0; n < e.length; n++) {
    const s = e[n];
    if (s === "\\" && n + 1 < e.length) {
      n++;
      const m = e[n];
      switch (m) {
        case "n":
          a += `
`;
          break;
        case "r":
          a += "\r";
          break;
        case "t":
          a += "	";
          break;
        default:
          a += m;
      }
      continue;
    }
    a += s;
  }
  return a;
}, "decodeEscapedString"), he = class extends p {
  static {
    t(this, "RailroadValueConverter");
  }
  runConverter(r, e, a) {
    const n = super.runConverter(r, e, a);
    if (r.name === "TITLE" && typeof n == "string") {
      const s = n.trim();
      if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'")) return R(s);
    }
    return n;
  }
  runCustomConverter(r, e, a) {
    if (r.name === "RR_STRING") return R(e);
  }
}, ge = { parser: {
  TokenBuilder: /* @__PURE__ */ t(() => new fe(), "TokenBuilder"),
  ValueConverter: /* @__PURE__ */ t(() => new he(), "ValueConverter")
} };
function Te(r = d) {
  const e = i(c(r), u), a = i(l({ shared: e }), N, ge);
  return e.ServiceRegistry.register(a), {
    shared: e,
    Railroad: a
  };
}
t(Te, "createRailroadServices");
var Se = class extends v {
  static {
    t(this, "RailroadAbnfTokenBuilder");
  }
  constructor() {
    super(["railroad-abnf-beta"]);
  }
}, Ce = class extends p {
  static {
    t(this, "RailroadAbnfValueConverter");
  }
  runConverter(r, e, a) {
    const n = super.runConverter(r, e, a);
    if (r.name === "TITLE" && typeof n == "string") {
      const s = n.trim();
      if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'")) return s.slice(1, -1);
    }
    return n;
  }
  runCustomConverter(r, e, a) {
    if (r.name === "ABNF_STRING") return e.slice(1, -1);
  }
}, ke = { parser: {
  TokenBuilder: /* @__PURE__ */ t(() => new Se(), "TokenBuilder"),
  ValueConverter: /* @__PURE__ */ t(() => new Ce(), "ValueConverter")
} };
function Re(r = d) {
  const e = i(c(r), u), a = i(l({ shared: e }), _, ke);
  return e.ServiceRegistry.register(a), {
    shared: e,
    RailroadAbnf: a
  };
}
t(Re, "createRailroadAbnfServices");
var Ee = class extends v {
  static {
    t(this, "RailroadEbnfTokenBuilder");
  }
  constructor() {
    super(["railroad-ebnf-beta"]);
  }
}, E = /* @__PURE__ */ t((r) => {
  const e = r.slice(1, -1);
  let a = "";
  for (let n = 0; n < e.length; n++) {
    const s = e[n];
    if (s === "\\" && n + 1 < e.length) {
      n++;
      const m = e[n];
      switch (m) {
        case "n":
          a += `
`;
          break;
        case "r":
          a += "\r";
          break;
        case "t":
          a += "	";
          break;
        default:
          a += m;
      }
      continue;
    }
    a += s;
  }
  return a;
}, "decodeEscapedString"), ye = class extends p {
  static {
    t(this, "RailroadEbnfValueConverter");
  }
  runConverter(r, e, a) {
    const n = super.runConverter(r, e, a);
    if (r.name === "TITLE" && typeof n == "string") {
      const s = n.trim();
      if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'")) return E(s);
    }
    return n;
  }
  runCustomConverter(r, e, a) {
    if (r.name === "EBNF_STRING") return E(e);
    if (r.name === "EBNF_SPECIAL_SEQUENCE") return e.slice(1, -1).trim();
  }
}, we = { parser: {
  TokenBuilder: /* @__PURE__ */ t(() => new Ee(), "TokenBuilder"),
  ValueConverter: /* @__PURE__ */ t(() => new ye(), "ValueConverter")
} };
function Ve(r = d) {
  const e = i(c(r), u), a = i(l({ shared: e }), I, we);
  return e.ServiceRegistry.register(a), {
    shared: e,
    RailroadEbnf: a
  };
}
t(Ve, "createRailroadEbnfServices");
var Pe = class extends v {
  static {
    t(this, "RailroadPegTokenBuilder");
  }
  constructor() {
    super(["railroad-peg-beta"]);
  }
}, y = /* @__PURE__ */ t((r) => {
  const e = r.slice(1, -1);
  let a = "";
  for (let n = 0; n < e.length; n++) {
    const s = e[n];
    if (s === "\\" && n + 1 < e.length) {
      n++;
      const m = e[n];
      switch (m) {
        case "n":
          a += `
`;
          break;
        case "r":
          a += "\r";
          break;
        case "t":
          a += "	";
          break;
        default:
          a += m;
      }
      continue;
    }
    a += s;
  }
  return a;
}, "decodeEscapedString"), Be = class extends p {
  static {
    t(this, "RailroadPegValueConverter");
  }
  runConverter(r, e, a) {
    const n = super.runConverter(r, e, a);
    if (r.name === "TITLE" && typeof n == "string") {
      const s = n.trim();
      if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'")) return y(s);
    }
    return n;
  }
  runCustomConverter(r, e, a) {
    if (r.name === "PEG_STRING") return y(e);
  }
}, be = { parser: {
  TokenBuilder: /* @__PURE__ */ t(() => new Pe(), "TokenBuilder"),
  ValueConverter: /* @__PURE__ */ t(() => new Be(), "ValueConverter")
} };
function Me(r = d) {
  const e = i(c(r), u), a = i(l({ shared: e }), P, be);
  return e.ServiceRegistry.register(a), {
    shared: e,
    RailroadPeg: a
  };
}
t(Me, "createRailroadPegServices");
var Ge = class extends p {
  static {
    t(this, "TreeViewValueConverter");
  }
  runCustomConverter(r, e, a) {
    if (r.name === "INDENTATION") return e?.length || 0;
    if (r.name === "QUOTED_NAME") return e.substring(1, e.length - 1);
    if (r.name === "BARE_NAME") return e.replace(/[\t ]+$/, "");
    if (r.name === "CLASS_ANNOTATION") return e.trim().substring(3).trim();
    if (r.name === "ICON_ANNOTATION") {
      const n = e.trim();
      return n.substring(5, n.length - 1);
    }
    if (r.name === "DESC_ANNOTATION") return e.trim().substring(2).trim();
  }
}, Ae = class extends v {
  static {
    t(this, "TreeViewTokenBuilder");
  }
  constructor() {
    super(["treeView-beta"]);
  }
}, Ne = { parser: {
  TokenBuilder: /* @__PURE__ */ t(() => new Ae(), "TokenBuilder"),
  ValueConverter: /* @__PURE__ */ t(() => new Ge(), "ValueConverter")
} };
function Ie(r = d) {
  const e = i(c(r), u), a = i(l({ shared: e }), $, Ne);
  return e.ServiceRegistry.register(a), {
    shared: e,
    TreeView: a
  };
}
t(Ie, "createTreeViewServices");
var xe = class extends v {
  static {
    t(this, "TreemapTokenBuilder");
  }
  constructor() {
    super(["treemap"]);
  }
}, _e = /classDef\s+([A-Z_a-z]\w+)(?:\s+([^\n\r;]*))?;?/, Le = class extends p {
  static {
    t(this, "TreemapValueConverter");
  }
  runCustomConverter(r, e, a) {
    if (r.name === "NUMBER2") return parseFloat(e.replace(/,/g, ""));
    if (r.name === "SEPARATOR") return e.substring(1, e.length - 1);
    if (r.name === "STRING2") return e.substring(1, e.length - 1);
    if (r.name === "INDENTATION") return e.length;
    if (r.name === "ClassDef") {
      if (typeof e != "string") return e;
      const n = _e.exec(e);
      if (n) return {
        $type: "ClassDefStatement",
        className: n[1],
        styleText: n[2] || void 0
      };
    }
  }
};
function V(r) {
  const e = r.validation.TreemapValidator, a = r.validation.ValidationRegistry;
  if (a) {
    const n = { Treemap: e.checkSingleRoot.bind(e) };
    a.register(n, e);
  }
}
t(V, "registerValidationChecks");
var We = class {
  static {
    t(this, "TreemapValidator");
  }
  checkSingleRoot(r, e) {
    let a;
    for (const n of r.TreemapRows)
      n.item && (a === void 0 && n.indent === void 0 ? a = 0 : n.indent === void 0 ? e("error", "Multiple root nodes are not allowed in a treemap.", {
        node: n,
        property: "item"
      }) : a !== void 0 && a >= parseInt(n.indent, 10) && e("error", "Multiple root nodes are not allowed in a treemap.", {
        node: n,
        property: "item"
      }));
  }
}, Oe = {
  parser: {
    TokenBuilder: /* @__PURE__ */ t(() => new xe(), "TokenBuilder"),
    ValueConverter: /* @__PURE__ */ t(() => new Le(), "ValueConverter")
  },
  validation: { TreemapValidator: /* @__PURE__ */ t(() => new We(), "TreemapValidator") }
};
function $e(r = d) {
  const e = i(c(r), u), a = i(l({ shared: e }), D, Oe);
  return e.ServiceRegistry.register(a), V(a), {
    shared: e,
    Treemap: a
  };
}
t($e, "createTreemapServices");
var De = class extends p {
  static {
    t(this, "WardleyValueConverter");
  }
  runCustomConverter(r, e, a) {
    if (r.name.toUpperCase() === "LINK_LABEL")
      return e.substring(1).trim();
  }
}, Fe = { parser: { ValueConverter: /* @__PURE__ */ t(() => new De(), "ValueConverter") } };
function Ue(r = d) {
  const e = i(c(r), u), a = i(l({ shared: e }), b, Fe);
  return e.ServiceRegistry.register(a), {
    shared: e,
    Wardley: a
  };
}
t(Ue, "createWardleyServices");
var o = {}, Ye = {
  info: /* @__PURE__ */ t(async () => {
    const { createInfoServices: r } = await import("./info-DKCQHKI2-Df7h9MSE.js");
    o.info = r().Info.parser.LangiumParser;
  }, "info"),
  packet: /* @__PURE__ */ t(async () => {
    const { createPacketServices: r } = await import("./packet-7NZHBO7P-4PLslLZJ.js");
    o.packet = r().Packet.parser.LangiumParser;
  }, "packet"),
  pie: /* @__PURE__ */ t(async () => {
    const { createPieServices: r } = await import("./pie-RZYD4A2V-DBE9a8Kz.js");
    o.pie = r().Pie.parser.LangiumParser;
  }, "pie"),
  treeView: /* @__PURE__ */ t(async () => {
    const { createTreeViewServices: r } = await import("./treeView-QDETBFTQ-vTKOZls1.js");
    o.treeView = r().TreeView.parser.LangiumParser;
  }, "treeView"),
  architecture: /* @__PURE__ */ t(async () => {
    const { createArchitectureServices: r } = await import("./architecture-TIHT7OUA-pbFO1xSx.js");
    o.architecture = r().Architecture.parser.LangiumParser;
  }, "architecture"),
  gitGraph: /* @__PURE__ */ t(async () => {
    const { createGitGraphServices: r } = await import("./gitGraph-TEB2WS4Q-D6Ru11Cs.js");
    o.gitGraph = r().GitGraph.parser.LangiumParser;
  }, "gitGraph"),
  eventmodeling: /* @__PURE__ */ t(async () => {
    const { createEventModelingServices: r } = await import("./eventmodeling-45OFAUF4-DMpGs2yI.js");
    o.eventmodeling = r().EventModel.parser.LangiumParser;
  }, "eventmodeling"),
  radar: /* @__PURE__ */ t(async () => {
    const { createRadarServices: r } = await import("./radar-I7S5WNFK-DFTxtd_t.js");
    o.radar = r().Radar.parser.LangiumParser;
  }, "radar"),
  railroad: /* @__PURE__ */ t(async () => {
    const { createRailroadServices: r } = await import("./railroad-3IZDKUUU-DALJwv16.js");
    o.railroad = r().Railroad.parser.LangiumParser;
  }, "railroad"),
  railroadEbnf: /* @__PURE__ */ t(async () => {
    const { createRailroadEbnfServices: r } = await import("./railroad-ebnf-EBAXGLYW-s_1ZOb_9.js");
    o.railroadEbnf = r().RailroadEbnf.parser.LangiumParser;
  }, "railroadEbnf"),
  railroadAbnf: /* @__PURE__ */ t(async () => {
    const { createRailroadAbnfServices: r } = await import("./railroad-abnf-AHOZXSZD-CntW2udQ.js");
    o.railroadAbnf = r().RailroadAbnf.parser.LangiumParser;
  }, "railroadAbnf"),
  railroadPeg: /* @__PURE__ */ t(async () => {
    const { createRailroadPegServices: r } = await import("./railroad-peg-LSFZ7HO6-CaM5A0Ml.js");
    o.railroadPeg = r().RailroadPeg.parser.LangiumParser;
  }, "railroadPeg"),
  treemap: /* @__PURE__ */ t(async () => {
    const { createTreemapServices: r } = await import("./treemap-6X3UGDF4-Ddzv6Gqd.js");
    o.treemap = r().Treemap.parser.LangiumParser;
  }, "treemap"),
  wardley: /* @__PURE__ */ t(async () => {
    const { createWardleyServices: r } = await import("./wardley-OPB4EBWU-DBgFLc64.js");
    o.wardley = r().Wardley.parser.LangiumParser;
  }, "wardley"),
  cynefin: /* @__PURE__ */ t(async () => {
    const { createCynefinServices: r } = await import("./cynefin-VYW2F7L2-ALQKF7N6.js");
    o.cynefin = r().Cynefin.parser.LangiumParser;
  }, "cynefin")
};
async function je(r, e) {
  const a = Ye[r];
  if (!a) throw new Error(`Unknown diagram type: ${r}`);
  o[r] || await a();
  const n = o[r].parse(e);
  if (n.lexerErrors.length > 0 || n.parserErrors.length > 0) throw new ze(n);
  return n.value;
}
t(je, "parse");
var ze = class extends Error {
  constructor(r) {
    const e = r.lexerErrors.map((n) => `Lexer error on line ${n.line !== void 0 && !isNaN(n.line) ? n.line : "?"}, column ${n.column !== void 0 && !isNaN(n.column) ? n.column : "?"}: ${n.message}`).join(`
`), a = r.parserErrors.map((n) => `Parse error on line ${n.token.startLine !== void 0 && !isNaN(n.token.startLine) ? n.token.startLine : "?"}, column ${n.token.startColumn !== void 0 && !isNaN(n.token.startColumn) ? n.token.startColumn : "?"}: ${n.message}`).join(`
`);
    super(`Parsing failed: ${e} ${a}`), this.result = r;
  }
  static {
    t(this, "MermaidParseError");
  }
};
export {
  Q as A,
  te as C,
  Z as D,
  re as E,
  j as M,
  q as O,
  oe as S,
  ee as T,
  me as _,
  Oe as a,
  ue as b,
  Ie as c,
  we as d,
  Ve as f,
  Te as g,
  ge as h,
  Ue as i,
  Y as j,
  H as k,
  be as l,
  Re as m,
  je as n,
  $e as o,
  ke as p,
  Fe as r,
  Ne as s,
  ze as t,
  Me as u,
  pe as v,
  ne as w,
  ie as x,
  de as y
};