@legionworks/facet 1.9.0

package/dist/gallery/frame/chunks/markdown-ffg06nfz.js

@@ -0,0 +1,86 @@
+import {
+  AbstractMermaidTokenBuilder,
+  CommonValueConverter,
+  EmptyFileSystem,
+  EventModelingGeneratedModule,
+  MermaidGeneratedSharedModule,
+  __name,
+  createDefaultCoreModule,
+  createDefaultSharedCoreModule,
+  inject
+} from "./markdown-dz3z5w30.js";
+
+// node_modules/@mermaid-js/parser/dist/chunks/mermaid-parser.core/chunk-5JV3BV7I.mjs
+var EventModelingTokenBuilder = class extends AbstractMermaidTokenBuilder {
+  static {
+    __name(this, "EventModelingTokenBuilder");
+  }
+  constructor() {
+    super(["eventmodeling"]);
+  }
+};
+var COMMAND_TYPES = /* @__PURE__ */ new Set(["cmd", "command"]);
+var EVENT_TYPES = /* @__PURE__ */ new Set(["evt", "event"]);
+var READMODEL_TYPES = /* @__PURE__ */ new Set(["rmo", "readmodel"]);
+var PROCESSOR_TYPES = /* @__PURE__ */ new Set(["pcr", "processor"]);
+var UI_TYPES = /* @__PURE__ */ new Set(["ui"]);
+function registerValidationChecks(services) {
+  const validator = services.validation.EventModelingValidator;
+  const registry = services.validation.ValidationRegistry;
+  if (registry) {
+    const checks = {
+      EmTimeFrame: validator.checkSourceFrameTypes.bind(validator),
+      EmResetFrame: validator.checkSourceFrameTypes.bind(validator)
+    };
+    registry.register(checks, validator);
+  }
+}
+__name(registerValidationChecks, "registerValidationChecks");
+var EventModelingValidator = class {
+  static {
+    __name(this, "EventModelingValidator");
+  }
+  checkSourceFrameTypes(frame, accept) {
+    if (frame.sourceFrames.length === 0) {
+      return;
+    }
+    if (COMMAND_TYPES.has(frame.modelEntityType)) {
+      this.validateSources(frame, /* @__PURE__ */ new Set([...UI_TYPES, ...PROCESSOR_TYPES]), "command", "ui or processor", accept);
+    } else if (EVENT_TYPES.has(frame.modelEntityType)) {
+      this.validateSources(frame, COMMAND_TYPES, "event", "command", accept);
+    } else if (READMODEL_TYPES.has(frame.modelEntityType)) {
+      this.validateSources(frame, EVENT_TYPES, "read model", "event", accept);
+    } else if (PROCESSOR_TYPES.has(frame.modelEntityType)) {
+      this.validateSources(frame, READMODEL_TYPES, "processor", "read model", accept);
+    } else if (UI_TYPES.has(frame.modelEntityType)) {
+      this.validateSources(frame, READMODEL_TYPES, "ui", "read model", accept);
+    }
+  }
+  validateSources(frame, allowedSourceTypes, targetLabel, expectedSourceLabel, accept) {
+    for (const sourceRef of frame.sourceFrames) {
+      const source = sourceRef.ref;
+      if (source !== undefined && !allowedSourceTypes.has(source.modelEntityType)) {
+        accept("error", `A ${targetLabel} can only receive input from a ${expectedSourceLabel}, not from '${source.modelEntityType}'.`, { node: frame, property: "sourceFrames" });
+      }
+    }
+  }
+};
+var EventModelingModule = {
+  parser: {
+    TokenBuilder: /* @__PURE__ */ __name(() => new EventModelingTokenBuilder, "TokenBuilder"),
+    ValueConverter: /* @__PURE__ */ __name(() => new CommonValueConverter, "ValueConverter")
+  },
+  validation: {
+    EventModelingValidator: /* @__PURE__ */ __name(() => new EventModelingValidator, "EventModelingValidator")
+  }
+};
+function createEventModelingServices(context = EmptyFileSystem) {
+  const shared = inject(createDefaultSharedCoreModule(context), MermaidGeneratedSharedModule);
+  const EventModel = inject(createDefaultCoreModule({ shared }), EventModelingGeneratedModule, EventModelingModule);
+  shared.ServiceRegistry.register(EventModel);
+  registerValidationChecks(EventModel);
+  return { shared, EventModel };
+}
+__name(createEventModelingServices, "createEventModelingServices");
+
+export { EventModelingModule, createEventModelingServices };

