@takazudo/zudo-doc 0.2.21 → 1.0.0

package/dist/sidebar-with-defaults/index.d.ts

@@ -0,0 +1,38 @@
+/** @jsxRuntime automatic */
+/** @jsxImportSource preact */
+import type { JSX } from "preact";
+import type { SidebarNavNode, SidebarRootMenuItem } from "../sidebar/types.js";
+import type { LocaleLink } from "../url-helpers/index.js";
+export type { SidebarNavNode, SidebarRootMenuItem };
+export interface SidebarWithDefaultsProps {
+    /** Slug of the active doc page, used to highlight the current entry. */
+    currentSlug?: string;
+    /** Active locale string, e.g. "en", "ja". */
+    lang?: string;
+    /** Header-nav category matcher used to scope the tree (e.g. "guides"). */
+    navSection?: string;
+    /** Active version slug, when rendering inside `/v/{version}/...`. */
+    currentVersion?: string;
+    /**
+     * Current page URL path used to build the locale-switcher links shown in
+     * the mobile sidebar footer.
+     */
+    currentPath?: string;
+}
+/** Dependencies injected by the host stub. */
+export interface SidebarWithDefaultsDeps {
+    defaultLocale: string;
+    localeCount: number;
+    buildRootMenuItems: (lang: string, currentVersion: string | undefined) => SidebarRootMenuItem[];
+    buildLocaleLinksForNav: (currentPath: string, lang: string, localeCount: number) => LocaleLink[] | undefined;
+    buildSidebarNodes: (lang: string, navSection: string | undefined, currentVersion: string | undefined, emptyWhenUnsectioned?: boolean) => SidebarNavNode[];
+    getThemeDefaultMode: () => "light" | "dark" | undefined;
+    t: (key: string, lang: string) => string;
+}
+/**
+ * Create a `SidebarWithDefaults` component bound to the host's nav builders.
+ *
+ * The host stub calls this once with its concrete dependencies and re-exports
+ * the result.
+ */
+export declare function createSidebarWithDefaults(deps: SidebarWithDefaultsDeps): (props: SidebarWithDefaultsProps) => JSX.Element;

package/dist/sidebar-with-defaults/index.js

@@ -0,0 +1,45 @@
+import { jsx } from "preact/jsx-runtime";
+import { Island } from "@takazudo/zfb";
+import { SidebarTree } from "../sidebar-tree-island/index.js";
+function createSidebarWithDefaults(deps) {
+  const {
+    defaultLocale,
+    localeCount,
+    buildRootMenuItems,
+    buildLocaleLinksForNav,
+    buildSidebarNodes,
+    getThemeDefaultMode,
+    t
+  } = deps;
+  function SidebarWithDefaults(props) {
+    const {
+      currentSlug,
+      lang = defaultLocale,
+      navSection,
+      currentVersion,
+      currentPath = ""
+    } = props;
+    const rootMenuItems = buildRootMenuItems(lang, currentVersion);
+    const backToMenuLabel = navSection ? t("nav.backToMenu", lang) : void 0;
+    const nodes = buildSidebarNodes(lang, navSection, currentVersion, false);
+    const localeLinks = buildLocaleLinksForNav(currentPath, lang, localeCount);
+    return Island({
+      when: "load",
+      children: /* @__PURE__ */ jsx(
+        SidebarTree,
+        {
+          nodes,
+          currentSlug,
+          rootMenuItems,
+          backToMenuLabel,
+          localeLinks,
+          themeDefaultMode: getThemeDefaultMode()
+        }
+      )
+    });
+  }
+  return SidebarWithDefaults;
+}
+export {
+  createSidebarWithDefaults
+};

package/dist/site-tree-nav/index.d.ts

