nimbus-docs 0.0.3 → 0.1.1

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { BadgeVariant, Breadcrumb, NimbusConfig, PrevNext, PrevNextLink, PrevNextOverrides, SearchProvider, SearchResult, SidebarBadge, SidebarConfig, SidebarConfigItem, SidebarExternalLinkItem, SidebarGroupItem, SidebarItem, SidebarLinkItem, SidebarSection, TOCItem } from "./types.js";
+import { BadgeVariant, Breadcrumb, NimbusConfig, PrevNext, PrevNextLink, PrevNextOverrides, ResolvedVersions, SearchProvider, SearchResult, SidebarBadge, SidebarConfig, SidebarConfigItem, SidebarExternalLinkItem, SidebarGroupItem, SidebarItem, SidebarLinkItem, SidebarSection, TOCItem, VersionAlternateRecord, VersionAlternatesTable, VersionPageRef, VersionStatus, VersionsConfig } from "./types.js";
 import mdx from "@astrojs/mdx";
 import * as astro_content0 from "astro:content";
 import { CollectionEntry } from "astro:content";
@@ -114,6 +114,79 @@ declare function defaultCodeTransformers(): ShikiTransformer[];
  * Define a typed Nimbus config. Returns the config unchanged but inferred.
  */
 declare function defineConfig<T extends NimbusConfig>(config: T): T;
+interface IndexedEntry {
+  /** The Astro CollectionEntry, untyped at the union level. */
+  entry: astro_content0.CollectionEntry<string>;
+  /** Collection this entry belongs to (e.g. `"docs"`, `"blog"`). */
+  collection: string;
+  /** Display title — schema field if present, otherwise the entry id. */
+  title: string;
+  /** Description — undefined when the schema doesn't expose one or it's empty. */
+  description: string | undefined;
+  /**
+   * Page URL path under the site (no origin, no trailing slash unless
+   * empty). Computed via the convention that the **primary** docs
+   * collection mounts at the site root (e.g. `/getting-started`) while
+   * every other collection mounts under its name (`/api/payments/create`,
+   * `/blog/my-first-post`). Routes building `.md` alternates append
+   * `/index.md`; chrome building HTML links append a trailing slash.
+   */
+  url: string;
+}
+interface IndexedTopLevelGroup {
+  /** Top-level slug — first URL segment under root. */
+  slug: string;
+  /** Display label (today: identical to `slug`; reserved for future sidebar-label integration). */
+  label: string;
+  /** Entries inside this group, sorted alphabetically by url. */
+  members: IndexedEntry[];
+  /**
+   * What kind of group this is:
+   *   - `"primary"` — a folder inside the primary `docs` collection.
+   *   - `"secondary"` — a separate non-version, non-primary collection
+   *     (`blog`, `api`, `changelog`, …).
+   *   - `"version"` — an older docs version (`docs-v1`, `docs-v2`, …)
+   *     when versioning is configured. Routes that build the **root**
+   *     `/llms.txt` should typically filter these out (old versions
+   *     pollute the entry point); routes that emit per-section files
+   *     should include them so `/v1/llms.txt` still ships.
+   */
+  kind: "primary" | "secondary" | "version";
+  /**
+   * True when this group is a version collection listed in
+   * `versions.hidden`. Hidden versions are URL-reachable but should
+   * not surface on any indexing or discovery surface — neither root
+   * `/llms.txt` nor a per-section `/<slug>/llms.txt`. Pagefind
+   * exclusion happens per-page via `data-pagefind-ignore`. Routes that
+   * emit per-section files should skip groups where `hidden === true`.
+   */
+  hidden: boolean;
+}
+interface IndexedTopLevel {
+  /**
+   * Single-entry top-level items — the root `/llms.txt` links directly
+   * to each leaf's `.md` alternate. Sorted alphabetically by `url`.
+   */
+  leaves: IndexedEntry[];
+  /**
+   * Multi-entry top-level items — each becomes a section file at
+   * `/<slug>/llms.txt`. Sorted alphabetically by `slug`.
+   */
+  groups: IndexedTopLevelGroup[];
+}
+declare function getIndexedEntries(): Promise<IndexedEntry[]>;
+/**
+ * Partition the indexed entries into the shape the root `/llms.txt`
+ * and `/[section]/llms.txt` routes need.
+ *
+ * Convention:
+ *   - Primary `"docs"` entries follow the leaf/group rule based on
+ *     their `entry.id` top segment (matches single-collection behavior).
+ *   - Every other collection becomes a single top-level group named
+ *     after the collection, regardless of how many entries it has.
+ *     This matches the URL convention (`/api/...`, `/blog/...`).
+ */
+declare function getIndexedTopLevel(): Promise<IndexedTopLevel>;
 /**
  * Build the sidebar tree for the given current path, scoped to the
  * top-level section containing that page.
@@ -122,15 +195,29 @@ declare function defineConfig<T extends NimbusConfig>(config: T): T;
  * resolves config-driven sidebar. Otherwise auto-generates from filesystem
  * (i.e. the `docs` collection's entry IDs).
  *
- * The returned tree is always scoped: only the current section's children
- * are returned. To enumerate every top-level section (for header tabs or
- * a section switcher), use `getSidebarSections`.
+ * Returned shape depends on `sidebar.scope` in `nimbus.config.ts`:
+ *   - `"full"` (default) — every top-level item on every page.
+ *   - `"section"` — only the current top-level section's children. Use
+ *     the header section-tab strip (via `getSidebarSections`) for
+ *     cross-section nav when this mode is on.
+ *
+ * **Versioning awareness.** When the page is in a version collection
+ * (`docs-<v>` where `<v>` is in `versions.others`), pass `collection` as
+ * the second argument. The sidebar build will swap any
+ * `{ autogenerate: { collection: "docs" } }` items to autogenerate from
+ * that version's collection instead, and treat it as the primary for
+ * the build. Without this, version pages render the current-version
+ * sidebar and prev/next derives from the wrong tree.
  *
  * @param currentSlug - The current page's URL path (e.g. "/getting-started").
  *                     Used to set `isCurrent` on matching links and to pick
- *                     which top-level section to surface.
+ *                     which top-level section to surface when scoping.
+ * @param options.collection - The current page's Astro collection ID.
+ *                     Pass `entry.collection` from your route.
  */
