@forsakringskassan/docs-generator 1.26.0 → 1.28.0

package/dist/index.js

@@ -0,0 +1,2283 @@
+'use strict';
+
+var fs = require('node:fs/promises');
+var path = require('node:path');
+var vendor = require('./vendor-uab7h6x-.js');
+var createMarkdownRenderer = require('./create-markdown-renderer-CPrI2LLQ.js');
+var require$$1 = require('crypto');
+require('node:crypto');
+var vueDocgenApi = require('vue-docgen-api');
+var path$1 = require('node:path/posix');
+var fs$1 = require('node:fs');
+var sass = require('sass');
+var node_url = require('node:url');
+var esbuild = require('esbuild');
+var node_util = require('node:util');
+var nunjucks = require('nunjucks');
+var vue = require('vue');
+var vue2 = require('./vue2-CBDrnmVO.js');
+var vue3 = require('./vue3-xJIC7Aol.js');
+var express = require('express');
+var childProcess = require('node:child_process');
+require('path');
+require('url');
+require('fs');
+require('fs/promises');
+require('events');
+require('stream');
+require('string_decoder');
+require('constants');
+require('util');
+require('assert');
+require('readline');
+require('child_process');
+require('node:buffer');
+require('node:process');
+require('node:os');
+require('node:timers/promises');
+require('@vue/compiler-sfc');
+require('typescript');
+require('os');
+require('http');
+require('https');
+require('buffer');
+require('net');
+require('tls');
+require('tty');
+require('querystring');
+
+function defineSources(sources) {
+  return sources;
+}
+
+function formatSize(value) {
+  const suffices = ["kB", "MB"];
+  if (value < 1e3) {
+    return `${value}`;
+  }
+  for (const suffix of suffices) {
+    value = Math.round(value / 1e3 * 100) / 100;
+    if (value < 1e3) {
+      return `${value} ${suffix}`;
+    }
+  }
+  value = Math.round(value / 1e3 * 100) / 100;
+  return `${value} GB`;
+}
+
+const matchHeading = /^(#+)(.*)$/gm;
+function getHeadings(text) {
+  return Array.from(text.matchAll(matchHeading), parseHeading);
+}
+function parseHeading(match) {
+  const [, prefix, text] = match;
+  const rank = prefix.length;
+  const id = createMarkdownRenderer.generateId(text);
+  return {
+    rank,
+    title: text.trim(),
+    anchor: id
+  };
+}
+function getDocumentOutline(text, _format) {
+  const entries = getHeadings(text);
+  const root = { title: "", rank: 0, anchor: "", subheadings: [] };
+  const stack = [root];
+  const top = () => stack[stack.length - 1];
+  for (const entry of entries) {
+    const heading = {
+      title: entry.title,
+      rank: entry.rank,
+      anchor: entry.anchor,
+      subheadings: []
+    };
+    while (top().rank >= entry.rank) {
+      stack.pop();
+    }
+    top().subheadings.push(heading);
+    stack.push(heading);
+  }
+  return root.subheadings;
+}
+
+function getIntegrity(source) {
+  const hash = require$$1.createHash("sha384").update(source).digest("base64");
+  return `sha384-${hash}`;
+}
+
+function haveOutput(doc) {
+  const { fileInfo } = doc;
+  return Boolean(fileInfo.outputName);
+}
+
+function interpolate(value, data) {
+  return value.replace(/{{([^}]+)}}/g, (match, raw) => {
+    const key = raw.trim();
+    return data[key] ?? match;
+  });
+}
+
+function parseImport(raw) {
+  const comments = [];
+  const stripped = raw.replace(/<!--.*?-->/gms, (match) => {
+    comments.push(match);
+    return "";
+  });
+  const filename = stripped.trim();
+  const extension = path.parse(filename).ext.slice(1);
+  return {
+    filename,
+    extension,
+    comments
+  };
+}
+
+function quote(text) {
+  return String(text).replace(/"/g, "&quot;");
+}
+function* serializeAttr(key, value) {
+  if (value === null || value === false) {
+    return;
+  }
+  if (value === true) {
+    yield key;
+    return;
+  }
+  if (typeof value === "string" || typeof value === "number") {
+    yield `${key}="${quote(value)}"`;
+    return;
+  }
+  for (const [innerKey, innerValue] of Object.entries(value)) {
+    yield* serializeAttr([key, innerKey].join("-"), innerValue);
+  }
+}
+function* serializeAttrs(attrs) {
+  for (const [key, value] of Object.entries(attrs)) {
+    yield* serializeAttr(key, value);
+  }
+}
+
+function difference(a, b) {
+  const _difference = new Set(a);
+  for (const elem of b) {
+    _difference.delete(elem);
+  }
+  return _difference;
+}
+
+function slugify(value) {
+  return value.toLowerCase().replace(/\//g, "--").replace(/[^a-z]+/g, "-").replace(/(^-+|-+$)/, "");
+}
+
+function toArray$3(value) {
+  return Array.isArray(value) ? value : [value];
+}
+function isIndexPage(parsed) {
+  const folder = path.basename(parsed.dir);
+  if (parsed.name === folder) {
+    return true;
+  }
+  if (parsed.name.toLowerCase() === "readme") {
+    return true;
+  }
+  if (parsed.name === "index") {
+    return true;
+  }
+  return false;
+}
+function getBadge(attrs) {
+  if (!attrs.status) {
+    return void 0;
+  }
+  switch (attrs.status) {
+    case "Produktionsklar":
+      return "success";
+    case "Deprekerad":
+    case "Experimentell":
+      return "error";
+    case "Prelimin\xE4r":
+    case "Draft":
+    case "Beta":
+      return "info";
+    default:
+      return "info";
+  }
+}
+function getComponentAlias(attrs) {
+  if (attrs.component) {
+    return toArray$3(attrs.component).map((it) => `component:${it}`);
+  } else {
+    return [];
+  }
+}
+function parseFile$1(filePath, basePath, content) {
+  const relative = basePath ? path.relative(basePath, createMarkdownRenderer.normalizePath(filePath)) : createMarkdownRenderer.normalizePath(filePath);
+  const parsed = path.parse(relative);
+  const blocks = vendor.fm(content);
+  const attributes = blocks.attributes;
+  const isIndex = isIndexPage(parsed);
+  const filename = isIndex ? "index" : parsed.name.toLowerCase();
+  const name = attributes.name ? attributes.name : parsed.name;
+  const urlpath = parsed.dir;
+  const outline = getDocumentOutline(blocks.body);
+  return {
+    id: `fs:${filePath.replace(/\\/g, "/")}`,
+    name,
+    alias: [...getComponentAlias(attributes)],
+    visible: attributes.visible ?? true,
+    attributes: {
+      title: attributes.title ?? name,
+      layout: attributes.layout,
+      status: attributes.status,
+      badge: getBadge(attributes),
+      component: attributes.component ? toArray$3(attributes.component) : void 0,
+      sortorder: attributes.sortorder ?? Infinity
+    },
+    body: blocks.body,
+    outline,
+    format: "markdown",
+    tags: [],
+    template: blocks.attributes.layout ?? "default",
+    fileInfo: {
+      path: ["", "."].includes(urlpath) ? "." : `./${createMarkdownRenderer.normalizePath(urlpath)}`,
+      name: filename,
+      fullPath: createMarkdownRenderer.normalizePath(filePath),
+      outputName: `${filename}.html`
+    }
+  };
+}
+async function frontMatterFileReader(filePath, basePath) {
+  const content = await fs.readFile(filePath, "utf-8");
+  const doc = parseFile$1(filePath, basePath, content);
+  return [doc];
+}
+
+const EMPTY_CHAR = "&#8208;";
+const EM_DASH = "&#8212;";
+function translateProps(props) {
+  var _a, _b;
+  const translatedProps = [];
+  for (const prop of props) {
+    const translatedProp = {
+      name: prop.name,
+      description: prop.description ?? EMPTY_CHAR,
+      type: ((_a = prop.type) == null ? void 0 : _a.name) ?? EMPTY_CHAR,
+      required: prop.required ? "true" : "false",
+      default: ((_b = prop.defaultValue) == null ? void 0 : _b.value) ?? EMPTY_CHAR
+    };
+    translatedProps.push(translatedProp);
+  }
+  return translatedProps;
+}
+function translateEvents(events) {
+  const translatedEvents = [];
+  for (const event of events) {
+    const translatedEvent = {
+      name: event.name,
+      description: event.description ?? EMPTY_CHAR,
+      properties: translateEventProperties(event)
+    };
+    translatedEvents.push(translatedEvent);
+  }
+  return translatedEvents;
+}
+function translateEventProperties(event) {
+  const properties = event.properties;
+  const types = event.type ? Object.values(event.type.names) : [];
+  if (!properties && !types.length) {
+    return EMPTY_CHAR;
+  }
+  if (!properties) {
+    return `<anonymous>: ${String(types)}`;
+  }
+  const translatedProperties = [];
+  for (let i = 0; i < properties.length; i++) {
+    const property = properties[i];
+    const name = property.name ?? "<anonymous>";
+    const eventType = types[i];
+    const hasEventType = !eventType || eventType !== "undefined";
+    const resolvedType = hasEventType ? eventType : String(property.type.names);
+    const type = `: ${resolvedType}`;
+    const description = property.description ? ` ${EM_DASH} ${property.description}` : "";
+    translatedProperties.push(`${name}${type}${description}`);
+  }
+  return translatedProperties.join("\n");
+}
+function translateSlots(slots) {
+  const translatedSlots = [];
+  for (const slot of slots) {
+    const translatedSlot = {
+      name: slot.name,
+      description: slot.description ?? EMPTY_CHAR,
+      bindings: translateSlotBindings(slot)
+    };
+    translatedSlots.push(translatedSlot);
+  }
+  return translatedSlots;
+}
+function translateSlotBindings(slot) {
+  if (!slot.bindings) {
+    return EMPTY_CHAR;
+  }
+  const translatedBindings = [];
+  for (const binding of slot.bindings) {
+    translatedBindings.push(binding.name ? binding.name : EMPTY_CHAR);
+  }
+  return translatedBindings.join("\n");
+}
+async function translateAPI(filePath) {
+  const api = await vueDocgenApi.parse(filePath);
+  const props = api.props ? translateProps(api.props) : [];
+  const events = api.events ? translateEvents(api.events) : [];
+  const slots = api.slots ? translateSlots(api.slots) : [];
+  return {
+    props,
+    events,
+    slots
+  };
+}
+
+const md = vendor.MarkdownIt({ breaks: true });
+function generateTableHead(headers) {
+  return [
+    "<thead><tr>",
+    ...headers.map((header) => `<th>${header}</th>`),
+    "</tr></thead>"
+  ].join("");
+}
+function generateTableBody(content) {
+  const rows = content.map((row) => {
+    return [
+      "<tr>",
+      ...row.map((value) => `<td>${md.render(value)}</td>`),
+      "</tr>"
+    ].join("");
+  });
+  return ["<tbody>", ...rows, "</tbody>"].join("");
+}
+function generateTable(caption, headers, content) {
+  return [
+    '<div class="docs-table"><table>',
+    `<caption>${caption}</caption>`,
+    generateTableHead(headers),
+    generateTableBody(content),
+    "</table></div>"
+  ].join("");
+}
+
+function capitalize(text) {
+  return `${text.charAt(0).toUpperCase()}${text.slice(1)}`;
+}
+function parseAPIToArray(api) {
+  const content = [];
+  const headers = Object.keys(api[0]);
+  const capitalizedHeaders = headers.map(capitalize);
+  content.push(capitalizedHeaders);
+  for (const row of api) {
+    content.push(Object.values(row));
+  }
+  return content;
+}
+function parseAPI(filePath, api) {
+  const relative = createMarkdownRenderer.normalizePath(filePath);
+  const parsedPath = path.parse(relative);
+  const componentName = parsedPath.name;
+  let html = "";
+  if (api.props.length) {
+    const propsArray = parseAPIToArray(api.props);
+    html += generateTable("Props", propsArray[0], propsArray.slice(1));
+  }
+  if (api.events.length) {
+    const eventsArray = parseAPIToArray(api.events);
+    html += generateTable("Events", eventsArray[0], eventsArray.slice(1));
+  }
+  if (api.slots.length) {
+    const slotsArray = parseAPIToArray(api.slots);
+    html += generateTable("Slots", slotsArray[0], slotsArray.slice(1));
+  }
+  return {
+    id: `fs:${filePath.replace(/\\/g, "/")}`,
+    name: `vue:${componentName}`,
+    alias: [],
+    visible: false,
+    attributes: { sortorder: Infinity },
+    body: html,
+    outline: [],
+    format: "html",
+    tags: [],
+    template: "",
+    fileInfo: {
+      path: "",
+      name: "",
+      fullPath: "",
+      outputName: false
+    }
+  };
+}
+async function vueFileReader(filePath) {
+  const translated = await translateAPI(filePath);
+  const doc = parseAPI(filePath, translated);
+  return [doc];
+}
+
+async function globAll(pattern) {
+  if (!pattern) {
+    return /* @__PURE__ */ new Set();
+  }
+  if (!Array.isArray(pattern)) {
+    return globAll([pattern]);
+  }
+  const results = await Promise.all(pattern.map((it) => vendor.glob(it)));
+  return new Set(results.flat());
+}
+async function getDocumentsForSource(src) {
+  const { transform } = src;
+  const include = await globAll(src.include);
+  const exclude = await globAll(src.exclude);
+  const files = Array.from(difference(include, exclude));
+  const promises = files.map(async (it) => {
+    const docs2 = await src.fileReader(it, src.basePath);
+    if (transform) {
+      return docs2.map((it2) => transform(it2));
+    } else {
+      return docs2;
+    }
+  });
+  const docs = await Promise.all(promises);
+  return docs.flat();
+}
+async function getAllDocuments(sourceFiles) {
+  const result = await Promise.all(sourceFiles.map(getDocumentsForSource));
+  return result.flat();
+}
+function fileReaderProcessor(sourceFiles) {
+  return {
+    stage: "generate-docs",
+    name: "file-reader-processor",
+    async handler(context) {
+      const result = await getAllDocuments(sourceFiles);
+      context.addDocument(result);
+      context.log(result.length, "documents found");
+    }
+  };
+}
+
+function parseFile(filePath, basePath, content) {
+  const attributes = JSON.parse(content);
+  const { title, href } = attributes;
+  if (!title) {
+    throw new Error(`No title property set in "${filePath}"`);
+  }
+  const relative = basePath ? path.relative(basePath, createMarkdownRenderer.normalizePath(filePath)) : createMarkdownRenderer.normalizePath(filePath);
+  const parsed = path.parse(relative);
+  const filename = parsed.name.toLowerCase();
+  const name = parsed.name;
+  const urlpath = parsed.dir;
+  return {
+    id: `nav:${filePath.replace(/\\/g, "/")}`,
+    name,
+    alias: [],
+    visible: attributes.href ? true : false,
+    attributes: {
+      title,
+      href,
+      sortorder: attributes.sortorder ?? Infinity
+    },
+    body: content,
+    outline: [],
+    format: "json",
+    tags: [],
+    template: "default",
+    fileInfo: {
+      path: ["", "."].includes(urlpath) ? "." : `./${createMarkdownRenderer.normalizePath(urlpath)}`,
+      name: filename,
+      fullPath: createMarkdownRenderer.normalizePath(filePath),
+      outputName: false
+    }
+  };
+}
+async function navigationFileReader(filePath, basePath) {
+  const content = await fs.readFile(filePath, "utf-8");
+  const doc = parseFile(filePath, basePath, content);
+  return [doc];
+}
+
+function resolveScssImport(filePath) {
+  const { dir, base } = path$1.parse(filePath);
+  const search = [`${base}.css`, `${base}.scss`, `_${base}.scss`, `${base}`];
+  for (const variant of search) {
+    try {
+      const moduleName = path$1.join(dir, variant);
+      const resolved = require.resolve(moduleName);
+      return node_url.pathToFileURL(resolved);
+    } catch (err) {
+      if (err.code !== "MODULE_NOT_FOUND") {
+        throw err;
+      }
+    }
+  }
+  throw new Error(`Failed to resolve "${filePath}"`);
+}
+const tildeImporter = {
+  canonicalize(url) {
+    const indexOfTilde = url.indexOf("~");
+    if (indexOfTilde >= 0) {
+      return resolveScssImport(url.slice(indexOfTilde + 1));
+    }
+    if (url.startsWith("file://")) {
+      const path$1 = node_url.fileURLToPath(url);
+      const relative = path.isAbsolute(path$1) ? path.relative(__dirname, path$1) : path$1;
+      return resolveScssImport(relative.replace(/\\/g, "/"));
+    }
+    return null;
+  },
+  async load(url) {
+    const filepath = node_url.fileURLToPath(url);
+    const parsed = path.parse(filepath);
+    const contents = await fs.readFile(filepath, "utf-8");
+    return {
+      contents,
+      syntax: parsed.ext.slice(1) === "scss" ? "scss" : "css"
+    };
+  }
+};
+
+async function compileSassString(dst, style) {
+  const result = await sass.compileStringAsync(style, {
+    style: "expanded",
+    importers: [tildeImporter]
+  });
+  await fs.mkdir(path.dirname(dst), { recursive: true });
+  await fs.writeFile(dst, result.css, "utf-8");
+}
+
+async function compileStyle(assetFolder, name, src) {
+  try {
+    const outfile = path$1.join("temp", `asset-${name}.css`);
+    const source = await fs.readFile(src, "utf-8");
+    await compileSassString(outfile, source);
+    const content = await fs.readFile(outfile, "utf-8");
+    const fingerprint = createMarkdownRenderer.getFingerprint(content);
+    const integrity = getIntegrity(content);
+    const filename = `${name}-${fingerprint}.css`;
+    const dst = path$1.join(assetFolder, filename);
+    await fs.rename(outfile, dst);
+    const stat = await fs.stat(dst);
+    return {
+      name,
+      filename,
+      publicPath: `./assets/${filename}`,
+      integrity,
+      size: stat.size,
+      type: "css"
+    };
+  } catch (err) {
+    console.error(err);
+    throw new Error(`Failed to compile style "${name}"`);
+  }
+}
+
+function cssAssetProcessor(assetFolder, assets) {
+  return {
+    name: "css-asset-processor",
+    after: "assets",
+    async handler(context) {
+      const assetInfo = context.getTemplateData("assets") ?? {};
+      const head = context.getTemplateData("injectHead") ?? [];
+      const body = context.getTemplateData("injectBody") ?? [];
+      for (const asset of assets) {
+        const info = await compileStyle(
+          assetFolder,
+          asset.name,
+          asset.src
+        );
+        const attrs = serializeAttrs(asset.options.attributes);
+        const inject = { ...info, attrs: Array.from(attrs).join(" ") };
+        assetInfo[asset.name] = info;
+        switch (asset.options.appendTo) {
+          case "none":
+            break;
+          case "head":
+            head.push(inject);
+            break;
+          case "body":
+            body.push(inject);
+            break;
+        }
+        context.setTemplateData("injectHead", head);
+        context.setTemplateData("injectBody", body);
+        context.log(info.filename, formatSize(info.size));
+      }
+      context.setTemplateData("assets", assetInfo);
+    }
+  };
+}
+
+function toArray$2(value) {
+  if (Array.isArray(value)) {
+    return value;
+  } else {
+    return [value];
+  }
+}
+async function compileScript(assetFolder, name, src, options) {
+  const iconLib = process.env.DOCS_ICON_LIB ?? "@fkui/icon-lib-default";
+  try {
+    const outfile = path.join("temp", `asset-${name}.js`);
+    await esbuild.build({
+      entryPoints: toArray$2(src),
+      outfile,
+      bundle: true,
+      format: "iife",
+      platform: "browser",
+      external: ["vue", "@fkui/vue"],
+      tsconfig: path.join(__dirname, "../tsconfig-examples.json"),
+      define: {
+        "process.env.DOCS_ICON_LIB": JSON.stringify(iconLib)
+      },
+      ...options
+    });
+    const content = await fs.readFile(outfile, "utf-8");
+    const fingerprint = createMarkdownRenderer.getFingerprint(content);
+    const integrity = getIntegrity(content);
+    const filename = `${name}-${fingerprint}.js`;
+    const dst = path.join(assetFolder, filename);
+    await fs.rename(outfile, dst);
+    const stat = await fs.stat(dst);
+    return {
+      name,
+      filename,
+      publicPath: `./assets/${filename}`,
+      integrity,
+      size: stat.size,
+      type: "js"
+    };
+  } catch {
+    throw new Error(`Failed to compile script "${name}"`);
+  }
+}
+
+function jsAssetProcessor(assetFolder, assets) {
+  return {
+    name: "js-asset-processor",
+    after: "assets",
+    async handler(context) {
+      const assetInfo = context.getTemplateData("assets") ?? {};
+      const head = context.getTemplateData("injectHead") ?? [];
+      const body = context.getTemplateData("injectBody") ?? [];
+      for (const asset of assets) {
+        const info = await compileScript(
+          assetFolder,
+          asset.name,
+          asset.src
+        );
+        const attrs = serializeAttrs(asset.options.attributes);
+        const inject = { ...info, attrs: Array.from(attrs).join(" ") };
+        assetInfo[asset.name] = info;
+        switch (asset.options.appendTo) {
+          case "none":
+            break;
+          case "head":
+            head.push(inject);
+            break;
+          case "body":
+            body.push(inject);
+            break;
+        }
+        context.setTemplateData("injectHead", head);
+        context.setTemplateData("injectBody", body);
+        context.log(info.filename, formatSize(info.size));
+      }
+    }
+  };
+}
+
+function staticResourcesProcessor(assetFolder, resources) {
+  return {
+    name: "static-resources-processor",
+    after: "render",
+    async handler(context) {
+      for (const resource of [...resources, ...context.resources]) {
+        const src = resource.from;
+        const dst = path$1.join(assetFolder, resource.to);
+        await fs.cp(src, dst, {
+          recursive: true
+        });
+        context.log(src, "->", dst);
+      }
+    }
+  };
+}
+
+function getExampleImport(searchDirs, filename) {
+  const pattern = searchDirs.map((dir) => `${dir}/**/${filename}`);
+  const matches = vendor.globSync(pattern);
+  if (matches.length === 0) {
+    const message = `No files matched import "${filename}"`;
+    throw new Error(message);
+  } else if (matches.length > 1) {
+    const message = `Multiple files matched import "${filename}"`;
+    throw new Error(message);
+  } else {
+    return createMarkdownRenderer.normalizePath(matches[0]);
+  }
+}
+
+function getExampleName(filename) {
+  return path.parse(filename).name;
+}
+
+const vueMajor = parseInt(vue.version.split(".", 2)[0], 10);
+const vueGenerator = {
+  [2]: vue2.generateCode,
+  [3]: vue3.generateCode
+};
+function generateExample(options) {
+  const { language } = options;
+  if (language === "import") {
+    const parsed = parseImport(options.source);
+    const filename = getExampleImport(
+      options.exampleFolders,
+      parsed.filename
+    );
+    const source = fs$1.readFileSync(filename, "utf-8");
+    const language2 = parsed.extension;
+    const comments = parsed.comments;
+    const example = generateExample({
+      ...options,
+      source,
+      language: language2,
+      filename
+    });
+    return { ...example, comments };
+  }
+  switch (language) {
+    case "vue":
+      return generateVueExample(options);
+    case "html":
+      return generateStaticExample(options);
+    default:
+      return generateStaticExample(options);
+  }
+}
+function generateVueExample(options) {
+  const { filename, source, parent, setupPath, tags } = options;
+  const fn = vueGenerator[vueMajor];
+  const slug = getExampleName(filename);
+  const fingerprint = createMarkdownRenderer.getFingerprint(source);
+  const { markup, sourcecode, output } = fn({
+    filename,
+    slug,
+    fingerprint,
+    code: source,
+    setupPath
+  });
+  return {
+    source,
+    language: options.language,
+    comments: [],
+    tags,
+    markup,
+    output,
+    runtime: true,
+    task: {
+      outputFile: output,
+      sourcecode,
+      sourceFile: filename,
+      parent
+    }
+  };
+}
+function generateStaticExample(options) {
+  const { source, language, tags } = options;
+  const runtimeLanguages = ["html"];
+  return {
+    source,
+    language: options.language,
+    comments: [],
+    tags,
+    markup: source,
+    output: null,
+    runtime: runtimeLanguages.includes(language)
+  };
+}
+
+function isNavigationSection(node) {
+  return "key" in node;
+}
+function pathFromDoc({ fileInfo }) {
+  if (fileInfo.name === "index") {
+    return [fileInfo.path.replace(/\\/g, "/"), true];
+  } else {
+    return [
+      `./${path.join(fileInfo.path, fileInfo.name).replace(/\\/g, "/")}`,
+      false
+    ];
+  }
+}
+function getParentKey(name) {
+  return name.split("/").slice(0, -1).join("/");
+}
+function generateNavtree(docs) {
+  const section = {};
+  function createSection(key, title, sortorder) {
+    const existing = section[key];
+    if (existing) {
+      existing.title = title;
+      existing.sortorder = sortorder;
+    } else {
+      const node = {
+        key,
+        title,
+        path: "",
+        sortorder,
+        children: []
+      };
+      section[key] = node;
+      if (key !== ".") {
+        const parent = attach(key);
+        parent.children.push(node);
+      }
+    }
+  }
+  function attach(key) {
+    const parentKey = getParentKey(key);
+    let parent = section[parentKey];
+    if (parent) {
+      return parent;
+    }
+    parent = {
+      key: parentKey,
+      title: parentKey.split("/").at(-1) ?? "(missing title)",
+      path: "",
+      sortorder: Infinity,
+      children: []
+    };
+    section[parentKey] = parent;
+    let anchestor = parentKey;
+    let current = parent;
+    while (anchestor !== ".") {
+      anchestor = getParentKey(anchestor);
+      if (section[anchestor]) {
+        section[anchestor].children.push(current);
+        break;
+      }
+      const node = {
+        key: anchestor,
+        title: "",
+        path: "",
+        sortorder: Infinity,
+        children: [current]
+      };
+      section[anchestor] = node;
+      current = node;
+    }
+    return parent;
+  }
+  for (const doc of docs) {
+    const [name, isSection] = pathFromDoc(doc);
+    const title = doc.attributes.title ?? doc.fileInfo.name;
+    const sortorder = doc.attributes.sortorder;
+    if (doc.attributes.href) {
+      const parent2 = attach(name);
+      const leafNode = {
+        id: doc.id,
+        title,
+        path: doc.attributes.href,
+        sortorder,
+        external: true
+      };
+      parent2.children.push(leafNode);
+      continue;
+    }
+    if (!doc.fileInfo.outputName) {
+      if (isSection) {
+        createSection(name, title, sortorder);
+      }
+      continue;
+    }
+    if (!doc.visible) {
+      if (isSection) {
+        createSection(name, title, sortorder);
+      }
+      continue;
+    }
+    if (name === ".") {
+      createSection(name, title, sortorder);
+      continue;
+    }
+    const parent = attach(name);
+    if (isSection) {
+      const leafNode = {
+        id: doc.id,
+        title,
+        path: `${name}/`,
+        sortorder,
+        external: false
+      };
+      const existing = section[name];
+      if (existing) {
+        existing.title = title;
+        existing.path = leafNode.path;
+        existing.sortorder = sortorder;
+        existing.children.unshift(leafNode);
+      } else {
+        const sectionNode = {
+          key: name,
+          title,
+          path: leafNode.path,
+          sortorder,
+          children: [leafNode]
+        };
+        section[name] = sectionNode;
+        parent.children.push(sectionNode);
+      }
+    } else {
+      const leafNode = {
+        id: doc.id,
+        title,
+        path: `${doc.fileInfo.path}/${doc.fileInfo.outputName}`,
+        sortorder,
+        external: false
+      };
+      parent.children.push(leafNode);
+    }
+  }
+  const root = section["."];
+  if (root) {
+    return root;
+  } else {
+    return {
+      key: ".",
+      title: "",
+      path: "",
+      sortorder: Infinity,
+      children: []
+    };
+  }
+}
+
+function navigationProcessor() {
+  return {
+    stage: "generate-nav",
+    name: "navigation-processor",
+    handler(context) {
+      const navtree = generateNavtree(context.docs);
+      context.setTopNavigation(navtree);
+      context.setSideNavigation(navtree);
+    }
+  };
+}
+
+function sortNavigationTree(tree) {
+  tree.children.sort((a, b) => {
+    if (a.sortorder < b.sortorder) {
+      return -1;
+    } else if (a.sortorder > b.sortorder) {
+      return 1;
+    }
+    const titleA = a.title.toUpperCase();
+    const titleB = b.title.toUpperCase();
+    if (titleA < titleB) {
+      return -1;
+    }
+    if (titleA > titleB) {
+      return 1;
+    }
+    return 0;
+  });
+  for (const child of tree.children) {
+    if (isNavigationSection(child)) {
+      sortNavigationTree(child);
+    }
+  }
+}
+
+class TemplateLoader {
+  async = true;
+  folders;
+  templateCache;
+  constructor(folders = []) {
+    this.folders = [...folders, path.join(__dirname, "../templates")];
+    this.templateCache = /* @__PURE__ */ new Map();
+  }
+  async getSource(name, callback) {
+    try {
+      const { content, filePath } = await this.resolveTemplate(name);
+      callback(null, {
+        src: content,
+        path: filePath,
+        noCache: false
+      });
+    } catch (err) {
+      if (err instanceof Error) {
+        callback(err, null);
+      } else {
+        callback(new Error(String(err)), null);
+      }
+    }
+  }
+  async resolveTemplate(name) {
+    const { templateCache, folders } = this;
+    const cached = templateCache.get(name);
+    if (cached) {
+      return cached;
+    }
+    const searchPaths = folders.map((it) => path.join(it, name));
+    const filePath = searchPaths.find((it) => fs$1.existsSync(it));
+    if (!filePath) {
+      const searched = folders.map((it) => `  - "${it}"`).join("\n");
+      const message = `Failed to resolve template "${name}", searched in:
+
+${searched}
+
+Make sure the name is correct and the template file exists in one of the listed directories.`;
+      throw new Error(message);
+    }
+    const content = await fs.readFile(filePath, "utf-8");
+    const resolved = { content, filePath };
+    templateCache.set(name, resolved);
+    return resolved;
+  }
+}
+
+function dump(value) {
+  return `<pre>${JSON.stringify(value, null, 2)}</pre>`;
+}
+
+function json(value) {
+  return JSON.stringify(value, null, 2);
+}
+
+function isExternalUrl(url) {
+  return url.startsWith("http://") || url.startsWith("https://") || url.startsWith("//");
+}
+function isAbsoluteUrl(url) {
+  return url.startsWith("/");
+}
+function relative(url, { fileInfo }) {
+  if (isExternalUrl(url)) {
+    return url;
+  }
+  if (isAbsoluteUrl(url)) {
+    url = `.${url}`;
+  }
+  url = createMarkdownRenderer.normalizePath(url);
+  const outputPath = createMarkdownRenderer.normalizePath(fileInfo.path);
+  if (outputPath === url || `${outputPath}/` === url) {
+    return "./";
+  }
+  const relative2 = path$1.relative(outputPath, url);
+  const prefix = relative2.startsWith(".") ? "" : "./";
+  const suffix = url.endsWith("/") ? "/" : "";
+  return [prefix, relative2, suffix].join("");
+}
+
+function take(haystack, key, value) {
+  return haystack.filter((it) => it[key] === value);
+}
+
+class MissingTemplateError extends Error {
+  searchDir;
+  constructor(fileInfo, template, format, searchDir) {
+    const message = `Failed to find template "${template}" (${format} format) when rendering "${fileInfo.fullPath}"`;
+    super(message);
+    this.name = "MissingTemplateError";
+    this.searchDir = searchDir;
+  }
+  prettyError() {
+    return [
+      this.message,
+      "",
+      "Searched the following directories:",
+      ...this.searchDir.map((it) => `  - ${it}`)
+    ].join("\n");
+  }
+}
+const templateDirectory = path.join(__dirname, "../templates");
+const cache$1 = /* @__PURE__ */ new Map();
+function cacheKey(layout, extension) {
+  return [layout, extension].join("|");
+}
+function findTemplate(from, src, format) {
+  let layout;
+  if (typeof src === "string") {
+    layout = src;
+    format ??= "html";
+  } else {
+    layout = src.template;
+    format = src.format !== "json" ? "html" : "json";
+  }
+  const key = cacheKey(layout, format);
+  const cached = cache$1.get(key);
+  if (cached) {
+    return cached;
+  }
+  const template = `${layout}.template.${format}`;
+  const templateFile = path.join(templateDirectory, template);
+  if (!fs$1.existsSync(templateFile)) {
+    throw new MissingTemplateError(from, template, format, [
+      templateDirectory
+    ]);
+  }
+  cache$1.set(key, template);
+  return template;
+}
+
+const scriptPath = path.join(__dirname, "compile-example.js");
+let loader = null;
+function haveOutputFile(fileInfo) {
+  return fileInfo.outputName !== false;
+}
+function fillActiveNavigation(doc, node) {
+  if (isNavigationSection(node)) {
+    const children = node.children.map(
+      (it) => fillActiveNavigation(doc, it)
+    );
+    const active = children.some((it) => it.active);
+    return {
+      ...node,
+      active,
+      children
+    };
+  } else {
+    const active = doc.id === node.id;
+    return {
+      ...node,
+      active
+    };
+  }
+}
+function findSidenav(doc, tree) {
+  const { path: path2, name } = doc.fileInfo;
+  const category = path2 === "." ? name : path2.split("/")[1];
+  const sidenav = tree.children.filter(isNavigationSection).find((it) => it.key === `./${category}`);
+  if (sidenav) {
+    return fillActiveNavigation(doc, sidenav);
+  }
+}
+function cache(cacheFolder, outputFolder) {
+  return (it) => {
+    const cacheFile = path.join(cacheFolder, it.outputFile);
+    const outputFile = path.join(outputFolder, it.outputFile);
+    if (fs$1.existsSync(cacheFile)) {
+      fs$1.copyFileSync(cacheFile, outputFile);
+      return false;
+    } else {
+      return true;
+    }
+  };
+}
+async function compileExamples(options) {
+  const { fileInfo, tasks, vendors } = options;
+  if (tasks.length === 0) {
+    return;
+  }
+  const cacheFolder = path.posix.join(options.cacheFolder, fileInfo.path);
+  const outputFolder = path.posix.join(options.outputFolder, fileInfo.path);
+  const cacheMiss = cache(cacheFolder, outputFolder);
+  const dirtyTasks = tasks.filter(cacheMiss);
+  const batch = {
+    outputFolder,
+    external: vendors.map((it) => it.package),
+    tasks: dirtyTasks
+  };
+  const result = await vendor.execa("node", [scriptPath], {
+    input: JSON.stringify(batch),
+    all: true
+  });
+  const hasOutput = result.all ? result.all.length > 0 : false;
+  if (hasOutput) {
+    console.log(result.all);
+  }
+}
+async function compileStandalones(options) {
+  const { fileInfo, tasks, renderTemplate, templateData } = options;
+  if (tasks.length === 0) {
+    return;
+  }
+  const cacheFolder = path.posix.join(options.cacheFolder, fileInfo.path);
+  const outputFolder = path.posix.join(options.outputFolder, fileInfo.path);
+  const cacheMiss = cache(cacheFolder, outputFolder);
+  const dirtyTasks = tasks.filter(cacheMiss);
+  const standaloneTemplate = findTemplate(fileInfo, "example");
+  for (const task of dirtyTasks) {
+    const outputFile = path.join(outputFolder, task.outputFile);
+    const content = await renderTemplate(standaloneTemplate, {
+      ...templateData,
+      content: task.content
+    });
+    await fs.writeFile(outputFile, content, "utf-8");
+  }
+}
+function createTemplateLoader(folders) {
+  loader = new TemplateLoader(folders);
+}
+async function render(doc, docs, nav, vendors, options) {
+  const { fileInfo } = doc;
+  const { outputFolder, cacheFolder } = options;
+  if (!haveOutputFile(fileInfo)) {
+    return null;
+  }
+  const dst = createMarkdownRenderer.getOutputFilePath(outputFolder, fileInfo);
+  const mkdir = fs.mkdir(path.dirname(dst), { recursive: true });
+  const topnav = nav.topnav;
+  const sidenav = findSidenav(doc, nav.sidenav);
+  if (sidenav && isNavigationSection(sidenav)) {
+    sortNavigationTree(sidenav);
+  }
+  const njk = new nunjucks.Environment(loader, { autoescape: false });
+  const asyncRender = node_util.promisify(njk.render);
+  const renderTemplate = asyncRender.bind(njk);
+  const template = findTemplate(doc.fileInfo, doc);
+  const templateData = {
+    ...options.templateData,
+    site: options.site,
+    doc,
+    topnav,
+    sidenav,
+    vendors
+  };
+  const generatedExamples = [];
+  const generatedStandalone = [];
+  const markdownRenderer = createMarkdownRenderer.createMarkdownRenderer({
+    docs,
+    generateExample({ source, language, filename, tags }) {
+      const example = generateExample({
+        source,
+        language,
+        filename,
+        parent: fileInfo.fullPath,
+        setupPath: options.setupPath,
+        exampleFolders: options.exampleFolders,
+        tags
+      });
+      if (example.output) {
+        const { dir, name } = path.parse(example.output);
+        generatedExamples.push(example.task);
+        generatedStandalone.push({
+          outputFile: path.join(dir, `${name}.html`),
+          content: example.markup
+        });
+      }
+      return example;
+    },
+    addResource(dst2, src) {
+      if (!fs$1.existsSync(src)) {
+        throw new Error(`Failed to find image "${src}"`);
+      }
+      options.addResource(dst2, src);
+    },
+    handleSoftError(error) {
+      throw error;
+    }
+  });
+  njk.addFilter("marked", (content2) => {
+    return markdownRenderer.render(doc, content2);
+  });
+  njk.addFilter("json", json);
+  njk.addFilter("dump", dump);
+  njk.addFilter("relative", relative);
+  njk.addFilter("take", take);
+  njk.addExtension("BlockContainer", {
+    tags: ["container"],
+    parse(parser, nodes) {
+      const tok = parser.nextToken();
+      const args = parser.parseSignature(null, true);
+      parser.advanceAfterBlockEnd(tok.value);
+      return new nodes.CallExtensionAsync(this, "run", args, []);
+    },
+    async run({ ctx }, container, callback) {
+      const blocks = options.templateBlocks.get(container) ?? [];
+      const promises = blocks.map(({ renderer }) => {
+        if ("filename" in renderer) {
+          const data = renderer.data;
+          return renderTemplate(renderer.filename, {
+            ...ctx,
+            ...data
+          });
+        }
+        if ("render" in renderer) {
+          return Promise.resolve(renderer.render());
+        }
+        return Promise.resolve("");
+      });
+      const content2 = await Promise.all(promises);
+      const markup = content2.join("");
+      return callback(null, new nunjucks.runtime.SafeString(markup));
+    }
+  });
+  await mkdir;
+  let content;
+  try {
+    content = await renderTemplate(template, templateData);
+  } catch (err) {
+    const prefix = `Failed to render "${fileInfo.fullPath}"`;
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`${prefix}: ${message}`, { cause: err });
+  }
+  const expandedDst = dst.replace(/\[([^]+)\]/g, (match, key) => {
+    if (key === "hash") {
+      return createMarkdownRenderer.getFingerprint(doc.body);
+    } else {
+      return match;
+    }
+  });
+  const writeFile = fs.writeFile(expandedDst, content ?? "null", "utf-8");
+  try {
+    await compileExamples({
+      fileInfo,
+      cacheFolder,
+      outputFolder,
+      tasks: generatedExamples,
+      vendors
+    });
+  } catch (err) {
+    const prefix = `Failed to compile examples from "${fileInfo.fullPath}"`;
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`${prefix}: ${message}`, { cause: err });
+  }
+  try {
+    await compileStandalones({
+      fileInfo,
+      cacheFolder,
+      outputFolder,
+      tasks: generatedStandalone,
+      renderTemplate,
+      templateData
+    });
+  } catch (err) {
+    const prefix = `Failed to render standalone examples from "${fileInfo.fullPath}"`;
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`${prefix}: ${message}`, { cause: err });
+  }
+  await writeFile;
+  return dst;
+}
+
+const progressbar = new vendor.cliProgress.SingleBar({
+  format: " {bar} {percentage}% | {value}/{total} documents | {filename}",
+  barCompleteChar: "\u2588",
+  barIncompleteChar: "\u2591",
+  hideCursor: true,
+  clearOnComplete: true
+});
+function nunjucksProcessor(options) {
+  return {
+    stage: "render",
+    name: "nunjucks-renderer",
+    async handler(context) {
+      function renderDocument(doc) {
+        const nav = {
+          topnav: context.topnav,
+          sidenav: context.sidenav
+        };
+        return render(doc, context.docs, nav, context.vendors, {
+          ...options,
+          templateBlocks: context.getAllTemplateBlocks(),
+          templateData: context.getAllTemplateData(),
+          addResource(dst, src) {
+            context.addResource(dst, src);
+          }
+        });
+      }
+      const docs = context.docs.filter((it) => {
+        return it.fileInfo.outputName;
+      });
+      createTemplateLoader(options.templateFolders);
+      progressbar.start(docs.length, 0, {
+        filename: docs.length > 0 ? docs[0].fileInfo.fullPath : ""
+      });
+      const generatedFiles = [];
+      try {
+        for (const doc of context.docs) {
+          const filePath = await renderDocument(doc);
+          if (filePath) {
+            generatedFiles.push(filePath);
+          }
+          progressbar.increment(1, {
+            filename: doc.fileInfo.fullPath
+          });
+        }
+      } finally {
+        progressbar.stop();
+      }
+      context.log(docs.length, "documents rendered");
+      return generatedFiles;
+    }
+  };
+}
+
+function flattenOutline(outline) {
+  return outline.flatMap((entry) => {
+    return [
+      { heading: entry.title, anchor: entry.anchor },
+      ...flattenOutline(entry.subheadings)
+    ];
+  });
+}
+function findExamples(doc) {
+  if (doc.format !== "markdown") {
+    return [];
+  }
+  const collected = [];
+  const md = vendor.MarkdownIt();
+  md.renderer.rules.fence = (tokens, idx) => {
+    const { content, info, map } = tokens[idx];
+    const [language, ...tags] = info.split(/\s+/);
+    const hashContent = `${map == null ? void 0 : map[0]}:${map == null ? void 0 : map[1]}:${info}:${content}`;
+    const fingerprint = createMarkdownRenderer.getFingerprint(hashContent);
+    collected.push({
+      selector: `#example-${fingerprint}`,
+      language,
+      tags
+    });
+    return "";
+  };
+  md.render(doc.body);
+  return collected;
+}
+function manifestPageFromDocument(doc) {
+  const { fileInfo } = doc;
+  return {
+    path: createMarkdownRenderer.getOutputFilePath("", fileInfo),
+    title: doc.attributes.title ?? doc.name ?? "",
+    outline: flattenOutline(doc.outline),
+    examples: findExamples(doc)
+  };
+}
+
+function customRequire(name) {
+  if (typeof window.__modules__ === "undefined") {
+    window.__modules__ = {};
+  }
+  const mod = window.__modules__[name];
+  if (!mod) {
+    throw new Error(`Cannot find module "${name}"`);
+  }
+  return mod;
+}
+function getAssetSource(asset, require) {
+  const lines = [];
+  const pkg = asset.package.replace(/\\/g, "/");
+  if (!asset.expose) {
+    return `import "${pkg}"`;
+  }
+  if (asset.expose === "named") {
+    lines.push(`import * as lib from "${pkg}";`);
+  } else {
+    lines.push(`import lib from "${pkg}";`);
+  }
+  asset.subpaths.map((subpath, index) => {
+    if (asset.expose === "named") {
+      lines.push(`import * as lib$${index} from "${subpath}";`);
+    } else {
+      lines.push(`import lib$${index} from "${subpath}";`);
+    }
+  });
+  lines.push(`window.require = window.require || ${require};`);
+  lines.push(`window.__modules__ = window.__modules__ || {};`);
+  lines.push(`window.__modules__["${asset.package}"] = lib;`);
+  if (typeof asset.alias !== "undefined") {
+    lines.push(`window.__modules__["${asset.alias}"] = lib;`);
+  }
+  asset.subpaths.map((subpath, index) => {
+    lines.push(`window.__modules__["${subpath}"] = lib$${index};`);
+  });
+  if (typeof asset.global !== "undefined") {
+    lines.push(`window["${asset.global}"] = lib;`);
+  }
+  return lines.join("\n");
+}
+async function compileVendor(assetFolder, vendor, options) {
+  const name = path.isAbsolute(vendor.package) ? path.basename(vendor.package) : vendor.package;
+  const slug = slugify(name);
+  const outfile = `temp/vendor-${slug}.out.js`;
+  const tmpfile = `temp/vendor-${slug}.in.js`;
+  const source = getAssetSource(vendor, customRequire.toString());
+  const tsconfig = path.resolve(__dirname, "../tsconfig-examples.json");
+  await fs.writeFile(tmpfile, source, "utf-8");
+  await esbuild.build({
+    entryPoints: [tmpfile],
+    outfile,
+    bundle: true,
+    format: "iife",
+    platform: "browser",
+    tsconfig,
+    define: {
+      "process.env.NODE_ENV": JSON.stringify(
+        process.env.NODE_ENV ?? "production"
+      )
+    },
+    alias: vendor.alias ? { [`${vendor.package}`]: vendor.alias } : void 0,
+    ...options
+  });
+  const content = await fs.readFile(outfile, "utf-8");
+  const fingerprint = createMarkdownRenderer.getFingerprint(content);
+  const integrity = getIntegrity(content);
+  const filename = `vendor-${slug}-${fingerprint}.js`;
+  const dst = path.join(assetFolder, filename).replace(/\\/g, "/");
+  await fs.rename(outfile, dst);
+  const stat = await fs.stat(dst);
+  return {
+    package: vendor.package,
+    filename,
+    publicPath: `./assets/${filename}`,
+    integrity,
+    size: stat.size
+  };
+}
+
+function normalizeVendorDefinition(vendor) {
+  if (typeof vendor === "string") {
+    return {
+      package: vendor,
+      global: void 0,
+      expose: "named",
+      subpaths: []
+    };
+  } else {
+    return {
+      package: vendor.package,
+      global: vendor.global,
+      expose: vendor.expose ?? "named",
+      subpaths: vendor.subpaths ?? [],
+      alias: vendor.alias ?? void 0
+    };
+  }
+}
+
+function getPackageName(vendor) {
+  return typeof vendor === "string" ? vendor : vendor.package;
+}
+function generateVendorAssets(assetFolder, assets) {
+  const packages = assets.map(getPackageName);
+  const normalized = assets.map(normalizeVendorDefinition);
+  const promises = normalized.map((it) => {
+    const external = packages.filter((pkg) => pkg !== it.package);
+    return compileVendor(assetFolder, it, {
+      external
+    });
+  });
+  return Promise.all(promises);
+}
+function vendorProcessor(assetFolder, vendor) {
+  return {
+    stage: "assets",
+    name: "vendor-processor",
+    async handler(context) {
+      const assets = await generateVendorAssets(assetFolder, vendor);
+      context.addVendorAsset(assets);
+      for (const asset of assets) {
+        const filename = path$1.basename(asset.publicPath);
+        context.log(filename, formatSize(asset.size));
+      }
+    }
+  };
+}
+
+function livereloadProcessor(options) {
+  const { enabled } = options;
+  return {
+    after: "generate-docs",
+    name: "livereload-processor",
+    enabled,
+    handler(context) {
+      context.addTemplateBlock("body:end", "livereload", {
+        filename: "partials/livereload.html"
+      });
+    }
+  };
+}
+
+async function keypress() {
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  return new Promise((resolve) => {
+    process.stdin.once("data", (data) => {
+      process.stdin.setRawMode(false);
+      process.stdin.resume();
+      resolve(data.toString("utf-8"));
+    });
+  });
+}
+
+function printMenu(addr) {
+  console.log();
+  console.group(
+    `Starting development server at http://localhost:${addr.port}`
+  );
+  console.log();
+  console.log("[q] quit");
+  console.log();
+  console.groupEnd();
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function createRebuilder(callback, livereload) {
+  let inflight = false;
+  let queue = [];
+  async function rebuild(filePath) {
+    queue.push(filePath);
+    if (inflight) {
+      return;
+    }
+    inflight = true;
+    try {
+      while (queue.length > 0) {
+        const modifiedFiles = queue;
+        queue = [];
+        const generatedFiles = await callback(modifiedFiles);
+        livereload(generatedFiles);
+        await sleep(200);
+      }
+    } finally {
+      inflight = false;
+    }
+  }
+  return rebuild;
+}
+async function serve(options) {
+  const app = express();
+  app.use(express.static(options.outputFolder));
+  const server = app.listen(8080);
+  printMenu(server.address());
+  const livereload = vendor.tinylr();
+  livereload.listen(35729);
+  const watcher = vendor.chokidar.watch(options.watch);
+  const rebuild = createRebuilder(options.rebuild, (filePath) => {
+    const files = filePath.map((it) => {
+      return path$1.relative(options.outputFolder, it);
+    });
+    livereload.changed({ body: { files } });
+  });
+  watcher.on("change", async (filePath) => {
+    rebuild(filePath);
+  });
+  for (; ; ) {
+    const key = await keypress();
+    switch (key) {
+      case "":
+      case "q":
+        console.log("Shutting down gracefully");
+        server.close();
+        watcher.close();
+        livereload.close();
+        process.stdin.unref();
+        return;
+    }
+  }
+}
+
+function toArray$1(value) {
+  return Array.isArray(value) ? value : [value];
+}
+function filterProcessors(stage2, processors) {
+  const before = [];
+  const during = [];
+  const after = [];
+  for (const processor of processors) {
+    if (processor.enabled === false) {
+      continue;
+    }
+    if (processor.before === stage2) {
+      before.push(processor);
+    }
+    if (processor.stage === stage2) {
+      during.push(processor);
+    }
+    if (processor.after === stage2) {
+      after.push(processor);
+    }
+  }
+  return [...before, ...during, ...after];
+}
+async function stage(stage2, context, processors, { verbose } = { verbose: true }) {
+  if (verbose) {
+    console.log(`stage:${stage2}`);
+  }
+  let generatedFiles = [];
+  const filteredProcessors = filterProcessors(stage2, processors);
+  for (let i = 0; i < filteredProcessors.length; i++) {
+    const processor = filteredProcessors[i];
+    const isLast = i === filteredProcessors.length - 1;
+    if (verbose) {
+      console.log(isLast ? "  \u2514\u2500" : "  \u251C\u2500", processor.name);
+    }
+    try {
+      const result = await processor.handler({
+        ...context,
+        log(...args) {
+          if (verbose) {
+            console.log(isLast ? "      " : "  \u2502   ", ...args);
+          }
+        }
+      });
+      if (result) {
+        generatedFiles = [...generatedFiles, ...result];
+      }
+    } catch (err) {
+      console.error(`When running processor "${processor.name}":`);
+      console.error(err);
+      throw err;
+    }
+  }
+  return generatedFiles;
+}
+function createContext() {
+  let docs = [];
+  let vendors = [];
+  const resources = [];
+  const templateBlocks = /* @__PURE__ */ new Map();
+  let topnav = {
+    key: ".",
+    title: "",
+    path: "",
+    sortorder: Infinity,
+    children: []
+  };
+  let sidenav = {
+    key: ".",
+    title: "",
+    path: "",
+    sortorder: Infinity,
+    children: []
+  };
+  const templateData = {};
+  return {
+    get docs() {
+      return docs;
+    },
+    get vendors() {
+      return vendors;
+    },
+    get resources() {
+      return resources;
+    },
+    get topnav() {
+      return topnav;
+    },
+    get sidenav() {
+      return sidenav;
+    },
+    addDocument(document) {
+      docs = [...docs, ...toArray$1(document)];
+    },
+    addVendorAsset(asset) {
+      vendors = [...vendors, ...toArray$1(asset)];
+    },
+    addResource(dst, src) {
+      resources.push({
+        from: src.replace(/\\/g, "/"),
+        to: dst
+      });
+    },
+    addTemplateBlock(container, id, renderer) {
+      const block = {
+        container,
+        id,
+        renderer
+      };
+      const list = templateBlocks.get(container) ?? [];
+      templateBlocks.set(container, [...list, block]);
+    },
+    getAllTemplateBlocks() {
+      return templateBlocks;
+    },
+    setTopNavigation(root) {
+      topnav = root;
+    },
+    setSideNavigation(root) {
+      sidenav = root;
+    },
+    getAllTemplateData() {
+      return templateData;
+    },
+    getTemplateData(key) {
+      return templateData[key];
+    },
+    setTemplateData(key, value) {
+      templateData[key] = value;
+    }
+  };
+}
+class Generator {
+  site;
+  outputFolder;
+  cacheFolder;
+  assetFolder;
+  exampleFolders;
+  templateFolders;
+  processors;
+  vendor;
+  setupPath;
+  scripts;
+  styles;
+  resources;
+  sourceFiles;
+  constructor(options) {
+    if (typeof options.site === "undefined") {
+      throw new Error("site metadata not set in configuration");
+    }
+    this.site = options.site;
+    this.outputFolder = options.outputFolder;
+    this.cacheFolder = options.cacheFolder;
+    this.assetFolder = path.posix.join(options.outputFolder, "assets");
+    this.exampleFolders = options.exampleFolders;
+    this.templateFolders = options.templateFolders ?? [];
+    this.processors = options.processors ?? [];
+    this.vendor = options.vendor ?? [];
+    this.setupPath = options.setupPath.replace(/\\/g, "/");
+    this.scripts = [];
+    this.styles = [];
+    this.resources = [];
+    this.sourceFiles = [];
+  }
+  compileScript(name, src, options) {
+    this.scripts.push({
+      name,
+      src,
+      options: {
+        appendTo: "none",
+        attributes: {},
+        ...options
+      }
+    });
+  }
+  compileStyle(name, src, options) {
+    this.styles.push({
+      name,
+      src,
+      options: {
+        appendTo: "none",
+        attributes: {},
+        ...options
+      }
+    });
+  }
+  /**
+   * @param dst - Destination directory relative to asset folder.
+   * @param src - File or directory to copy.
+   */
+  copyResource(dst, src) {
+    this.resources.push({
+      from: src.replace(/\\/g, "/"),
+      to: dst
+    });
+  }
+  /**
+   * Generate a manifest listing all generated documents that will be present
+   * in `outputFolder`.
+   *
+   * Note: this only collects documents from the `generate-docs` stage,
+   * potential documents generated at later stages will not be present.
+   *
+   * @public
+   */
+  async manifest(sourceFiles) {
+    const processors = [
+      fileReaderProcessor(sourceFiles),
+      ...this.processors
+    ];
+    const context = createContext();
+    await stage("generate-docs", context, processors, { verbose: false });
+    const docs = context.docs.filter(haveOutput);
+    const pages = docs.map(manifestPageFromDocument);
+    return { pages };
+  }
+  async build(sourceFiles) {
+    this.sourceFiles = sourceFiles;
+    const {
+      site,
+      outputFolder,
+      cacheFolder,
+      assetFolder,
+      exampleFolders,
+      templateFolders,
+      setupPath
+    } = this;
+    await this._prepareFolders();
+    const processors = [
+      fileReaderProcessor(sourceFiles),
+      vendorProcessor(assetFolder, this.vendor),
+      cssAssetProcessor(assetFolder, this.styles),
+      jsAssetProcessor(assetFolder, this.scripts),
+      staticResourcesProcessor(assetFolder, this.resources),
+      navigationProcessor(),
+      nunjucksProcessor({
+        site: {
+          lang: "en",
+          ...site
+        },
+        outputFolder,
+        cacheFolder,
+        exampleFolders,
+        templateFolders,
+        setupPath
+      }),
+      ...this.processors
+    ];
+    const context = createContext();
+    const generatedFiles = [
+      await stage("generate-docs", context, processors),
+      await stage("generate-nav", context, processors),
+      await stage("assets", context, processors),
+      await stage("render", context, processors)
+    ];
+    return generatedFiles.flat();
+  }
+  /**
+   * Start a development server hosting the generated documentation.
+   */
+  serve() {
+    const { outputFolder, sourceFiles } = this;
+    const watch = sourceFiles.map((it) => it.include).flat();
+    return serve({
+      outputFolder,
+      watch,
+      rebuild: (_filePath) => {
+        return this.build(sourceFiles);
+      }
+    });
+  }
+  async _prepareFolders() {
+    const { outputFolder, cacheFolder, assetFolder } = this;
+    await fs.rm(cacheFolder, { force: true, recursive: true });
+    if (fs$1.existsSync(outputFolder)) {
+      await fs.mkdir(path.dirname(cacheFolder), { recursive: true });
+      await vendor.fse.copy(outputFolder, cacheFolder);
+      await fs.rm(outputFolder, { recursive: true });
+    }
+    await fs.mkdir(outputFolder, { recursive: true });
+    await fs.mkdir(assetFolder, { recursive: true });
+    await fs.mkdir("temp", { recursive: true });
+  }
+}
+
+function toArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+function matomoProcessor(options) {
+  const { enabled, siteId, apiUrl, trackerUrl, hostname } = options;
+  return {
+    after: "generate-docs",
+    name: "matomo-processor",
+    enabled,
+    handler(context) {
+      context.addTemplateBlock("head", "matomo", {
+        filename: "partials/matomo.html",
+        data: {
+          siteId,
+          apiUrl,
+          trackerUrl,
+          hostname: hostname ? toArray(hostname) : []
+        }
+      });
+    }
+  };
+}
+
+function renderMarkdown(manifest) {
+  return [
+    "## Documentation manifest",
+    "",
+    "> Do not edit this file. It is a automatically generated by `@forsakringskassan/docs-generator`.",
+    "",
+    "```",
+    ...manifest.pages.map((it) => it.path),
+    "```",
+    ""
+  ].join("\n");
+}
+function renderJSON(manifest) {
+  return JSON.stringify(manifest, null, 2);
+}
+function manifestProcessor(options) {
+  const { markdown, json } = options;
+  return {
+    name: "manifestProcessor",
+    before: "render",
+    async handler(context) {
+      const docs = context.docs.filter(haveOutput);
+      const pages = docs.map(manifestPageFromDocument);
+      pages.sort((a, b) => {
+        return a.path.localeCompare(b.path);
+      });
+      const manifest = { pages };
+      if (markdown) {
+        const content = renderMarkdown(manifest);
+        await fs.writeFile(markdown, content, "utf-8");
+      }
+      if (json) {
+        const content = renderJSON(manifest);
+        await fs.writeFile(json, content, "utf-8");
+      }
+    }
+  };
+}
+
+function themeSelectProcessor() {
+  return {
+    name: "theme-select-processor",
+    after: "generate-docs",
+    handler(context) {
+      context.addTemplateBlock("toolbar", "theme-select", {
+        filename: "partials/theme-select.html"
+      });
+    }
+  };
+}
+
+function selectableVersionProcessor(pkg, container) {
+  return {
+    name: "selectable-version-processor",
+    after: "generate-docs",
+    handler(context) {
+      context.addTemplateBlock(container, "version", {
+        filename: "partials/selectable-version.html",
+        data: { pkg }
+      });
+    }
+  };
+}
+
+function generateNavigation(entries) {
+  const children = entries.map((it, index) => {
+    const key = path$1.parse(it.path).name;
+    return {
+      key,
+      sortorder: index,
+      children: [],
+      ...it
+    };
+  });
+  return {
+    key: ".",
+    path: "./index.html",
+    sortorder: Infinity,
+    children
+  };
+}
+function topnavProcessor(filename, title) {
+  return {
+    after: "generate-nav",
+    name: "topnav-processor",
+    async handler(context) {
+      const content = await fs.readFile(filename, "utf-8");
+      const parsed = JSON.parse(content);
+      const rootNode = generateNavigation(parsed);
+      context.setTopNavigation({
+        title,
+        ...rootNode
+      });
+    }
+  };
+}
+
+function run(cmd, defaultValue) {
+  return new Promise((resolve) => {
+    childProcess.exec(cmd, { encoding: "utf-8" }, (error, stdout) => {
+      if (error) {
+        console.error(error);
+        resolve(defaultValue);
+      } else {
+        resolve(stdout.trim());
+      }
+    });
+  });
+}
+async function getGitBranch() {
+  const { CHANGE_BRANCH, CHANGE_NAME } = process.env;
+  if (CHANGE_BRANCH) {
+    return CHANGE_BRANCH;
+  }
+  if (CHANGE_NAME) {
+    return CHANGE_NAME;
+  }
+  const branch = await run("git rev-parse --abbrev-ref HEAD", "unknown");
+  if (branch === "HEAD" || branch === "") {
+    return "unknown";
+  } else {
+    return branch;
+  }
+}
+function getPullRequestID() {
+  return process.env.JOB_BASE_NAME;
+}
+async function getSCMData(pkg, options) {
+  const commitHash = await run(`git rev-parse HEAD`);
+  const commitShort = await run(`git rev-parse --short HEAD`);
+  if (!commitHash || !commitShort) {
+    return null;
+  }
+  const { homepage } = pkg;
+  const pr = getPullRequestID();
+  const prUrl = pr ? interpolate(options.prUrlFormat, { homepage, pr }) : void 0;
+  return {
+    branch: await getGitBranch(),
+    commitShort,
+    commitHash,
+    commitUrl: interpolate(options.commitUrlFormat, {
+      hash: commitHash,
+      short: commitShort,
+      homepage
+    }),
+    pr,
+    prUrl
+  };
+}
+function getBuildDatetime() {
+  const date = /* @__PURE__ */ new Date();
+  return {
+    date: date.toLocaleDateString("sv-SE"),
+    time: date.toLocaleTimeString("sv-SE")
+  };
+}
+function versionProcessor(pkg, container, options) {
+  const { enabled = true, scm = false } = options ?? {};
+  return {
+    name: "version-processor",
+    after: "generate-docs",
+    async handler(context) {
+      if (!enabled) {
+        return;
+      }
+      const scmData = scm ? await getSCMData(pkg, scm) : null;
+      const buildData = getBuildDatetime();
+      const data = {
+        pkg,
+        scm: scmData,
+        build: buildData
+      };
+      context.addTemplateBlock(container, "version", {
+        filename: "partials/version.njk.html",
+        data
+      });
+    }
+  };
+}
+
+function versionBannerProcessor(message, container) {
+  return {
+    name: "version-banner-processor",
+    after: "generate-docs",
+    handler(context) {
+      context.addTemplateBlock(container, "version-banner", {
+        filename: "partials/version-banner.html",
+        data: { message }
+      });
+    }
+  };
+}
+
+function generateIndex(entries) {
+  const index = {
+    terms: [],
+    results: [],
+    mapping: {}
+  };
+  for (const entry of entries) {
+    index.results.push({
+      url: entry.url,
+      title: entry.title
+    });
+    const resultIndex = index.results.length - 1;
+    for (const word of entry.words) {
+      index.terms.push(word);
+      const termIndex = index.terms.length - 1;
+      index.mapping[termIndex] = resultIndex;
+    }
+  }
+  return index;
+}
+
+function extractTerms(doc) {
+  const { title, component } = doc.attributes;
+  if (title && component) {
+    return component.map((it) => `${title} (${it})`);
+  } else if (component) {
+    return component;
+  } else if (title) {
+    return [title];
+  } else {
+    return [];
+  }
+}
+function isIndexable(doc) {
+  return Boolean(doc.visible && doc.fileInfo.outputName);
+}
+function getTerms(doc) {
+  return {
+    url: createMarkdownRenderer.getOutputFilePath(".", doc.fileInfo) ?? "",
+    title: doc.name,
+    words: extractTerms(doc)
+  };
+}
+function searchProcessor() {
+  return {
+    after: "generate-docs",
+    name: "search-processor",
+    handler(context) {
+      const entries = context.docs.filter(isIndexable).map(getTerms);
+      const index = generateIndex(entries);
+      const body = JSON.stringify(index);
+      const fingerprint = createMarkdownRenderer.getFingerprint(body);
+      const integrity = getIntegrity(body);
+      const outputName = `search-data-[hash].json`;
+      const expandedName = `search-data-${fingerprint}.json`;
+      context.setTemplateData("searchDataUrl", expandedName);
+      context.setTemplateData("searchDataIntegrity", integrity);
+      context.addDocument({
+        id: "search:data",
+        name: "search-data",
+        alias: [],
+        visible: false,
+        attributes: {
+          sortorder: Infinity
+        },
+        body,
+        outline: [],
+        format: "json",
+        tags: [],
+        template: "json",
+        fileInfo: {
+          path: "",
+          name: "virtual:search-data",
+          fullPath: "virtual:search-data",
+          outputName
+        }
+      });
+      context.addTemplateBlock("toolbar", "search-toolbar", {
+        filename: "partials/search-toolbar.html",
+        data: {
+          rootUrl(doc) {
+            const { fileInfo } = doc;
+            const relative = path$1.relative(fileInfo.path, ".");
+            return relative !== "" ? relative : ".";
+          }
+        }
+      });
+      context.addTemplateBlock("body:end", "search-dialog", {
+        filename: "partials/search-dialog.html"
+      });
+      context.log("Indexed", entries.length, "documents");
+    }
+  };
+}
+
+exports.Generator = Generator;
+exports.defineSources = defineSources;
+exports.frontMatterFileReader = frontMatterFileReader;
+exports.livereloadProcessor = livereloadProcessor;
+exports.manifestProcessor = manifestProcessor;
+exports.matomoProcessor = matomoProcessor;
+exports.navigationFileReader = navigationFileReader;
+exports.searchProcessor = searchProcessor;
+exports.selectableVersionProcessor = selectableVersionProcessor;
+exports.themeSelectProcessor = themeSelectProcessor;
+exports.topnavProcessor = topnavProcessor;
+exports.versionBannerProcessor = versionBannerProcessor;
+exports.versionProcessor = versionProcessor;
+exports.vueFileReader = vueFileReader;