@@ -0,0 +1,71 @@
+/** @jsxRuntime automatic */
+/** @jsxImportSource preact */
+import type { JSX } from "preact";
+import type { SidebarNavNode } from "../sidebar/types.js";
+/**
+ * Minimal nav source needed by the site-tree-nav factory.
+ * Typed `unknown[]` for navDocs so the factory does not import the host's
+ * concrete entry type (the host casts when injecting).
+ */
+export interface SiteTreeNavSource {
+    navDocs: unknown[];
+    categoryMeta: Map<string, unknown>;
+}
+/** Props for the SiteTreeNavWrapper component. */
+export interface SiteTreeNavWrapperProps {
+    /**
+     * Active locale. Injected via createMdxComponents() closure.
+     * Defaults to defaultLocale when not provided.
+     */
+    lang?: string;
+    /**
+     * Optional aria-label for the wrapping <nav> element.
+     * Forwarded to the v2 SiteTreeNavDemo component.
+     */
+    ariaLabel?: string;
+}
+/** Injected dependencies for {@link createSiteTreeNavWrapper}. */
+export interface SiteTreeNavDeps {
+    /** Default locale code (e.g. `"en"`). */
+    defaultLocale: string;
+    /**
+     * Resolve the identity-stable nav source for an EN/locale context.
+     * Host passes `resolveNavSource` from `pages/lib/_nav-source-docs.ts`.
+     */
+    resolveNavSource: (lang: string, currentVersion: string | undefined, options?: {
+        applyDefaultLocaleOnlyFilter?: boolean;
+        keepUnlisted?: boolean;
+    }) => SiteTreeNavSource;
+    /**
+     * Build the nav tree for a locale.
+     * Host passes `buildNavTree` from `@/utils/docs`.
+     * Returns `SidebarNavNode[]` — the host's NavNode is structurally
+     * compatible with SidebarNavNode (same fields including `position`).
+     */
+    buildNavTree: (docs: unknown[], locale: string, categoryMeta: Map<string, unknown>) => SidebarNavNode[];
+    /**
+     * Group satellite nodes under target category prefixes in the nav tree.
+     * Host passes `groupSatelliteNodes` from `@/utils/docs`.
+     */
+    groupSatelliteNodes: (tree: SidebarNavNode[], prefixes: string[]) => SidebarNavNode[];
+    /**
+     * Collect all categoryMatch strings from headerNav in order.
+     * Host passes `getCategoryOrder()` (already bound to settings.headerNav)
+     * from `@/utils/nav-scope`.
+     */
+    getCategoryOrder: () => string[];
+}
+/**
+ * Create the `SiteTreeNavWrapper` component bound to the host's nav source
+ * and tree-building dependencies.
+ *
+ * Builds the full site nav tree and renders it via the interactive SiteTreeNav
+ * island (wrapped in Island({when:"idle"})) — restoring byte-parity with the
+ * Astro reference at /docs/components/site-tree-nav/ (refs #1453/#1442).
+ *
+ * The island renders the collapsible multi-column grid the reference shows.
+ * SiteTreeNavDemo (static <details> list) is no longer used for MDX content.
+ *
+ * Returns null when the tree is empty after filtering.
+ */
+export declare function createSiteTreeNavWrapper(deps: SiteTreeNavDeps): (props: SiteTreeNavWrapperProps) => JSX.Element | null;

package/dist/site-tree-nav/index.js

