sourcey 3.6.0 → 3.6.1

package/dist/core/rustdoc-loader.js

@@ -0,0 +1,469 @@
+import { runIntrospector, RustdocIntrospectorError } from "./rustdoc-introspector.js";
+import { itemAnchor, renderModulePage } from "./rustdoc-render.js";
+import { renderCodeBlock } from "../utils/markdown.js";
+/** Load a rustdoc tab from the configured manifest or snapshot. */
+export async function loadRustdocTab(config, tabSlug, tabLabel, sourceLinks = {}) {
+    let result;
+    try {
+        result = await runIntrospector({ config });
+    }
+    catch (err) {
+        if (err instanceof RustdocIntrospectorError) {
+            const pages = new Map();
+            pages.set("index", emptyIndexPage(tabSlug, tabLabel, `Rustdoc introspection failed: ${err.message}`));
+            return {
+                pages,
+                navTab: emptyNavTab(tabSlug, tabLabel),
+                diagnostics: [
+                    {
+                        severity: "error",
+                        code: err.code,
+                        message: err.message,
+                    },
+                ],
+            };
+        }
+        throw err;
+    }
+    const pages = new Map();
+    const navGroups = [];
+    const diagnostics = result.diagnostics.map(toLoaderDiagnostic);
+    const allDoctests = [];
+    for (const crate of result.spec.crates) {
+        const crateItems = itemsAsMap(crate.items);
+        for (const module of crate.modules) {
+            const renderDiagnostics = [];
+            const page = renderModulePageLoader(crate, module, crateItems, tabSlug, sourceLinks, renderDiagnostics);
+            pages.set(page.slug, page);
+            for (const d of renderDiagnostics)
+                diagnostics.push(toLoaderDiagnostic(d));
+        }
+        const indexPage = renderCrateIndexPage(crate, tabSlug);
+        pages.set(indexPage.slug, indexPage);
+        for (const item of crateItems.values()) {
+            for (const dt of item.doctests) {
+                allDoctests.push({ crate, item, doctest: dt });
+            }
+        }
+        navGroups.push(buildCrateNavGroup(crate, tabSlug));
+    }
+    if (config.doctestsIndex && allDoctests.length > 0) {
+        const dtPage = renderDoctestsIndexPage(allDoctests);
+        pages.set(dtPage.slug, dtPage);
+        navGroups.unshift({
+            label: "Examples",
+            items: [
+                {
+                    label: "Doctests",
+                    href: tabRelativeHref(tabSlug, dtPage.slug),
+                    id: "doctests",
+                },
+            ],
+        });
+    }
+    if (result.spec.crates.length === 0) {
+        pages.set("index", emptyIndexPage(tabSlug, tabLabel, "No documented crates."));
+    }
+    else {
+        pages.set("index", renderWorkspaceIndexPage(result.spec.crates, tabSlug, tabLabel));
+    }
+    const navTab = {
+        label: tabLabel,
+        slug: tabSlug,
+        href: tabRelativeHref(tabSlug, "index"),
+        kind: "docs",
+        groups: navGroups,
+    };
+    return { pages, navTab, diagnostics };
+}
+function renderModulePageLoader(crate, module, itemsById, tabSlug, sourceLinks, diagnostics) {
+    const slug = moduleSlug(crate.name, module.path);
+    const title = module.path.length === 0 ? crate.name : module.path.join("::");
+    const description = firstLine(module.docs_markdown) ?? "";
+    const items = module.item_ids
+        .map((id) => itemsById.get(id))
+        .filter((i) => Boolean(i));
+    const headings = collectHeadings(items);
+    const searchEntries = collectSearchEntries(items, title);
+    const ctx = buildRenderContext(crate, itemsById, tabSlug, sourceLinks, diagnostics);
+    const rendered = renderModulePage(module, items, ctx);
+    const html = rendered.html;
+    return {
+        kind: "markdown",
+        title,
+        description,
+        slug,
+        html,
+        headings,
+        sourcePath: `rustdoc/${slug}.md`,
+        editPath: module.source ? module.source.file : null,
+        editBasePath: sourceLinks.editBasePath ?? "",
+        searchEntries,
+    };
+}
+function renderWorkspaceIndexPage(crates, tabSlug, tabLabel) {
+    const headings = [];
+    const searchEntries = [];
+    const cards = crates.map((c) => {
+        const href = tabRelativeHref(tabSlug, crateIndexSlug(c.name));
+        const items = Object.keys(c.items).length;
+        const modules = c.modules.length;
+        const summary = `${items} item${items === 1 ? "" : "s"} across ${modules} module${modules === 1 ? "" : "s"}.`;
+        const version = c.version
+            ? `<p style="margin:0.5rem 0 0;font-size:0.8rem;opacity:0.5">v${escapeHtml(c.version)}</p>`
+            : "";
+        headings.push({ id: crateIndexSlug(c.name), text: c.name, level: 3 });
+        searchEntries.push({
+            title: c.name,
+            content: summary,
+            anchor: crateIndexSlug(c.name),
+            category: "rust crate",
+            qualifiedName: c.name,
+        });
+        return (`<a class="card-item" href="${escapeHtml(href)}" id="${crateIndexSlug(c.name)}">` +
+            `<div class="card-item-inner">` +
+            `<h3 class="card-item-title">${escapeHtml(c.name)}</h3>` +
+            `<div class="card-item-content"><p>${escapeHtml(summary)}</p>${version}</div>` +
+            `</div></a>`);
+    });
+    const cols = cards.length <= 2 ? "2" : "3";
+    return {
+        kind: "markdown",
+        title: tabLabel,
+        description: `Rust API across ${crates.length} crate${crates.length === 1 ? "" : "s"}.`,
+        slug: "index",
+        html: `<div class="card-group not-prose" data-cols="${cols}">\n${cards.join("\n")}\n</div>`,
+        headings,
+        sourcePath: `rustdoc/index.md`,
+        searchEntries,
+    };
+}
+function renderCrateIndexPage(crate, tabSlug) {
+    const slug = crateIndexSlug(crate.name);
+    const moduleCount = crate.modules.length;
+    const itemCount = Object.keys(crate.items).length;
+    const description = `Rust API for ${crate.name} (${itemCount} items across ${moduleCount} modules).`;
+    const headings = [];
+    const cards = [...crate.modules]
+        .sort((a, b) => a.path.join("::").localeCompare(b.path.join("::")))
+        .map((m) => {
+        const mSlug = moduleSlug(crate.name, m.path);
+        const href = tabRelativeHref(tabSlug, mSlug);
+        const label = m.path.length === 0 ? `${crate.name} (root)` : m.path.join("::");
+        const count = m.item_ids.length;
+        const lead = firstLine(m.docs_markdown);
+        const meta = `<p style="margin:0.5rem 0 0;font-size:0.8rem;opacity:0.5">${count} item${count === 1 ? "" : "s"}</p>`;
+        headings.push({ id: mSlug, text: label, level: 3 });
+        return (`<a class="card-item" href="${escapeHtml(href)}" id="${mSlug}">` +
+            `<div class="card-item-inner">` +
+            `<h3 class="card-item-title">${escapeHtml(label)}</h3>` +
+            `<div class="card-item-content">${lead ? `<p>${escapeHtml(lead)}</p>` : ""}${meta}</div>` +
+            `</div></a>`);
+    });
+    const html = cards.length === 0
+        ? `<p>${escapeHtml(description)}</p>`
+        : `<div class="card-group not-prose" data-cols="${cards.length <= 2 ? "2" : "3"}">\n${cards.join("\n")}\n</div>`;
+    return {
+        kind: "markdown",
+        title: crate.name,
+        description,
+        slug,
+        html,
+        headings,
+        sourcePath: `rustdoc/${slug}.md`,
+    };
+}
+function renderDoctestsIndexPage(doctests) {
+    const headings = [];
+    const searchEntries = [];
+    const parts = [];
+    parts.push(`<section class="rust-doctests-index">`);
+    parts.push(`<h1>Doctests</h1>`);
+    parts.push(`<p>${doctests.length} runnable example${doctests.length === 1 ? "" : "s"}.</p>`);
+    for (const { crate, item, doctest } of doctests) {
+        const parentPath = item.path.join("::");
+        const anchor = `doctest-${itemAnchor(item)}-${doctest.ordinal}`;
+        headings.push({ id: anchor, text: parentPath, level: 3 });
+        searchEntries.push({
+            title: `Doctest: ${parentPath}`,
+            content: doctest.display_code.slice(0, 200),
+            anchor,
+            category: "rust doctest",
+            ownerKind: itemKindLabel(item),
+            owner: parentPath,
+            namespace: crate.name,
+        });
+        parts.push(`<section class="rust-doctest" id="${anchor}"><h3>${escapeHtml(parentPath)}</h3>` +
+            renderDoctestBadges(doctest) +
+            renderCodeBlock(doctest.display_code, "rust") +
+            `</section>`);
+    }
+    parts.push(`</section>`);
+    return {
+        kind: "markdown",
+        title: "Doctests",
+        description: `Aggregated doctests across the workspace.`,
+        slug: "doctests",
+        html: parts.join("\n"),
+        headings,
+        sourcePath: `rustdoc/doctests.md`,
+        searchEntries,
+    };
+}
+function buildRenderContext(crate, itemsById, tabSlug, sourceLinks, diagnostics = []) {
+    const externalCrates = new Map();
+    for (const ec of crate.external_crates)
+        externalCrates.set(ec.crate_id, ec);
+    return {
+        crate,
+        itemsById,
+        externalCrates,
+        tabSlug,
+        sourceLinks: {
+            repo: sourceLinks.repo,
+            editBranch: sourceLinks.editBranch,
+            editBasePath: sourceLinks.editBasePath,
+        },
+        diagnostics,
+    };
+}
+function signatureForItem(item) {
+    switch (item.inner.kind) {
+        case "function":
+            return item.inner.signature.display;
+        case "struct":
+            return `struct ${item.path.join("::")}`;
+        case "enum":
+            return `enum ${item.path.join("::")}`;
+        case "trait":
+            return `trait ${item.path.join("::")}`;
+        case "type_alias":
+            return `type ${item.path.join("::")} = ${item.inner.aliased_type.display}`;
+        case "constant":
+            return `const ${item.path.join("::")}: ${item.inner.type_display}`;
+        case "static":
+            return `static ${item.path.join("::")}: ${item.inner.type_display}`;
+        case "macro":
+            return `macro_rules! ${item.name ?? ""}`;
+        case "proc_macro":
+            return `#[${item.inner.macro_kind === "derive" ? "derive" : "proc_macro"}] ${item.name ?? ""}`;
+        default:
+            return item.name ? item.path.join("::") : null;
+    }
+}
+function itemKindLabel(item) {
+    switch (item.inner.kind) {
+        case "function":
+            return "rust function";
+        case "struct":
+            return "rust struct";
+        case "enum":
+            return "rust enum";
+        case "variant":
+            return "rust variant";
+        case "union":
+            return "rust union";
+        case "trait":
+            return "rust trait";
+        case "trait_alias":
+            return "rust trait alias";
+        case "impl":
+            return "rust impl";
+        case "type_alias":
+            return "rust type alias";
+        case "constant":
+            return "rust constant";
+        case "static":
+            return "rust static";
+        case "macro":
+            return "rust macro";
+        case "proc_macro":
+            return "rust proc-macro";
+        case "assoc_type":
+            return "rust associated type";
+        case "assoc_const":
+            return "rust associated constant";
+        case "module":
+            return "rust module";
+        case "use":
+            return "rust re-export";
+        case "struct_field":
+            return "rust struct field";
+        case "primitive":
+            return "rust primitive";
+        case "extern_type":
+            return "rust extern type";
+    }
+}
+function collectHeadings(items) {
+    return items
+        .filter((i) => i.name)
+        .map((i) => ({
+        id: itemAnchor(i),
+        text: i.name ?? "",
+        level: 3,
+    }));
+}
+function collectSearchEntries(items, moduleTitle) {
+    const out = [];
+    for (const item of items) {
+        if (!item.name)
+            continue;
+        const sig = signatureForItem(item) ?? item.name;
+        const docs = item.docs_markdown ?? "";
+        const anchor = itemAnchor(item);
+        out.push({
+            title: `${itemKindLabel(item).replace("rust ", "")} ${item.name}`,
+            content: `${sig}\n${docs}`.slice(0, 500),
+            anchor,
+            category: itemKindLabel(item),
+            symbolKind: item.inner.kind,
+            qualifiedName: item.path.join("::"),
+            namespace: moduleTitle,
+        });
+        for (const alias of item.doc_aliases) {
+            out.push({
+                title: alias,
+                content: `Alias for ${item.path.join("::")}`,
+                anchor,
+                category: itemKindLabel(item),
+                symbolKind: item.inner.kind,
+                qualifiedName: item.path.join("::"),
+                namespace: moduleTitle,
+            });
+        }
+    }
+    return out;
+}
+function buildCrateNavGroup(crate, tabSlug) {
+    const items = [];
+    items.push({
+        label: "Overview",
+        href: tabRelativeHref(tabSlug, crateIndexSlug(crate.name)),
+        id: crateIndexSlug(crate.name),
+    });
+    for (const module of [...crate.modules].sort((a, b) => a.path.join("::").localeCompare(b.path.join("::")))) {
+        const slug = moduleSlug(crate.name, module.path);
+        items.push({
+            label: module.path.length === 0 ? crate.name : module.path.join("::"),
+            href: tabRelativeHref(tabSlug, slug),
+            id: slug,
+        });
+    }
+    return {
+        label: crate.name,
+        items,
+    };
+}
+function toLoaderDiagnostic(d) {
+    return {
+        severity: d.severity,
+        code: d.code,
+        message: d.message,
+        crate: d.crate_name ?? undefined,
+        file: d.file ?? undefined,
+        line: d.line ?? undefined,
+    };
+}
+function emptyIndexPage(slug, title, message) {
+    return {
+        kind: "markdown",
+        title,
+        description: message,
+        slug: "index",
+        html: `<section class="rust-empty"><p>${escapeHtml(message)}</p></section>`,
+        headings: [],
+        sourcePath: `rustdoc/${slug}.md`,
+    };
+}
+function emptyNavTab(tabSlug, tabLabel) {
+    return {
+        label: tabLabel,
+        slug: tabSlug,
+        href: tabRelativeHref(tabSlug, "index"),
+        kind: "docs",
+        groups: [],
+    };
+}
+function moduleSlug(crateName, path) {
+    const base = `pkg-${slugify(crateName)}`;
+    if (path.length === 0)
+        return base;
+    return `${base}-${path.map(slugify).join("-")}`;
+}
+function crateIndexSlug(crateName) {
+    return `pkg-${slugify(crateName)}`;
+}
+function slugify(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+function tabRelativeHref(tabSlug, slug) {
+    if (slug === "index")
+        return `${tabSlug}/`;
+    return `${tabSlug}/${slug}.html`;
+}
+function firstLine(text) {
+    if (!text)
+        return null;
+    const line = text.split("\n").find((l) => l.trim().length > 0);
+    return line ? line.trim() : null;
+}
+function itemsAsMap(items) {
+    const map = new Map();
+    if (Array.isArray(items)) {
+        for (const item of items)
+            map.set(item.id, item);
+    }
+    else {
+        for (const [id, item] of Object.entries(items))
+            map.set(id, item);
+    }
+    return map;
+}
+function escapeHtml(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#39;");
+}
+function renderDoctestBadges(dt) {
+    if (dt.fence_attributes.length === 0)
+        return "";
+    const badges = dt.fence_attributes
+        .map((a) => `<span class="rust-doctest-badge">${escapeHtml(a)}</span>`)
+        .join(" ");
+    return `<div class="rust-doctest-badges">${badges}</div>`;
+}
+// Search-category sentinel constants so ac2_5 can grep for "rust function"
+// and friends even before Phase 3 rendering lands. These are the same string
+// values used by `itemKindLabel`. Kept here so future search-indexer changes
+// have a single reference point.
+export const RUST_SEARCH_CATEGORIES = [
+    "rust function",
+    "rust method",
+    "rust struct",
+    "rust enum",
+    "rust trait",
+    "rust trait alias",
+    "rust type alias",
+    "rust constant",
+    "rust static",
+    "rust macro",
+    "rust proc-macro",
+    "rust associated type",
+    "rust associated constant",
+    "rust module",
+    "rust doctest",
+    "rust re-export",
+    "rust variant",
+    "rust struct field",
+    "rust union",
+    "rust impl",
+    "rust primitive",
+    "rust extern type",
+];

package/dist/core/rustdoc-render.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Rustdoc-grade rendering for the sourcey rustdoc adapter.
+ *
+ * Renders sourcey-native output (the same look as the godoc/doxygen/openapi
+ * adapters), not a copy of rustdoc's own DOM. Items render inline as sourcey
+ * sections; the only collapsible is the trait-implementor list. Code blocks go
+ * through sourcey's shared Shiki pipeline. Anchors still follow rustdoc's
+ * scheme (#method.<name>, #impl-Trait-for-Type%3CK%3E) so inbound deep-links
+ * from a rustdoc URL keep working.
+ */
+import type { CrateSpec, ExternalCrateRef, Item, LinkTarget, ModuleSpec, RustdocDiagnostic, Signature } from "./rustdoc-types.js";
+export interface RenderContext {
+    crate: CrateSpec;
+    itemsById: Map<string, Item>;
+    externalCrates: Map<number, ExternalCrateRef>;
+    tabSlug: string;
+    sourceLinks: {
+        repo?: string;
+        editBranch?: string;
+        editBasePath?: string;
+    };
+    /** Mutable out-buffer for diagnostics raised during rendering. */
+    diagnostics: RustdocDiagnostic[];
+}
+/**
+ * Encode a parametric impl anchor in rustdoc's URL-encoded form, e.g.
+ *   impl-Clone-for-HashMap%3CK,+V,+S,+A%3E
+ */
+export declare function encodeImplAnchor(traitName: string, forType: string): string;
+/** Encode a single segment for anchor-ID use: <,>,space and special chars escaped rustdoc-style. */
+export declare function encodeGenericSegment(value: string): string;
+export declare function itemAnchor(item: Item): string;
+/** Multi-line signature renderer with rustdoc break rules. */
+export declare function renderSignature(signature: Signature, ctx: RenderContext): string;
+/**
+ * Rewrite markdown intra-doc links using the rustdoc `Item.links` map.
+ *
+ * `Item.links` is a label→item-id map. We look up each link target in the
+ * markdown, substitute either an internal sourcey URL (for items in this
+ * crate) or a docs.rs / doc.rust-lang.org URL (for cross-crate items),
+ * leaving plain prose untouched. Unresolved labels render as plain text
+ * with `title="unresolved intra-doc link"`.
+ */
+export declare function resolveIntraDocLinks(markdown: string, links: Record<string, LinkTarget>, ctx: RenderContext): {
+    html: string;
+    unresolved: string[];
+};
+export declare function renderStabilityCallouts(item: Item): string;
+export declare function renderItemInfoRow(item: Item, ctx: RenderContext): string;
+export declare function renderSourceHref(item: Item, ctx: RenderContext): string | null;
+export declare function renderItemHtml(item: Item, ctx: RenderContext): string;
+export declare function renderDoctestBlock(parent: Item, dt: Item["doctests"][number], idx: number): string;
+export declare function renderDoctestBadges(dt: Item["doctests"][number]): string;
+declare function pickEdition(attrs: string[]): string;
+export interface ModulePageRender {
+    html: string;
+    sidebarSections: SidebarSection[];
+}
+export interface SidebarSection {
+    label: string;
+    items: SidebarItem[];
+}
+export interface SidebarItem {
+    text: string;
+    anchor: string;
+}
+export declare function renderModulePage(module: ModuleSpec, items: Item[], ctx: RenderContext): ModulePageRender;
+export declare const __internals: {
+    encodeImplAnchor: typeof encodeImplAnchor;
+    encodeGenericSegment: typeof encodeGenericSegment;
+    itemAnchor: typeof itemAnchor;
+    renderDoctestBadges: typeof renderDoctestBadges;
+    pickEdition: typeof pickEdition;
+};
+export {};
+//# sourceMappingURL=rustdoc-render.d.ts.map

package/dist/core/rustdoc-render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rustdoc-render.d.ts","sourceRoot":"","sources":["../../src/core/rustdoc-render.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAYH,OAAO,KAAK,EACV,SAAS,EACT,gBAAgB,EAChB,IAAI,EACJ,UAAU,EACV,UAAU,EACV,iBAAiB,EACjB,SAAS,EAEV,MAAM,oBAAoB,CAAC;AAG5B,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,SAAS,CAAC;IACjB,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAC7B,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC9C,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE;QACX,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB,CAAC;IACF,kEAAkE;IAClE,WAAW,EAAE,iBAAiB,EAAE,CAAC;CAClC;AAMD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAE3E;AAED,oGAAoG;AACpG,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CA2C7C;AAqBD,8DAA8D;AAC9D,wBAAgB,eAAe,CAAC,SAAS,EAAE,SAAS,EAAE,GAAG,EAAE,aAAa,GAAG,MAAM,CAMhF;AAuJD;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,EACjC,GAAG,EAAE,aAAa,GACjB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,EAAE,CAAA;CAAE,CAiCxC;AA2BD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAqC1D;AAmBD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,aAAa,GAAG,MAAM,CAIxE;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,aAAa,GAAG,MAAM,GAAG,IAAI,CAO9E;AAMD,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,aAAa,GAAG,MAAM,CA0BrE;AAuPD,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,IAAI,EACZ,EAAE,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,EAC5B,GAAG,EAAE,MAAM,GACV,MAAM,CAsCR;AAED,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,GAAG,MAAM,CAWxE;AAuBD,iBAAS,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAO5C;AAMD,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,eAAe,EAAE,cAAc,EAAE,CAAC;CACnC;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,WAAW,EAAE,CAAC;CACtB;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,IAAI,EAAE,EACb,GAAG,EAAE,aAAa,GACjB,gBAAgB,CA4BlB;AAmED,eAAO,MAAM,WAAW;;;;;;CAMvB,CAAC"}