package/dist/gallery/frame/chunks/markdown-fvfncadf.js

@@ -0,0 +1,472 @@
+import {
+  FacetRenderError,
+  appendRenderError,
+  countPageShim,
+  dispatchRender,
+  isRenderer,
+  isTsxExecutionMode
+} from "./markdown-d1wfbs70.js";
+
+// src/gallery-web/theme.ts
+function isResolvedGalleryTheme(value) {
+  return value === "dark" || value === "light";
+}
+
+// src/gallery-web/frame/renderer-validation.ts
+function validateRenderer(value) {
+  if (!isRenderer(value)) {
+    throw new FacetRenderError("artifact payload is missing a supported renderer", "invalid_request");
+  }
+  return value;
+}
+
+// src/gallery-web/frame/frame-payload.ts
+var GESTURE_MODES = ["native", "panzoom"];
+function isGestureMode(value) {
+  return typeof value === "string" && GESTURE_MODES.includes(value);
+}
+function isUint8Array(value) {
+  return Object.prototype.toString.call(value) === "[object Uint8Array]";
+}
+function decodePayloadBytes(bytes) {
+  if (typeof bytes !== "string")
+    return new Uint8Array(bytes);
+  const binary = atob(bytes);
+  const out = new Uint8Array(binary.length);
+  for (let i = 0;i < binary.length; i += 1)
+    out[i] = binary.charCodeAt(i);
+  return out;
+}
+function parseViewBox(value) {
+  if (value === null)
+    return null;
+  const values = value.trim().split(/[\s,]+/).map(Number);
+  if (values.length !== 4 || values.some((entry) => !Number.isFinite(entry)) || values[2] <= 0 || values[3] <= 0)
+    return null;
+  return { minX: values[0], minY: values[1], width: values[2], height: values[3] };
+}
+function isFrameViewState(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  const state = value;
+  return typeof state.zoom === "number" && Number.isFinite(state.zoom) && state.zoom > 0 && typeof state.panX === "number" && Number.isFinite(state.panX) && typeof state.panY === "number" && Number.isFinite(state.panY);
+}
+
+// src/gallery-web/view-state.ts
+var MIN_ZOOM = 0.25;
+var MAX_ZOOM = 8;
+function clampZoom(zoom) {
+  if (!Number.isFinite(zoom))
+    return 1;
+  return Math.max(MIN_ZOOM, Math.min(MAX_ZOOM, zoom));
+}
+var EMPTY_VIEW_STATE = { zoom: 1, panX: 0, panY: 0 };
+function resetViewState(_state) {
+  return { ...EMPTY_VIEW_STATE };
+}
+function normalizeViewState(state) {
+  return { zoom: state.zoom, panX: state.panX ?? 0, panY: state.panY ?? 0 };
+}
+function zoomAtPoint(state, nextZoom, cursorX, cursorY) {
+  const zoom = clampZoom(nextZoom);
+  const ratio = zoom / state.zoom;
+  const panX = state.panX ?? 0;
+  const panY = state.panY ?? 0;
+  return {
+    zoom,
+    panX: cursorX - (cursorX - panX) * ratio,
+    panY: cursorY - (cursorY - panY) * ratio
+  };
+}
+var ZOOM_KEY_FACTOR = Math.exp(100 * 0.001);
+var PAN_STEP_PX = 10;
+var PAN_STEP_PX_SHIFT = 50;
+function nextViewStateForKey(state, key, shiftKey, rect) {
+  if (key === "+" || key === "=") {
+    return zoomAtPoint(state, clampZoom(state.zoom * ZOOM_KEY_FACTOR), rect.width / 2, rect.height / 2);
+  }
+  if (key === "-") {
+    return zoomAtPoint(state, clampZoom(state.zoom / ZOOM_KEY_FACTOR), rect.width / 2, rect.height / 2);
+  }
+  if (key === "0") {
+    return resetViewState(state);
+  }
+  if (key === "ArrowLeft" || key === "ArrowRight" || key === "ArrowUp" || key === "ArrowDown") {
+    const amount = shiftKey ? PAN_STEP_PX_SHIFT : PAN_STEP_PX;
+    const dx = key === "ArrowLeft" ? -amount : key === "ArrowRight" ? amount : 0;
+    const dy = key === "ArrowUp" ? -amount : key === "ArrowDown" ? amount : 0;
+    return {
+      ...state,
+      panX: (state.panX ?? 0) + dx,
+      panY: (state.panY ?? 0) + dy
+    };
+  }
+  return null;
+}
+
+// src/gallery-web/frame/runtime.ts
+var STANDALONE_DIAGRAM_TYPES = new Set(["mermaid", "svg", "chart"]);
+var DIAGRAM_REGION_SELECTOR = "[data-facet-diagram-region]";
+function nextDiagramRegionEngagement(state, event) {
+  if (event.type === "dismiss")
+    return { activeRegion: null, armedRegion: null };
+  if (event.type === "pointerenter") {
+    return state.activeRegion === event.region ? state : { ...state, armedRegion: event.region };
+  }
+  if (event.type === "pointerleave") {
+    return state.armedRegion === event.region ? { ...state, armedRegion: null } : state;
+  }
+  return state.armedRegion === event.region ? { activeRegion: event.region, armedRegion: null } : state;
+}
+function asStylable(node) {
+  return node !== null && "style" in node ? node : null;
+}
+function setPointerEventsIfStylable(node, value) {
+  const stylable = asStylable(node);
+  if (stylable !== null)
+    stylable.style.pointerEvents = value;
+}
+function setPointerEventsForAllChildren(container, value) {
+  for (const child of Array.from(container.children)) {
+    setPointerEventsIfStylable(child, value);
+  }
+}
+function renderedSvg(container) {
+  const root = container.children.length === 1 ? container.firstElementChild : null;
+  if (root?.nodeName.toLowerCase() !== "svg")
+    return null;
+  const viewBox = parseViewBox(root.getAttribute("viewBox"));
+  if (viewBox === null)
+    return null;
+  return { svg: root, viewBox };
+}
+function installDiagramRegionGestures(container) {
+  const regions = Array.from(container.querySelectorAll(DIAGRAM_REGION_SELECTOR));
+  let enabled = false;
+  let engagement = { activeRegion: null, armedRegion: null };
+  let controls = [];
+  const transition = (event) => {
+    engagement = nextDiagramRegionEngagement(engagement, event);
+    controls.forEach((control) => control.sync());
+  };
+  controls = regions.flatMap((region, index) => {
+    const svg = region.querySelector(":scope > svg");
+    if (svg === null)
+      return [];
+    const rect = svg.getBoundingClientRect();
+    const naturalWidth = rect.width;
+    const naturalHeight = rect.height;
+    if (naturalWidth <= 0 || naturalHeight <= 0)
+      return [];
+    region.style.width = `${Math.ceil(naturalWidth)}px`;
+    region.style.height = `${Math.ceil(naturalHeight)}px`;
+    region.style.overflow = "hidden";
+    const regionId = String(index);
+    let zoom = 1;
+    let drag = null;
+    const sync = () => {
+      if (engagement.activeRegion === regionId)
+        region.setAttribute("data-facet-diagram-engaged", "true");
+      else
+        region.removeAttribute("data-facet-diagram-engaged");
+    };
+    const eventRegion = (event) => {
+      const target = event.target;
+      return target instanceof Element ? target.closest(DIAGRAM_REGION_SELECTOR) : null;
+    };
+    region.addEventListener("pointerenter", () => {
+      if (enabled)
+        transition({ type: "pointerenter", region: regionId });
+    });
+    region.addEventListener("pointerleave", () => {
+      if (enabled)
+        transition({ type: "pointerleave", region: regionId });
+    });
+    region.addEventListener("pointerdown", (event) => {
+      if (!enabled || eventRegion(event) !== region)
+        return;
+      transition({ type: "activate", region: regionId });
+      if (engagement.activeRegion !== regionId)
+        return;
+      region.focus({ preventScroll: true });
+      drag = { x: event.clientX, y: event.clientY, pointerId: event.pointerId };
+      region.setPointerCapture(event.pointerId);
+      region.style.cursor = "grabbing";
+      event.preventDefault();
+    });
+    region.addEventListener("pointermove", (event) => {
+      if (drag === null || event.pointerId !== drag.pointerId || eventRegion(event) !== region)
+        return;
+      region.scrollLeft = Math.max(0, region.scrollLeft - (event.clientX - drag.x));
+      region.scrollTop = Math.max(0, region.scrollTop - (event.clientY - drag.y));
+      drag = { ...drag, x: event.clientX, y: event.clientY };
+      event.preventDefault();
+    });
+    const endDrag = (event) => {
+      if (drag === null || event.pointerId !== drag.pointerId)
+        return;
+      releaseDrag();
+    };
+    const releaseDrag = () => {
+      const activeDrag = drag;
+      drag = null;
+      if (activeDrag !== null && region.isConnected && region.hasPointerCapture(activeDrag.pointerId)) {
+        region.releasePointerCapture(activeDrag.pointerId);
+      }
+      region.style.cursor = "";
+    };
+    region.addEventListener("pointerup", endDrag);
+    region.addEventListener("pointercancel", endDrag);
+    region.addEventListener("wheel", (event) => {
+      if (!enabled || engagement.activeRegion !== regionId || eventRegion(event) !== region)
+        return;
+      event.preventDefault();
+      const nextZoom = clampZoom(zoom * Math.exp(-event.deltaY * 0.001));
+      const regionRect = region.getBoundingClientRect();
+      const cursorX = event.clientX - regionRect.left;
+      const cursorY = event.clientY - regionRect.top;
+      const scale = nextZoom / zoom;
+      zoom = nextZoom;
+      svg.style.width = `${Math.ceil(naturalWidth * zoom)}px`;
+      svg.style.maxWidth = "none";
+      svg.style.height = "auto";
+      region.scrollLeft = Math.max(0, (region.scrollLeft + cursorX) * scale - cursorX);
+      region.scrollTop = Math.max(0, (region.scrollTop + cursorY) * scale - cursorY);
+    }, { passive: false });
+    return [
+      {
+        region,
+        regionId,
+        sync,
+        dismiss: () => {
+          releaseDrag();
+        },
+        reset: () => {
+          zoom = 1;
+          svg.style.width = `${Math.ceil(naturalWidth)}px`;
+          svg.style.maxWidth = "none";
+          svg.style.height = "auto";
+          region.scrollLeft = 0;
+          region.scrollTop = 0;
+          releaseDrag();
+        }
+      }
+    ];
+  });
+  return {
+    setEnabled(nextEnabled) {
+      enabled = nextEnabled;
+      if (!enabled) {
+        controls.forEach((control) => control.dismiss());
+        transition({ type: "dismiss" });
+      }
+    },
+    dismiss() {
+      const wasEngaged = engagement.activeRegion !== null;
+      controls.forEach((control) => control.dismiss());
+      transition({ type: "dismiss" });
+      return wasEngaged;
+    },
+    reset() {
+      controls.forEach((control) => control.reset());
+      transition({ type: "dismiss" });
+    }
+  };
+}
+function validatePayload(value) {
+  if (value === null || typeof value !== "object") {
+    throw new FacetRenderError("artifact payload is missing", "invalid_request");
+  }
+  const payload = value;
+  if (typeof payload.artifactType !== "string") {
+    throw new FacetRenderError("artifact payload is missing artifactType", "invalid_request");
+  }
+  if (!isResolvedGalleryTheme(payload.theme)) {
+    throw new FacetRenderError("artifact payload has invalid theme", "invalid_request");
+  }
+  if (typeof payload.bytes !== "string" && !isUint8Array(payload.bytes)) {
+    throw new FacetRenderError("artifact payload is missing bytes", "invalid_request");
+  }
+  if (payload.execution !== undefined && !isTsxExecutionMode(payload.execution)) {
+    throw new FacetRenderError("artifact payload has invalid execution", "invalid_request");
+  }
+  return {
+    artifactType: payload.artifactType,
+    renderer: validateRenderer(payload.renderer),
+    bytes: decodePayloadBytes(payload.bytes),
+    theme: payload.theme,
+    ...payload.execution === undefined ? {} : { execution: payload.execution }
+  };
+}
+function installGalleryFrameApi(registry) {
+  const container = document.getElementById("artifact");
+  if (container === null)
+    throw new Error("frame runtime: #artifact container missing");
+  let rendered = false;
+  document.documentElement.style.height = "100%";
+  document.documentElement.style.overflow = "hidden";
+  document.body.style.height = "100%";
+  document.body.style.margin = "0";
+  document.body.style.padding = "0";
+  document.body.style.overflow = "hidden";
+  container.style.height = "100%";
+  container.style.width = "100%";
+  container.style.overflow = "auto";
+  container.style.boxSizing = "border-box";
+  let currentRenderResult = null;
+  let diagramRegions = null;
+  let gestureMode = "native";
+  let drag = null;
+  let capturedPointerId = null;
+  const onWheel = (event) => {
+    event.preventDefault();
+    const rect = container.getBoundingClientRect();
+    const state = currentRenderResult?.readViewState() ?? EMPTY_VIEW_STATE;
+    const factor = Math.exp(-event.deltaY * 0.001);
+    const nextZoom = clampZoom(state.zoom * factor);
+    const cursorX = event.clientX - rect.left;
+    const cursorY = event.clientY - rect.top;
+    const next = zoomAtPoint(state, nextZoom, cursorX, cursorY);
+    currentRenderResult?.applyViewState(normalizeViewState(next));
+  };
+  const onPointerDown = (event) => {
+    drag = { x: event.clientX, y: event.clientY };
+    container.setPointerCapture(event.pointerId);
+    capturedPointerId = event.pointerId;
+    container.style.cursor = "grabbing";
+  };
+  const onPointerMove = (event) => {
+    if (drag === null)
+      return;
+    const dx = event.clientX - drag.x;
+    const dy = event.clientY - drag.y;
+    drag = { x: event.clientX, y: event.clientY };
+    const state = normalizeViewState(currentRenderResult?.readViewState() ?? EMPTY_VIEW_STATE);
+    currentRenderResult?.applyViewState({
+      ...state,
+      panX: state.panX + dx,
+      panY: state.panY + dy
+    });
+  };
+  const onPointerEnd = (event) => {
+    drag = null;
+    container.releasePointerCapture(event.pointerId);
+    capturedPointerId = null;
+    container.style.cursor = "auto";
+  };
+  let gesturesInstalled = false;
+  const installGestureListeners = () => {
+    if (gesturesInstalled)
+      return;
+    gesturesInstalled = true;
+    container.addEventListener("wheel", onWheel, { passive: false });
+    container.addEventListener("pointerdown", onPointerDown);
+    container.addEventListener("pointermove", onPointerMove);
+    container.addEventListener("pointerup", onPointerEnd);
+    container.addEventListener("pointercancel", onPointerEnd);
+  };
+  const removeGestureListeners = () => {
+    if (!gesturesInstalled)
+      return;
+    gesturesInstalled = false;
+    container.removeEventListener("wheel", onWheel);
+    container.removeEventListener("pointerdown", onPointerDown);
+    container.removeEventListener("pointermove", onPointerMove);
+    container.removeEventListener("pointerup", onPointerEnd);
+    container.removeEventListener("pointercancel", onPointerEnd);
+    if (capturedPointerId !== null) {
+      container.releasePointerCapture(capturedPointerId);
+      capturedPointerId = null;
+    }
+  };
+  const setGestureMode = (mode) => {
+    if (!isGestureMode(mode)) {
+      throw new FacetRenderError("gesture mode is invalid", "invalid_request");
+    }
+    gestureMode = mode;
+    if (mode === "panzoom") {
+      installGestureListeners();
+    } else {
+      removeGestureListeners();
+      drag = null;
+      container.style.cursor = "auto";
+    }
+    diagramRegions?.setEnabled(mode === "native");
+    setPointerEventsForAllChildren(container, mode === "panzoom" ? "none" : "");
+  };
+  const api = {
+    async render(payload) {
+      if (rendered)
+        throw new FacetRenderError("frame already rendered", "invalid_request");
+      const validated = validatePayload(payload);
+      rendered = true;
+      try {
+        await dispatchRender(registry, { container, theme: validated.theme }, validated);
+      } catch (error) {
+        appendRenderError(container, error instanceof Error ? error.message : String(error));
+        throw error;
+      }
+      diagramRegions = installDiagramRegionGestures(container);
+      const svg = renderedSvg(container);
+      const viewMode = svg === null ? "css" : "native";
+      let viewState = { ...EMPTY_VIEW_STATE };
+      const applyViewState = (state) => {
+        if (!isFrameViewState(state)) {
+          throw new FacetRenderError("view state is invalid", "invalid_request");
+        }
+        viewState = { zoom: state.zoom, panX: state.panX, panY: state.panY };
+        if (svg !== null) {
+          svg.svg.style.width = `${Math.ceil(svg.viewBox.width * state.zoom)}px`;
+          svg.svg.style.maxWidth = "none";
+          svg.svg.style.height = "auto";
+        } else {
+          const root = asStylable(container.firstElementChild);
+          if (root !== null) {
+            root.style.transformOrigin = "top left";
+            root.style.transform = `scale(${state.zoom})`;
+          }
+        }
+        container.scrollLeft = Math.max(0, -state.panX);
+        container.scrollTop = Math.max(0, -state.panY);
+      };
+      const defaultGestureMode = STANDALONE_DIAGRAM_TYPES.has(validated.artifactType) ? "panzoom" : "native";
+      setGestureMode(defaultGestureMode);
+      currentRenderResult = {
+        observed: countPageShim(),
+        viewMode,
+        applyViewState,
+        readViewState: () => ({ ...viewState }),
+        defaultGestureMode,
+        gestureMode: () => gestureMode,
+        setGestureMode,
+        resetDiagramRegions: () => diagramRegions?.reset()
+      };
+      return currentRenderResult;
+    }
+  };
+  Reflect.set(window, "__facetFrame", api);
+  document.addEventListener("pointerdown", (event) => {
+    const target = event.target;
+    if (target instanceof Element && target.closest(DIAGRAM_REGION_SELECTOR) !== null)
+      return;
+    diagramRegions?.dismiss();
+  });
+  document.addEventListener("keydown", (event) => {
+    const result = currentRenderResult;
+    if (!result)
+      return;
+    if (event.key === "Escape" && diagramRegions?.dismiss()) {
+      event.preventDefault();
+      return;
+    }
+    const next = nextViewStateForKey(result.readViewState(), event.key, event.shiftKey, container.getBoundingClientRect());
+    if (next === null)
+      return;
+    event.preventDefault();
+    if (event.key === "0")
+      result.setGestureMode(result.defaultGestureMode);
+    result.applyViewState(normalizeViewState(next));
+  });
+}
+
+export { installGalleryFrameApi };