@@ -0,0 +1,36 @@
+import { jsx } from "preact/jsx-runtime";
+import { Island } from "@takazudo/zfb";
+import { SiteTreeNav } from "../site-tree-nav-island/index.js";
+function createSiteTreeNavWrapper(deps) {
+  const { defaultLocale, resolveNavSource, buildNavTree, groupSatelliteNodes, getCategoryOrder } = deps;
+  function SiteTreeNavWrapper({
+    lang = defaultLocale,
+    ariaLabel
+  }) {
+    const locale = lang;
+    const { navDocs, categoryMeta } = resolveNavSource(locale, void 0, {
+      applyDefaultLocaleOnlyFilter: true,
+      keepUnlisted: true
+    });
+    const tree = buildNavTree(navDocs, locale, categoryMeta);
+    const categoryOrder = getCategoryOrder();
+    const groupedTree = groupSatelliteNodes(tree, categoryOrder);
+    if (groupedTree.length === 0) return null;
+    return Island({
+      when: "idle",
+      children: /* @__PURE__ */ jsx(
+        SiteTreeNav,
+        {
+          tree: groupedTree,
+          categoryOrder,
+          categoryIgnore: ["inbox", "develop"],
+          ariaLabel
+        }
+      )
+    });
+  }
+  return SiteTreeNavWrapper;
+}
+export {
+  createSiteTreeNavWrapper
+};

package/dist/site-tree-nav-island/index.d.ts

@@ -0,0 +1,11 @@
+import type { SidebarNavNode } from "../sidebar/types.js";
+export interface SiteTreeNavProps {
+    tree: SidebarNavNode[];
+    ariaLabel?: string;
+    categoryOrder?: string[];
+    categoryIgnore?: string[];
+}
+export declare function SiteTreeNav({ tree, ariaLabel, categoryOrder, categoryIgnore, }: SiteTreeNavProps): import("preact").JSX.Element;
+export declare namespace SiteTreeNav {
+    var displayName: string;
+}

package/dist/site-tree-nav-island/index.js