-declare function getSidebar(currentSlug: string): Promise<SidebarItem[]>;
+declare function getSidebar(currentSlug: string, options?: {
+  collection?: string;
+}): Promise<SidebarItem[]>;
 /**
  * Derive one section per top-level group in the sidebar — used by
  * `Header.astro` to render the section tab strip (and by any other
@@ -138,8 +225,13 @@ declare function getSidebar(currentSlug: string): Promise<SidebarItem[]>;
  *
  * Reads the un-scoped tree so every section is visible, then collapses
  * each top-level group to `{ label, href, isActive }`.
+ *
+ * Accepts the same `collection` option as `getSidebar` so version pages
+ * see version-scoped section tabs.
  */
-declare function getSidebarSections(currentSlug: string): Promise<SidebarSection[]>;
+declare function getSidebarSections(currentSlug: string, options?: {
+  collection?: string;
+}): Promise<SidebarSection[]>;
 /**
  * Resolve prev/next links for the current page.
  *
@@ -250,6 +342,195 @@ declare function getDocsPageProps(astro: AstroGlobal): Promise<{
     slug: string;
   }[];
 }>;
+/**
+ * `getStaticPaths` implementation for a catch-all route over a non-primary
+ * collection (`api`, `blog`, …). Companion to `getDocsStaticPaths`.
+ *
+ * Returns one path per visible entry in the named collection. Drafts are
+ * filtered in production (same rule as `getDocsStaticPaths`). Each path
+ * passes `{ entry }` as props for `getCollectionPageProps()`.
+ *
+ * Usage:
+ *
+ *   // src/pages/api/[...slug].astro
+ *   export const prerender = true;
+ *   export const getStaticPaths = getCollectionStaticPaths("api");
+ *
+ * Why a sibling helper instead of an option on `getDocsStaticPaths`: the
+ * `Docs` name carries the "primary collection mounted at root" semantic.
+ * Non-primary collections mount under their own URL namespace
+ * (`/<collection>/...`) by convention; the helper name reflects that.
+ */
+declare function getCollectionStaticPaths(collection: string): GetStaticPaths;
+/**
+ * Read the current entry from `Astro.props`, render it, and return the
+ * pieces a docs-style page needs — typed for an arbitrary collection.
+ *
+ * Companion to `getCollectionStaticPaths`. Use this in routes mounted at
+ * non-primary collections (`api`, `blog`, …) instead of `getDocsPageProps`,
+ * which is typed to the `docs` collection.
+ *
+ * Pass the collection name as a type parameter for the entry's data
+ * shape to narrow correctly:
+ *
+ *   const { entry, Content, headings } = await getCollectionPageProps<"api">(Astro);
+ */
+declare function getCollectionPageProps<C extends string>(astro: AstroGlobal): Promise<{
+  entry: astro_content0.CollectionEntry<C>;
+  Content: unknown;
+  headings: {
+    depth: number;
+    text: string;
+    slug: string;
+  }[];
+}>;
+/**
+ * Return the resolved versioning manifest for the current site, or `null`
+ * if the site is unversioned (`nimbus.config.ts` has no `versions` block).
+ *
+ * Optional fields are normalised to empty arrays (`deprecated`, `hidden`)
+ * and `all` is `[current, ...others]` in manifest order — convenient for
+ * picker enumeration or anywhere you need every known version slug.
+ *
+ * Usage:
+ *
+ *   const versions = await getVersions();
+ *   if (versions) {
+ *     for (const slug of versions.all) {
+ *       // …enumerate
+ *     }
+ *   }
+ *
+ * Reads from `virtual:nimbus/config`, so the cost is one cached dynamic
+ * import per build.
+ */
+declare function getVersions(): Promise<ResolvedVersions | null>;
+/**
+ * Return the version slug a given Astro content collection ID belongs to,
+ * or `null` if the collection is not a version of the primary docs.
+ *
+ * Rules:
+ *   - `"docs"` → `versions.current` (the current version's label).
+ *   - `"docs-<slug>"` where `<slug>` appears in `versions.current` or
+ *     `versions.others` → `<slug>`.
+ *   - Anything else (e.g. `"blog"`, `"api"`, `"docs-archive"` when
+ *     `archive` isn't in the manifest) → `null`.
+ *
+ * Returns `null` whenever the site has no `versions` config at all,
+ * regardless of collection ID.
+ *
+ * Usage in a route:
+ *
+ *   const { entry } = Astro.props;
+ *   const version = await getCurrentVersion(entry.collection);
+ *   // version === "v3" for entries in `docs`, "v2" for entries in `docs-v2`, …
+ */
+declare function getCurrentVersion(collectionId: string): Promise<string | null>;
+/**
+ * Look up the cross-version alternates for a given Astro entry.
+ *
+ * Returns `null` when the entry is not part of a versioning manifest
+ * (unversioned site, non-`docs` collection like `blog`/`api`, or the
+ * lookup misses for any other reason). Otherwise returns a record with:
+ *
+ *   - `self`: the entry being looked up, expressed as a `VersionPageRef`.
+ *   - `alternates`: every other version's sibling page for the same
+ *     logical content (same slug or linked via `previousSlug`). Sorted
+ *     in manifest version order.
+ *   - `canonical`: the current-version sibling when one exists and
+ *     isn't `self`. `null` when `self` is already the current version
+ *     or no current-version sibling exists.
+ *
+ * Routes inject `<link rel="alternate">` for every entry in
+ * `alternates`, and `<link rel="canonical">` pointing at `canonical.url`
+ * when canonical is non-null.
+ *
+ * Usage in a route:
+ *
+ *   const { entry } = Astro.props;
+ *   const alts = await getVersionAlternates(entry.collection, entry.id);
+ *
+ *   {alts?.alternates.map((a) => (
+ *     <link rel="alternate" data-version={a.version} href={a.url} />
+ *   ))}
+ *   {alts?.canonical && <link rel="canonical" href={alts.canonical.url} />}
+ */
+declare function getVersionAlternates(collectionId: string, entryId: string): Promise<VersionAlternateRecord | null>;
+/**
+ * Convenience wrapper: returns just the canonical URL for an entry, or
+ * `null` when none applies. Equivalent to
+ * `(await getVersionAlternates(c, e))?.canonical?.url ?? null` — handy
+ * when a route only needs the canonical and not the full alternates list.
+ */
+declare function getCanonicalUrl(collectionId: string, entryId: string): Promise<string | null>;
+/**
+ * Return the agent index URL path (the `/llms.txt` route) that
+ * corresponds to a given Astro collection. The path is mount-point
+ * aware: pages in version collections point at the per-version index,
+ * pages in non-primary collections point at their per-collection index,
+ * and the primary `docs` collection points at the root.
+ *
+ *   - `"docs"`        → `"/llms.txt"`
+ *   - `"docs-v1"`     → `"/v1/llms.txt"`     (when `v1` is in `versions.others`)
+ *   - `"blog"`        → `"/blog/llms.txt"`
+ *   - `"api"`         → `"/api/llms.txt"`
+ *   - `"docs-archive"` (unrecognised version slug) → `"/docs-archive/llms.txt"`
+ *
+ * Returns a path with a leading slash and no trailing slash. Routes
+ * resolve it against `Astro.site` to produce a full URL.
+ *
+ * Used by `BaseLayout` and `AgentDirective` to surface the correct
+ * agent index hint on every page — readers landing on `/v1/foo` get
+ * pointed at `/v1/llms.txt`, not `/llms.txt`, so agents don't crawl
+ * the wrong section.
+ */
+declare function getCollectionLlmsUrl(collectionId: string): Promise<string>;
+/**
+ * Look up the versioning status for a page's collection — what the
+ * layout needs to decide whether to render the deprecation banner,
+ * apply the Pagefind facet filters, or exclude the page from search
+ * entirely.
+ *
+ * Returns `null` when the site is unversioned or the page is not part
+ * of a version collection (regular `docs`, `blog`, `api`, …). Layouts
+ * treat that as "no versioning UI to apply" — render normally.
+ *
+ * Usage:
+ *
+ *   const status = await getVersionStatus(entry.collection);
+ *   if (status?.isDeprecated) {
+ *     // render the deprecation banner
+ *   }
+ */
+/**
+ * Resolve a URL that's guaranteed to exist within a given version's
+ * collection. Used by the picker (and any other "jump to that version"
+ * surface) to avoid landing readers on a 404 when the current page has
+ * no same-logical-page sibling in the target version.
+ *
+ * Resolution order:
+ *   1. If `docs-<v>/index` exists, return its URL (the conventional
+ *      "version landing page").
+ *   2. If `docs-<v>/overview` exists, return its URL (common alternate
+ *      name for a landing page).
+ *   3. Otherwise return the first indexed entry's URL in that version,
+ *      sorted by URL — matches `getIndexedTopLevel()`'s sort so the
+ *      choice is deterministic across builds.
+ *   4. If the version has no indexed entries at all, return `null`.
+ *      Callers should treat that as "this version has nothing to link
+ *      to" and either omit the picker entry or fall back to the
+ *      version's URL prefix root (which may still 404, but that's the
+ *      authoring problem to fix, not the picker's).
+ *
+ * `version` is the manifest slug (e.g. `"v0"`), NOT the collection ID
+ * (`"docs-v0"`). For the current version, returns `"/"` when at least
+ * one current-version entry exists, else `null`.
+ *
+ * Reads from `getIndexedEntries()`, so the cost is one cached lookup
+ * per build (the indexed list is computed once per page render).
+ */
+declare function getVersionLandingUrl(version: string): Promise<string | null>;
+declare function getVersionStatus(collectionId: string): Promise<VersionStatus | null>;
 //#endregion
