@purview-dev/astroc4 1.0.0-prerelease.3 → 1.0.0-prerelease.4

package/dist/index.js

@@ -0,0 +1,1125 @@
+// src/index.ts
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { LikeC4VitePlugin } from "likec4/vite-plugin";
+
+// src/fences.ts
+import { createHash } from "node:crypto";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+var require2 = createRequire(import.meta.url);
+var likec4ApiPromise;
+function loadLikeC4() {
+  likec4ApiPromise ??= Promise.resolve(require2("likec4").LikeC4);
+  return likec4ApiPromise;
+}
+function preloadLikeC4() {
+  return loadLikeC4();
+}
+var FENCE_LANG = "likec4";
+var INLINE_COMPONENT = "__LikeC4Fence";
+var PROJECT_COMPONENT = "__LikeC4View";
+var PACKAGE_NAME = "@purview-dev/astroc4";
+var IMPORTS = {
+  [INLINE_COMPONENT]: `${PACKAGE_NAME}/components/LikeC4Fence.astro`,
+  [PROJECT_COMPONENT]: `${PACKAGE_NAME}/components/LikeC4View.astro`
+};
+var layoutCache = new Map;
+function parseFenceMeta(meta) {
+  const options = {};
+  if (!meta)
+    return options;
+  const pattern = /(\w+)=(?:"([^"]*)"|'([^']*)'|(\S+))/g;
+  let match;
+  while ((match = pattern.exec(meta)) !== null) {
+    const key = match[1];
+    if (!key)
+      continue;
+    options[key] = match[2] ?? match[3] ?? match[4] ?? "";
+  }
+  return options;
+}
+async function layoutSnippet(source) {
+  const key = createHash("sha256").update(source).digest("hex");
+  const cached = layoutCache.get(key);
+  if (cached)
+    return cached;
+  const LikeC4 = await loadLikeC4();
+  const likec4 = await LikeC4.fromSource(source);
+  if (likec4.hasErrors()) {
+    const detail = likec4.getErrors().map((error) => String(error.message).split(`
+`)[0]?.trim() ?? "").slice(0, 3).join("; ");
+    throw new Error(detail || "the snippet could not be parsed");
+  }
+  const model = await likec4.layoutedModel();
+  const dump = JSON.parse(JSON.stringify(model.$data));
+  const result = { dump, viewIds: Object.keys(dump.views ?? {}) };
+  layoutCache.set(key, result);
+  return result;
+}
+function importNode(local, source) {
+  return {
+    type: "mdxjsEsm",
+    value: `import ${local} from ${JSON.stringify(source)};`,
+    data: {
+      estree: {
+        type: "Program",
+        sourceType: "module",
+        body: [
+          {
+            type: "ImportDeclaration",
+            specifiers: [
+              { type: "ImportDefaultSpecifier", local: { type: "Identifier", name: local } }
+            ],
+            source: { type: "Literal", value: source, raw: JSON.stringify(source) },
+            attributes: []
+          }
+        ]
+      }
+    }
+  };
+}
+function attributes(pairs) {
+  return Object.entries(pairs).filter(([, value]) => value !== undefined && value !== null && value !== "").map(([name, value]) => ({ type: "mdxJsxAttribute", name, value: String(value) }));
+}
+function describe(fileURL) {
+  if (!fileURL)
+    return "a content file";
+  try {
+    return fileURLToPath(fileURL);
+  } catch {
+    return String(fileURL);
+  }
+}
+function likec4Fences() {
+  return (factory) => {
+    if (factory.sourceFormat !== "mdx") {
+      if (!factory.source.includes("```" + FENCE_LANG))
+        return null;
+      return {
+        name: "likec4-fences:warn",
+        code(node, ctx) {
+          if (node.lang !== FENCE_LANG)
+            return;
+          console.warn(`[likec4-fences] ${describe(ctx.fileURL)} has a \`\`\`${FENCE_LANG} fence, but fences only ` + "render as diagrams in .mdx files. Rename the page to .mdx, or use <LikeC4View /> directly.");
+        }
+      };
+    }
+    if (!factory.source.includes("```" + FENCE_LANG))
+      return null;
+    const used = new Set;
+    return {
+      name: "likec4-fences",
+      async code(node, ctx) {
+        if (node.lang !== FENCE_LANG)
+          return;
+        const where = `${describe(ctx.fileURL)}: \`\`\`${FENCE_LANG} fence`;
+        const options = parseFenceMeta(node.meta);
+        const source = (node.value ?? "").trim();
+        const common = {
+          title: options.title,
+          description: options.description,
+          height: options.height,
+          collapsible: options.collapsible,
+          defaultOpen: options.defaultOpen
+        };
+        if (source.length === 0) {
+          if (!options.view) {
+            throw new Error(`${where} is empty, so it needs \`view="<id>"\` to name a view in the project model.`);
+          }
+          used.add(PROJECT_COMPONENT);
+          ctx.replaceNode(node, {
+            type: "mdxJsxFlowElement",
+            name: PROJECT_COMPONENT,
+            attributes: attributes({ ...common, viewId: options.view }),
+            children: []
+          });
+          return;
+        }
+        let layout;
+        try {
+          layout = await layoutSnippet(source);
+        } catch (error) {
+          throw new Error(`${where} is not valid LikeC4 — ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const viewId = options.view ?? layout.viewIds[0];
+        if (!viewId || !layout.viewIds.includes(viewId)) {
+          throw new Error(`${where} has no view "${viewId ?? "(none)"}". Declared: ${layout.viewIds.join(", ") || "(none)"}.`);
+        }
+        used.add(INLINE_COMPONENT);
+        ctx.replaceNode(node, {
+          type: "mdxJsxFlowElement",
+          name: INLINE_COMPONENT,
+          attributes: attributes({ ...common, viewId, model: JSON.stringify(layout.dump) }),
+          children: []
+        });
+      },
+      after(root, ctx) {
+        if (used.size === 0)
+          return;
+        ctx.insertChildAt(root, 0, [...used].map((local) => importNode(local, IMPORTS[local])));
+      }
+    };
+  };
+}
+
+// src/grammar/source.ts
+import { createHash as createHash2 } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// src/grammar/langium.ts
+var NOT_VALUE_DOMAINS = /Id$/;
+var PROPERTY_SUPPLEMENTS = ["kind", "tag"];
+function parseLangium(source) {
+  const statements = splitStatements(stripComments(source).replace(/^[ \t]*grammar[ \t]+[A-Za-z_]\w*[ \t]*$/gm, ""));
+  const rules = statements.map(readStatement).filter((rule) => rule !== undefined);
+  const parserRules = rules.filter((rule) => rule.kind === "rule" || rule.kind === "fragment");
+  if (parserRules.length === 0) {
+    throw new Error("the file contains no Langium parser rules — is this still `packages/language-server/src/like-c4.langium`?");
+  }
+  const enums = resolveEnums(parserRules);
+  const blocks = findBlocks(parserRules);
+  const properties = unique([...findProperties(parserRules), ...PROPERTY_SUPPLEMENTS]);
+  const arrows = findArrows(parserRules);
+  const literals = unique(parserRules.flatMap((rule) => rule.tokens.filter((t) => t.type === "literal").map((t) => t.value)));
+  const classified = new Set([...blocks, ...properties, ...Object.values(enums).flat()]);
+  const keywords = literals.filter((value) => /^[A-Za-z_]\w*$/.test(value) && !classified.has(value));
+  const terminals = readTerminals(rules);
+  if (keywords.length === 0 && blocks.length === 0 && Object.keys(enums).length === 0) {
+    throw new Error("the file contains no LikeC4 keywords — the Langium grammar could not be read");
+  }
+  return {
+    blocks,
+    keywords,
+    properties,
+    arrows,
+    enums,
+    icons: terminalAlternatives(terminals.LIB_ICON),
+    booleans: terminalAlternatives(terminals.BOOLEAN),
+    ruleCount: parserRules.length
+  };
+}
+function stripComments(source) {
+  let out = "";
+  let i = 0;
+  while (i < source.length) {
+    const char = source[i];
+    if (char === "/" && source[i + 1] === "/") {
+      while (i < source.length && source[i] !== `
+`)
+        i++;
+      out += " ";
+      continue;
+    }
+    if (char === "/" && source[i + 1] === "*") {
+      i += 2;
+      while (i < source.length && !(source[i] === "*" && source[i + 1] === "/"))
+        i++;
+      i += 2;
+      out += " ";
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      const end = endOfString(source, i);
+      out += source.slice(i, end);
+      i = end;
+      continue;
+    }
+    if (char === "/") {
+      const end = endOfRegex(source, i);
+      out += source.slice(i, end);
+      i = end;
+      continue;
+    }
+    out += char;
+    i++;
+  }
+  return out;
+}
+function endOfString(source, start) {
+  const quote = source[start];
+  let i = start + 1;
+  while (i < source.length) {
+    if (source[i] === "\\") {
+      i += 2;
+      continue;
+    }
+    if (source[i] === quote)
+      return i + 1;
+    i++;
+  }
+  return source.length;
+}
+function endOfRegex(source, start) {
+  let i = start + 1;
+  let inClass = false;
+  while (i < source.length) {
+    const char = source[i];
+    if (char === "\\") {
+      i += 2;
+      continue;
+    }
+    if (char === "[")
+      inClass = true;
+    else if (char === "]")
+      inClass = false;
+    else if (char === "/" && !inClass)
+      return i + 1;
+    i++;
+  }
+  return source.length;
+}
+function splitStatements(source) {
+  const statements = [];
+  let depth = 0;
+  let start = 0;
+  let i = 0;
+  while (i < source.length) {
+    const char = source[i];
+    if (char === "'" || char === '"') {
+      i = endOfString(source, i);
+      continue;
+    }
+    if (char === "/") {
+      i = endOfRegex(source, i);
+      continue;
+    }
+    if (char === "{")
+      depth++;
+    else if (char === "}")
+      depth = Math.max(0, depth - 1);
+    else if (char === ";" && depth === 0) {
+      statements.push(source.slice(start, i));
+      start = i + 1;
+    }
+    i++;
+  }
+  const tail = source.slice(start).trim();
+  if (tail.length > 0)
+    statements.push(tail);
+  return statements.filter((statement) => statement.trim().length > 0);
+}
+var HEADERS = [
+  { kind: "terminal", hidden: true, pattern: /^\s*hidden\s+terminal\s+([A-Za-z_]\w*)\s*(?:<[^>]*>)?\s*:/ },
+  {
+    kind: "terminal",
+    hidden: false,
+    pattern: /^\s*terminal\s+(?:fragment\s+)?([A-Za-z_]\w*)\s*(?:<[^>]*>)?\s*(?:returns\s+[A-Za-z_]\w*\s*)?:/
+  },
+  { kind: "fragment", hidden: false, pattern: /^\s*fragment\s+([A-Za-z_]\w*)\s*:/ },
+  {
+    kind: "rule",
+    hidden: false,
+    pattern: /^\s*(?:entry\s+)?([A-Za-z_]\w*)\s*(?:<[^>]*>)?\s*(?:returns\s+([A-Za-z_]\w*)\s*)?:/
+  }
+];
+function readStatement(statement) {
+  for (const header of HEADERS) {
+    const match = header.pattern.exec(statement);
+    const name = match?.[1];
+    if (!match || !name)
+      continue;
+    return {
+      name,
+      kind: header.kind,
+      hidden: header.hidden,
+      returns: header.kind === "rule" ? match[2] : undefined,
+      tokens: tokenize(statement.slice(match[0].length))
+    };
+  }
+  return;
+}
+function tokenize(body) {
+  const tokens = [];
+  let i = 0;
+  while (i < body.length) {
+    const char = body.charAt(i);
+    if (/\s/.test(char)) {
+      i++;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      const end = endOfString(body, i);
+      tokens.push({ type: "literal", value: unquote(body.slice(i, end)) });
+      i = end;
+      continue;
+    }
+    if (char === "/") {
+      const end = endOfRegex(body, i);
+      tokens.push({ type: "regex", value: body.slice(i + 1, end - 1) });
+      i = end;
+      continue;
+    }
+    const identifier = /^[A-Za-z_]\w*/.exec(body.slice(i));
+    if (identifier) {
+      tokens.push({ type: "ident", value: identifier[0] });
+      i += identifier[0].length;
+      continue;
+    }
+    tokens.push({ type: "punct", value: char });
+    i++;
+  }
+  return tokens;
+}
+function unquote(quoted) {
+  const inner = quoted.slice(1, -1);
+  let out = "";
+  for (let i = 0;i < inner.length; i++) {
+    if (inner[i] !== "\\") {
+      out += inner[i];
+      continue;
+    }
+    const escaped = inner[++i];
+    if (escaped === "n")
+      out += `
+`;
+    else if (escaped === "t")
+      out += "\t";
+    else if (escaped === "r")
+      out += "\r";
+    else
+      out += escaped ?? "";
+  }
+  return out;
+}
+function findBlocks(rules) {
+  return unique(rules.flatMap((rule) => {
+    const tokens = rule.tokens;
+    const first = tokens.findIndex((token) => token.type === "literal");
+    const keyword = first === -1 ? undefined : tokens[first]?.value;
+    if (!keyword || keyword === "{" || !/^[A-Za-z_]\w*$/.test(keyword))
+      return [];
+    for (let i = first + 1;i < tokens.length; i++) {
+      const token = tokens[i];
+      if (!token)
+        break;
+      if (token.value === "(" || token.value === "|")
+        return [];
+      if (token.type === "literal" && token.value === "{")
+        return [keyword];
+    }
+    return [];
+  }));
+}
+function findProperties(rules) {
+  const properties = [];
+  for (const rule of rules) {
+    const tokens = rule.tokens;
+    for (let i = 0;i < tokens.length; i++) {
+      const token = tokens[i];
+      if (!token || token.type !== "ident" || token.value !== "key")
+        continue;
+      const equals = equalsIndex(tokens, i);
+      if (equals === -1)
+        continue;
+      let j = equals + 1;
+      if (tokens[j]?.value === "(") {
+        for (j++;j < tokens.length && tokens[j]?.value !== ")"; j++) {
+          const inner = tokens[j];
+          if (inner?.type === "literal")
+            properties.push(inner.value);
+        }
+        continue;
+      }
+      const value = tokens[j];
+      if (value?.type === "literal")
+        properties.push(value.value);
+    }
+  }
+  return properties.filter((value) => /^[A-Za-z_]\w*$/.test(value));
+}
+function equalsIndex(tokens, i) {
+  if (tokens[i]?.type !== "ident")
+    return -1;
+  const next = tokens[i + 1]?.value;
+  if (next === "=")
+    return i + 1;
+  if ((next === "?" || next === "+") && tokens[i + 2]?.value === "=")
+    return i + 2;
+  return -1;
+}
+function findArrows(rules) {
+  const connector = rules.find((rule) => rule.name === "RelationConnector");
+  const fromConnector = (connector?.tokens ?? []).filter((token) => token.type === "literal" && token.value.includes("->")).map((token) => token.value);
+  return unique([...fromConnector, "->", "<->"]).sort((a, b) => b.length - a.length || a.localeCompare(b));
+}
+function resolveEnums(rules) {
+  const candidates = new Map;
+  for (const rule of rules) {
+    if (rule.returns !== "string" || NOT_VALUE_DOMAINS.test(rule.name))
+      continue;
+    const onlyValuesAndChoices = rule.tokens.every((token) => token.type === "literal" || token.type === "ident" || token.type === "punct" && (token.value === "|" || token.value === ";"));
+    if (onlyValuesAndChoices)
+      candidates.set(rule.name, []);
+  }
+  for (let pass = 0;pass < rules.length; pass++) {
+    let changed = false;
+    for (const rule of rules) {
+      if (!candidates.has(rule.name))
+        continue;
+      const resolved = [];
+      let complete = true;
+      for (const token of rule.tokens) {
+        if (token.type === "literal") {
+          resolved.push(token.value);
+          continue;
+        }
+        if (token.type !== "ident")
+          continue;
+        const inherited = candidates.get(token.value);
+        if (inherited === undefined) {
+          complete = false;
+          break;
+        }
+        resolved.push(...inherited);
+      }
+      const next = unique(resolved);
+      if (!complete || next.length === 0)
+        continue;
+      if ((candidates.get(rule.name) ?? []).length !== next.length) {
+        candidates.set(rule.name, next);
+        changed = true;
+      }
+    }
+    if (!changed)
+      break;
+  }
+  const enums = {};
+  for (const [name, values] of [...candidates].sort(([a], [b]) => a.localeCompare(b))) {
+    if (values.length > 0)
+      enums[name] = values;
+  }
+  return enums;
+}
+function readTerminals(rules) {
+  const terminals = {};
+  for (const rule of rules) {
+    if (rule.kind !== "terminal")
+      continue;
+    const token = rule.tokens.find((candidate) => candidate.type === "regex" || candidate.type === "literal");
+    if (!token)
+      continue;
+    terminals[rule.name] = {
+      hidden: rule.hidden,
+      kind: token.type === "regex" ? "regex" : "literal",
+      value: token.value
+    };
+  }
+  return terminals;
+}
+function terminalAlternatives(terminal) {
+  if (!terminal || terminal.kind !== "regex")
+    return [];
+  const group = /\(([^()]*)\)/.exec(terminal.value);
+  if (!group)
+    return [];
+  return unique((group[1] ?? "").split("|").map((value) => value.trim())).filter((value) => /^[A-Za-z][\w-]*$/.test(value));
+}
+function unique(values) {
+  return [...new Set(values)].sort((a, b) => a.localeCompare(b));
+}
+
+// src/grammar/textmate.ts
+var SCOPE_NAME = "source.likec4";
+var LANGUAGE_NAME = "likec4";
+var LANGUAGE_ALIASES = ["c4"];
+var TMLANGUAGE_SCHEMA = "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json";
+var VALUE_DOMAINS = [
+  "BorderStyleValue",
+  "DynamicViewDisplayVariantValue",
+  "EdgeRoutingValue",
+  "ElementShape",
+  "IconPositionValue",
+  "LineOptions",
+  "ArrowType",
+  "RankValue",
+  "SizeValue",
+  "SizingValue",
+  "ThemeColor",
+  "ViewLayoutDirection"
+];
+var KEYWORD_DOMAINS = ["DynamicViewFlowKeyword"];
+var VARIABLE_DOMAINS = ["Participant"];
+var OPERATOR_WORDS = ["and", "or", "not", "is"];
+var FALLBACK_ICON_PACKS = ["aws", "azure", "bootstrap", "gcp", "tech"];
+function buildTmLanguage(vocabulary, meta = {}) {
+  const control = uniqueDomain(vocabulary, KEYWORD_DOMAINS);
+  const variables = uniqueDomain(vocabulary, VARIABLE_DOMAINS);
+  const icons = vocabulary.icons.length > 0 ? vocabulary.icons : FALLBACK_ICON_PACKS;
+  const reserved = alternationOf([...vocabulary.keywords, ...vocabulary.blocks, ...control]);
+  const grammar = {
+    $schema: TMLANGUAGE_SCHEMA,
+    ...meta.repo && meta.ref ? {
+      $generated: {
+        repo: meta.repo,
+        ref: meta.ref,
+        ...meta.sha ? { sha: meta.sha } : {},
+        by: "astroc4/scripts/sync-grammar.ts"
+      }
+    } : {},
+    name: LANGUAGE_NAME,
+    displayName: "LikeC4",
+    scopeName: SCOPE_NAME,
+    fileTypes: ["c4", "likec4"],
+    patterns: [{ include: "#everything" }],
+    repository: {
+      everything: {
+        patterns: [
+          "comments",
+          "strings",
+          "urls",
+          "icons",
+          "hex-colors",
+          "tags",
+          "typed-arrow",
+          "declarations",
+          "keywords",
+          "numbers",
+          "operators",
+          "punctuation"
+        ].map((name) => ({ include: `#${name}` }))
+      },
+      comments: comments(),
+      strings: strings(),
+      urls: urls(),
+      icons: iconIds(icons),
+      "hex-colors": hexColours(),
+      tags: tags(),
+      "typed-arrow": typedArrow(),
+      declarations: declarations(reserved),
+      keywords: keywords({ ...vocabulary, control, variables }),
+      numbers: numbers(),
+      operators: operators(vocabulary.arrows),
+      punctuation: punctuation()
+    }
+  };
+  if (meta.repo && meta.ref) {
+    grammar.$generated = {
+      repo: meta.repo,
+      ref: meta.ref,
+      ...meta.sha ? { sha: meta.sha } : {},
+      by: "astroc4/scripts/sync-grammar.ts"
+    };
+  }
+  return grammar;
+}
+function comments() {
+  return {
+    patterns: [
+      {
+        name: "comment.block.likec4",
+        begin: "/\\*",
+        end: "\\*/",
+        captures: { 0: { name: "punctuation.definition.comment.likec4" } }
+      },
+      {
+        name: "comment.line.double-slash.likec4",
+        match: "//.*$",
+        captures: { 0: { name: "punctuation.definition.comment.likec4" } }
+      }
+    ]
+  };
+}
+function strings() {
+  const triple = (quote) => ({
+    name: "string.quoted.triple.likec4",
+    begin: quote.repeat(3),
+    end: quote.repeat(3),
+    beginCaptures: { 0: { name: "punctuation.definition.string.begin.likec4" } },
+    endCaptures: { 0: { name: "punctuation.definition.string.end.likec4" } }
+  });
+  const single = (quote, name) => ({
+    name,
+    begin: quote,
+    end: `${quote}|$`,
+    beginCaptures: { 0: { name: "punctuation.definition.string.begin.likec4" } },
+    endCaptures: { 0: { name: "punctuation.definition.string.end.likec4" } },
+    patterns: [{ name: "constant.character.escape.likec4", match: "\\\\." }]
+  });
+  return {
+    patterns: [
+      triple("'"),
+      triple('"'),
+      single("'", "string.quoted.single.likec4"),
+      single('"', "string.quoted.double.likec4")
+    ]
+  };
+}
+function urls() {
+  return { name: "markup.underline.link.likec4", match: `\\bhttps?://[^\\s'"]+` };
+}
+function iconIds(packs) {
+  return {
+    comment: "Bundled icon ids: `tech:nginx`, `aws:…`, `gcp:…`, …",
+    match: `\\b(${alternationOf(packs)})(:)([\\w-]+)`,
+    captures: {
+      1: { name: "support.constant.icon-pack.likec4" },
+      2: { name: "punctuation.separator.likec4" },
+      3: { name: "support.constant.icon.likec4" }
+    }
+  };
+}
+function hexColours() {
+  return {
+    name: "constant.other.color.rgb-value.hex.likec4",
+    match: "#(?:[0-9A-Fa-f]{8}|[0-9A-Fa-f]{6}|[0-9A-Fa-f]{3})(?![\\w-])"
+  };
+}
+function tags() {
+  return { name: "entity.name.tag.likec4", match: "#[A-Za-z_][\\w-]*" };
+}
+function typedArrow() {
+  return {
+    comment: "`a -[https]-> b`",
+    match: "(-\\[)\\s*([A-Za-z_][\\w-]*)\\s*(\\]->)",
+    captures: {
+      1: { name: "keyword.operator.arrow.likec4" },
+      2: { name: "entity.name.type.relationship.likec4" },
+      3: { name: "keyword.operator.arrow.likec4" }
+    }
+  };
+}
+function declarations(reserved) {
+  const notReserved = reserved ? `(?!(?:${reserved})\\b)` : "";
+  return {
+    patterns: [
+      {
+        comment: "`element system`, `deploymentNode region`, `tag tls`, `relationship https`. Not `where tag is #x`.",
+        match: "\\b(element|deploymentNode|tag|relationship)\\s+(?!is\\b)([A-Za-z_][\\w-]*)(?=\\s*(?:\\{|$|//))",
+        captures: {
+          1: { name: "storage.type.likec4" },
+          2: { name: "entity.name.type.likec4" }
+        }
+      },
+      {
+        comment: "`color testingBlue #0046BE` declares; `color testingBlue` inside a style block only refers.",
+        match: "\\b(color)\\s+([A-Za-z_][\\w-]*)(?=\\s+#)",
+        captures: {
+          1: { name: "storage.type.likec4" },
+          2: { name: "entity.name.type.likec4" }
+        }
+      },
+      {
+        comment: "`view index`, `dynamic view firstRequest`, `deployment view prod`, `view internals of site`",
+        match: "\\b(?:(dynamic|deployment)\\s+)?(view)\\s+([A-Za-z_]\\w*)",
+        captures: {
+          1: { name: "storage.modifier.likec4" },
+          2: { name: "storage.type.view.likec4" },
+          3: { name: "entity.name.function.view.likec4" }
+        }
+      },
+      {
+        comment: "`reader = actor 'Engineer'`",
+        match: `\\b([A-Za-z_]\\w*)\\s*(=)(?!=)\\s*${notReserved}([A-Za-z_]\\w*)?`,
+        captures: {
+          1: { name: "variable.other.definition.likec4" },
+          2: { name: "keyword.operator.assignment.likec4" },
+          3: { name: "entity.name.type.likec4" }
+        }
+      }
+    ]
+  };
+}
+function keywords(vocabulary) {
+  const patterns = [];
+  const blocks = alternationOf(vocabulary.blocks);
+  if (blocks) {
+    patterns.push({
+      comment: "Keywords that open a block: `model { … }`.",
+      name: "keyword.control.block.likec4",
+      match: `\\b(?:${blocks})\\b(?=\\s*\\{)`
+    });
+  }
+  const control = alternationOf([...vocabulary.keywords, ...vocabulary.control, ...vocabulary.blocks]);
+  patterns.push({
+    name: "keyword.operator.word.likec4",
+    match: `\\b(?:${alternationOf(OPERATOR_WORDS)})\\b`
+  });
+  if (control) {
+    patterns.push({ name: "keyword.control.likec4", match: `\\b(?:${control})\\b` });
+  }
+  const variables = alternationOf(vocabulary.variables);
+  if (variables) {
+    patterns.push({ name: "variable.language.likec4", match: `\\b(?:${variables})\\b` });
+  }
+  const properties = alternationOf(vocabulary.properties);
+  if (properties) {
+    patterns.push({ name: "support.type.property-name.likec4", match: `\\b(?:${properties})\\b` });
+  }
+  const values = alternationOf(uniqueDomain(vocabulary, VALUE_DOMAINS));
+  if (values) {
+    patterns.push({ name: "constant.language.likec4", match: `\\b(?:${values})\\b` });
+  }
+  return { patterns };
+}
+function numbers() {
+  return { name: "constant.numeric.likec4", match: "\\b\\d+(?:\\.\\d+)?%?" };
+}
+function operators(arrows) {
+  const patterns = [];
+  const connectors = alternationOf(arrows);
+  if (connectors) {
+    patterns.push({ name: "keyword.operator.arrow.likec4", match: connectors });
+  }
+  patterns.push({ name: "keyword.operator.wildcard.likec4", match: "\\.\\*\\*|\\.\\*|\\*\\*|\\*" });
+  return { patterns };
+}
+function punctuation() {
+  return {
+    patterns: [
+      { name: "punctuation.section.block.begin.likec4", match: "\\{" },
+      { name: "punctuation.section.block.end.likec4", match: "\\}" },
+      { name: "punctuation.separator.comma.likec4", match: "," },
+      { name: "punctuation.accessor.likec4", match: "\\." }
+    ]
+  };
+}
+function uniqueDomain(vocabulary, names) {
+  const values = names.flatMap((name) => vocabulary.enums[name] ?? []);
+  return [...new Set(values)].sort((a, b) => a.localeCompare(b));
+}
+function alternationOf(values) {
+  return values.map(escapeRegExp).join("|");
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/grammar/source.ts
+var DEFAULT_REPO = "likec4/likec4";
+var DEFAULT_REF = "main";
+var LANGIUM_PATH = "packages/language-server/src/like-c4.langium";
+var DEFAULT_BASE_URL = "https://raw.githubusercontent.com";
+var CACHE_VERSION = 1;
+var BUNDLED_GRAMMAR = new URL("./likec4.tmLanguage.json", import.meta.url);
+var BUNDLED_LANGIUM = new URL("./like-c4.langium", import.meta.url);
+var REF_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._/-]*$/;
+
+class GrammarRefError extends Error {
+  name = "GrammarRefError";
+}
+
+class GrammarFetchError extends Error {
+  name = "GrammarFetchError";
+}
+async function resolveLikeC4Grammar(options = {}) {
+  const env = options.env ?? process.env;
+  const repo = options.repo ?? DEFAULT_REPO;
+  const ref = env.ASTROC4_REF || options.ref || DEFAULT_REF;
+  const offline = options.offline ?? isTruthy(env.ASTROC4_OFFLINE);
+  const onError = options.onError ?? "fail";
+  const logger = options.logger;
+  validateRef(ref);
+  if (offline) {
+    return bundled("offline: true", options);
+  }
+  const cache = await readCache(options, { repo, ref });
+  if (cache?.fresh && !options.refresh) {
+    return derive(cache.langium, { repo, ref, source: "cache", fetchedAt: cache.fetchedAt, etag: cache.etag });
+  }
+  let fetched;
+  try {
+    fetched = await fetchLangiumSource({ ...options, repo, ref, etag: cache?.etag });
+  } catch (error) {
+    if (!(error instanceof Error))
+      throw error;
+    if (error instanceof GrammarRefError)
+      throw error;
+    if (onError === "fail")
+      throw error;
+    if (onError === "warn")
+      logger?.warn?.(`[astroc4] ${error.message}`);
+    if (cache) {
+      if (onError === "warn") {
+        logger?.warn?.(`[astroc4] using the grammar cached at ${new Date(cache.fetchedAt).toISOString()}`);
+      }
+      return derive(cache.langium, {
+        repo,
+        ref,
+        source: "cache",
+        fetchedAt: cache.fetchedAt,
+        etag: cache.etag
+      });
+    }
+    return bundled(error.message, options);
+  }
+  if ("notModified" in fetched) {
+    if (!cache) {
+      throw new GrammarFetchError("the grammar host answered 304 for a grammar that is not cached — retry with `refresh: true`");
+    }
+    await writeCache(options, { repo, ref }, cache);
+    return derive(cache.langium, { repo, ref, source: "cache", fetchedAt: cache.fetchedAt, etag: cache.etag });
+  }
+  const result = derive(fetched.text, { repo, ref, source: "network", etag: fetched.etag });
+  await writeCache(options, { repo, ref }, { langium: fetched.text, etag: fetched.etag });
+  return result;
+}
+function derive(langium, info) {
+  let vocabulary;
+  try {
+    vocabulary = parseLangium(langium);
+  } catch (cause) {
+    throw new GrammarFetchError(`${info.repo}@${info.ref}: the grammar could not be read — ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+  }
+  const sha = grammarSha(langium);
+  return {
+    grammar: buildTmLanguage(vocabulary, { repo: info.repo, ref: info.ref, sha }),
+    langium,
+    meta: {
+      repo: info.repo,
+      ref: info.ref,
+      source: info.source,
+      fetchedAt: info.fetchedAt ?? Date.now(),
+      etag: info.etag,
+      sha
+    }
+  };
+}
+async function bundled(reason, options) {
+  const path = options.bundledLangiumPath ?? fileURLToPath2(BUNDLED_LANGIUM);
+  const snapshot = await bundledProvenance();
+  const source = derive(await readFile(path, "utf8"), {
+    repo: snapshot.repo ?? DEFAULT_REPO,
+    ref: snapshot.ref ?? DEFAULT_REF,
+    source: "bundled"
+  });
+  source.meta.reason = reason;
+  return source;
+}
+async function bundledProvenance() {
+  try {
+    const { $generated } = JSON.parse(await readFile(fileURLToPath2(BUNDLED_GRAMMAR), "utf8"));
+    return { repo: $generated?.repo, ref: $generated?.ref };
+  } catch {
+    return {};
+  }
+}
+function grammarSha(source) {
+  return createHash2("sha256").update(source).digest("hex").slice(0, 12);
+}
+function validateRef(ref) {
+  if (typeof ref !== "string" || ref.length === 0) {
+    throw new GrammarRefError("the LikeC4 grammar `ref` must be a branch, tag or commit SHA");
+  }
+  if (!REF_PATTERN.test(ref) || ref.includes("..") || ref.endsWith("/") || ref.includes("//")) {
+    throw new GrammarRefError(`"${ref}" is not a usable LikeC4 grammar ref — expected a branch, tag or commit SHA such as "main" or "v1.59.4"`);
+  }
+  return ref;
+}
+async function fetchLangiumSource(options) {
+  const repo = options.repo;
+  const ref = options.ref;
+  const baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+  const url = `${baseUrl}/${repo}/${ref}/${LANGIUM_PATH}`;
+  const timeout = options.timeout ?? 15000;
+  const request = options.fetchImpl ?? fetch;
+  const headers = { "user-agent": "astroc4", accept: "text/plain" };
+  if (options.etag)
+    headers["if-none-match"] = options.etag;
+  let response;
+  try {
+    response = await request(url, { headers, redirect: "follow", signal: AbortSignal.timeout(timeout) });
+  } catch (cause) {
+    throw new GrammarFetchError(`could not fetch the LikeC4 grammar from ${url} — ${cause instanceof Error ? cause.message : String(cause)}. ` + "Builds are strict by default: pass `highlighting: { offline: true }` to use the bundled grammar instead.", { cause });
+  }
+  if (response.status === 304)
+    return { notModified: true };
+  if (response.status === 404) {
+    throw new GrammarRefError(`${repo} has no "${ref}", or it no longer has ${LANGIUM_PATH} (${url}). ` + 'Use a tag such as "v1.59.4", a commit SHA, or "main".');
+  }
+  if (!response.ok) {
+    throw new GrammarFetchError(`${url} responded ${response.status} ${response.statusText} — set ` + '`highlighting: { onError: "warn" }` to fall back to the bundled grammar.');
+  }
+  const text = await response.text();
+  if (text.trim().length === 0) {
+    throw new GrammarFetchError(`${url} returned an empty file — the grammar is not usable`);
+  }
+  return { text, etag: response.headers.get("etag") ?? undefined };
+}
+function cachePath(options, identity) {
+  const dir = options.cacheDir ?? join(options.root ?? process.cwd(), "node_modules", ".cache", "astroc4");
+  const key = createHash2("sha256").update(`${identity.repo}@${identity.ref}`).digest("hex").slice(0, 16);
+  return join(dir, `grammar-${key}.json`);
+}
+async function readCache(options, identity) {
+  let raw;
+  try {
+    raw = await readFile(cachePath(options, identity), "utf8");
+  } catch {
+    return;
+  }
+  try {
+    const entry = JSON.parse(raw);
+    if (entry?.version !== CACHE_VERSION || entry.repo !== identity.repo || entry.ref !== identity.ref || typeof entry.langium !== "string" || typeof entry.fetchedAt !== "number") {
+      return;
+    }
+    const ttl = options.cacheTtl ?? 3600;
+    return { ...entry, fresh: Date.now() - entry.fetchedAt < ttl * 1000 };
+  } catch {
+    return;
+  }
+}
+async function writeCache(options, identity, entry) {
+  const path = cachePath(options, identity);
+  const temporary = `${path}.${process.pid}.tmp`;
+  try {
+    await mkdir(join(path, ".."), { recursive: true });
+    await writeFile(temporary, JSON.stringify({
+      version: CACHE_VERSION,
+      repo: identity.repo,
+      ref: identity.ref,
+      etag: entry.etag,
+      fetchedAt: Date.now(),
+      langium: entry.langium
+    }), "utf8");
+    await rename(temporary, path);
+  } catch (error) {
+    options.logger?.warn?.(`[astroc4] could not cache the LikeC4 grammar in ${path} — ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function isTruthy(value) {
+  return typeof value === "string" && /^(1|true|yes|on)$/i.test(value.trim());
+}
+
+// src/translations.ts
+var translations = {
+  en: {
+    "likec4.view.title": "Architecture diagram",
+    "likec4.view.description": "Interactive LikeC4 diagram for this section.",
+    "likec4.view.hint": "Click a node in the diagram to open its details.",
+    "likec4.view.badge": "Click any node to open the modal",
+    "likec4.view.loading": "Loading architecture diagram…",
+    "likec4.fence.title": "Diagram",
+    "likec4.fence.hint": "Click any node to open its details.",
+    "likec4.fence.loading": "Loading diagram…",
+    "likec4.error.title": "We couldn’t load this diagram.",
+    "likec4.error.body": "Please retry, or refresh the page if the issue persists.",
+    "likec4.error.retry": "Retry",
+    "likec4.error.viewIdRequired": "A LikeC4 viewId is required to render the diagram.",
+    "likec4.error.noProjects": "No LikeC4 projects are available in this workspace.",
+    "likec4.error.unknownProject": 'Unknown LikeC4 projectId "{projectId}". Available projects: {available}.',
+    "likec4.error.unresolvedProject": "Unable to resolve a LikeC4 project.",
+    "likec4.error.loadFailed": 'Unable to load LikeC4 project "{projectId}".'
+  }
+};
+
+// src/index.ts
+var PACKAGE_NAME2 = "@purview-dev/astroc4";
+function starlightLikeC4(options = {}) {
+  return {
+    name: PACKAGE_NAME2,
+    hooks: {
+      "i18n:setup"({ injectTranslations }) {
+        injectTranslations(translations);
+      },
+      async "config:setup"({ config, astroConfig, updateConfig, addIntegration, logger }) {
+        addIntegration(likec4Integration(options));
+        if (options.highlighting === false)
+          return;
+        await injectHighlighting({
+          root: fileURLToPath3(astroConfig.root),
+          expressiveCode: config.expressiveCode,
+          updateConfig,
+          logger,
+          options: typeof options.highlighting === "object" ? options.highlighting : {}
+        });
+      }
+    }
+  };
+}
+async function injectHighlighting({
+  root,
+  expressiveCode,
+  updateConfig,
+  logger,
+  options
+}) {
+  if (expressiveCode === false) {
+    logger.warn("LikeC4 syntax highlighting is skipped: `expressiveCode: false` disables the code blocks it " + "would highlight. Diagrams are unaffected.");
+    return;
+  }
+  const source = await resolveLikeC4Grammar({ root, ...options, logger });
+  const registration = {
+    ...source.grammar,
+    name: LANGUAGE_NAME,
+    aliases: [...LANGUAGE_ALIASES]
+  };
+  updateConfig({
+    expressiveCode: withLikeC4Language(expressiveCode, registration)
+  });
+  const { repo, ref, sha, source: from } = source.meta;
+  logger.info(`LikeC4 grammar ${repo}@${ref} (${sha})${from === "network" ? "" : ` from ${from}`} — ` + "highlighting ```c4 and ```likec4 fences");
+}
+function withLikeC4Language(expressiveCode, registration) {
+  const current = isObject(expressiveCode) ? expressiveCode : {};
+  const shiki = isObject(current.shiki) ? current.shiki : {};
+  const langs = Array.isArray(shiki.langs) ? [...shiki.langs] : [];
+  const existing = langs.findIndex(isLikeC4Language);
+  if (existing === -1)
+    langs.push(registration);
+  else
+    langs[existing] = registration;
+  return { ...current, shiki: { ...shiki, langs } };
+}
+function isLikeC4Language(entry) {
+  if (typeof entry === "string")
+    return entry === LANGUAGE_NAME || LANGUAGE_ALIASES.includes(entry);
+  if (!isObject(entry))
+    return false;
+  if (entry.name === LANGUAGE_NAME || entry.scopeName === "source.likec4")
+    return true;
+  return Array.isArray(entry.aliases) && entry.aliases.some((alias) => LANGUAGE_ALIASES.includes(alias));
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function likec4Integration({ vitePlugin = {}, fences = true }) {
+  return {
+    name: `${PACKAGE_NAME2}/integration`,
+    hooks: {
+      "astro:config:setup": async ({ command, config, updateConfig, logger }) => {
+        updateConfig({
+          vite: {
+            plugins: [LikeC4VitePlugin(vitePlugin)],
+            ssr: { noExternal: [PACKAGE_NAME2] }
+          }
+        });
+        if (fences) {
+          await registerFences(config, updateConfig, logger);
+        }
+        if (command === "build") {
+          await preloadLikeC4();
+        }
+      }
+    }
+  };
+}
+async function registerFences(config, updateConfig, logger) {
+  const { satteri, isSatteriProcessor } = await import("@astrojs/markdown-satteri");
+  const existing = config.markdown?.processor;
+  if (existing === undefined) {
+    updateConfig({ markdown: { processor: satteri({ mdastPlugins: [likec4Fences()] }) } });
+    return;
+  }
+  if (!isSatteriProcessor(existing)) {
+    logger.warn("```likec4 fences are disabled: the site is not using the Sätteri Markdown processor. " + "<LikeC4View /> still works.");
+    return;
+  }
+  const existingOptions = existing.options ?? {};
+  updateConfig({
+    markdown: {
+      processor: satteri({
+        ...existingOptions,
+        mdastPlugins: [...existingOptions.mdastPlugins ?? [], likec4Fences()]
+      })
+    }
+  });
+}
+export {
+  starlightLikeC4 as default,
+  withLikeC4Language
+};
+
+//# debugId=BA2D1DBED70A424964756E2164756E21
+//# sourceMappingURL=index.js.map