@@ -0,0 +1,176 @@
+"use client";
+import { Fragment, jsx, jsxs } from "preact/jsx-runtime";
+import { useState } from "preact/hooks";
+import { INDENT, connectorLeft, ConnectorLines, CategoryLinkIcon } from "../tree-nav-shared/index.js";
+import { ChevronRight } from "../icons/index.js";
+const SITE_BASE_PAD = "clamp(0.5rem, 0.8vw, 1rem)";
+function padLeft(depth) {
+  if (depth === 0) return SITE_BASE_PAD;
+  return `calc(${depth} * ${INDENT} + 1.25rem + 5px)`;
+}
+function reorderTree(tree, order) {
+  const map = new Map(tree.map((node) => [node.slug, node]));
+  const ordered = [];
+  for (const slug of order) {
+    const node = map.get(slug);
+    if (node) {
+      ordered.push(node);
+      map.delete(slug);
+    }
+  }
+  for (const node of map.values()) {
+    ordered.push(node);
+  }
+  return ordered;
+}
+function SiteTreeNav({
+  tree,
+  ariaLabel = "Site index",
+  categoryOrder,
+  categoryIgnore
+}) {
+  let processedTree = tree;
+  if (categoryIgnore) {
+    const ignoreSet = new Set(categoryIgnore);
+    processedTree = processedTree.filter((node) => !ignoreSet.has(node.slug));
+  }
+  if (categoryOrder) {
+    processedTree = reorderTree(processedTree, categoryOrder);
+  }
+  return /* @__PURE__ */ jsx(
+    "nav",
+    {
+      "aria-label": ariaLabel,
+      "data-site-nav": true,
+      className: "grid gap-vsp-md",
+      style: {
+        gridTemplateColumns: "repeat(auto-fill, minmax(min(18rem, 100%), 1fr))"
+      },
+      children: processedTree.map((node) => /* @__PURE__ */ jsx("div", { className: "min-w-0 border border-muted pl-hsp-sm py-vsp-2xs", children: node.children.length > 0 ? /* @__PURE__ */ jsx(CategoryNode, { node, depth: 0, isLast: true }) : /* @__PURE__ */ jsx(LeafNode, { node, depth: 0, isLast: true }) }, node.slug))
+    }
+  );
+}
+SiteTreeNav.displayName = "SiteTreeNav";
+function NodeList({ nodes, depth }) {
+  return /* @__PURE__ */ jsx(Fragment, { children: nodes.map((node, index) => {
+    const isLast = index === nodes.length - 1;
+    return node.children.length > 0 ? /* @__PURE__ */ jsx(
+      CategoryNode,
+      {
+        node,
+        depth,
+        isLast
+      },
+      node.slug
+    ) : /* @__PURE__ */ jsx(
+      LeafNode,
+      {
+        node,
+        depth,
+        isLast
+      },
+      node.slug
+    );
+  }) });
+}
+function CategoryNode({
+  node,
+  depth,
+  isLast
+}) {
+  const [open, setOpen] = useState(true);
+  const toggle = () => setOpen((prev) => !prev);
+  const paddingLeft = padLeft(depth);
+  return /* @__PURE__ */ jsxs("div", { className: `${depth >= 1 && !isLast ? "relative" : ""}`, children: [
+    depth >= 1 && !isLast && open && /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: "absolute border-l border-dashed border-muted z-local-1",
+        style: {
+          left: connectorLeft(depth),
+          top: 0,
+          bottom: 0
+        }
+      }
+    ),
+    /* @__PURE__ */ jsxs("div", { className: "relative", children: [
+      /* @__PURE__ */ jsx(
+        ConnectorLines,
+        {
+          depth,
+          isLast,
+          widthScale: 2,
+          topPad: "calc(0.15rem + var(--spacing-vsp-xs))"
+        }
+      ),
+      /* @__PURE__ */ jsxs(
+        "div",
+        {
+          className: "flex w-full items-center justify-between text-small font-semibold pt-[0.15rem] text-fg",
+          style: { paddingLeft },
+          children: [
+            node.href ? /* @__PURE__ */ jsxs(
+              "a",
+              {
+                href: node.href,
+                className: "flex-1 flex items-start gap-hsp-xs py-vsp-xs text-fg hover:text-accent hover:underline focus:underline",
+                children: [
+                  depth === 0 && /* @__PURE__ */ jsx("span", { className: "flex h-[1lh] items-center", children: /* @__PURE__ */ jsx(CategoryLinkIcon, { className: "w-[18px] 2xl:w-[24px]" }) }),
+                  node.label
+                ]
+              }
+            ) : /* @__PURE__ */ jsx(
+              "button",
+              {
+                type: "button",
+                onClick: toggle,
+                className: "flex-1 py-vsp-xs text-left hover:text-accent hover:underline focus:underline",
+                children: node.label
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              "button",
+              {
+                type: "button",
+                onClick: toggle,
+                className: "aspect-square flex items-center justify-center w-[1.75rem] border-y border-l border-muted hover:underline focus:underline",
+                "aria-expanded": open,
+                "aria-label": open ? `Collapse ${node.label}` : `Expand ${node.label}`,
+                children: /* @__PURE__ */ jsx(ChevronRight, { className: `h-icon-xs w-icon-xs transition-transform duration-150 ${open ? "rotate-90" : ""} text-muted` })
+              }
+            )
+          ]
+        }
+      )
+    ] }),
+    open && /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx(NodeList, { nodes: node.children, depth: depth + 1 }) })
+  ] });
+}
+function LeafNode({
+  node,
+  depth,
+  isLast
+}) {
+  if (!node.href) return null;
+  const isRoot = depth === 0;
+  const paddingLeft = padLeft(depth);
+  const topPad = isRoot ? "calc(var(--spacing-vsp-xs) + 0.15rem)" : "var(--spacing-vsp-2xs)";
+  return /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsxs("div", { className: "relative", children: [
+    /* @__PURE__ */ jsx(ConnectorLines, { depth, isLast, widthScale: 2, topPad }),
+    /* @__PURE__ */ jsxs(
+      "a",
+      {
+        href: node.href,
+        className: isRoot ? "flex items-start gap-hsp-xs py-[calc(var(--spacing-vsp-xs)+0.15rem)] text-small font-semibold text-fg hover:text-accent hover:underline focus:underline" : `block py-vsp-2xs ${isLast ? "pb-vsp-xs" : ""} text-small text-fg hover:text-accent hover:underline focus:underline`,
+        style: { paddingLeft },
+        children: [
+          isRoot && /* @__PURE__ */ jsx("span", { className: "flex h-[1lh] items-center", children: /* @__PURE__ */ jsx(CategoryLinkIcon, { className: "w-[18px] 2xl:w-[24px]" }) }),
+          node.label
+        ]
+      }
+    )
+  ] }) });
+}
+export {
+  SiteTreeNav
+};