package/dist/gallery/frame/chunks/markdown-gvyszqpv.js

@@ -0,0 +1,19 @@
+import {
+  select_default
+} from "./markdown-xw8dsk8b.js";
+import {
+  __name
+} from "./markdown-1s5vwkf2.js";
+
+// node_modules/mermaid/dist/chunks/mermaid.core/chunk-XXDRQBXY.mjs
+var getDiagramElement = /* @__PURE__ */ __name((id, securityLevel) => {
+  let sandboxElement;
+  if (securityLevel === "sandbox") {
+    sandboxElement = select_default("#i" + id);
+  }
+  const root = securityLevel === "sandbox" ? select_default(sandboxElement.nodes()[0].contentDocument.body) : select_default("body");
+  const svg = root.select(`[id="${id}"]`);
+  return svg;
+}, "getDiagramElement");
+
+export { getDiagramElement };

package/dist/gallery/frame/chunks/markdown-gx1p0ew0.js

@@ -0,0 +1,88 @@
+import {
+  AbstractMermaidTokenBuilder,
+  AbstractMermaidValueConverter,
+  EmptyFileSystem,
+  MermaidGeneratedSharedModule,
+  RailroadEbnfGrammarGeneratedModule,
+  __name,
+  createDefaultCoreModule,
+  createDefaultSharedCoreModule,
+  inject
+} from "./markdown-dz3z5w30.js";
+
+// node_modules/@mermaid-js/parser/dist/chunks/mermaid-parser.core/chunk-U6XO7XAA.mjs
+var RailroadEbnfTokenBuilder = class extends AbstractMermaidTokenBuilder {
+  static {
+    __name(this, "RailroadEbnfTokenBuilder");
+  }
+  constructor() {
+    super(["railroad-ebnf-beta"]);
+  }
+};
+var decodeEscapedString = /* @__PURE__ */ __name((input) => {
+  const content = input.slice(1, -1);
+  let value = "";
+  for (let index = 0;index < content.length; index++) {
+    const character = content[index];
+    if (character === "\\" && index + 1 < content.length) {
+      index++;
+      const escaped = content[index];
+      switch (escaped) {
+        case "n":
+          value += `
+`;
+          break;
+        case "r":
+          value += "\r";
+          break;
+        case "t":
+          value += "\t";
+          break;
+        default:
+          value += escaped;
+      }
+      continue;
+    }
+    value += character;
+  }
+  return value;
+}, "decodeEscapedString");
+var RailroadEbnfValueConverter = class extends AbstractMermaidValueConverter {
+  static {
+    __name(this, "RailroadEbnfValueConverter");
+  }
+  runConverter(rule, input, cstNode) {
+    const value = super.runConverter(rule, input, cstNode);
+    if (rule.name === "TITLE" && typeof value === "string") {
+      const trimmedValue = value.trim();
+      if (trimmedValue.startsWith('"') && trimmedValue.endsWith('"') || trimmedValue.startsWith("'") && trimmedValue.endsWith("'")) {
+        return decodeEscapedString(trimmedValue);
+      }
+    }
+    return value;
+  }
+  runCustomConverter(rule, input, _cstNode) {
+    if (rule.name === "EBNF_STRING") {
+      return decodeEscapedString(input);
+    }
+    if (rule.name === "EBNF_SPECIAL_SEQUENCE") {
+      return input.slice(1, -1).trim();
+    }
+    return;
+  }
+};
+var RailroadEbnfModule = {
+  parser: {
+    TokenBuilder: /* @__PURE__ */ __name(() => new RailroadEbnfTokenBuilder, "TokenBuilder"),
+    ValueConverter: /* @__PURE__ */ __name(() => new RailroadEbnfValueConverter, "ValueConverter")
+  }
+};
+function createRailroadEbnfServices(context = EmptyFileSystem) {
+  const shared = inject(createDefaultSharedCoreModule(context), MermaidGeneratedSharedModule);
+  const RailroadEbnf = inject(createDefaultCoreModule({ shared }), RailroadEbnfGrammarGeneratedModule, RailroadEbnfModule);
+  shared.ServiceRegistry.register(RailroadEbnf);
+  return { shared, RailroadEbnf };
+}
+__name(createRailroadEbnfServices, "createRailroadEbnfServices");
+
+export { RailroadEbnfModule, createRailroadEbnfServices };