@ng-doc/builder 22.0.0 → 22.2.0

package/generator/content/html-worker.js

@@ -387,6 +387,13 @@ var init_kebab_case = __esm({
   }
 });
 
+// libs/core/helpers/playground-target-slugs.ts
+var init_playground_target_slugs = __esm({
+  "libs/core/helpers/playground-target-slugs.ts"() {
+    "use strict";
+  }
+});
+
 // libs/core/helpers/stringify.ts
 var init_stringify = __esm({
   "libs/core/helpers/stringify.ts"() {
@@ -428,6 +435,7 @@ var init_helpers = __esm({
     init_is_same_object();
     init_kebab_case();
     init_object_keys();
+    init_playground_target_slugs();
     init_stringify();
     init_uid();
     init_unique();
@@ -776,6 +784,329 @@ var init_helpers2 = __esm({
   }
 });
 
+// libs/utils/html/plugins/keyword-positions.ts
+function scanInlineCode(text) {
+  if (WHOLE_KEYWORD.test(text)) {
+    return { whole: true, position: () => REFERENCE };
+  }
+  if (HTML_START.test(text) || !(CODE_PUNCTUATION.test(text) || DECLARATION_START.test(text))) {
+    return void 0;
+  }
+  const scan = scanTypeScript(text);
+  return isProse(text, scan.masked) ? void 0 : scan;
+}
+function scanCodeBlock(text, mode) {
+  return mode === "html" ? scanHtml(text) : scanTypeScript(text);
+}
+function scanTypeScript(text) {
+  const masked = maskTypeScript(text);
+  const locals = localBindings(text, masked);
+  return {
+    whole: false,
+    masked,
+    position(start, end, key) {
+      if (masked[start] === TEMPLATE) {
+        const before = text[start - 1] ?? "";
+        const element = key.includes("-") && (before === "<" || before === "/" && text[start - 2] === "<");
+        const controlFlow = CONTROL_FLOW.test(key) && !WORD_CHARACTER.test(before);
+        return element || controlFlow ? REFERENCE : NOT_A_REFERENCE;
+      }
+      if (masked[start] !== CODE) {
+        return NOT_A_REFERENCE;
+      }
+      const previous = previousSignificant(text, start, masked);
+      const next = nextSignificant(text, end, masked);
+      const nextCharacter = text[next] ?? "";
+      if (SYNTAX_WORDS.has(key) || RESERVED_WORDS.has(key) && nextCharacter !== "(") {
+        return NOT_A_REFERENCE;
+      }
+      if (text[previous] === "." && text[previous - 1] !== ".") {
+        const ownerEnd = text[previous - 1] === "?" ? previous - 1 : previous;
+        const owner = text.slice(0, ownerEnd).match(IDENTIFIER_BEFORE)?.[0];
+        const word = text.slice(start, end);
+        return owner && !/[.#]/.test(word) ? { link: true, keyword: `${owner}.${key.toLowerCase()}` } : NOT_A_REFERENCE;
+      }
+      if (isDeclaredName(text, masked, previous, next)) {
+        return NOT_A_REFERENCE;
+      }
+      return locals.has(key) ? NOT_A_REFERENCE : REFERENCE;
+    }
+  };
+}
+function isDeclaredName(text, masked, previous, next) {
+  const after = text[next];
+  const afterNext = text[nextSignificant(text, next + 1, masked)];
+  if (after === ":" && text[next + 1] !== ":") {
+    const ternary = text[previous] === "?" && text[previous + 1] !== ".";
+    return !ternary && previousWord(text, previous) !== "case";
+  }
+  if ((after === "?" || after === "!") && afterNext === ":") {
+    return true;
+  }
+  if (after === "?" && (afterNext === ")" || afterNext === ",")) {
+    return true;
+  }
+  if (after === "=" && text[next + 1] !== "=" && text[next + 1] !== ">") {
+    return !TYPE_CONTEXT.includes(text[previous] ?? "") && !TYPE_WORDS.includes(previousWord(text, previous));
+  }
+  return false;
+}
+function scanHtml(text) {
+  const masked = maskHtml(text);
+  return {
+    whole: false,
+    position: (start) => masked[start] === CODE ? REFERENCE : NOT_A_REFERENCE
+  };
+}
+function maskTypeScript(text) {
+  const masked = new Uint8Array(text.length);
+  const templates = [];
+  let depth = 0;
+  let index = 0;
+  const string = (quote) => {
+    const start = index++;
+    while (index < text.length && text[index] !== quote && text[index] !== "\n") {
+      index += text[index] === "\\" ? 2 : 1;
+    }
+    masked.fill(STRING, start, Math.min(++index, text.length));
+  };
+  const template = () => {
+    const start = index++;
+    while (index < text.length && text[index] !== "`") {
+      if (text[index] === "\\") {
+        index += 2;
+      } else if (text[index] === "$" && text[index + 1] === "{") {
+        masked.fill(TEMPLATE, start, index);
+        templates.push(depth);
+        index += 2;
+        return;
+      } else {
+        index++;
+      }
+    }
+    masked.fill(TEMPLATE, start, Math.min(++index, text.length));
+  };
+  while (index < text.length) {
+    const character = text[index];
+    if (character === "/" && text[index + 1] === "/") {
+      const end = text.indexOf("\n", index);
+      const stop = end < 0 ? text.length : end;
+      masked.fill(COMMENT, index, stop);
+      index = stop;
+    } else if (character === "/" && text[index + 1] === "*") {
+      const end = text.indexOf("*/", index + 2);
+      const stop = end < 0 ? text.length : end + 2;
+      masked.fill(COMMENT, index, stop);
+      index = stop;
+    } else if (character === "'" || character === '"') {
+      string(character);
+    } else if (character === "`") {
+      template();
+    } else if (character === "{") {
+      depth++;
+      index++;
+    } else if (character === "}") {
+      if (templates.length && templates[templates.length - 1] === depth) {
+        templates.pop();
+        template();
+      } else {
+        depth--;
+        index++;
+      }
+    } else {
+      index++;
+    }
+  }
+  return masked;
+}
+function maskHtml(text) {
+  const masked = new Uint8Array(text.length);
+  let index = 0;
+  while (index < text.length) {
+    if (text.startsWith("<!--", index)) {
+      const end = text.indexOf("-->", index + 4);
+      const stop = end < 0 ? text.length : end + 3;
+      masked.fill(COMMENT, index, stop);
+      index = stop;
+    } else if (text[index] === "<" && /[A-Za-z/]/.test(text[index + 1] ?? "")) {
+      index = maskTag(text, index + 1, masked);
+    } else {
+      index++;
+    }
+  }
+  return masked;
+}
+function maskTag(text, index, masked) {
+  while (index < text.length && text[index] !== ">") {
+    if (text[index] !== "=") {
+      index++;
+      continue;
+    }
+    index++;
+    while (text[index] === " " || text[index] === "	" || text[index] === "\n") index++;
+    const quote = text[index];
+    const start = index;
+    if (quote === '"' || quote === "'") {
+      const end = text.indexOf(quote, index + 1);
+      index = end < 0 ? text.length : end + 1;
+    } else {
+      while (index < text.length && !/[\s>]/.test(text[index] ?? "")) index++;
+    }
+    masked.fill(STRING, start, index);
+  }
+  return index + 1;
+}
+function localBindings(text, masked) {
+  const names = /* @__PURE__ */ new Set();
+  for (const match of text.matchAll(/\b(?:const|let|var)\s+([\p{L}_$][\p{L}\w$]*)/gu)) {
+    if (!masked[match.index]) names.add(match[1] ?? "");
+  }
+  for (const match of text.matchAll(
+    /\bimport\s+(?:type\s+)?([^;]*?)\s+from\s+(['"])\.{1,2}\/[^'"]*\2/gu
+  )) {
+    if (masked[match.index]) continue;
+    for (const name of (match[1] ?? "").matchAll(
+      /([\p{L}_$][\p{L}\w$]*)(?:\s+as\s+([\p{L}_$][\p{L}\w$]*))?/gu
+    )) {
+      const local = name[2] ?? name[1] ?? "";
+      if (local !== "type" && local !== "as") names.add(local);
+    }
+  }
+  return names;
+}
+function isProse(text, masked) {
+  for (const match of text.matchAll(/[\p{L}_$][\p{L}\w$]*(?: [\p{L}_$][\p{L}\w$]*){2,}/gu)) {
+    const words = match[0].split(" ");
+    const plain = words.filter((word) => !SYNTAX_WORDS.has(word) && !RESERVED_WORDS.has(word));
+    if (!masked[match.index] && plain.length >= 3) {
+      return true;
+    }
+  }
+  return false;
+}
+function previousSignificant(text, index, masked) {
+  let position = index - 1;
+  while (position >= 0 && insignificant(text, position, masked)) position--;
+  return position;
+}
+function nextSignificant(text, index, masked) {
+  let position = index;
+  while (position < text.length && insignificant(text, position, masked)) position++;
+  return position;
+}
+function insignificant(text, index, masked) {
+  return masked[index] === COMMENT || /\s/.test(text[index] ?? "");
+}
+function previousWord(text, index) {
+  let start = index;
+  while (start >= 0 && WORD_CHARACTER.test(text[start] ?? "")) start--;
+  return text.slice(start + 1, index + 1);
+}
+var WORD_CHARACTER, IDENTIFIER_BEFORE, WHOLE_KEYWORD, CODE_PUNCTUATION, DECLARATION_START, HTML_START, SYNTAX_WORDS, RESERVED_WORDS, TYPE_CONTEXT, TYPE_WORDS, CODE, STRING, COMMENT, TEMPLATE, CONTROL_FLOW, NOT_A_REFERENCE, REFERENCE;
+var init_keyword_positions = __esm({
+  "libs/utils/html/plugins/keyword-positions.ts"() {
+    "use strict";
+    WORD_CHARACTER = /[*\p{L}\w$@-]/u;
+    IDENTIFIER_BEFORE = /[\p{L}\w$@-]+$/u;
+    WHOLE_KEYWORD = /^\s*[*\p{L}\w$@-]+(?:[.#][\p{L}\w-]+)?(?:\?[\w=&]+)?\s*$/u;
+    CODE_PUNCTUATION = /[(){}[\]<>|:=@]/;
+    DECLARATION_START = /^\s*(?:export|import|class|interface|type|const|let|var|function|enum|abstract|declare)\s/;
+    HTML_START = /^\s*<\/?[A-Za-z]/;
+    SYNTAX_WORDS = /* @__PURE__ */ new Set([
+      "await",
+      "break",
+      "case",
+      "catch",
+      "continue",
+      "debugger",
+      "delete",
+      "do",
+      "else",
+      "false",
+      "finally",
+      "for",
+      "function",
+      "if",
+      "instanceof",
+      "new",
+      "null",
+      "return",
+      "super",
+      "switch",
+      "this",
+      "throw",
+      "true",
+      "try",
+      "typeof",
+      "void",
+      "while",
+      "with",
+      "yield"
+    ]);
+    RESERVED_WORDS = /* @__PURE__ */ new Set([
+      "abstract",
+      "accessor",
+      "any",
+      "as",
+      "asserts",
+      "async",
+      "bigint",
+      "boolean",
+      "class",
+      "const",
+      "constructor",
+      "declare",
+      "default",
+      "enum",
+      "export",
+      "extends",
+      "from",
+      "get",
+      "implements",
+      "import",
+      "in",
+      "infer",
+      "interface",
+      "is",
+      "keyof",
+      "let",
+      "module",
+      "namespace",
+      "never",
+      "number",
+      "object",
+      "of",
+      "out",
+      "override",
+      "package",
+      "private",
+      "protected",
+      "public",
+      "readonly",
+      "require",
+      "satisfies",
+      "set",
+      "static",
+      "string",
+      "symbol",
+      "type",
+      "undefined",
+      "unique",
+      "unknown",
+      "var"
+    ]);
+    TYPE_CONTEXT = [":", "|", "&", "<"];
+    TYPE_WORDS = ["type", "extends", "keyof", "typeof"];
+    CODE = 0;
+    STRING = 1;
+    COMMENT = 2;
+    TEMPLATE = 3;
+    CONTROL_FLOW = /^@[a-z]+$/;
+    NOT_A_REFERENCE = Object.freeze({ link: false });
+    REFERENCE = Object.freeze({ link: true });
+  }
+});
+
 // libs/utils/html/plugins/keywords.plugin.ts
 import { isElement as isElement5 } from "hast-util-is-element";
 import { toString } from "hast-util-to-string";
@@ -787,23 +1118,50 @@ function keywordsPlugin(config) {
     }
     const isInlineCode = !isElement5(ancestors[ancestors.length - 1], "pre");
     const lang = asArray(node.properties?.["className"] ?? []).find((className) => className.startsWith("language-"))?.replace("language-", "") ?? "";
-    if (isInlineCode || LANGUAGES.includes(lang)) {
-      visitParents(node, "text", (node2, ancestors2) => {
-        if (hasLinkAncestor(ancestors2)) {
-          return;
-        }
-        const parent = ancestors2[ancestors2.length - 1];
-        const index = parent.children.indexOf(node2);
-        const nodes = getNodes(node2, parent, isInlineCode, config, lang);
-        Array.prototype.splice.apply(parent.children, [index, 1].concat(nodes));
-        return [SKIP, index + nodes.length];
-      });
+    if (!isInlineCode && !LANGUAGES.includes(lang)) {
+      return;
     }
+    const offsets = textOffsets(node);
+    const text = Array.from(offsets.keys()).map((textNode) => textNode.value).join("");
+    const scan = isInlineCode ? scanInlineCode(text) : scanCodeBlock(text, HTML_LANGUAGES.includes(lang) ? "html" : "typescript");
+    if (!scan) {
+      return;
+    }
+    visitParents(node, "text", (node2, ancestors2) => {
+      if (hasLinkAncestor(ancestors2)) {
+        return;
+      }
+      const parent = ancestors2[ancestors2.length - 1];
+      const index = parent.children.indexOf(node2);
+      const nodes = getNodes(
+        node2,
+        parent,
+        isInlineCode,
+        config,
+        lang,
+        scan,
+        offsets.get(node2) ?? 0
+      );
+      Array.prototype.splice.apply(parent.children, [index, 1].concat(nodes));
+      return [SKIP, index + nodes.length];
+    });
   });
 }
-function getNodes(node, parent, isInlineCode, config, language) {
+function textOffsets(node) {
+  const offsets = /* @__PURE__ */ new Map();
+  let offset = 0;
+  visitParents(node, "text", (text) => {
+    offsets.set(text, offset);
+    offset += text.value.length;
+  });
+  return offsets;
+}
+function getNodes(node, parent, isInlineCode, config, language, scan, offset) {
   const { addUsedKeyword, getKeyword } = config;
+  let start = offset;
   return toString(node).split(SPLIT_REGEXP).map((word) => {
+    const wordStart = start;
+    start += word.length;
     const match = word.match(MATCH_KEYWORD_REGEXP);
     if (!match) {
       return { type: "text", value: word };
@@ -814,8 +1172,13 @@ function getNodes(node, parent, isInlineCode, config, language) {
       anchor = "",
       queryParams = ""
     } = match.groups;
-    const usedKeyword = `${key}${delimiter}${anchor?.toLowerCase()}`;
-    const rootKeyword = getKeyword?.(key);
+    const position = scan.position(wordStart, wordStart + word.length, key);
+    if (!position.link) {
+      return { type: "text", value: word };
+    }
+    const isMember = position.keyword !== void 0;
+    const usedKeyword = position.keyword ?? `${key}${delimiter}${anchor?.toLowerCase()}`;
+    const rootKeyword = isMember ? void 0 : getKeyword?.(key);
     const keyword = getKeyword?.(usedKeyword);
     const isGuideKeyword = key.startsWith("*");
     const isLanguageAllowed = !keyword?.languages && ALWAYS_ALLOWED_LANGUAGES.includes(language) || !!keyword?.languages?.includes(language);
@@ -828,7 +1191,7 @@ function getNodes(node, parent, isInlineCode, config, language) {
     addUsedKeyword?.(usedKeyword);
     const notFoundGuideKeyword = isGuideKeyword && !keyword;
     const notFoundApiAnchorKeyword = !!rootKeyword && !!anchor && !keyword;
-    if (getKeyword && isInlineCode && (notFoundGuideKeyword || notFoundApiAnchorKeyword)) {
+    if (getKeyword && scan.whole && (notFoundGuideKeyword || notFoundApiAnchorKeyword)) {
       throw new Error(`Route with keyword "${word}" is missing.`);
     }
     if (parent.properties) {
@@ -844,7 +1207,7 @@ function getNodes(node, parent, isInlineCode, config, language) {
       }
     }
     return keyword ? createLinkNode(
-      isInlineCode ? keyword.title : word,
+      isInlineCode && !isMember ? keyword.title : word,
       keyword.path,
       keyword.type,
       keyword.description
@@ -864,14 +1227,16 @@ function createLinkNode(text, href, type, description) {
     children: [{ type: "text", value: text }]
   };
 }
-var ALWAYS_ALLOWED_LANGUAGES, LANGUAGES, SPLIT_REGEXP, MATCH_KEYWORD_REGEXP;
+var ALWAYS_ALLOWED_LANGUAGES, HTML_LANGUAGES, LANGUAGES, SPLIT_REGEXP, MATCH_KEYWORD_REGEXP;
 var init_keywords_plugin = __esm({
   "libs/utils/html/plugins/keywords.plugin.ts"() {
     "use strict";
     init_core();
     init_helpers2();
+    init_keyword_positions();
     ALWAYS_ALLOWED_LANGUAGES = ["typescript", "ts", "angular-ts"];
-    LANGUAGES = ["typescript", "ts", "angular-ts", ...KEYWORD_ALLOWED_LANGUAGES];
+    HTML_LANGUAGES = [...KEYWORD_ALLOWED_LANGUAGES];
+    LANGUAGES = [...ALWAYS_ALLOWED_LANGUAGES, ...HTML_LANGUAGES];
     SPLIT_REGEXP = /([*\p{L}\w$@-]+(?:[.#][\p{L}\w-]+)?(?:\?[\w=&]+)?)/u;
     MATCH_KEYWORD_REGEXP = /(?<key>[*\p{L}\w$@-]+)((?<delimiter>[.#])(?<anchor>[\p{L}\w-]+))?(?<queryParams>\?[\w=&]+)?/u;
   }
@@ -929,13 +1294,14 @@ var init_add_heading_anchors_plugin = __esm({
 });
 
 // libs/utils/html/plugins/cached-shiki.plugin.ts
-import rehypeShiki from "@shikijs/rehype";
 import { toString as toString2 } from "hast-util-to-string";
 import { visit as visit2 } from "unist-util-visit";
 function cachedShikiPlugin(settings) {
-  const { cache, themes, identity, defaultLanguage } = settings;
+  const { cache, themes, languages, identity, defaultLanguage } = settings;
   const id = `${themes.light}
-${themes.dark}`;
+${themes.dark}
+${languages ?? ""}
+${settings.grammars ?? "all"}`;
   return async (tree) => {
     const blocks = [];
     visit2(tree, "element", (node, index, parent) => {
@@ -952,11 +1318,18 @@ ${themes.dark}`;
       blocks.push({
         node,
         parent,
-        key: cache.key({ options: identity, themes, lang, meta, code })
+        key: cache.key({
+          options: identity,
+          themes,
+          ...languages === void 0 ? {} : { languages },
+          lang,
+          meta,
+          code
+        })
       });
     });
     let highlighter;
-    const load = async () => highlighter ??= await highlighterFor(id, settings.options);
+    const load = async () => highlighter ??= await highlighterFor(id, settings.transformer);
     if (cache.loads?.(themes) !== true) await load();
     const values = [];
     for (const block of blocks) {
@@ -977,13 +1350,11 @@ ${themes.dark}`;
     });
   };
 }
-function highlighterFor(id, options) {
+function highlighterFor(id, transformer) {
   const known = highlighters.get(id);
   if (known) return known;
   const created = (async () => {
-    const transform = rehypeShiki(
-      options()
-    );
+    const transform = transformer();
     await transform({ type: "root", children: [] });
     return transform;
   })();
@@ -1001,11 +1372,18 @@ async function highlight(transform, node) {
 function fragment(value) {
   try {
     const parsed = JSON.parse(value);
-    return Array.isArray(parsed) && parsed.length > 0 && parsed.every((item) => isNode(item) && item.type === "element") ? parsed : void 0;
+    return Array.isArray(parsed) && parsed.length > 0 && parsed.every(isReplacement) ? parsed : void 0;
   } catch {
     return void 0;
   }
 }
+function isReplacement(value) {
+  if (isNode(value)) return value.type === "element";
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const node = value;
+  const children = node["children"];
+  return node["type"] === "root" && Array.isArray(children) && children.length > 0 && children.every((child) => isNode(child) && child.type === "element");
+}
 function isNode(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return false;
   const node = value;
@@ -1198,11 +1576,158 @@ var init_table_wrapper = __esm({
   }
 });
 
+// libs/utils/html/shiki-grammars.ts
+import {
+  bundledLanguages,
+  createHighlighter
+} from "shiki";
+import { visit as visit7 } from "unist-util-visit";
+function shikiGrammars() {
+  grammars ??= ShikiGrammars.create().catch((error) => {
+    grammars = void 0;
+    throw error;
+  });
+  return grammars;
+}
+function createGrammarlessHighlighter(themes) {
+  return createHighlighter({ themes, langs: [] });
+}
+function blockLanguages(tree, defaultLanguage) {
+  const languages = /* @__PURE__ */ new Set();
+  visit7(tree, "element", (node) => {
+    if (node.tagName !== "pre") return;
+    const head = node.children[0];
+    if (!head || head.type !== "element" || head.tagName !== "code" || !head.properties) return;
+    const classes = head.properties["className"];
+    const languageClass = Array.isArray(classes) ? classes.find((item) => typeof item === "string" && item.startsWith(languagePrefix2)) : void 0;
+    languages.add(
+      typeof languageClass === "string" ? languageClass.slice(languagePrefix2.length) : defaultLanguage
+    );
+  });
+  return languages;
+}
+function includedScopes(registration) {
+  const scopes = /* @__PURE__ */ new Set();
+  const walk = (value) => {
+    if (Array.isArray(value)) value.forEach(walk);
+    else if (value && typeof value === "object")
+      for (const [key, item] of Object.entries(value)) {
+        if (key === "include" && typeof item === "string") {
+          if (!item.startsWith("#") && !item.startsWith("$")) scopes.add(item.split("#")[0]);
+        } else walk(item);
+      }
+  };
+  walk(registration);
+  return scopes;
+}
+function prefixes(scope) {
+  const parts = scope.split(".");
+  return parts.map((_, index) => parts.slice(0, index + 1).join("."));
+}
+var ShikiGrammars, grammars, languagePrefix2;
+var init_shiki_grammars = __esm({
+  "libs/utils/html/shiki-grammars.ts"() {
+    "use strict";
+    ShikiGrammars = class _ShikiGrammars {
+      constructor(registrations) {
+        this.byName = /* @__PURE__ */ new Map();
+        this.byScope = /* @__PURE__ */ new Map();
+        this.injectors = /* @__PURE__ */ new Map();
+        this.order = /* @__PURE__ */ new Map();
+        this.closures = /* @__PURE__ */ new Map();
+        this.loaded = /* @__PURE__ */ new WeakMap();
+        const mention = (name) => {
+          if (!this.order.has(name)) this.order.set(name, this.order.size);
+        };
+        for (const registration of registrations) {
+          mention(registration.name);
+          for (const embedded of registration.embeddedLangs ?? []) mention(embedded);
+          if (this.byScope.has(registration.scopeName)) continue;
+          this.byScope.set(registration.scopeName, registration);
+          this.byName.set(registration.name, registration);
+          for (const alias of registration.aliases ?? []) this.byName.set(alias, registration);
+          for (const target of registration.injectTo ?? []) {
+            const list = this.injectors.get(target) ?? [];
+            list.push(registration);
+            this.injectors.set(target, list);
+          }
+        }
+      }
+      /**
+       * The bundled grammars, in the order `@shikijs/rehype` registers them: every bundled language
+       * name, each with the registrations of its module.
+       */
+      static async create() {
+        const modules = await Promise.all(
+          Object.keys(bundledLanguages).map(
+            (name) => bundledLanguages[name]()
+          )
+        );
+        return new _ShikiGrammars(modules.flatMap((module) => module.default));
+      }
+      /**
+       * The grammars that a block of `language` can reach, in registration order; empty for a
+       * language that no bundled grammar names (it falls back to plain text, as before).
+       * @param language
+       */
+      closure(language) {
+        const known = this.closures.get(language);
+        if (known) return known;
+        const set = /* @__PURE__ */ new Set();
+        const queue = [this.byName.get(language)];
+        while (queue.length) {
+          const registration = queue.pop();
+          if (!registration || set.has(registration)) continue;
+          set.add(registration);
+          for (const name of [
+            ...registration.embeddedLangs ?? [],
+            ...registration.embeddedLangsLazy ?? []
+          ])
+            queue.push(this.byName.get(name));
+          for (const scope of includedScopes(registration)) queue.push(this.byScope.get(scope));
+          for (const prefix of prefixes(registration.scopeName))
+            queue.push(...this.injectors.get(prefix) ?? []);
+          for (const target of registration.injectTo ?? [])
+            queue.push(...this.injectors.get(target) ?? []);
+        }
+        const closure = [...set].sort(
+          (left, right) => this.order.get(left.name) - this.order.get(right.name)
+        );
+        this.closures.set(language, closure);
+        return closure;
+      }
+      /**
+       * Loads the closures of `languages` that `highlighter` does not hold yet.
+       * @param highlighter
+       * @param languages
+       */
+      load(highlighter, languages) {
+        let loaded = this.loaded.get(highlighter);
+        if (!loaded) this.loaded.set(highlighter, loaded = /* @__PURE__ */ new Set());
+        const missing = /* @__PURE__ */ new Set();
+        for (const language of languages)
+          for (const registration of this.closure(language))
+            if (!loaded.has(registration.name)) missing.add(registration);
+        if (!missing.size) return;
+        const batch = [...missing].sort(
+          (left, right) => this.order.get(left.name) - this.order.get(right.name)
+        );
+        highlighter.loadLanguageSync(batch);
+        for (const registration of batch) loaded.add(registration.name);
+      }
+    };
+    languagePrefix2 = "language-";
+  }
+});
+
 // libs/utils/html/process-html.ts
-import rehypeShiki2 from "@shikijs/rehype";
+import rehypeShiki from "@shikijs/rehype";
+import rehypeShikiFromHighlighter from "@shikijs/rehype/core";
+import { createHash as createHash2 } from "node:crypto";
 import rehypeMinifyWhitespace2 from "rehype-minify-whitespace";
 import rehypeParse3 from "rehype-parse";
 import rehypeStringify3 from "rehype-stringify";
+import { bundledLanguages as bundledLanguages2, createHighlighter as createHighlighter2 } from "shiki";
 import { unified as unified3 } from "unified";
 async function processHtml(html, config) {
   const anchors = /* @__PURE__ */ new Set();
@@ -1210,6 +1735,8 @@ async function processHtml(html, config) {
     light: config.lightTheme ?? "github-light",
     dark: config.darkTheme ?? "ayu-dark"
   };
+  const langs = config.langs?.length ? config.langs : void 0;
+  const used = !langs && config.grammars === "used";
   try {
     const content = await unified3().use(rehypeParse3, { fragment: true }).use(rehypeStringify3).use(mermaidPlugin).use(
       config.highlight ? [
@@ -1218,12 +1745,16 @@ async function processHtml(html, config) {
           {
             cache: config.highlight,
             themes,
+            ...langs ? { languages: languagesId(langs) } : {},
+            ...used ? { grammars: "used" } : {},
             identity: HIGHLIGHT_IDENTITY,
             defaultLanguage: DEFAULT_LANGUAGE,
-            options: () => shikiOptions(themes)
+            transformer: () => langs ? withLanguages(themes, langs) : used ? withUsedGrammars(themes) : rehypeShiki(
+              shikiOptions(themes)
+            )
           }
         ]
-      ] : [[rehypeShiki2, shikiOptions(themes)]]
+      ] : langs ? [[() => withLanguages(themes, langs)]] : used ? [[() => withUsedGrammars(themes)]] : [[rehypeShiki, shikiOptions(themes)]]
     ).use(highlightCodeLines).use(table_wrapper_default).use(sluggerPlugin, anchors.add.bind(anchors), config.headings).use(rehypeMinifyWhitespace2).use(addHeadingAnchors, config.route).use(markElementsPlugin).process(html).then((file) => file.toString());
     return { content, anchors: Array.from(anchors) };
   } catch (error) {
@@ -1249,7 +1780,59 @@ function shikiOptions(themes) {
 function shikiTheme(name) {
   return name === NG_DOC_SYNTAX_THEME_NAME ? ngDocSyntaxTheme() : name;
 }
-var DEFAULT_LANGUAGE, HIGHLIGHT_IDENTITY;
+function languagesId(langs) {
+  let id = languageIds.get(langs);
+  if (id === void 0) {
+    id = createHash2("sha256").update(JSON.stringify(langs)).digest("hex");
+    languageIds.set(langs, id);
+  }
+  return id;
+}
+function withLanguages(themes, langs) {
+  const id = `${themes.light}
+${themes.dark}
+${languagesId(langs)}`;
+  return async (tree) => {
+    let highlighter = languageHighlighters.get(id);
+    if (!highlighter) {
+      highlighter = createHighlighter2({
+        themes: [shikiTheme(themes.light), shikiTheme(themes.dark)],
+        // Later registrations of a name replace earlier ones, so the given languages win.
+        langs: [...Object.keys(bundledLanguages2), ...langs]
+      });
+      languageHighlighters.set(id, highlighter);
+      const created = highlighter;
+      created.catch(() => {
+        if (languageHighlighters.get(id) === created) languageHighlighters.delete(id);
+      });
+    }
+    const transform = rehypeShikiFromHighlighter(await highlighter, shikiOptions(themes));
+    await transform(tree);
+  };
+}
+function withUsedGrammars(themes) {
+  const id = `${themes.light}
+${themes.dark}`;
+  return async (tree) => {
+    let highlighter = usedHighlighters.get(id);
+    if (!highlighter) {
+      highlighter = createGrammarlessHighlighter([
+        shikiTheme(themes.light),
+        shikiTheme(themes.dark)
+      ]);
+      usedHighlighters.set(id, highlighter);
+      const created = highlighter;
+      created.catch(() => {
+        if (usedHighlighters.get(id) === created) usedHighlighters.delete(id);
+      });
+    }
+    const [grammars2, ready] = await Promise.all([shikiGrammars(), highlighter]);
+    grammars2.load(ready, blockLanguages(tree, DEFAULT_LANGUAGE));
+    const transform = rehypeShikiFromHighlighter(ready, shikiOptions(themes));
+    await transform(tree);
+  };
+}
+var DEFAULT_LANGUAGE, HIGHLIGHT_IDENTITY, languageHighlighters, languageIds, usedHighlighters;
 var init_process_html = __esm({
   "libs/utils/html/process-html.ts"() {
     "use strict";
@@ -1261,24 +1844,28 @@ var init_process_html = __esm({
     init_mermaid_plugin();
     init_slugger_plugin();
     init_table_wrapper();
+    init_shiki_grammars();
     DEFAULT_LANGUAGE = "ts";
     HIGHLIGHT_IDENTITY = {
-      format: 1,
+      format: 2,
       defaultLanguage: DEFAULT_LANGUAGE,
       fallbackLanguage: "text",
       addLanguageClass: true,
       parseMetaString: "json-without-backslashes",
       tokenizeTimeLimit: 0
     };
+    languageHighlighters = /* @__PURE__ */ new Map();
+    languageIds = /* @__PURE__ */ new WeakMap();
+    usedHighlighters = /* @__PURE__ */ new Map();
   }
 });
 
 // libs/utils/html/plugins/remove-not-indexable-content.plugin.ts
 import { filter } from "unist-util-filter";
-import { visit as visit7 } from "unist-util-visit";
+import { visit as visit8 } from "unist-util-visit";
 function removeNotIndexableContentPlugin() {
   return (tree) => {
-    visit7(tree, "element", (node) => {
+    visit8(tree, "element", (node) => {
       if (isHeading(node) && isHiddenSpan(node.children[0])) {
         node.children = node.children.slice(1);
       }
@@ -1364,13 +1951,13 @@ import { parseFile } from "@orama/plugin-parsedoc";
 async function renderDocuments(task, highlight2, aborted = notAborted) {
   const results = [];
   for (const document of task.documents) {
-    const result = await renderDocument(document, task.themes, highlight2, aborted);
+    const result = await renderDocument(document, task, highlight2, aborted);
     results.push(result);
     if (!("html" in result)) break;
   }
   return results;
 }
-async function renderDocument(document, themes, highlight2, aborted) {
+async function renderDocument(document, { themes, langs, grammars: grammars2 }, highlight2, aborted) {
   if (aborted()) return { aborted: true, mismatches: 0 };
   const utilities = await htmlUtilities();
   if (aborted()) return { aborted: true, mismatches: 0 };
@@ -1380,6 +1967,8 @@ async function renderDocument(document, themes, highlight2, aborted) {
     ...document.route === void 0 ? {} : { route: document.route },
     lightTheme: themes.light,
     darkTheme: themes.dark,
+    ...langs ? { langs } : {},
+    grammars: grammars2 ?? "used",
     ...call ? { highlight: call } : {}
   });
   const mismatches = call?.mismatches.length ?? 0;
@@ -1554,7 +2143,9 @@ function serveHtmlThread(port) {
             await renderDocuments(
               {
                 documents: [{ html: WARM_DOCUMENT }],
-                themes: job["themes"]
+                themes: job["themes"],
+                ...job["langs"] ? { langs: job["langs"] } : {},
+                ...job["grammars"] === "all" ? { grammars: "all" } : {}
               },
               () => job["cache"] === true ? cache : void 0
             );
@@ -1583,7 +2174,7 @@ var init_html_pipeline = __esm({
     init_protocol();
     htmlUtilities = () => Promise.resolve().then(() => (init_utils(), utils_exports));
     notAborted = () => false;
-    WARM_DOCUMENT = '<pre><code class="language-ts">const warm = 1;</code></pre>';
+    WARM_DOCUMENT = ["ts", "angular-ts", "angular-html"].map((language) => `<pre><code class="language-${language}">warm</code></pre>`).join("");
   }
 });