@ng-doc/builder 22.0.0-beta.2 → 22.1.0

package/generator/content/html-worker.js

@@ -0,0 +1,2181 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// libs/builder/generator/contracts.ts
+var init_contracts = __esm({
+  "libs/builder/generator/contracts.ts"() {
+    "use strict";
+  }
+});
+
+// libs/builder/generator/kernel/canonical.ts
+import { createHash } from "node:crypto";
+function compareCodeUnits(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function sha256Hex(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function canonicalJson(value) {
+  return canonical(value, /* @__PURE__ */ new Set()) ?? "null";
+}
+function canonical(value, path) {
+  if (value !== null && typeof value === "object" && typeof value.toJSON === "function")
+    value = value.toJSON();
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (path.has(value)) throw new TypeError("Converting circular structure to canonical JSON");
+  path.add(value);
+  let text;
+  if (Array.isArray(value)) {
+    text = `[${Array.from(value, (item) => canonical(item, path) ?? "null").join(",")}]`;
+  } else {
+    const fields = [];
+    for (const key of Object.keys(value).sort(compareCodeUnits)) {
+      const item = canonical(value[key], path);
+      if (item !== void 0) fields.push(`${JSON.stringify(key)}:${item}`);
+    }
+    text = `{${fields.join(",")}}`;
+  }
+  path.delete(value);
+  return text;
+}
+function digestOf(value) {
+  return sha256Hex(canonicalJson(value));
+}
+var init_canonical = __esm({
+  "libs/builder/generator/kernel/canonical.ts"() {
+    "use strict";
+    init_contracts();
+  }
+});
+
+// libs/builder/generator/worker/protocol.ts
+function encode(value) {
+  const result = JSON.stringify(
+    value,
+    function(key, item) {
+      const original = this[key];
+      if (typeof item === "function" || typeof item === "symbol" || typeof item === "bigint" || typeof item === "number" && !Number.isFinite(item) || original !== null && typeof original === "object" && !Array.isArray(original) && (Object.getPrototypeOf(original) !== Object.prototype && Object.getPrototypeOf(original) !== null || typeof original.toJSON === "function"))
+        throw new Error("Worker transport requires JSON values");
+      return item;
+    }
+  );
+  if (result === void 0) throw new Error("Worker transport requires a JSON value");
+  return result;
+}
+function decode(value) {
+  if (typeof value !== "string") throw new Error("Worker message must be JSON text");
+  const parsed = JSON.parse(value);
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("Worker message must be an object");
+  }
+  return parsed;
+}
+var init_protocol = __esm({
+  "libs/builder/generator/worker/protocol.ts"() {
+    "use strict";
+  }
+});
+
+// libs/utils/html/minify.ts
+import rehypeMinifyWhitespace from "rehype-minify-whitespace";
+import rehypeParse from "rehype-parse";
+import rehypeStringify from "rehype-stringify";
+import { unified } from "unified";
+function minify(html) {
+  return unified().use(rehypeParse, { fragment: true }).use(rehypeStringify).use(rehypeMinifyWhitespace).processSync(html).toString();
+}
+var init_minify = __esm({
+  "libs/utils/html/minify.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/constants/angular-entities.ts
+var init_angular_entities = __esm({
+  "libs/core/constants/angular-entities.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/constants/declarations.ts
+var init_declarations = __esm({
+  "libs/core/constants/declarations.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/constants/defaults.ts
+var NG_DOC_ELEMENT;
+var init_defaults = __esm({
+  "libs/core/constants/defaults.ts"() {
+    "use strict";
+    NG_DOC_ELEMENT = "ngde";
+  }
+});
+
+// libs/core/constants/dynamic-selector.ts
+var init_dynamic_selector = __esm({
+  "libs/core/constants/dynamic-selector.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/constants/empty.ts
+var init_empty = __esm({
+  "libs/core/constants/empty.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/constants/syntax-theme.ts
+function ngDocSyntaxTheme() {
+  return {
+    name: NG_DOC_SYNTAX_THEME_NAME,
+    type: "light",
+    colors: {
+      "editor.foreground": syntax("plain"),
+      "editor.background": "var(--ng-doc-code-background)"
+    },
+    // A more specific scope wins over a shorter one, so the order below does not matter.
+    tokenColors: [
+      {
+        scope: ["comment", "punctuation.definition.comment", "string.quoted.docstring"],
+        settings: { foreground: syntax("comment"), fontStyle: "italic" }
+      },
+      {
+        scope: [
+          "punctuation",
+          "meta.brace",
+          "keyword.operator",
+          "punctuation.definition.tag",
+          "punctuation.definition.template-expression",
+          "punctuation.section.embedded"
+        ],
+        settings: { foreground: syntax("punctuation") }
+      },
+      {
+        scope: [
+          "keyword",
+          "storage",
+          "keyword.operator.new",
+          "keyword.operator.expression",
+          "keyword.operator.word",
+          "variable.language",
+          "markup.heading"
+        ],
+        settings: { foreground: syntax("keyword") }
+      },
+      {
+        scope: [
+          "entity.name.type",
+          "entity.name.class",
+          "entity.name.namespace",
+          "entity.other.inherited-class",
+          "support.type",
+          "support.class",
+          "markup.underline.link"
+        ],
+        settings: { foreground: syntax("type") }
+      },
+      {
+        scope: [
+          "entity.name.function",
+          "support.function",
+          "variable.function",
+          "entity.other.attribute-name"
+        ],
+        settings: { foreground: syntax("function") }
+      },
+      {
+        scope: [
+          "string",
+          "punctuation.definition.string",
+          "markup.inline.raw",
+          "markup.fenced_code"
+        ],
+        settings: { foreground: syntax("string") }
+      },
+      {
+        // Code embedded in a string, such as a template literal's `${…}`.
+        scope: ["meta.template.expression", "meta.embedded"],
+        settings: { foreground: syntax("plain") }
+      },
+      {
+        scope: [
+          "constant.numeric",
+          "constant.language",
+          "constant.character",
+          "constant.other",
+          "keyword.other.unit"
+        ],
+        settings: { foreground: syntax("number") }
+      },
+      {
+        scope: ["entity.name.tag", "support.class.component"],
+        settings: { foreground: syntax("tag") }
+      },
+      {
+        // The `@` and the decorator name; its arguments keep their own colours.
+        scope: ["punctuation.decorator", "meta.decorator entity.name.function"],
+        settings: { foreground: syntax("decorator") }
+      },
+      { scope: ["markup.bold", "markup.heading"], settings: { fontStyle: "bold" } },
+      { scope: ["markup.italic"], settings: { fontStyle: "italic" } }
+    ]
+  };
+}
+var NG_DOC_SYNTAX_THEME_NAME, syntax;
+var init_syntax_theme = __esm({
+  "libs/core/constants/syntax-theme.ts"() {
+    "use strict";
+    NG_DOC_SYNTAX_THEME_NAME = "css-variables";
+    syntax = (token) => `var(--ng-doc-syntax-${token})`;
+  }
+});
+
+// libs/core/constants/index.ts
+var init_constants = __esm({
+  "libs/core/constants/index.ts"() {
+    "use strict";
+    init_angular_entities();
+    init_declarations();
+    init_defaults();
+    init_dynamic_selector();
+    init_empty();
+    init_syntax_theme();
+  }
+});
+
+// libs/core/helpers/is-iterable.ts
+function isIterable(value) {
+  return value !== null && typeof value[Symbol.iterator] === "function" && typeof value !== "string";
+}
+var init_is_iterable = __esm({
+  "libs/core/helpers/is-iterable.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/helpers/is-present.ts
+function isPresent(value) {
+  return value !== void 0 && value !== null && (typeof value !== "string" || value !== "");
+}
+var init_is_present = __esm({
+  "libs/core/helpers/is-present.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/helpers/as-array.ts
+function asArray(...items) {
+  return items.map((data) => {
+    if (!isPresent(data)) {
+      return [];
+    }
+    return Array.isArray(data) ? data : isIterable(data) ? Array.from(data) : [data];
+  }).flat();
+}
+var init_as_array = __esm({
+  "libs/core/helpers/as-array.ts"() {
+    "use strict";
+    init_is_iterable();
+    init_is_present();
+  }
+});
+
+// libs/core/helpers/is-node-tag.ts
+var init_is_node_tag = __esm({
+  "libs/core/helpers/is-node-tag.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/helpers/object-keys.ts
+var init_object_keys = __esm({
+  "libs/core/helpers/object-keys.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/helpers/build-playground-demo-template.ts
+import * as CSSWhat from "css-what";
+import { SelectorType } from "css-what";
+var init_build_playground_demo_template = __esm({
+  "libs/core/helpers/build-playground-demo-template.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/helpers/capitalize.ts
+var init_capitalize = __esm({
+  "libs/core/helpers/capitalize.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/helpers/escape-html.ts
+var init_escape_html = __esm({
+  "libs/core/helpers/escape-html.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/helpers/escape-regexp.ts
+var init_escape_regexp = __esm({
+  "libs/core/helpers/escape-regexp.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/helpers/extract-value.ts
+var init_extract_value = __esm({
+  "libs/core/helpers/extract-value.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/helpers/extract-function-defaults.ts
+var init_extract_function_defaults = __esm({
+  "libs/core/helpers/extract-function-defaults.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/helpers/get-assigned-inputs.ts
+var init_get_assigned_inputs = __esm({
+  "libs/core/helpers/get-assigned-inputs.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/helpers/is-keyboard-event.ts
+var init_is_keyboard_event = __esm({
+  "libs/core/helpers/is-keyboard-event.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/helpers/is-route.ts
+var init_is_route = __esm({
+  "libs/core/helpers/is-route.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/helpers/is-same-object.ts
+var init_is_same_object = __esm({
+  "libs/core/helpers/is-same-object.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/helpers/kebab-case.ts
+var init_kebab_case = __esm({
+  "libs/core/helpers/kebab-case.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/helpers/stringify.ts
+var init_stringify = __esm({
+  "libs/core/helpers/stringify.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/helpers/uid.ts
+var init_uid = __esm({
+  "libs/core/helpers/uid.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/helpers/unique.ts
+var init_unique = __esm({
+  "libs/core/helpers/unique.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/helpers/index.ts
+var init_helpers = __esm({
+  "libs/core/helpers/index.ts"() {
+    "use strict";
+    init_as_array();
+    init_build_playground_demo_template();
+    init_capitalize();
+    init_escape_html();
+    init_escape_regexp();
+    init_extract_function_defaults();
+    init_extract_value();
+    init_get_assigned_inputs();
+    init_is_iterable();
+    init_is_keyboard_event();
+    init_is_node_tag();
+    init_is_present();
+    init_is_route();
+    init_is_same_object();
+    init_kebab_case();
+    init_object_keys();
+    init_stringify();
+    init_uid();
+    init_unique();
+  }
+});
+
+// libs/core/interfaces/api.ts
+var init_api = __esm({
+  "libs/core/interfaces/api.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/interfaces/api-list.ts
+var init_api_list = __esm({
+  "libs/core/interfaces/api-list.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/interfaces/api-list-item.ts
+var init_api_list_item = __esm({
+  "libs/core/interfaces/api-list-item.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/interfaces/api-scope.ts
+var init_api_scope = __esm({
+  "libs/core/interfaces/api-scope.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/interfaces/base-entity.ts
+var init_base_entity = __esm({
+  "libs/core/interfaces/base-entity.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/interfaces/category.ts
+var init_category = __esm({
+  "libs/core/interfaces/category.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/interfaces/content-module.ts
+var init_content_module = __esm({
+  "libs/core/interfaces/content-module.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/interfaces/demo-options.ts
+var init_demo_options = __esm({
+  "libs/core/interfaces/demo-options.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/interfaces/js-doc-metadata.ts
+var init_js_doc_metadata = __esm({
+  "libs/core/interfaces/js-doc-metadata.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/interfaces/keyword-map.ts
+var KEYWORD_ALLOWED_LANGUAGES;
+var init_keyword_map = __esm({
+  "libs/core/interfaces/keyword-map.ts"() {
+    "use strict";
+    KEYWORD_ALLOWED_LANGUAGES = ["html"];
+  }
+});
+
+// libs/core/interfaces/page.ts
+var init_page = __esm({
+  "libs/core/interfaces/page.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/interfaces/page-anchor.ts
+var init_page_anchor = __esm({
+  "libs/core/interfaces/page-anchor.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/interfaces/page-info.ts
+var init_page_info = __esm({
+  "libs/core/interfaces/page-info.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/interfaces/playground-config.ts
+var init_playground_config = __esm({
+  "libs/core/interfaces/playground-config.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/interfaces/playground-content.ts
+var init_playground_content = __esm({
+  "libs/core/interfaces/playground-content.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/interfaces/playground-data.ts
+var init_playground_data = __esm({
+  "libs/core/interfaces/playground-data.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/interfaces/playground-options.ts
+var init_playground_options = __esm({
+  "libs/core/interfaces/playground-options.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/interfaces/section-index.ts
+var init_section_index = __esm({
+  "libs/core/interfaces/section-index.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/interfaces/index.ts
+var init_interfaces = __esm({
+  "libs/core/interfaces/index.ts"() {
+    "use strict";
+    init_api();
+    init_api_list();
+    init_api_list_item();
+    init_api_scope();
+    init_base_entity();
+    init_category();
+    init_content_module();
+    init_demo_options();
+    init_js_doc_metadata();
+    init_keyword_map();
+    init_page();
+    init_page_anchor();
+    init_page_info();
+    init_playground_config();
+    init_playground_content();
+    init_playground_data();
+    init_playground_options();
+    init_section_index();
+  }
+});
+
+// libs/core/types/code-type.ts
+var init_code_type = __esm({
+  "libs/core/types/code-type.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/types/constructor.ts
+var init_constructor = __esm({
+  "libs/core/types/constructor.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/types/entity-type.ts
+var init_entity_type = __esm({
+  "libs/core/types/entity-type.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/types/extracted-value.ts
+var init_extracted_value = __esm({
+  "libs/core/types/extracted-value.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/types/function.ts
+var init_function = __esm({
+  "libs/core/types/function.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/types/heading.ts
+var init_heading = __esm({
+  "libs/core/types/heading.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/types/input-type.ts
+var init_input_type = __esm({
+  "libs/core/types/input-type.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/types/keywords-loader.ts
+var init_keywords_loader = __esm({
+  "libs/core/types/keywords-loader.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/types/page-type.ts
+var init_page_type = __esm({
+  "libs/core/types/page-type.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/types/style-type.ts
+var init_style_type = __esm({
+  "libs/core/types/style-type.ts"() {
+    "use strict";
+  }
+});
+
+// libs/core/types/index.ts
+var init_types = __esm({
+  "libs/core/types/index.ts"() {
+    "use strict";
+    init_code_type();
+    init_constructor();
+    init_entity_type();
+    init_extracted_value();
+    init_function();
+    init_heading();
+    init_input_type();
+    init_keywords_loader();
+    init_page_type();
+    init_style_type();
+  }
+});
+
+// libs/core/index.ts
+var init_core = __esm({
+  "libs/core/index.ts"() {
+    "use strict";
+    init_constants();
+    init_helpers();
+    init_interfaces();
+    init_types();
+  }
+});
+
+// libs/utils/html/helpers/attr-value.ts
+function attrValue(node, attr) {
+  const attrKey = attr.toLowerCase();
+  return node.properties?.[attrKey] ? String(node.properties[attrKey]) : void 0;
+}
+var init_attr_value = __esm({
+  "libs/utils/html/helpers/attr-value.ts"() {
+    "use strict";
+  }
+});
+
+// libs/utils/html/helpers/has-class.ts
+function hasClass(node, cls) {
+  const className = node.properties?.["className"]?.toString() ?? "";
+  return !!className && className.includes(cls);
+}
+var init_has_class = __esm({
+  "libs/utils/html/helpers/has-class.ts"() {
+    "use strict";
+  }
+});
+
+// libs/utils/html/helpers/has-link-ancestor.ts
+import { isElement } from "hast-util-is-element";
+function hasLinkAncestor(ancestors) {
+  return ancestors.some((ancestor) => isElement(ancestor, "a"));
+}
+var init_has_link_ancestor = __esm({
+  "libs/utils/html/helpers/has-link-ancestor.ts"() {
+    "use strict";
+  }
+});
+
+// libs/utils/html/helpers/is-code-block.ts
+function isCodeBlock(parent, node) {
+  return parent?.type === "element" && parent.tagName === "pre" && node.tagName === "code";
+}
+var init_is_code_block = __esm({
+  "libs/utils/html/helpers/is-code-block.ts"() {
+    "use strict";
+  }
+});
+
+// libs/utils/html/helpers/is-code-node.ts
+import { isElement as isElement2 } from "hast-util-is-element";
+function isCodeNode(node) {
+  return isElement2(node, "code") || isElement2(node, "ng-doc-code");
+}
+var init_is_code_node = __esm({
+  "libs/utils/html/helpers/is-code-node.ts"() {
+    "use strict";
+  }
+});
+
+// libs/utils/html/helpers/is-element.ts
+function isElement3(node) {
+  return node?.type === "element";
+}
+var init_is_element = __esm({
+  "libs/utils/html/helpers/is-element.ts"() {
+    "use strict";
+  }
+});
+
+// libs/utils/html/helpers/is-heading.ts
+import { isElement as isElement4 } from "hast-util-is-element";
+function isHeading(node) {
+  return isElement4(node, HEADINGS);
+}
+var HEADINGS;
+var init_is_heading = __esm({
+  "libs/utils/html/helpers/is-heading.ts"() {
+    "use strict";
+    HEADINGS = ["h1", "h2", "h3", "h4", "h5", "h6"];
+  }
+});
+
+// libs/utils/html/helpers/index.ts
+var init_helpers2 = __esm({
+  "libs/utils/html/helpers/index.ts"() {
+    "use strict";
+    init_attr_value();
+    init_has_class();
+    init_has_link_ancestor();
+    init_is_code_block();
+    init_is_code_node();
+    init_is_element();
+    init_is_heading();
+  }
+});
+
+// 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";
+import { SKIP, visitParents } from "unist-util-visit-parents";
+function keywordsPlugin(config) {
+  return (tree) => visitParents(tree, "element", (node, ancestors) => {
+    if (!isCodeNode(node)) {
+      return;
+    }
+    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)) {
+      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 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 };
+    }
+    const {
+      key = "",
+      delimiter = "",
+      anchor = "",
+      queryParams = ""
+    } = match.groups;
+    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);
+    if (!isInlineCode && keyword && !isLanguageAllowed) {
+      return { type: "text", value: word };
+    }
+    if (isGuideKeyword && key.length === 1) {
+      return { type: "text", value: word };
+    }
+    addUsedKeyword?.(usedKeyword);
+    const notFoundGuideKeyword = isGuideKeyword && !keyword;
+    const notFoundApiAnchorKeyword = !!rootKeyword && !!anchor && !keyword;
+    if (getKeyword && scan.whole && (notFoundGuideKeyword || notFoundApiAnchorKeyword)) {
+      throw new Error(`Route with keyword "${word}" is missing.`);
+    }
+    if (parent.properties) {
+      if (isInlineCode && keyword?.type === "link") {
+        parent.tagName = "a";
+        parent.properties = {
+          href: `${keyword.path}${queryParams ?? ""}`,
+          className: [NG_DOC_ELEMENT]
+        };
+        return { type: "text", value: keyword.title };
+      } else if (isInlineCode && keyword) {
+        parent.properties["className"] = [NG_DOC_ELEMENT, "ng-doc-code-with-link"];
+      }
+    }
+    return keyword ? createLinkNode(
+      isInlineCode && !isMember ? keyword.title : word,
+      keyword.path,
+      keyword.type,
+      keyword.description
+    ) : { type: "text", value: word };
+  });
+}
+function createLinkNode(text, href, type, description) {
+  return {
+    type: "element",
+    tagName: "a",
+    properties: {
+      href,
+      class: ["ng-doc-code-anchor", NG_DOC_ELEMENT],
+      "data-link-type": type,
+      ngDocTooltip: description
+    },
+    children: [{ type: "text", value: text }]
+  };
+}
+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"];
+    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;
+  }
+});
+
+// libs/utils/html/post-process-html.ts
+import rehypeParse2 from "rehype-parse";
+import rehypeStringify2 from "rehype-stringify";
+import { unified as unified2 } from "unified";
+async function postProcessHtml(html) {
+  const usedKeywords = /* @__PURE__ */ new Set();
+  try {
+    const content = await unified2().use(rehypeParse2, { fragment: true }).use(rehypeStringify2).use(keywordsPlugin, { addUsedKeyword: usedKeywords.add.bind(usedKeywords) }).process(html).then((file) => file.toString());
+    return { content, usedKeywords: Array.from(usedKeywords) };
+  } catch (error) {
+    return { content: html, usedKeywords: [], error };
+  }
+}
+var init_post_process_html = __esm({
+  "libs/utils/html/post-process-html.ts"() {
+    "use strict";
+    init_keywords_plugin();
+  }
+});
+
+// libs/utils/html/plugins/add-heading-anchors.plugin.ts
+import { visit } from "unist-util-visit";
+function addHeadingAnchors(route) {
+  return (tree) => visit(tree, "element", (node) => {
+    if (route && isHeading(node) && node.properties && node.properties["id"] && !hasClass(node, NO_ANCHOR_CLASS)) {
+      node.children.push({
+        type: "element",
+        tagName: "ng-doc-heading-anchor",
+        properties: {
+          className: ["ng-doc-anchor"],
+          anchor: node.properties["id"]
+        },
+        children: []
+      });
+      node.properties = {
+        ...node.properties,
+        href: route,
+        headingLink: "true"
+      };
+    }
+  });
+}
+var NO_ANCHOR_CLASS;
+var init_add_heading_anchors_plugin = __esm({
+  "libs/utils/html/plugins/add-heading-anchors.plugin.ts"() {
+    "use strict";
+    init_helpers2();
+    NO_ANCHOR_CLASS = "no-anchor";
+  }
+});
+
+// libs/utils/html/plugins/cached-shiki.plugin.ts
+import { toString as toString2 } from "hast-util-to-string";
+import { visit as visit2 } from "unist-util-visit";
+function cachedShikiPlugin(settings) {
+  const { cache, themes, languages, identity, defaultLanguage } = settings;
+  const id = `${themes.light}
+${themes.dark}
+${languages ?? ""}
+${settings.grammars ?? "all"}`;
+  return async (tree) => {
+    const blocks = [];
+    visit2(tree, "element", (node, index, parent) => {
+      if (!parent || index == null || 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(languagePrefix)) : void 0;
+      const lang = typeof languageClass === "string" ? languageClass.slice(languagePrefix.length) : defaultLanguage;
+      if (!lang) return;
+      const data = head.data;
+      const meta = data?.meta ?? head.properties["metastring"]?.toString() ?? "";
+      const code = toString2(head);
+      blocks.push({
+        node,
+        parent,
+        key: cache.key({
+          options: identity,
+          themes,
+          ...languages === void 0 ? {} : { languages },
+          lang,
+          meta,
+          code
+        })
+      });
+    });
+    let highlighter;
+    const load = async () => highlighter ??= await highlighterFor(id, settings.transformer);
+    if (cache.loads?.(themes) !== true) await load();
+    const values = [];
+    for (const block of blocks) {
+      const cached = cache.get(block.key);
+      const hit = cached === void 0 ? void 0 : fragment(cached);
+      if (hit && !cache.verify) {
+        values.push(hit);
+        continue;
+      }
+      const fresh = await highlight(await load(), block.node);
+      if (hit && fresh !== cached) cache.mismatch?.(block.key);
+      if (fresh !== cached) cache.set(block.key, fresh);
+      values.push(JSON.parse(fresh));
+    }
+    blocks.forEach((block, position) => {
+      const index = block.parent.children.indexOf(block.node);
+      if (index >= 0) block.parent.children.splice(index, 1, ...values[position]);
+    });
+  };
+}
+function highlighterFor(id, transformer) {
+  const known = highlighters.get(id);
+  if (known) return known;
+  const created = (async () => {
+    const transform = transformer();
+    await transform({ type: "root", children: [] });
+    return transform;
+  })();
+  highlighters.set(id, created);
+  created.catch(() => {
+    if (highlighters.get(id) === created) highlighters.delete(id);
+  });
+  return created;
+}
+async function highlight(transform, node) {
+  const root = { type: "root", children: [node] };
+  await transform(root);
+  return JSON.stringify(root.children);
+}
+function fragment(value) {
+  try {
+    const parsed = JSON.parse(value);
+    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;
+  if (node["type"] === "text") return typeof node["value"] === "string";
+  const properties = node["properties"];
+  const children = node["children"];
+  return node["type"] === "element" && typeof node["tagName"] === "string" && !!properties && typeof properties === "object" && !Array.isArray(properties) && Array.isArray(children) && children.every(isNode);
+}
+var languagePrefix, highlighters;
+var init_cached_shiki_plugin = __esm({
+  "libs/utils/html/plugins/cached-shiki.plugin.ts"() {
+    "use strict";
+    languagePrefix = "language-";
+    highlighters = /* @__PURE__ */ new Map();
+  }
+});
+
+// libs/utils/html/plugins/highlight-code-lines.ts
+import { visit as visit3 } from "unist-util-visit";
+function highlightCodeLines() {
+  return (tree) => {
+    visit3(tree, "element", (node, _i, parent) => {
+      if (isCodeBlock(parent, node) && parent?.type === "element") {
+        const highlightedLines = JSON.parse(
+          attrValue(parent, "highlightedLines") ?? "[]"
+        );
+        highlightedLines.length && node.children.filter(isElement3).forEach((child, i) => {
+          if (child.properties.class === "line" && highlightedLines.includes(i + 1)) {
+            child.properties.class = "line highlighted";
+          }
+        });
+      }
+    });
+  };
+}
+var init_highlight_code_lines = __esm({
+  "libs/utils/html/plugins/highlight-code-lines.ts"() {
+    "use strict";
+    init_helpers2();
+  }
+});
+
+// libs/utils/html/plugins/mark-elements.plugin.ts
+import { visit as visit4 } from "unist-util-visit";
+function markElementsPlugin() {
+  return (tree) => {
+    visit4(tree, "element", (node) => {
+      if (node.properties) {
+        node.properties["className"] = [...asArray(node.properties.className), NG_DOC_ELEMENT];
+      }
+    });
+  };
+}
+var init_mark_elements_plugin = __esm({
+  "libs/utils/html/plugins/mark-elements.plugin.ts"() {
+    "use strict";
+    init_core();
+  }
+});
+
+// libs/utils/html/plugins/mermaid.plugin.ts
+import { toString as toString3 } from "hast-util-to-string";
+import { visit as visit5 } from "unist-util-visit";
+function mermaidPlugin() {
+  return (tree) => {
+    visit5(tree, "element", (node) => {
+      if (node.tagName === "pre") {
+        const codeNode = node.children[0];
+        if (codeNode.tagName === "code" && codeNode.properties?.["lang"] === "mermaid") {
+          node.properties = { className: ["mermaid"] };
+          node.children = [
+            {
+              type: "text",
+              value: toString3(codeNode)
+            }
+          ];
+        }
+      }
+    });
+  };
+}
+var init_mermaid_plugin = __esm({
+  "libs/utils/html/plugins/mermaid.plugin.ts"() {
+    "use strict";
+  }
+});
+
+// libs/utils/html/plugins/slugger.plugin.ts
+import GithubSlugger from "github-slugger";
+import { hasProperty } from "hast-util-has-property";
+import { headingRank } from "hast-util-heading-rank";
+import { isElement as isElement6 } from "hast-util-is-element";
+import { toString as toString4 } from "hast-util-to-string";
+import { visitParents as visitParents2 } from "unist-util-visit-parents";
+function sluggerPlugin(addAnchor, headings = ["h1", "h2", "h3", "h4"]) {
+  if (!addAnchor) {
+    return () => {
+    };
+  }
+  const slugger = new GithubSlugger();
+  return (tree) => {
+    slugger.reset();
+    visitParents2(tree, "element", (node, ancestors) => {
+      const scope = getKeywordScope(ancestors);
+      const isHeading2 = !!headingRank(node) && !hasProperty(node, "id") && !!headings?.includes(node.tagName.toLowerCase());
+      const attrSlug = attrValue(node, "dataSlug");
+      const attrSlugTitle = attrValue(node, "dataSlugTitle");
+      const attrSlugType = attrValue(node, "dataSlugType");
+      const dataToSlug = isHeading2 ? toString4(node).trim() : attrSlug;
+      if (dataToSlug) {
+        if (node.properties) {
+          const id = attrSlug && attrSlugType === "member" ? attrSlug : slugger.slug(dataToSlug);
+          node.properties["id"] = id;
+          if (isHeading2) {
+            hideLeadingEmoji(node);
+          }
+          addAnchor({
+            anchorId: id,
+            anchor: new GithubSlugger().slug(dataToSlug),
+            title: attrSlugTitle || dataToSlug,
+            scope,
+            type: isHeading2 && attrSlugType !== "member" || attrSlug && attrSlugType === "heading" ? "heading" : "member"
+          });
+        }
+      }
+    });
+  };
+}
+function hideLeadingEmoji(heading) {
+  const first = heading.children[0];
+  const emoji = first?.type === "text" ? LEADING_EMOJI.exec(first.value)?.[0] : void 0;
+  if (!emoji) {
+    return;
+  }
+  const rest = { type: "text", value: first.value.slice(emoji.length) };
+  heading.children.splice(
+    0,
+    1,
+    {
+      type: "element",
+      tagName: "span",
+      properties: { ariaHidden: "true" },
+      children: [{ type: "text", value: emoji }]
+    },
+    rest
+  );
+}
+function getKeywordScope(ancestors) {
+  const keywordScope = ancestors.find(
+    (ancestor) => isElement6(ancestor) && ancestor.tagName === "ng-doc-keyword-scope"
+  );
+  const key = keywordScope?.properties?.["id"];
+  return key ? {
+    key: String(key),
+    title: String(keywordScope?.properties?.["title"])
+  } : void 0;
+}
+var LEADING_EMOJI;
+var init_slugger_plugin = __esm({
+  "libs/utils/html/plugins/slugger.plugin.ts"() {
+    "use strict";
+    init_helpers2();
+    LEADING_EMOJI = new RegExp("^(?:\\p{Regional_Indicator}{2}|(?:\\p{Emoji_Presentation}|\\p{Extended_Pictographic}\\uFE0F)(?:\\p{Emoji_Modifier}|\\uFE0F|\\u200D\\p{Extended_Pictographic}\\uFE0F?)*)(?=\\s)", "u");
+  }
+});
+
+// libs/utils/html/plugins/table-wrapper.ts
+import { visit as visit6 } from "unist-util-visit";
+function table_wrapper_default() {
+  return (tree) => {
+    visit6(tree, "element", (node, index, parent) => {
+      const table = node?.tagName === "table";
+      if (table) {
+        const wrapper = {
+          type: "element",
+          tagName: "div",
+          properties: {
+            className: "ng-doc-table-wrapper"
+          },
+          children: [node]
+        };
+        parent.children[index] = wrapper;
+      }
+    });
+  };
+}
+var init_table_wrapper = __esm({
+  "libs/utils/html/plugins/table-wrapper.ts"() {
+    "use strict";
+  }
+});
+
+// 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 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();
+  const themes = {
+    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 ? [
+        [
+          cachedShikiPlugin,
+          {
+            cache: config.highlight,
+            themes,
+            ...langs ? { languages: languagesId(langs) } : {},
+            ...used ? { grammars: "used" } : {},
+            identity: HIGHLIGHT_IDENTITY,
+            defaultLanguage: DEFAULT_LANGUAGE,
+            transformer: () => langs ? withLanguages(themes, langs) : used ? withUsedGrammars(themes) : rehypeShiki(
+              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) {
+    return { content: html, anchors: [], error };
+  }
+}
+function shikiOptions(themes) {
+  return {
+    defaultLanguage: DEFAULT_LANGUAGE,
+    fallbackLanguage: "text",
+    addLanguageClass: true,
+    parseMetaString: (meta) => JSON.parse(meta?.replace(/\\/g, "") || "{}"),
+    // Shiki stops tokenizing a line after 500 ms by default and silently colours the rest of
+    // it like the last token. A slow or pre-empted process then renders other HTML than a fast
+    // one, so the build output would depend on machine load. No limit keeps it deterministic.
+    tokenizeTimeLimit: 0,
+    themes: {
+      light: shikiTheme(themes.light),
+      dark: shikiTheme(themes.dark)
+    }
+  };
+}
+function shikiTheme(name) {
+  return name === NG_DOC_SYNTAX_THEME_NAME ? ngDocSyntaxTheme() : name;
+}
+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";
+    init_core();
+    init_add_heading_anchors_plugin();
+    init_cached_shiki_plugin();
+    init_highlight_code_lines();
+    init_mark_elements_plugin();
+    init_mermaid_plugin();
+    init_slugger_plugin();
+    init_table_wrapper();
+    init_shiki_grammars();
+    DEFAULT_LANGUAGE = "ts";
+    HIGHLIGHT_IDENTITY = {
+      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 visit8 } from "unist-util-visit";
+function removeNotIndexableContentPlugin() {
+  return (tree) => {
+    visit8(tree, "element", (node) => {
+      if (isHeading(node) && isHiddenSpan(node.children[0])) {
+        node.children = node.children.slice(1);
+      }
+    });
+    return filter(tree, { cascade: true }, (node) => {
+      const preWithCode = node?.tagName === "pre" && node?.children?.some(isCodeNode);
+      const notIndexable = node?.properties?.["indexable"] === "false";
+      return !node?.tagName || !preWithCode && !notIndexable;
+    });
+  };
+}
+function isHiddenSpan(node) {
+  return node?.type === "element" && node.tagName === "span" && node.properties?.["ariaHidden"] === "true";
+}
+var init_remove_not_indexable_content_plugin = __esm({
+  "libs/utils/html/plugins/remove-not-indexable-content.plugin.ts"() {
+    "use strict";
+    init_helpers2();
+  }
+});
+
+// libs/utils/html/remove-not-indexable-content.ts
+import { rehype } from "rehype";
+async function removeNotIndexableContent(html) {
+  return rehype().use(removeNotIndexableContentPlugin).process(html).then((file) => file.toString());
+}
+var init_remove_not_indexable_content = __esm({
+  "libs/utils/html/remove-not-indexable-content.ts"() {
+    "use strict";
+    init_remove_not_indexable_content_plugin();
+  }
+});
+
+// libs/utils/html/replace-keywords.ts
+import rehypeParse4 from "rehype-parse";
+import rehypeStringify4 from "rehype-stringify";
+import { unified as unified4 } from "unified";
+async function replaceKeywords(html, { getKeyword }) {
+  return unified4().use(rehypeParse4, { fragment: true }).use(rehypeStringify4).use(keywordsPlugin, { getKeyword }).process(html).then((file) => file.toString());
+}
+var init_replace_keywords = __esm({
+  "libs/utils/html/replace-keywords.ts"() {
+    "use strict";
+    init_keywords_plugin();
+  }
+});
+
+// libs/utils/html/stringify-entities.ts
+import { stringifyEntities as stringify } from "stringify-entities";
+function stringifyEntities(content) {
+  return stringify(content);
+}
+var init_stringify_entities = __esm({
+  "libs/utils/html/stringify-entities.ts"() {
+    "use strict";
+  }
+});
+
+// libs/utils/index.ts
+var utils_exports = {};
+__export(utils_exports, {
+  minify: () => minify,
+  postProcessHtml: () => postProcessHtml,
+  processHtml: () => processHtml,
+  removeNotIndexableContent: () => removeNotIndexableContent,
+  replaceKeywords: () => replaceKeywords,
+  stringifyEntities: () => stringifyEntities
+});
+var init_utils = __esm({
+  "libs/utils/index.ts"() {
+    "use strict";
+    init_minify();
+    init_post_process_html();
+    init_process_html();
+    init_remove_not_indexable_content();
+    init_replace_keywords();
+    init_stringify_entities();
+  }
+});
+
+// libs/builder/generator/content/html-pipeline.ts
+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, highlight2, aborted);
+    results.push(result);
+    if (!("html" in result)) break;
+  }
+  return results;
+}
+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 };
+  const call = highlight2();
+  const result = await utilities.processHtml(document.html, {
+    ..."headings" in document ? { headings: document.headings } : {},
+    ...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;
+  if (result.error) return { failed: "process", message: String(result.error), mismatches };
+  if (aborted()) return { aborted: true, mismatches };
+  const post = await utilities.postProcessHtml(result.content);
+  if (post.error) return { failed: "post-process", message: String(post.error), mismatches };
+  if (aborted()) return { aborted: true, mismatches };
+  return {
+    html: post.content,
+    anchors: result.anchors.map(normalizeAnchor),
+    usedKeywords: post.usedKeywords,
+    mismatches
+  };
+}
+async function linkDocument(task, getKeyword, aborted = notAborted) {
+  const consulted = [];
+  const seen = /* @__PURE__ */ new Set();
+  try {
+    const utilities = await htmlUtilities();
+    const html = await utilities.replaceKeywords(task.html, {
+      getKeyword: (key) => {
+        if (!seen.has(key)) {
+          seen.add(key);
+          consulted.push(key);
+        }
+        return getKeyword(key);
+      }
+    });
+    if (aborted()) return { aborted: true, consulted };
+    const indexable = await utilities.removeNotIndexableContent(html);
+    if (aborted()) return { aborted: true, consulted };
+    const searchRecords = await buildSearchRecords(indexable, task);
+    if (aborted()) return { aborted: true, consulted };
+    return { html, searchRecords, consulted };
+  } catch (error) {
+    return { failed: String(error), consulted };
+  }
+}
+function bindingsOf(keywords) {
+  return new Map(keywords.map((keyword) => [keyword.key, keyword]));
+}
+async function buildSearchRecords(html, task) {
+  const documents = await parseFile(html, "html", {
+    transformFn: transformSearchNode,
+    mergeStrategy: "split"
+  });
+  const records = [];
+  let section;
+  for (const document of documents) {
+    if (!document?.content?.trim()) continue;
+    if (isSearchHeading(document)) {
+      section = document;
+      continue;
+    }
+    const fragment2 = section?.properties?.["id"];
+    records.push({
+      breadcrumbs: task.breadcrumbs,
+      pageType: task.pageType,
+      // Without the whitespace around them, a no-break space included: a heading's decorative
+      // emoji is joined to its text with one. `helpers/build-indexes.ts` of the legacy engine trims
+      // them the same way; keep both in step, so the two search indexes stay equal.
+      title: task.title.trim(),
+      section: (section?.content ?? "").trim(),
+      route: task.absoluteRoute,
+      ...typeof fragment2 === "string" && fragment2 ? { fragment: fragment2 } : {},
+      content: document.content
+    });
+  }
+  return records;
+}
+function transformSearchNode(node) {
+  return ["strong", "a", "time", "span", "small", "b", "p", "ul"].includes(node.tag) ? { ...node, raw: `<p>${node.content}</p>` } : node;
+}
+function isSearchHeading(document) {
+  return ["h1", "h2", "h3", "h4", "h5", "h6"].includes(document.type) && !!document.properties && !!document.properties["id"];
+}
+function normalizeAnchor(anchor) {
+  return {
+    anchorId: anchor.anchorId,
+    anchor: anchor.anchor,
+    title: anchor.title,
+    type: anchor.type,
+    ...anchor.scope === void 0 ? {} : { scope: anchor.scope }
+  };
+}
+function recordingHighlight(settings, themes, store) {
+  const records = [];
+  return {
+    records,
+    next: () => {
+      const record = { used: [], fresh: [], mismatched: [] };
+      records.push(record);
+      const mismatches = [];
+      return {
+        key: (block) => digestOf({ context: settings.context, block }),
+        get: (key) => {
+          const value = store.get(key);
+          if (value !== void 0) record.used.push(key);
+          return value;
+        },
+        set: (key, value) => {
+          store.set(key, value);
+          record.used.push(key);
+          record.fresh.push([key, value]);
+          store.prove();
+        },
+        loads: (requested) => requested.light === themes.light && requested.dark === themes.dark && store.proven(),
+        verify: settings.verify,
+        mismatch: (key) => {
+          mismatches.push(key);
+          record.mismatched.push(key);
+        },
+        mismatches
+      };
+    }
+  };
+}
+function serveHtmlThread(port) {
+  const entries = /* @__PURE__ */ new Map();
+  const proven = /* @__PURE__ */ new Set();
+  let keywordSet;
+  const reply = (value) => port.postMessage(encode(value));
+  const render = async (job) => {
+    const task = job["task"];
+    const settings = job["highlight"];
+    const recording = settings ? recordingHighlight(settings, task.themes, {
+      get: (key) => entries.get(key),
+      set: (key, value) => entries.set(key, value),
+      proven: () => proven.has(settings.context),
+      prove: () => proven.add(settings.context)
+    }) : void 0;
+    const documents = await renderDocuments(task, () => recording?.next());
+    return { documents, ...recording ? { highlight: recording.records } : {} };
+  };
+  const link = async (job) => {
+    if (!keywordSet || keywordSet.id !== job["keywords"])
+      throw new Error(`Unknown keyword set ${String(job["keywords"])}`);
+    const bindings = keywordSet.bindings;
+    return linkDocument(job["task"], (key) => bindings.get(key));
+  };
+  port.on("message", (message) => {
+    let id;
+    void (async () => {
+      try {
+        const job = decode(message);
+        id = job["id"];
+        switch (job["type"]) {
+          case "highlight": {
+            if (job["reset"] === true) entries.clear();
+            for (const [key, value] of job["entries"])
+              entries.set(key, value);
+            if (job["proven"] === true) proven.add(job["context"]);
+            return;
+          }
+          case "keywords":
+            keywordSet = {
+              id: job["id"],
+              bindings: bindingsOf(job["keywords"])
+            };
+            return;
+          case "warm": {
+            const cache = {
+              key: () => "",
+              get: () => void 0,
+              set: () => void 0,
+              loads: () => false,
+              verify: false,
+              mismatch: () => void 0,
+              mismatches: []
+            };
+            await renderDocuments(
+              {
+                documents: [{ html: WARM_DOCUMENT }],
+                themes: job["themes"],
+                ...job["langs"] ? { langs: job["langs"] } : {},
+                ...job["grammars"] === "all" ? { grammars: "all" } : {}
+              },
+              () => job["cache"] === true ? cache : void 0
+            );
+            return;
+          }
+          case "render":
+            reply({ type: "done", id, result: await render(job) });
+            return;
+          case "link":
+            reply({ type: "done", id, result: await link(job) });
+            return;
+          default:
+            throw new Error(`Unknown render thread job ${String(job["type"])}`);
+        }
+      } catch (error) {
+        reply({ type: "failed", id: id ?? null, message: String(error) });
+      }
+    })();
+  });
+}
+var htmlUtilities, notAborted, WARM_DOCUMENT;
+var init_html_pipeline = __esm({
+  "libs/builder/generator/content/html-pipeline.ts"() {
+    "use strict";
+    init_canonical();
+    init_protocol();
+    htmlUtilities = () => Promise.resolve().then(() => (init_utils(), utils_exports));
+    notAborted = () => false;
+    WARM_DOCUMENT = ["ts", "angular-ts", "angular-html"].map((language) => `<pre><code class="language-${language}">warm</code></pre>`).join("");
+  }
+});
+
+// libs/builder/generator/content/html-worker.ts
+import { parentPort } from "node:worker_threads";
+var require_html_worker = __commonJS({
+  "libs/builder/generator/content/html-worker.ts"() {
+    init_html_pipeline();
+    if (parentPort) serveHtmlThread(parentPort);
+  }
+});
+export default require_html_worker();