-export { type BadgeVariant, type Breadcrumb, type NimbusConfig, type NimbusIntegrationOptions, type PrevNext, type PrevNextLink, type PrevNextOverrides, type SearchProvider, type SearchResult, type SidebarBadge, type SidebarConfig, type SidebarConfigItem, type SidebarExternalLinkItem, type SidebarGroupItem, type SidebarItem, type SidebarLinkItem, type SidebarSection, type TOCItem, nimbus as default, defaultCodeTransformers, defineConfig, getBreadcrumbs, getDocsPageProps, getDocsStaticPaths, getEditUrl, getLastUpdated, getPrevNext, getSidebar, getSidebarSections, getTOC, getVisibleEntries, renderEntryAsMarkdown, sidebarHash };
+export { type BadgeVariant, type Breadcrumb, IndexedEntry, IndexedTopLevel, IndexedTopLevelGroup, type NimbusConfig, type NimbusIntegrationOptions, type PrevNext, type PrevNextLink, type PrevNextOverrides, type ResolvedVersions, type SearchProvider, type SearchResult, type SidebarBadge, type SidebarConfig, type SidebarConfigItem, type SidebarExternalLinkItem, type SidebarGroupItem, type SidebarItem, type SidebarLinkItem, type SidebarSection, type TOCItem, type VersionAlternateRecord, type VersionAlternatesTable, type VersionPageRef, type VersionStatus, type VersionsConfig, nimbus as default, defaultCodeTransformers, defineConfig, getBreadcrumbs, getCanonicalUrl, getCollectionLlmsUrl, getCollectionPageProps, getCollectionStaticPaths, getCurrentVersion, getDocsPageProps, getDocsStaticPaths, getEditUrl, getIndexedEntries, getIndexedTopLevel, getLastUpdated, getPrevNext, getSidebar, getSidebarSections, getTOC, getVersionAlternates, getVersionLandingUrl, getVersionStatus, getVersions, getVisibleEntries, renderEntryAsMarkdown, sidebarHash };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/_internal/content.ts","../src/_internal/sidebar.ts","../src/_internal/transform.ts","../src/integration.ts","../src/_internal/code-transformers.ts","../src/index.ts"],"mappings":";;;;;;;;;;;;;ACqoBA;;;;;;;;AC3nBA;iBFwBsB,iBAAA,CACpB,WAAA,cACC,OAAA,CAAQ,eAAA;;;;iBCimBK,WAAA,CAAY,KAAA,EAAO,WAAA;;;;;;;;;;;ADnmBnC;UExBiB,8BAAA;EACf,IAAA;EACA,KAAA,EAAO,MAAA;EACP,QAAA;AAAA;AAAA,KAGU,yBAAA,IACV,OAAA,EAAS,8BAAA;AAAA,UAGM,4BAAA;EFgBS;;;;EEXxB,YAAA,GAAe,MAAA,SAAe,yBAAA;ED4mBL;EC1mBzB,gBAAA;AAAA;AAAA,UAGQ,aAAA;EACR,IAAA;AAAA;;AArBF;;;;;;iBAiNgB,qBAAA,CACd,KAAA,EAAO,aAAA,EACP,OAAA,GAAS,4BAAA;;;UC7KM,wBAAA;EDpCR;ECsCP,GAAA,GAAM,UAAA,QAAkB,GAAA;EDrChB;ECuCR,OAAA;EDpCU;;;;;AAIZ;;;;;;;;;;AAQC;;;;EC4CC,WAAA;IAGM,cAAA;IACA,WAAA;IACA,IAAA,IAAQ,QAAA;EAAA;AAAA;AAAA,iBAIA,MAAA,CACd,SAAA,EAAW,YAAA,EACX,OAAA,GAAS,wBAAA,GACR,gBAAA;;;AFijBH;;;;;;;;AC3nBA;;AD2nBA,iBGjlBgB,uBAAA,CAAA,GAA2B,gBAAA;;;;;AHilB3C;iBI9jBgB,YAAA,WAAuB,YAAA,CAAA,CAAc,MAAA,EAAQ,CAAA,GAAI,CAAA;;;;;;;;;AH3ChE;;;;;AA+LD;;;iBGjGsB,UAAA,CAAW,WAAA,WAAsB,OAAA,CAAQ,WAAA;;;;;;;;;iBAazC,kBAAA,CAAmB,WAAA,WAAsB,OAAA,CAAQ,cAAA;AFvFvE;;;;;;AAAA,iBEyHsB,WAAA,CACpB,WAAA,UACA,OAAA;EACE,SAAA,GAAY,iBAAA;EACZ,WAAA,GAAc,WAAA;AAAA,IAEf,OAAA,CAAQ,QAAA;;;;;;AF9FX;iBEyGsB,cAAA,CACpB,WAAA,UACA,OAAA;EAAY,SAAA;AAAA,IACX,OAAA,CAAQ,UAAA;;;;;;;iBAUW,UAAA,CAAW,KAAA;EAC/B,EAAA;EACA,QAAA;AAAA,IACE,OAAA;;;;;ADtJJ;;;;;;;;ACmBA;;;;;;;;;;iBAiKsB,cAAA,CAAe,KAAA;EACnC,EAAA;EACA,QAAA;AAAA,IACE,OAAA,CAAQ,IAAA;;AAjHZ;;;;;iBA4HgB,MAAA,CACd,QAAA;EAAY,KAAA;EAAe,IAAA;EAAc,IAAA;AAAA,KACzC,OAAA;EAAY,eAAA;EAA0B,eAAA;AAAA,IACrC,OAAA;;;;;AAhFH;;;;;;;;;;;;;;cA4Ga,kBAAA,EAAoB,cAAA;;;;;AA3FjC;;;;;;;;;iBAmHsB,gBAAA,CAAiB,KAAA,EAAO,WAAA,GAAc,OAAA;EAC1D,KAAA,EADuD,cAAA,CACxB,eAAA;EAC/B,OAAA;EACA,QAAA;IAAY,KAAA;IAAe,IAAA;IAAc,IAAA;EAAA;AAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/_internal/content.ts","../src/_internal/sidebar.ts","../src/_internal/transform.ts","../src/integration.ts","../src/_internal/code-transformers.ts","../src/index.ts"],"mappings":";;;;;;;;;;;;;ACupBA;;;;;;;;AC7oBA;iBFwBsB,iBAAA,CACpB,WAAA,cACC,OAAA,CAAQ,eAAA;;;;iBCmnBK,WAAA,CAAY,KAAA,EAAO,WAAA;;;;;;;;;;;ADrnBnC;UExBiB,8BAAA;EACf,IAAA;EACA,KAAA,EAAO,MAAA;EACP,QAAA;AAAA;AAAA,KAGU,yBAAA,IACV,OAAA,EAAS,8BAAA;AAAA,UAGM,4BAAA;EFgBS;;;;EEXxB,YAAA,GAAe,MAAA,SAAe,yBAAA;ED8nBL;EC5nBzB,gBAAA;AAAA;AAAA,UAGQ,aAAA;EACR,IAAA;AAAA;;AArBF;;;;;;iBAiNgB,qBAAA,CACd,KAAA,EAAO,aAAA,EACP,OAAA,GAAS,4BAAA;;;UCnKM,wBAAA;ED9CR;ECgDP,GAAA,GAAM,UAAA,QAAkB,GAAA;ED/ChB;ECiDR,OAAA;ED9CU;;;;;AAIZ;;;;;;;;;;AAQC;;;;ECsDC,WAAA;IAGM,cAAA;IACA,WAAA;IACA,IAAA,IAAQ,QAAA;EAAA;AAAA;AAAA,iBAIA,MAAA,CACd,SAAA,EAAW,YAAA,EACX,OAAA,GAAS,wBAAA,GACR,gBAAA;;;AFyjBH;;;;;;;;AC7oBA;;AD6oBA,iBGnmBgB,uBAAA,CAAA,GAA2B,gBAAA;;;;;AHmmB3C;iBIlkBgB,YAAA,WAAuB,YAAA,CAAA,CAAc,MAAA,EAAQ,CAAA,GAAI,CAAA;AAAA,UAmChD,YAAA;EH/FM;EGiGrB,KAAA,EAF2B,cAAA,CAEI,eAAA;EHjGhB;EGmGf,UAAA;EHjGA;EGmGA,KAAA;EHnGgB;EGqGhB,WAAA;EHlGqB;;;;AA6LvB;;;;EGlFE,GAAA;AAAA;AAAA,UAGe,oBAAA;EHiFf;EG/EA,IAAA;EH+E0C;EG7E1C,KAAA;;EAEA,OAAA,EAAS,YAAA;EFxFM;;;;;;;;;;;EEoGf,IAAA;EFvEc;;;AAIhB;;;;;EE4EE,MAAA;AAAA;AAAA,UAGe,eAAA;EF9EJ;;;;EEmFX,MAAA,EAAQ,YAAA;EFjFS;;;;EEsFjB,MAAA,EAAQ,oBAAA;AAAA;AAAA,iBAoEY,iBAAA,CAAA,GAAqB,OAAA,CAAQ,YAAA;;;;;;;AAnKnD;;;;;iBA+NsB,kBAAA,CAAA,GAAsB,OAAA,CAAQ,eAAA;;;;;;;;;;AA5LpD;;;;;;;;;;;;AAoBA;;;;;;;iBAiQsB,UAAA,CACpB,WAAA,UACA,OAAA;EAAY,UAAA;AAAA,IACX,OAAA,CAAQ,WAAA;;;AAtOX;;;;;;;;;iBAyPsB,kBAAA,CACpB,WAAA,UACA,OAAA;EAAY,UAAA;AAAA,IACX,OAAA,CAAQ,cAAA;;;;AAlHX;;;iBAsNsB,WAAA,CACpB,WAAA,UACA,OAAA;EACE,SAAA,GAAY,iBAAA;EACZ,WAAA,GAAc,WAAA;AAAA,IAEf,OAAA,CAAQ,QAAA;;;;;;;iBAWW,cAAA,CACpB,WAAA,UACA,OAAA;EAAY,SAAA;AAAA,IACX,OAAA,CAAQ,UAAA;AA3HX;;;;;;AAAA,iBAqIsB,UAAA,CAAW,KAAA;EAC/B,EAAA;EACA,QAAA;AAAA,IACE,OAAA;;AAjCJ;;;;;;;;;;;;;;;;;;;AAiBA;;iBA8CsB,cAAA,CAAe,KAAA;EACnC,EAAA;EACA,QAAA;AAAA,IACE,OAAA,CAAQ,IAAA;;;;;;AApCZ;iBA+CgB,MAAA,CACd,QAAA;EAAY,KAAA;EAAe,IAAA;EAAc,IAAA;AAAA,KACzC,OAAA;EAAY,eAAA;EAA0B,eAAA;AAAA,IACrC,OAAA;AAjBH;;;;;;;;;;;AAcA;;;;;;;AAdA,cA6Ca,kBAAA,EAAoB,cAAA;;;;;;;AAAjC;;;;;AAwBA;;iBAAsB,gBAAA,CAAiB,KAAA,EAAO,WAAA,GAAc,OAAA;EAC1D,KAAA,EADuD,cAAA,CACxB,eAAA;EAC/B,OAAA;EACA,QAAA;IAAY,KAAA;IAAe,IAAA;IAAc,IAAA;EAAA;AAAA;;;;;;;;;;AAmC3C;;;;;AAuBA;;;;;iBAvBgB,wBAAA,CAAyB,UAAA,WAAqB,cAAA;;;;;;;;;;;;;;iBAuBxC,sBAAA,kBAAA,CACpB,KAAA,EAAO,WAAA,GACN,OAAA;EACD,KAAA,EAAgD,cAAA,CAAjB,eAAA,CAAgB,CAAA;EAC/C,OAAA;EACA,QAAA;IAAY,KAAA;IAAe,IAAA;IAAc,IAAA;EAAA;AAAA;AAyE3C;;;;;AAwCA;;;;;;;;;;AAeA;;;;;AAvDA,iBAlCsB,WAAA,CAAA,GAAe,OAAA,CAAQ,gBAAA;;;;AAsH7C;;;;;AA+DA;;;;;AAsBA;;;;;;;iBAzKsB,iBAAA,CACpB,YAAA,WACC,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsCmB,oBAAA,CACpB,YAAA,UACA,OAAA,WACC,OAAA,CAAQ,sBAAA;;;;;;;iBAYW,eAAA,CACpB,YAAA,UACA,OAAA,WACC,OAAA;;;;;;;;;;;;;;;;;;;;;;iBA0BmB,oBAAA,CACpB,YAAA,WACC,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6DmB,oBAAA,CACpB,OAAA,WACC,OAAA;AAAA,iBAoBmB,gBAAA,CACpB,YAAA,WACC,OAAA,CAAQ,aAAA"}