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

package/dist/expressive-code.js

@@ -0,0 +1,1171 @@
+// src/grammar/likec4.tmLanguage.json
+var likec4_tmLanguage_default = {
+  $schema: "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
+  $generated: {
+    repo: "likec4/likec4",
+    ref: "main",
+    sha: "da5af77245f9",
+    by: "astroc4/scripts/sync-grammar.ts"
+  },
+  name: "likec4",
+  displayName: "LikeC4",
+  scopeName: "source.likec4",
+  fileTypes: [
+    "c4",
+    "likec4"
+  ],
+  patterns: [
+    {
+      include: "#everything"
+    }
+  ],
+  repository: {
+    everything: {
+      patterns: [
+        {
+          include: "#comments"
+        },
+        {
+          include: "#strings"
+        },
+        {
+          include: "#urls"
+        },
+        {
+          include: "#icons"
+        },
+        {
+          include: "#hex-colors"
+        },
+        {
+          include: "#tags"
+        },
+        {
+          include: "#typed-arrow"
+        },
+        {
+          include: "#declarations"
+        },
+        {
+          include: "#keywords"
+        },
+        {
+          include: "#numbers"
+        },
+        {
+          include: "#operators"
+        },
+        {
+          include: "#punctuation"
+        }
+      ]
+    },
+    comments: {
+      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"
+            }
+          }
+        }
+      ]
+    },
+    strings: {
+      patterns: [
+        {
+          name: "string.quoted.triple.likec4",
+          begin: "'''",
+          end: "'''",
+          beginCaptures: {
+            "0": {
+              name: "punctuation.definition.string.begin.likec4"
+            }
+          },
+          endCaptures: {
+            "0": {
+              name: "punctuation.definition.string.end.likec4"
+            }
+          }
+        },
+        {
+          name: "string.quoted.triple.likec4",
+          begin: '"""',
+          end: '"""',
+          beginCaptures: {
+            "0": {
+              name: "punctuation.definition.string.begin.likec4"
+            }
+          },
+          endCaptures: {
+            "0": {
+              name: "punctuation.definition.string.end.likec4"
+            }
+          }
+        },
+        {
+          name: "string.quoted.single.likec4",
+          begin: "'",
+          end: "'|$",
+          beginCaptures: {
+            "0": {
+              name: "punctuation.definition.string.begin.likec4"
+            }
+          },
+          endCaptures: {
+            "0": {
+              name: "punctuation.definition.string.end.likec4"
+            }
+          },
+          patterns: [
+            {
+              name: "constant.character.escape.likec4",
+              match: "\\\\."
+            }
+          ]
+        },
+        {
+          name: "string.quoted.double.likec4",
+          begin: '"',
+          end: '"|$',
+          beginCaptures: {
+            "0": {
+              name: "punctuation.definition.string.begin.likec4"
+            }
+          },
+          endCaptures: {
+            "0": {
+              name: "punctuation.definition.string.end.likec4"
+            }
+          },
+          patterns: [
+            {
+              name: "constant.character.escape.likec4",
+              match: "\\\\."
+            }
+          ]
+        }
+      ]
+    },
+    urls: {
+      name: "markup.underline.link.likec4",
+      match: `\\bhttps?://[^\\s'"]+`
+    },
+    icons: {
+      comment: "Bundled icon ids: `tech:nginx`, `aws:…`, `gcp:…`, …",
+      match: "\\b(aws|azure|bootstrap|gcp|md|tech)(:)([\\w-]+)",
+      captures: {
+        "1": {
+          name: "support.constant.icon-pack.likec4"
+        },
+        "2": {
+          name: "punctuation.separator.likec4"
+        },
+        "3": {
+          name: "support.constant.icon.likec4"
+        }
+      }
+    },
+    "hex-colors": {
+      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-])"
+    },
+    tags: {
+      name: "entity.name.tag.likec4",
+      match: "#[A-Za-z_][\\w-]*"
+    },
+    "typed-arrow": {
+      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"
+        }
+      }
+    },
+    declarations: {
+      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*(?!(?:autoLayout|deploymentNode|dynamic|element|exclude|extend|extends|from|icons|import|include|instance|instanceOf|is|metadata|node|not|of|predicate|relationship|rgb|rgba|view|where|with|add|deployment|diff|dynamicPredicateGroup|global|group|likec4lib|model|predicateGroup|rank|remove|specification|style|styleGroup|views|alt|break|catch|else|finally|if|loop|opt|par|parallel|try|when)\\b)([A-Za-z_]\\w*)?",
+          captures: {
+            "1": {
+              name: "variable.other.definition.likec4"
+            },
+            "2": {
+              name: "keyword.operator.assignment.likec4"
+            },
+            "3": {
+              name: "entity.name.type.likec4"
+            }
+          }
+        }
+      ]
+    },
+    keywords: {
+      patterns: [
+        {
+          comment: "Keywords that open a block: `model { … }`.",
+          name: "keyword.control.block.likec4",
+          match: "\\b(?:add|deployment|diff|dynamicPredicateGroup|global|group|likec4lib|model|predicateGroup|rank|remove|specification|style|styleGroup|views)\\b(?=\\s*\\{)"
+        },
+        {
+          name: "keyword.operator.word.likec4",
+          match: "\\b(?:and|or|not|is)\\b"
+        },
+        {
+          name: "keyword.control.likec4",
+          match: "\\b(?:autoLayout|deploymentNode|dynamic|element|exclude|extend|extends|from|icons|import|include|instance|instanceOf|is|metadata|node|not|of|predicate|relationship|rgb|rgba|view|where|with|alt|break|catch|else|finally|if|loop|opt|par|parallel|try|when|add|deployment|diff|dynamicPredicateGroup|global|group|likec4lib|model|predicateGroup|rank|remove|specification|style|styleGroup|views)\\b"
+        },
+        {
+          name: "variable.language.likec4",
+          match: "\\b(?:source|target)\\b"
+        },
+        {
+          name: "support.type.property-name.likec4",
+          match: "\\b(?:border|color|description|descriptionFile|head|icon|iconColor|iconPosition|iconSize|includeAncestors|kind|line|link|multiple|navigateTo|notation|notes|opacity|order|padding|routing|shape|size|sizing|style|summary|tag|tail|technology|textSize|title|variant)\\b"
+        },
+        {
+          name: "constant.language.likec4",
+          match: "\\b(?:agent|amber|auto|blue|bottom|BottomTop|browser|bucket|component|crow|cylinder|dashed|diagram|diamond|document|dot|dotted|fixed|gray|green|indigo|large|left|LeftRight|lg|max|md|medium|min|mobile|muted|none|normal|odiamond|odot|onormal|open|ortho|person|primary|queue|rectangle|red|right|RightLeft|same|secondary|sequence|sink|sky|slate|sm|small|solid|source|spline|storage|top|TopBottom|vee|xl|xlarge|xs|xsmall)\\b"
+        }
+      ]
+    },
+    numbers: {
+      name: "constant.numeric.likec4",
+      match: "\\b\\d+(?:\\.\\d+)?%?"
+    },
+    operators: {
+      patterns: [
+        {
+          name: "keyword.operator.arrow.likec4",
+          match: "\\]<->|\\]->|<->|->"
+        },
+        {
+          name: "keyword.operator.wildcard.likec4",
+          match: "\\.\\*\\*|\\.\\*|\\*\\*|\\*"
+        }
+      ]
+    },
+    punctuation: {
+      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: "\\."
+        }
+      ]
+    }
+  }
+};
+
+// src/grammar/source.ts
+import { createHash } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath } 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 ?? fileURLToPath(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(fileURLToPath(BUNDLED_GRAMMAR), "utf8"));
+    return { repo: $generated?.repo, ref: $generated?.ref };
+  } catch {
+    return {};
+  }
+}
+function grammarSha(source) {
+  return createHash("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 = createHash("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/expressive-code.ts
+function registration(grammar) {
+  return {
+    ...grammar,
+    name: LANGUAGE_NAME,
+    aliases: [...LANGUAGE_ALIASES]
+  };
+}
+var likec4Language = registration(likec4_tmLanguage_default);
+async function loadLikeC4Language(options) {
+  const { grammar: resolved } = await resolveLikeC4Grammar(options);
+  return registration(resolved);
+}
+var expressive_code_default = likec4Language;
+export {
+  expressive_code_default as default,
+  likec4Language,
+  loadLikeC4Language
+};
+
+//# debugId=AA3350C3BE6D0C0664756E2164756E21
+//# sourceMappingURL=expressive-code.js.map