@miragon/design-iq-validator 5.3.0 → 5.5.0

package/README.md

@@ -5,7 +5,9 @@ structural checks (flow soundness, complete BPMNDI coverage), DMN structure and
 the generic cross-model reference rule (every required reference — `callActivity` calls,
 `businessRuleTask` decides — must resolve in the repo), and a per-mediaKind parse baseline for
 every other registered notation (a broken `.tt`/`.vc.json` is an ERROR; DSL notations are
-lenient by design). Every finding carries a stable `ruleId` (e.g. `bpmn/flow`, `dmn/di`,
+lenient by design; a `mermaid` fence in a Markdown document that does not start with a diagram
+type such as `flowchart` or `sequenceDiagram` is a WARN, `mermaid/diagram-type`, naming the
+document's line). Every finding carries a stable `ruleId` (e.g. `bpmn/flow`, `dmn/di`,
 `refs/dangling`). It treats the target repo as pure data — it never executes content-repo code.
 Exit code 0 = no errors (warnings allowed), 1 = errors.
 

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as runCli } from "./validate-D5Lo0E8X.js";
+import { a as runCli } from "./validate-DjtZJTGk.js";
 //#region src/cli.ts
 /**
 * CLI entry for the platform validator. A dedicated entry file (instead of an

package/dist/content-wjC_epKd.js

@@ -0,0 +1 @@
+export { t as CONTENT_CONFIG_FILE, i as contentConfigConflict, a as discoverModels, o as legacyContentConfigFile, s as loadContentConfig } from "./content-Bsv9ZLFd.js";

package/dist/{validate-D5Lo0E8X.js → validate-DjtZJTGk.js}

@@ -84,6 +84,457 @@ const notContentRepoError = (root) => {
 	return found === void 0 ? `[ERROR] ${root}: no ${CONTENT_CONFIG_NAMES} at the root — not a content repo (or wrong --root)` : `[ERROR] ${root}: ${found} at the root names no models folder — not a content repo (or wrong --root)`;
 };
 //#endregion
+//#region ../notations/markdown.ts
+const NONE = { kind: "none" };
+const PARAGRAPH = { kind: "paragraph" };
+const CODE = { kind: "code" };
+const FENCE_OPEN = /^(`{3,}|~{3,})(.*)$/;
+const THEMATIC_BREAK = /^(?:(?:\*[ \t]*){3,}|(?:-[ \t]*){3,}|(?:_[ \t]*){3,})$/;
+const ATX_HEADING = /^#{1,6}(?:[ \t]|$)/;
+const SETEXT_UNDERLINE = /^(?:=+|-+)[ \t]*$/;
+const BULLET = /^[-+*](?=[ \t]|$)/;
+const ORDERED = /^(\d{1,9})[.)](?=[ \t]|$)/;
+const BLANK = /^[ \t]*$/;
+/** a link reference definition on one line: [label]: destination "title" (a
+*  "[^" label is a footnote, which render.ts keeps as paragraph text; a bare
+*  destination ends at a space or a control character, as in markdown-it) */
+const LINK_DEFINITION = /^\[(?!\^)((?:[^[\]\\]|\\.)*)\]:[ \t]*(<(?:[^<>\\]|\\.)*>|[^ <\x00-\x1f\x7f][^ \x00-\x1f\x7f]*)(?:[ \t]+(?:"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\((?:[^()\\]|\\.)*\)))?[ \t]*$/;
+/** the destinations markdown-it's validateLink refuses: no definition then */
+const BAD_LINK = /^(?:vbscript|javascript|file|data):/i;
+const GOOD_DATA_LINK = /^data:image\/(?:gif|png|jpeg|webp);/i;
+/** markdown-it's maxNesting: content nested this deep (a Container's `level`)
+*  it does not parse, and drops the rest of the innermost quote around it,
+*  or of the document */
+const MAX_NESTING = 100;
+/** start, end and whether it may interrupt a paragraph; an end of /^$/ is the next blank line */
+const HTML_BLOCKS = [
+	[
+		/^<(?:script|pre|style|textarea)(?=\s|>|$)/i,
+		/<\/(?:script|pre|style|textarea)>/i,
+		true
+	],
+	[
+		/^<!--/,
+		/-->/,
+		true
+	],
+	[
+		/^<\?/,
+		/\?>/,
+		true
+	],
+	[
+		/^<![A-Za-z]/,
+		/>/,
+		true
+	],
+	[
+		/^<!\[CDATA\[/,
+		/\]\]>/,
+		true
+	],
+	[
+		new RegExp(`^</?(?:address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h1|h2|h3|h4|h5|h6|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul)(?=\\s|/?>|$)`, "i"),
+		/^$/,
+		true
+	],
+	[
+		new RegExp(`^(?:<[A-Za-z][A-Za-z0-9\\-]*(?:\\s+[a-zA-Z_:][a-zA-Z0-9:._-]*(?:\\s*=\\s*(?:[^"'=<>\`\\x00-\\x20]+|'[^']*'|"[^"]*"))?)*\\s*\\/?>|<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>)\\s*$`),
+		/^$/,
+		false
+	]
+];
+/** the leading blanks of a rest */
+function leading(rest) {
+	let col = rest.col;
+	let i = 0;
+	for (; i < rest.text.length; i++) {
+		const ch = rest.text[i];
+		if (ch === " ") col++;
+		else if (ch === "	") col += 4 - col % 4;
+		else break;
+	}
+	return {
+		indent: col - rest.col,
+		blank: i === rest.text.length
+	};
+}
+/** the columns of leading blanks */
+const indentOf = (rest) => leading(rest).indent;
+/** drop up to `n` columns of leading blanks; a tab cut in two leaves its other columns as spaces */
+function dropIndent(rest, n) {
+	const target = rest.col + n;
+	let col = rest.col;
+	let i = 0;
+	while (i < rest.text.length && col < target) {
+		const ch = rest.text[i];
+		if (ch === " ") col++;
+		else if (ch === "	") {
+			const next = col + 4 - col % 4;
+			if (next > target) return {
+				text: " ".repeat(next - target) + rest.text.slice(i + 1),
+				col: target
+			};
+			col = next;
+		} else break;
+		i++;
+	}
+	return {
+		text: rest.text.slice(i),
+		col
+	};
+}
+/** the line after its indent, when that is at most three columns (more is indented code) */
+function blockStart(rest) {
+	const indent = indentOf(rest);
+	return indent < 4 ? dropIndent(rest, indent) : void 0;
+}
+/** a quote's ">" and the one column of blank after it: a space, or the first
+*  column of a tab (which stays, a column narrower, as in markdown-it) */
+function afterQuoteMarker(at) {
+	const rest = {
+		text: at.text.slice(1),
+		col: at.col + 1
+	};
+	if (rest.text.startsWith(" ") || rest.text.startsWith("	") && rest.col % 4 === 3) return {
+		text: rest.text.slice(1),
+		col: rest.col + 1
+	};
+	return rest.text.startsWith("	") ? {
+		text: rest.text,
+		col: rest.col + 1
+	} : rest;
+}
+/** the rest of the line when it continues the container, undefined when the
+*  container ends. `lead` is the rest's leading blanks, kept up to date across
+*  the columns a list item drops, so a line is not measured once per container */
+function continues(container, rest, lead) {
+	if (container.kind === "quote") {
+		const at = dropIndent(rest, lead.indent);
+		return at.text.startsWith(">") ? afterQuoteMarker(at) : void 0;
+	}
+	const fresh = container.fresh;
+	container.fresh = false;
+	if (lead.blank ? fresh : lead.indent < container.indent) return void 0;
+	lead.indent = Math.max(0, lead.indent - container.indent);
+	return dropIndent(rest, container.indent);
+}
+/** a list item opening at `at` (the line after its indent of `indent` columns),
+*  inside containers nested `level` deep */
+function listItem(at, indent, level, interruptsParagraph) {
+	const ordered = ORDERED.exec(at.text);
+	const marker = ordered ?? BULLET.exec(at.text);
+	if (!marker) return void 0;
+	const after = {
+		text: at.text.slice(marker[0].length),
+		col: at.col + marker[0].length
+	};
+	const empty = BLANK.test(after.text);
+	if (interruptsParagraph && (empty || ordered && Number(ordered[1]) !== 1)) return void 0;
+	const blanks = indentOf(after);
+	const gap = empty || blanks > 4 ? 1 : blanks;
+	return {
+		item: {
+			kind: "item",
+			level: level + 2,
+			indent: indent + marker[0].length + gap,
+			fresh: empty
+		},
+		rest: dropIndent(after, gap)
+	};
+}
+/** the HTML block starting at `text` (a line after its indent), if any */
+function htmlBlock(text) {
+	return text.startsWith("<") ? HTML_BLOCKS.find(([start]) => start.test(text)) : void 0;
+}
+/** whether a line that does not continue a paragraph's containers starts a
+*  block of its own (else it is a lazy continuation line of the paragraph) */
+function startsBlock(rest) {
+	const at = blockStart(rest);
+	if (!at) return false;
+	const text = at.text;
+	return text.startsWith(">") || fenceOpen(text) !== void 0 || THEMATIC_BREAK.test(text) || BULLET.test(text) || ORDERED.test(text) || ATX_HEADING.test(text) || htmlBlock(text)?.[2] === true;
+}
+/** whether `text` (a line after its indent) is a link reference definition that
+*  fits on it and that markdown-it takes: a label with more than blanks, a
+*  destination with balanced parentheses and a scheme its validateLink allows */
+function linkDefinition(text) {
+	const definition = LINK_DEFINITION.exec(text);
+	if (!definition || definition[1].trim() === "") return false;
+	let destination = definition[2];
+	if (destination.startsWith("<")) destination = destination.slice(1, -1);
+	else {
+		let depth = 0;
+		for (let i = 0; i < destination.length && depth >= 0; i++) {
+			const ch = destination[i];
+			if (ch === "\\") i++;
+			else if (ch === "(") depth = depth < 32 ? depth + 1 : -1;
+			else if (ch === ")") depth--;
+		}
+		if (depth !== 0) return false;
+	}
+	destination = destination.trim();
+	return !BAD_LINK.test(destination) || GOOD_DATA_LINK.test(destination);
+}
+/** the opening run of a fence at `text` (a line after its indent), if any */
+function fenceOpen(text) {
+	const open = FENCE_OPEN.exec(text);
+	if (!open) return void 0;
+	const run = open[1];
+	const info = open[2];
+	if (run.startsWith("`") && info.includes("`")) return void 0;
+	return {
+		char: run[0],
+		size: run.length,
+		info: info.trim()
+	};
+}
+/** whether the line is the closing run of `fence` */
+function closes(rest, fence) {
+	const at = blockStart(rest);
+	if (!at) return false;
+	let n = 0;
+	while (at.text[n] === fence.char) n++;
+	return n >= fence.size && BLANK.test(at.text.slice(n));
+}
+/** every fenced code block of a Markdown document, in document order */
+function markdownFences(source) {
+	const lines = source.split(/\r\n|\r|\n/);
+	const brokenLast = BLANK.test(lines[lines.length - 1]);
+	if (brokenLast) lines.pop();
+	const fences = [];
+	const stack = [];
+	const level = () => stack.length > 0 ? stack[stack.length - 1].level : 0;
+	let leaf = NONE;
+	let dropping;
+	const finish = (fence, closed) => {
+		fences.push({
+			line: fence.line,
+			endLine: fence.line + fence.content.length + (closed ? 1 : 0),
+			info: fence.info,
+			lang: (fence.info.split(/\s+/)[0] ?? "").toLowerCase(),
+			content: fence.content.join(""),
+			closed
+		});
+	};
+	for (let i = 0; i < lines.length; i++) {
+		let rest = {
+			text: lines[i],
+			col: 0
+		};
+		const lineBreak = i < lines.length - 1 || brokenLast ? "\n" : "";
+		let matched = 0;
+		let lead;
+		for (const container of stack) {
+			const next = continues(container, rest, lead ??= leading(rest));
+			if (!next) break;
+			rest = next;
+			if (container.kind === "quote") lead = void 0;
+			matched++;
+		}
+		const all = matched === stack.length;
+		if (dropping) {
+			if (all) {
+				dropping.lastBlank = BLANK.test(rest.text);
+				continue;
+			}
+			if (!dropping.lastBlank && !BLANK.test(rest.text) && !startsBlock(rest)) continue;
+			dropping = void 0;
+		}
+		if (leaf.kind === "fence" && all) {
+			if (closes(rest, leaf)) {
+				finish(leaf, true);
+				leaf = NONE;
+			} else leaf.content.push(dropIndent(rest, leaf.indent).text + lineBreak);
+			continue;
+		}
+		if (leaf.kind === "html" && all) {
+			if (leaf.end.test(dropIndent(rest, indentOf(rest)).text)) leaf = NONE;
+			continue;
+		}
+		if (!all) {
+			if (leaf.kind === "paragraph" && !BLANK.test(rest.text) && !startsBlock(rest)) continue;
+			if (leaf.kind === "fence") finish(leaf, false);
+			stack.length = matched;
+			leaf = NONE;
+		}
+		while (level() < MAX_NESTING && !BLANK.test(rest.text)) {
+			const at = blockStart(rest);
+			if (!at) break;
+			if (at.text.startsWith(">")) {
+				stack.push({
+					kind: "quote",
+					level: level() + 1
+				});
+				rest = afterQuoteMarker(at);
+			} else {
+				if (THEMATIC_BREAK.test(at.text)) break;
+				const opening = listItem(at, indentOf(rest), level(), leaf.kind === "paragraph");
+				if (!opening) break;
+				stack.push(opening.item);
+				rest = opening.rest;
+			}
+			leaf = NONE;
+		}
+		if (BLANK.test(rest.text)) {
+			if (leaf.kind === "paragraph") leaf = NONE;
+			continue;
+		}
+		if (level() >= MAX_NESTING) {
+			const quote = stack.findLastIndex((container) => container.kind === "quote");
+			if (quote < 0) break;
+			stack.length = quote + 1;
+			leaf = NONE;
+			dropping = { lastBlank: false };
+			continue;
+		}
+		const at = blockStart(rest);
+		if (!at) {
+			if (leaf.kind !== "paragraph") leaf = CODE;
+			continue;
+		}
+		const open = fenceOpen(at.text);
+		if (open) {
+			leaf = {
+				kind: "fence",
+				...open,
+				indent: indentOf(rest),
+				line: i + 1,
+				content: []
+			};
+			continue;
+		}
+		const html = htmlBlock(at.text);
+		if (html && (html[2] || leaf.kind !== "paragraph")) {
+			leaf = html[1].test(at.text) ? NONE : {
+				kind: "html",
+				end: html[1]
+			};
+			continue;
+		}
+		if (leaf.kind !== "paragraph" && linkDefinition(at.text)) leaf = NONE;
+		else if (ATX_HEADING.test(at.text) || THEMATIC_BREAK.test(at.text)) leaf = NONE;
+		else if (leaf.kind === "paragraph" && SETEXT_UNDERLINE.test(at.text)) leaf = NONE;
+		else leaf = PARAGRAPH;
+	}
+	if (leaf.kind === "fence") finish(leaf, false);
+	return fences;
+}
+//#endregion
+//#region ../notations/mermaid.ts
+/**
+* Every diagram type MERMAID_VERSION renders, spelled as its header keyword
+* (its diagram detectors, minus the spellings the detector matches but the
+* grammar then refuses: a bare `architecture` or `requirement`). zenuml is
+* an external plugin mermaid does not bundle, so it is not here.
+*/
+const MERMAID_DIAGRAM_TYPES = [
+	"flowchart",
+	"flowchart-elk",
+	"graph",
+	"sequenceDiagram",
+	"classDiagram",
+	"classDiagram-v2",
+	"stateDiagram",
+	"stateDiagram-v2",
+	"erDiagram",
+	"journey",
+	"gantt",
+	"pie",
+	"quadrantChart",
+	"requirementDiagram",
+	"gitGraph",
+	"C4Context",
+	"C4Container",
+	"C4Component",
+	"C4Dynamic",
+	"C4Deployment",
+	"mindmap",
+	"timeline",
+	"sankey",
+	"sankey-beta",
+	"xychart",
+	"xychart-beta",
+	"block",
+	"block-beta",
+	"packet",
+	"packet-beta",
+	"kanban",
+	"architecture-beta",
+	"radar-beta",
+	"treemap",
+	"treemap-beta",
+	"info",
+	"swimlane-beta",
+	"treeView-beta",
+	"eventmodeling",
+	"ishikawa",
+	"ishikawa-beta",
+	"venn-beta",
+	"wardley-beta",
+	"cynefin-beta",
+	"railroad-beta",
+	"railroad-ebnf-beta",
+	"railroad-abnf-beta",
+	"railroad-peg-beta"
+];
+const FRONT_MATTER = /^([^\S\n\r]*)-{3}\s*[\n\r](.*?)[\n\r]\1-{3}\s*[\n\r]+/s;
+const DIRECTIVE = /%{2}{\s*(?:(\w+)\s*:|(\w+))\s*(?:(\w+)|((?:(?!}%{2}).|\r?\n)*))?\s*(?:}%{2})?/gi;
+const COMMENT_LINE = /^\s*%%(?!{)[^\n]+\n?/gm;
+/** a header keyword, followed by the end of the line, a space, ":" or ";" */
+const HEADER = new RegExp(`^(?:${MERMAID_DIAGRAM_TYPES.map((t) => t.replace(/[.*+?^${}()|[\]\\-]/g, "\\$&")).join("|")})(?=$|[\\s:;])`);
+/** mermaid's cleanupText: line breaks to \n, tag attributes single-quoted;
+*  the line structure stays, so the source lines can be matched against it */
+function cleanup(source) {
+	return source.replace(/\r\n?/g, "\n").replace(/<(\w+)([^>]*)>/g, (_tag, name, attrs) => `<${name}${attrs.replace(/="([^"]*)"/g, "='$1'")}>`);
+}
+/** The text mermaid's diagram parser reads: the source after mermaid's
+*  preprocess (front matter, directives and comment lines removed, leading
+*  whitespace trimmed). */
+function mermaidCode(source) {
+	return cleanup(source).replace(FRONT_MATTER, "").replace(DIRECTIVE, "").replace(COMMENT_LINE, "").trimStart();
+}
+/**
+* The 1-based source line of the 1-based line `codeLine` of mermaidCode(source).
+* The preprocess only removes lines (and joins the two ends of a directive
+* that spans lines), so the code is the source's lines in order: each code
+* line is matched to the next source line with the same text. A line the
+* preprocess rewrote matches nothing and takes the next line; a line past the
+* end clamps to the last one.
+*/
+function mermaidSourceLine(source, codeLine) {
+	const cleaned = cleanup(source);
+	const sourceLines = cleaned.split("\n").map((l) => l.trim());
+	const codeLines = mermaidCode(source).split("\n");
+	let next = (cleaned.match(FRONT_MATTER)?.[0] ?? "").split("\n").length - 1;
+	let at = next;
+	for (let i = 0; i < Math.min(codeLine, codeLines.length); i++) {
+		const text = codeLines[i].trim();
+		let k = next;
+		while (k < sourceLines.length && sourceLines[k] !== text) k++;
+		at = k < sourceLines.length ? k : next;
+		next = at + 1;
+	}
+	return Math.min(at, sourceLines.length - 1) + 1;
+}
+/**
+* The line that names the diagram type: the first line of mermaidCode that
+* is neither blank nor a bare `%%` comment (mermaid's type detection skips
+* those too). undefined when there is none: the source is empty, or nothing
+* but front matter, directives and comments.
+*/
+function mermaidHeader(source) {
+	const lines = mermaidCode(source).split("\n");
+	const index = lines.findIndex((l) => l.trim() !== "" && !l.trim().startsWith("%%"));
+	if (index < 0) return void 0;
+	const text = lines[index].trim();
+	return {
+		line: mermaidSourceLine(source, index + 1),
+		text,
+		diagramType: HEADER.exec(text)?.[0]
+	};
+}
+//#endregion
 //#region src/validate.ts
 /**
 * Deterministic validation of a content repository (the slim contract).
@@ -335,6 +786,24 @@ function checkDmnXml(raw, opts = {}) {
 	else for (const id of diRequired) if (!di.has(id)) err("dmn/di", `${id} has no DMNDI shape (breaks the visual editor)`);
 	return { findings };
 }
+/** the Mermaid types the header message names: the common ones, not every one */
+const COMMON_MERMAID_TYPES = "flowchart, sequenceDiagram, classDiagram, stateDiagram-v2, erDiagram, gantt, pie, mindmap";
+/**
+* Mermaid's own first step (its type detection, @designiq/notations/mermaid
+* mirrors it) for a ```mermaid fence opening on document line `line`: after
+* the front matter, directives and comments, the diagram's first line must
+* start with a diagram type. Light on purpose: the grammar itself needs
+* mermaid and a DOM, which the validator never loads; the Markdown view
+* shows those errors live. The message names the document's line (a Finding
+* has no line of its own).
+*/
+function mermaidFenceProblem(content, line) {
+	const header = mermaidHeader(content);
+	if (!header) return `line ${line}: empty Mermaid diagram: the first line must name a diagram type (${COMMON_MERMAID_TYPES}, …)`;
+	if (header.diagramType) return void 0;
+	const word = header.text.split(/[\s:;]/, 1)[0];
+	return `line ${line + header.line}: '${word}' is not a Mermaid diagram type (${COMMON_MERMAID_TYPES}, …)`;
+}
 /**
 * Baseline parse gate for models WITHOUT a dedicated checker (any registered
 * notation that is not .bpmn/.dmn): a discovered model must at minimum parse
@@ -368,10 +837,21 @@ function checkModelBaseline(raw, opts) {
 			if (wf !== true) err(`not well-formed XML: ${wf.err.msg}`);
 			break;
 		}
-		case "dsl": try {
-			extractModelGraph(opts.notation, raw);
-		} catch (e) {
-			err(`not parseable: ${e.message}`);
+		case "dsl":
+			try {
+				extractModelGraph(opts.notation, raw);
+			} catch (e) {
+				err(`not parseable: ${e.message}`);
+			}
+			break;
+		case "markdown": for (const fence of markdownFences(raw)) {
+			const problem = fence.lang === "mermaid" ? mermaidFenceProblem(fence.content, fence.line) : void 0;
+			if (problem) findings.push({
+				severity: "WARN",
+				ruleId: "mermaid/diagram-type",
+				file,
+				message: problem
+			});
 		}
 	}
 	return findings;
@@ -436,7 +916,7 @@ async function runCli() {
 	/** optional single-model filter (a model file stem) */
 	const only = argv[0];
 	const rel = (p) => p.startsWith("/") ? relative(ROOT, p) : p;
-	const { CONTENT_CONFIG_FILE, contentConfigConflict, discoverModels, legacyContentConfigFile, loadContentConfig } = await import("./content-DgyuLYdD.js");
+	const { CONTENT_CONFIG_FILE, contentConfigConflict, discoverModels, legacyContentConfigFile, loadContentConfig } = await import("./content-wjC_epKd.js");
 	const cfg = loadContentConfig(ROOT);
 	if (!cfg) {
 		console.error(notContentRepoError(ROOT));

package/dist/validate.js

@@ -1,2 +1 @@
-import { a as runCli, i as checkModelBaseline, n as checkDmnXml, r as checkModel, t as checkBpmnXml } from "./validate-D5Lo0E8X.js";
-export { checkBpmnXml, checkDmnXml, checkModel, checkModelBaseline, runCli };
+export { t as checkBpmnXml, n as checkDmnXml, r as checkModel, i as checkModelBaseline, a as runCli } from "./validate-DjtZJTGk.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miragon/design-iq-validator",
-  "version": "5.3.0",
+  "version": "5.5.0",
   "type": "module",
   "description": "Platform-owned validator for designIQ content repos — designiq.yml discovery, BPMN/DMN structure and diagram coverage, cross-model references, and a parse check for every other notation. Runs against any checkout via --root; never executes content-repo code.",
   "license": "MIT",
@@ -38,7 +38,7 @@
     "yaml": "2.9.1"
   },
   "devDependencies": {
-    "tsdown": "0.23.0",
+    "tsdown": "0.23.1",
     "@designiq/notations": "0.1.0"
   },
   "scripts": {

package/dist/content-DgyuLYdD.js

@@ -1,2 +0,0 @@
-import { a as discoverModels, i as contentConfigConflict, o as legacyContentConfigFile, s as loadContentConfig, t as CONTENT_CONFIG_FILE } from "./content-Bsv9ZLFd.js";
-export { CONTENT_CONFIG_FILE, contentConfigConflict, discoverModels, legacyContentConfigFile, loadContentConfig };