package/dist/slug/index.d.ts

@@ -0,0 +1,4 @@
+export declare function toRouteSlug(id: string): string;
+export declare function toHistorySlug(routeSlug: string): string;
+export declare function toSlugParams(routeSlug: string): string[];
+export declare function toTitleCase(str: string): string;

package/dist/slug/index.js

@@ -0,0 +1,19 @@
+function toRouteSlug(id) {
+  if (id === "index") return "";
+  return id.replace(/\/index$/, "");
+}
+function toHistorySlug(routeSlug) {
+  return routeSlug === "" ? "index" : routeSlug;
+}
+function toSlugParams(routeSlug) {
+  return routeSlug === "" ? [] : routeSlug.split("/");
+}
+function toTitleCase(str) {
+  return str.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+export {
+  toHistorySlug,
+  toRouteSlug,
+  toSlugParams,
+  toTitleCase
+};

package/dist/smart-break/index.d.ts

@@ -0,0 +1,55 @@
+/** @jsxRuntime automatic */
+/** @jsxImportSource preact */
+import type { VNode } from "preact";
+/**
+ * Heuristic: does `text` look like a URL, filesystem path, or similar
+ * structure where inserting <wbr> after delimiters aids line-wrapping?
+ *
+ * Returns true for URLs (contain "://"), POSIX-style absolute/relative
+ * paths ("/", "./", "../"), Windows drive paths ("C:\\..." or "C:/..."),
+ * strings with 2+ slashes (or backslashes) between alphanumerics, and
+ * plausible domain-plus-slash strings.
+ *
+ * Returns false for empty input and prose-y hyphen/slash/dot combinations
+ * like "and/or", "well-known", "state-of-the-art", "1.2.3-beta.4", "UI/UX".
+ */
+export declare function isPathLike(text: string): boolean;
+/**
+ * If `text` is path-like, return a Preact fragment with <wbr/> inserted
+ * after each delimiter (/, \, -, _, ., :, ?, #, &, =). Otherwise return
+ * the input string unchanged so callers can trust non-path prose passes
+ * through untouched.
+ */
+export declare function smartBreak(text: string): VNode | string;
+/**
+ * Preact function component wrapper — pure, server-renderable.
+ * Stringifies children and defers to smartBreak.
+ */
+export declare function SmartBreak({ children }: {
+    children?: unknown;
+}): VNode;
+/**
+ * HTML-escape `text` and inject a literal "<wbr>" tag after every
+ * delimiter character. Unlike smartBreakToHtml, this does NOT check
+ * isPathLike — it unconditionally breaks on delimiters.
+ *
+ * Useful when a caller has already decided that a larger string is
+ * path-like and wants to apply the same wbr-injection rule to a
+ * substring (e.g. a segment produced by splitting on a search-query
+ * regex) without re-running the heuristic on fragments that are too
+ * short to be classified correctly on their own.
+ *
+ * Byte-identical to smartBreakToHtml for inputs where isPathLike is
+ * true, so the shared contract holds.
+ */
+export declare function escapeAndInjectWbr(text: string): string;
+/**
+ * HTML-string counterpart of smartBreak. Produces a safe HTML string
+ * with literal "<wbr>" tags injected after each delimiter in path-like
+ * input, and HTML-escaped text elsewhere. For non-path input, returns
+ * the HTML-escaped text unchanged (no wbr injection).
+ *
+ * Use this when the consumer cannot render Preact VNodes (e.g. building
+ * an HTML string for `set:html` / dangerouslySetInnerHTML).
+ */
+export declare function smartBreakToHtml(text: string): string;

package/dist/{toc/smart-break.js → smart-break/index.js}

@@ -14,13 +14,23 @@ function isPathLike(text) {
   return false;
 }
 const DELIM_SPLIT = /([/\\\-_.:?#&=])/;
+const HTML_ESCAPE_MAP = {
+  "&": "&",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+function htmlEscape(s) {
+  return s.replace(/[&<>"']/g, (ch) => HTML_ESCAPE_MAP[ch]);
+}
 function smartBreak(text) {
   if (!isPathLike(text)) return text;
   const parts = text.split(DELIM_SPLIT);
   const nodes = [];
   for (let i = 0; i < parts.length; i++) {
-    const part = parts[i];
-    if (!part) continue;
+    const part = parts[i] ?? "";
+    if (part === "") continue;
     nodes.push(part);
     if (i % 2 === 1) nodes.push(/* @__PURE__ */ jsx("wbr", {}, `wbr-${i}`));
   }
@@ -29,8 +39,25 @@ function smartBreak(text) {
 function SmartBreak({ children }) {
   return /* @__PURE__ */ jsx(Fragment, { children: smartBreak(String(children ?? "")) });
 }
+function escapeAndInjectWbr(text) {
+  const parts = text.split(DELIM_SPLIT);
+  let out = "";
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i] ?? "";
+    if (part === "") continue;
+    out += htmlEscape(part);
+    if (i % 2 === 1) out += "<wbr>";
+  }
+  return out;
+}
+function smartBreakToHtml(text) {
+  if (!isPathLike(text)) return htmlEscape(text);
+  return escapeAndInjectWbr(text);
+}
 export {
   SmartBreak,
+  escapeAndInjectWbr,
   isPathLike,
-  smartBreak
+  smartBreak,
+  smartBreakToHtml
 };

package/dist/tab-item/index.d.ts

@@ -1,2 +1,2 @@
-export { TabItem, TabItemProps, TabItem as default } from './tab-item.js';
-import 'preact';
+export { TabItem, default } from "./tab-item.js";
+export type { TabItemProps } from "./tab-item.js";

package/dist/tab-item/tab-item.d.ts

@@ -1,7 +1,7 @@
-import * as preact from 'preact';
-import { ComponentChildren } from 'preact';
-
-interface TabItemProps {
+/** @jsxRuntime automatic */
+/** @jsxImportSource preact */
+import type { ComponentChildren } from "preact";
+export interface TabItemProps {
     /** Human-readable label rendered by the parent Tabs trigger row. */
     label: string;
     /**
@@ -33,6 +33,5 @@ interface TabItemProps {
  * `[data-tab-default]` and reapplies `hidden` / `aria-selected` so
  * the SSR-rendered defaults survive group sync and View Transitions.
  */
-declare function TabItem({ label, value, default: isDefault, children, }: TabItemProps): preact.JSX.Element;
-
-export { TabItem, type TabItemProps, TabItem as default };
+export declare function TabItem({ label, value, default: isDefault, children, }: TabItemProps): import("preact").JSX.Element;
+export default TabItem;

package/dist/tag-helpers/index.d.ts

@@ -0,0 +1,40 @@
+import type { TagVocabularyEntry, TagGovernanceMode } from "../settings.js";
+export type { TagVocabularyEntry, TagGovernanceMode };
+/** Result of resolving a raw tag string. */
+export interface ResolvedTag {
+    /** Canonical id after alias/redirect rewrites. Equal to the raw input when unchanged. */
+    canonical: string;
+    /** True when the canonical id should be dropped from aggregation (deprecated without redirect). */
+    deprecated: boolean;
+    /** True when the raw input matched a vocabulary entry (as id or alias). */
+    known: boolean;
+}
+/**
+ * Resolve a raw tag string to its canonical form.
+ *
+ * Parameterized version of the host's `resolveTag` — receives `tagVocabulary`
+ * and `tagGovernance` as arguments instead of reading `settings.*` at module scope.
+ *
+ * When the vocabulary is inactive (`tagVocabulary` is empty/falsy or
+ * `tagGovernance` is `"off"`), the raw value passes through unchanged with
+ * `known: false, deprecated: false`. Otherwise:
+ *
+ * - A direct id match returns that id.
+ * - An alias match returns the aliased entry's id.
+ * - `deprecated: { redirect: "<id>" }` rewrites to the redirect target.
+ * - `deprecated: true` (no redirect) returns `deprecated: true` so callers
+ *   can drop the tag from aggregation.
+ * - An unknown value returns the raw string with `known: false`.
+ */
+export declare function resolveTag(raw: string, tagVocabulary: readonly TagVocabularyEntry[] | false | undefined, tagGovernance: TagGovernanceMode | undefined): ResolvedTag;
+/**
+ * Resolve a list of raw tag strings (e.g. from frontmatter) to canonical ids,
+ * dropping deprecated-without-redirect entries and preserving order. Duplicates
+ * produced by alias collapse are removed.
+ *
+ * Builds the vocabulary index once and reuses it for all tags — O(N) index
+ * construction instead of O(N×M) when called with M tags.
+ *
+ * Parameterized version of the host's `resolvePageTags`.
+ */
+export declare function resolvePageTags(rawTags: readonly string[], tagVocabulary: readonly TagVocabularyEntry[] | false | undefined, tagGovernance: TagGovernanceMode | undefined): string[];

package/dist/tag-helpers/index.js

@@ -0,0 +1,54 @@
+function buildIndex(tagVocabulary) {
+  const byId = /* @__PURE__ */ new Map();
+  const byAlias = /* @__PURE__ */ new Map();
+  for (const entry of tagVocabulary) {
+    byId.set(entry.id, entry);
+    for (const alias of entry.aliases ?? []) byAlias.set(alias, entry);
+  }
+  return { byId, byAlias };
+}
+function resolveTagWithIndex(raw, index) {
+  const entry = index.byId.get(raw) ?? index.byAlias.get(raw);
+  if (!entry) return { canonical: raw, deprecated: false, known: false };
+  const dep = entry.deprecated;
+  if (dep && typeof dep === "object" && dep.redirect) {
+    const target = index.byId.get(dep.redirect);
+    if (target) return { canonical: target.id, deprecated: false, known: true };
+    return { canonical: entry.id, deprecated: true, known: true };
+  }
+  if (dep === true) {
+    return { canonical: entry.id, deprecated: true, known: true };
+  }
+  return { canonical: entry.id, deprecated: false, known: true };
+}
+function resolveTag(raw, tagVocabulary, tagGovernance) {
+  if (!tagVocabulary || tagGovernance === "off") {
+    return { canonical: raw, deprecated: false, known: false };
+  }
+  return resolveTagWithIndex(raw, buildIndex(tagVocabulary));
+}
+function resolvePageTags(rawTags, tagVocabulary, tagGovernance) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  if (!tagVocabulary || tagGovernance === "off") {
+    for (const raw of rawTags) {
+      if (seen.has(raw)) continue;
+      seen.add(raw);
+      out.push(raw);
+    }
+    return out;
+  }
+  const index = buildIndex(tagVocabulary);
+  for (const raw of rawTags) {
+    const { canonical, deprecated } = resolveTagWithIndex(raw, index);
+    if (deprecated) continue;
+    if (seen.has(canonical)) continue;
+    seen.add(canonical);
+    out.push(canonical);
+  }
+  return out;
+}
+export {
+  resolvePageTags,
+  resolveTag
+};