@ng-doc/builder 22.0.0-beta.1 → 22.0.0

package/generator/content/html-worker.js

@@ -0,0 +1,1598 @@
+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/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)) {
+      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];
+      });
+    }
+  });
+}
+function getNodes(node, parent, isInlineCode, config, language) {
+  const { addUsedKeyword, getKeyword } = config;
+  return toString(node).split(SPLIT_REGEXP).map((word) => {
+    const match = word.match(MATCH_KEYWORD_REGEXP);
+    if (!match) {
+      return { type: "text", value: word };
+    }
+    const {
+      key = "",
+      delimiter = "",
+      anchor = "",
+      queryParams = ""
+    } = match.groups;
+    const usedKeyword = `${key}${delimiter}${anchor?.toLowerCase()}`;
+    const rootKeyword = 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 && isInlineCode && (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 ? 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, LANGUAGES, SPLIT_REGEXP, MATCH_KEYWORD_REGEXP;
+var init_keywords_plugin = __esm({
+  "libs/utils/html/plugins/keywords.plugin.ts"() {
+    "use strict";
+    init_core();
+    init_helpers2();
+    ALWAYS_ALLOWED_LANGUAGES = ["typescript", "ts", "angular-ts"];
+    LANGUAGES = ["typescript", "ts", "angular-ts", ...KEYWORD_ALLOWED_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 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 id = `${themes.light}
+${themes.dark}`;
+  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, lang, meta, code })
+      });
+    });
+    let highlighter;
+    const load = async () => highlighter ??= await highlighterFor(id, settings.options);
+    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, options) {
+  const known = highlighters.get(id);
+  if (known) return known;
+  const created = (async () => {
+    const transform = rehypeShiki(
+      options()
+    );
+    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((item) => isNode(item) && item.type === "element") ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+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/process-html.ts
+import rehypeShiki2 from "@shikijs/rehype";
+import rehypeMinifyWhitespace2 from "rehype-minify-whitespace";
+import rehypeParse3 from "rehype-parse";
+import rehypeStringify3 from "rehype-stringify";
+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"
+  };
+  try {
+    const content = await unified3().use(rehypeParse3, { fragment: true }).use(rehypeStringify3).use(mermaidPlugin).use(
+      config.highlight ? [
+        [
+          cachedShikiPlugin,
+          {
+            cache: config.highlight,
+            themes,
+            identity: HIGHLIGHT_IDENTITY,
+            defaultLanguage: DEFAULT_LANGUAGE,
+            options: () => shikiOptions(themes)
+          }
+        ]
+      ] : [[rehypeShiki2, 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;
+}
+var DEFAULT_LANGUAGE, HIGHLIGHT_IDENTITY;
+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();
+    DEFAULT_LANGUAGE = "ts";
+    HIGHLIGHT_IDENTITY = {
+      format: 1,
+      defaultLanguage: DEFAULT_LANGUAGE,
+      fallbackLanguage: "text",
+      addLanguageClass: true,
+      parseMetaString: "json-without-backslashes",
+      tokenizeTimeLimit: 0
+    };
+  }
+});
+
+// libs/utils/html/plugins/remove-not-indexable-content.plugin.ts
+import { filter } from "unist-util-filter";
+import { visit as visit7 } from "unist-util-visit";
+function removeNotIndexableContentPlugin() {
+  return (tree) => {
+    visit7(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.themes, highlight2, aborted);
+    results.push(result);
+    if (!("html" in result)) break;
+  }
+  return results;
+}
+async function renderDocument(document, themes, 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,
+    ...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["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 = '<pre><code class="language-ts">const warm = 1;</code></pre>';
+  }
+});
+
+// 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();