@nanisoft/prism-ui 0.13.0 → 0.16.0

package/dist/pages/contact-page/index.js

@@ -0,0 +1,136 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Contact01, } from '../../blocks/contact-01/index.js';
+import { Card, CardContent, CardHeader, CardTitle } from '../../components/ui/card.js';
+import { CtaLink } from '../../components/ui/cta-link.js';
+import { Section, SectionHeading, childLevel } from '../../components/ui/section.js';
+import { cn } from '../../lib/utils.js';
+/**
+ * One declared field as `Contact01` draws it, with the two shapes kept apart.
+ *
+ * `Contact01` declares a union whose select arm requires `options`, and this Page's
+ * prop is flat on purpose, so the union is built here once and the flat pair is
+ * checked above before this runs. The alternative was forwarding the flat record
+ * and letting the Block's own diagnostic fire three frames down, which names the
+ * Block rather than the prop the caller passed.
+ */
+function asContactField(field) {
+    const shared = {
+        id: field.id,
+        label: field.label,
+        required: field.required,
+        description: field.description,
+        placeholder: field.placeholder,
+        autoComplete: field.autoComplete,
+    };
+    if (field.type !== 'select')
+        return { ...shared, type: field.type };
+    const options = field.options ?? [];
+    if (options.length === 0) {
+        throw new Error(`ContactPage: the field "${field.id}" is a select and passes no options, so the control would render with ` +
+            'nothing in it, which is a question no reader can answer and looks answered only because the control is ' +
+            'there and focusable. Pass the choices, or declare the field as a text field and check the answer in ' +
+            'your own handler.');
+    }
+    return { ...shared, type: 'select', options: options.map((option) => ({ ...option })) };
+}
+/**
+ * The two checks the office union makes for a TypeScript caller, run here for the
+ * JavaScript one and for the value that came out of a build step with the type's
+ * guarantee already gone.
+ *
+ * Both are about a card that would say less than it appears to. An office with no
+ * postal lines is a card that asserts a place exists and does not say where, and a
+ * map link with no words is a control announced as a coordinate.
+ */
+function assertOffices(offices) {
+    for (const office of offices ?? []) {
+        if (office.lines.length === 0) {
+            throw new Error(`ContactPage: the office "${office.id}" declares no postal lines, so the card would name a place and say ` +
+                'nothing about where it is. Pass the lines a reader would write on an envelope, or drop the office and ' +
+                'let the form carry the enquiry.');
+        }
+        if (office.mapHref !== undefined && (!office.mapLabel || office.mapLabel.trim() === '')) {
+            throw new Error(`ContactPage: the office "${office.id}" carries a map link with no mapLabel, so the control would be ` +
+                'announced by its destination, which is punctuation rather than a name. Pass the words that say what ' +
+                'the link does, or drop it.');
+        }
+    }
+}
+/**
+ * A complete contact screen: the page heading, the form the caller declares, the
+ * places a reader can reach a person, and the questions they should not have to ask
+ * to find this screen.
+ *
+ * **The offices are the part that makes this a Page rather than a `Contact01`, and
+ * it is worth saying what that Block cannot do.** A contact Block is a band: one
+ * form, in one column, with the caller's fields. A contact screen is the band, the
+ * places, and the questions, and the two extras are what a reader actually arrives
+ * with, because a reader who wants to write has a fallback and a reader who has run
+ * out of patience has a map. `Contact01` has an `address` arm and this Page does not
+ * use it, for three reasons that all point the same way: that arm holds exactly one
+ * postal address where a business has as many as it has regions; it has no field for
+ * a name for the place, so three cities are three unlabelled blocks of lines; and
+ * its link arm is a `mailto`, which is the wrong link for a place that is not
+ * reachable by post. A consumer whose only address is one postal address beside one
+ * form should compose `Contact01` with that arm, which is the better arrangement
+ * for one address, and the cost here is the other thing: the offices are a band
+ * under the form rather than a column beside it, because a Block that draws its own
+ * `Section` cannot be dropped into a grid column without the page's vertical rhythm
+ * doubling, which is the same reason `dashboard-page` stacks its bands rather than
+ * setting two of them side by side.
+ *
+ * **The offices are facts and not controls, and the type is what holds that.** A
+ * postal line is a string a reader copies. `detail` is a node, because the honest
+ * thing under a place is sometimes a sentence and sometimes a small table of
+ * opening hours, and a string would force one of those to be flattened. The only
+ * link a card may carry is the caller's own map link, and it carries words, and the
+ * union is what makes those words required. A screen that turned its regions into
+ * navigation would be telling a reader that a place is a topic they can read about,
+ * and the only topic any of them has is how to get there.
+ *
+ * **The page heading and the form band are two headings and not one sentence twice.**
+ * The rejected alternative was handing `title` to the form and letting the Block's
+ * section heading be the page's `h1`, which is what `onboarding-page` does and what
+ * it can do because its first band is the whole screen. Here the first band is a
+ * form with a name of its own, and a screen whose page heading was "Talk to us" and
+ * whose form heading was also "Talk to us" would be a page with one heading drawn
+ * twice and a reader navigating by heading who met the form rather than the page.
+ *
+ * **The status is `Contact01`'s, and the refusal to invent one is the whole of this
+ * Page's copy law.** There is no success sentence anywhere in this file, no `sent`
+ * flag written by this package, and no "we will reply within a day". A contact
+ * request can be delivered, held by a filter, filed by a bot, refused as a duplicate
+ * and answered, and one sentence cannot be true of all five, so the caller owns the
+ * promise and writes the words. The cost is that a consumer who installs this screen
+ * has to write a sentence they will get wrong once.
+ *
+ * **It is a client Component, and the reason is `onSubmit`.** A handler is a
+ * function, a function is a piece of state, and a function cannot cross from a
+ * server Component to a client Component, so a server Page that took one would hand
+ * a caller a form that gathers a person's name, an address and a message and then
+ * calls nothing. `Contact01` is a client module for the same reason and the Page
+ * cannot be a server module in front of it. The cost is stated rather than hidden:
+ * every datum on this screen is serialised across the boundary to reach a band three
+ * elements down, and the rejected alternative was a form slot, which would have
+ * been a Page that owns a heading, a row of addresses and nothing a reader could
+ * submit.
+ */
+export function ContactPage({ eyebrow, title, description, form, fields, onSubmit, submitLabel, consent, status, offices, officesLabel, footer, headingLevel = 'h1', className, }) {
+    assertOffices(offices);
+    /*
+      The band heading is one step below the page heading and an office's name is one
+      step below that, which is what `childLevel` is for: a hardcoded level in each
+      would be right exactly once.
+    */
+    const BandHeading = childLevel(headingLevel);
+    const OfficeHeading = childLevel(BandHeading);
+    return (_jsxs("div", { "data-slot": "contact-page", className: cn(className), children: [_jsx(Section, { "data-slot": "contact-page-heading", children: _jsx(SectionHeading, { as: headingLevel, align: "left", eyebrow: eyebrow, title: title, description: description }) }), _jsx(Contact01, { title: form.title, description: form.description, fields: fields.map(asContactField), onSubmit: onSubmit, submitLabel: submitLabel, consent: consent, status: status, variant: "stacked", headingLevel: BandHeading }), offices === undefined ? null : (_jsxs(Section, { "data-slot": "contact-page-offices", children: [_jsx(SectionHeading, { as: BandHeading, align: "left", title: officesLabel, className: "mb-10" }), _jsx("div", { "data-slot": "contact-page-office-row", className: "grid items-start gap-6 md:grid-cols-2 lg:grid-cols-3", children: offices.map((office) => (_jsxs(Card, { "data-slot": "contact-page-office", "data-office": office.id, className: "h-full", children: [_jsx(CardHeader, { children: _jsx(CardTitle, { as: OfficeHeading, children: office.name }) }), _jsxs(CardContent, { className: "flex flex-col items-start gap-4", children: [_jsx("address", { "data-slot": "contact-page-office-address", className: "text-muted-foreground flex flex-col gap-1 not-italic text-sm", children: office.lines.map((line, index) => (
+                                            /*
+                                              Positional, because a postal line is display content and a
+                                              business with two branches on one street can legitimately
+                                              print the same line twice.
+                                            */
+                                            _jsx("span", { children: line }, `${office.id}-${index}`))) }), office.detail === undefined ? null : (_jsx("div", { "data-slot": "contact-page-office-detail", className: "text-pretty text-sm", children: office.detail })), office.mapHref === undefined ? null : (_jsx(CtaLink, { "data-slot": "contact-page-office-map", href: office.mapHref, variant: "ghost", size: "sm", children: office.mapLabel }))] })] }, office.id))) })] })), footer === undefined ? null : (_jsx("div", { "data-slot": "contact-page-footer", children: footer }))] }));
+}
+export default ContactPage;

package/dist/pages/docs-shell/docs-shell.d.ts

@@ -15,15 +15,36 @@ import type { ReactNode } from 'react';
  * block used to make was true only of the group arm; it is now true of what the
  * Page renders, and it says which of the two is doing the work.
  *
- * `title` may be the empty string, and an entry with no words is not a page: it
- * renders as a label on the same rule that makes a group with no index a label,
- * and it is not a page the pager can reach either. A link with no accessible name
- * is announced as "link" and nothing else, which is the one thing a link in a
- * rail must never be.
+ * `title` may be the empty string, and an entry the Page cannot name is not
+ * rendered at all. It used to render as a label on the same rule that makes a
+ * group with no index a label, and that produced `<li><span></span></li>`: a
+ * row of nothing inside a `<nav>`, which one consumer measured at 102 across 25
+ * of its 31 documentation pages. A blank row is not a destination and it is not
+ * a label either, because a label is words. So the Page drops the entry and
+ * counts the drop on the rail as `data-unnamed-entries`, which is the same
+ * answer `Diagram` gives a relation it cannot resolve.
+ *
+ * **The page is not lost, and one thing is.** The address still resolves, the
+ * document still renders at it, and every link into it still works; what the rail
+ * loses is one row. The pager does lose that page, because the pager walks the
+ * same list and the row is no longer in it, so a reader who arrives at the address
+ * directly finds a document and no pager. That was already the answer before the
+ * row was dropped, and it is the cost of dropping rather than of this change:
+ * keeping it would mean publishing the nameless link a second time.
+ *
+ * **A blank `title` and a blank `href` are answered differently, and the reason
+ * is what each one has left.** A page with an address and no words is a real page
+ * with one unrenderable field, so dropping the row costs a reader nothing and
+ * taking the whole screen down over it would cost them everything. A page with
+ * words and no address is a row whose entire content is a route that does not
+ * exist, and there is nothing to render in its place, so `readTree` refuses it.
  */
 export type DocsNavPage = {
     type: 'page';
-    /** The words the reader meets. An empty string makes this a label, not a link. */
+    /**
+     * The words the reader meets. An empty or blank string names nothing, and the
+     * Page renders no row for the entry and counts the drop.
+     */
     title: string;
     /** The address the page is read at. An empty string is refused, by name. */
     href: string;
@@ -47,7 +68,15 @@ export type DocsNavPage = {
  */
 export type DocsNavGroup = {
     type: 'group';
-    /** The words on the label. A status inside them stays inside them. */
+    /**
+     * The words on the label. A status inside them stays inside them.
+     *
+     * An empty or blank string renders no label, and the pages under the group are
+     * still rendered: a group whose title cannot be rendered has lost a heading and
+     * not a section, so dropping the whole entry would delete pages the reader can
+     * otherwise reach. A group with no words and no children has nothing left to
+     * draw and is dropped whole.
+     */
     title: string;
     /**
      * The group's own index page, where it has one. Omit it for a group that is
@@ -159,11 +188,17 @@ export type DocsShellProps = {
      * The accessible name of the rail. Required whenever `nav` is passed, because
      * it is a word a reader hears and a Page that ships no copy ships no
      * reader-facing copy either.
+     *
+     * It is also the visible word on the disclosure that stands in for the rail
+     * below `lg`, because it is already this navigation's name and a Page cannot
+     * invent a second one. A consumer that files its navigation in another language
+     * gets the control in that language by having done this once.
      */
     navLabel: string;
     /**
      * The accessible name of the contents rail. Required whenever `toc` is passed,
-     * for the same reason `navLabel` is.
+     * for the same reason `navLabel` is, and the contents disclosure below `lg`
+     * carries it for the same reason too.
      */
     tocLabel: string;
     /**
@@ -259,13 +294,85 @@ export type DocsShellProps = {
  * author filed it. A Page that sorted its rail would flatten the one thing the
  * three sites disagree about and cannot both be right about.
  *
- * **The rail is bounded in height.** Atlas files nineteen pages and AlphaLens
- * files twenty-seven, so the taller tree is half again as long, and an unbounded
- * rail on a tall tree is a rail that pushes the document below the fold before
- * the reader has read a line of it. The rail and the contents rail are each
- * capped against the viewport and scroll inside it, so a nineteen-page tree and a
- * twenty-seven-page tree are both a full screen and neither is a page-long
- * sidebar.
+ * **The rail is bounded in height, and the bound is what the reader has to be
+ * able to see.** Atlas files nineteen pages and AlphaLens files twenty-seven, so
+ * the taller tree is half again as long, and an unbounded rail on a tall tree is
+ * a rail that pushes the document below the fold before the reader has read a
+ * line of it. The rail and the contents rail are each capped against the viewport
+ * and scroll inside it, so a nineteen-page tree and a twenty-seven-page tree are
+ * both a full screen and neither is a page-long sidebar.
+ *
+ * **A cap the reader cannot see is a defect, and this one was invisible for 344
+ * and 750 pixels.** Measured in two consumers' built exports at 1280 by 680, the
+ * rail's content stood at 912 and 1318 pixels against a 568 pixel box, so more
+ * than half of one site's documentation navigation sat below the fold with
+ * `mask-image: none`, no scrollbar Chrome would draw until the reader scrolled,
+ * no fade and no count. Chrome's overlay scrollbars are the reason this is not
+ * caught by looking: they appear on scroll, so the first render of a rail that
+ * hides half its content is indistinguishable from a rail that has all of it, and
+ * the last visible row was cut mid-word above dead space, which reads as a
+ * rendering fault rather than as a scroll region.
+ *
+ * **The affordance is a fade across the foot of the scroll region, with the space
+ * it covers reserved rather than borrowed.** Three answers were available and the
+ * other two were rejected for stated reasons. A persistent themed scrollbar is
+ * truthful at both ends and costs nothing to legibility, and it is still here in
+ * the sense that the region is a real scroll region rather than a clipped box,
+ * but it is a single hairline whose length says "there is more" without saying
+ * which way, it needs `scrollbar-gutter` reserved in a 15rem rail to stop the
+ * content shifting when a short tree becomes a tall one, and in Chrome it is the
+ * least reliable of the three to reason about because the property that makes it
+ * persistent is the same one whose default is an overlay. A collapse control needs
+ * a disclosure whose state a server Component cannot hold. An "N more" control is
+ * copy this Page does not ship and it needs the count the Page cannot compute
+ * without measuring, which is the one thing a server Component cannot do.
+ *
+ * So the fade, and it is painted on a wrapper that does not scroll rather than on
+ * the scroll region itself: a mask or a gradient inside the scrollport moves with
+ * the content and marks nothing. The wrapper carries the sticky offset, the
+ * scroll region keeps the cap and the scrolling, and the gradient is pinned to
+ * the wrapper's foot. The region carries `padding-bottom` of the same height, and
+ * that is the half that makes it honest: at rest the gradient falls on reserved
+ * space and the last row is fully legible, and only while there is more below
+ * does it fall on content. Without the padding the same gradient washes the last
+ * row permanently, which is the usual cost of this answer and the reason the
+ * padding is not optional.
+ *
+ * **The fade is paint, and it is on the accessibility tree's terms.** It is an
+ * empty element with `aria-hidden` and `pointer-events-none`, inside the `<nav>`
+ * and outside the `<ul>`, so it is not a list item, it is not announced, it never
+ * takes a press and it never reaches a Tab stop. A keyboard reader scrolls the
+ * region with the arrow keys exactly as before and reaches every entry, and a
+ * screen-reader user is told nothing at all, which is the right answer: the cut is
+ * a fact about ink, and announcing it would put a sentence in the middle of a
+ * list of a consumer's own pages.
+ *
+ * **Below `lg` there was no navigation at all, and the fix is a native
+ * disclosure.** At 768 and at 1024 both rails were `hidden` and the only
+ * navigation left inside `<main>` was the two-item pager at the foot of the
+ * article, so a reader on a thirty-one document reference at tablet width had no
+ * contents, no on-this-page and no way to a sibling page except Previous and
+ * Next. The disclosure is `<details>` and `<summary>`, which is the one
+ * disclosure widget that needs no runtime at all: it is expanded and collapsed by
+ * the platform, it is a real control in the Tab order with a real expanded state,
+ * and adding a client boundary to a server Component to reinvent it would put
+ * bytes on every documentation page in the family to save a reader one click.
+ *
+ * The tree is rendered twice, once in each arrangement, and only one of them is
+ * in the document at any width: the rail is `hidden lg:block` and the disclosure
+ * is `lg:hidden`, so the other one is `display: none` and is out of the
+ * accessibility tree and out of the tab order rather than a second copy a reader
+ * meets. The summary carries `navLabel` or `tocLabel`, which is the caller's own
+ * word for that navigation and therefore the one word on the control that cannot
+ * be wrong in a language the consumer did not write in.
+ *
+ * **The frame is three columns from `lg`, and the third is the consumer's to
+ * fill.** The rail is 15rem, the document takes the rest, and the contents rail
+ * is 13rem. The third track exists only when `toc` is passed, because the
+ * document takes the second track by auto-placement and a template that named a
+ * track no child occupies would leave the document in the 15rem one. Below `lg`
+ * the frame is a single column: the document fills it and the two navigations sit
+ * above it behind their disclosures.
  *
  * It is a Page rather than a Block because it is a whole screen and it is the
  * screen a content pipeline targets: a route that reads one document and hands
@@ -276,7 +383,10 @@ export type DocsShellProps = {
  *
  * It is a server Component. It fetches nothing, it holds no state and it imports
  * no router, so a consumer renders it from whichever route their framework names
- * and hands it the document their pipeline produced.
+ * and hands it the document their pipeline produced. The sub-`lg` disclosure is
+ * the reason that stays true under pressure: it is the one feature on this Page
+ * that a hand would be tempted to write as a client Component, and it is written
+ * as markup instead.
  */
 export declare function DocsShell({ title, description, nav, toc, currentHref, navLabel, tocLabel, pagerLabel, pagerLabels, header, footer, className, children, }: DocsShellProps): import("react").JSX.Element;
 export default DocsShell;

package/dist/pages/docs-shell/docs-shell.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"docs-shell.d.ts","sourceRoot":"","sources":["../../../src/pages/docs-shell/docs-shell.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAMtC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,kFAAkF;IAClF,KAAK,EAAE,MAAM,CAAA;IACb,4EAA4E;IAC5E,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,OAAO,CAAA;IACb,sEAAsE;IACtE,KAAK,EAAE,MAAM,CAAA;IACb;;;;;;;;;;OAUG;IACH,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,0EAA0E;IAC1E,KAAK,EAAE,SAAS,YAAY,EAAE,CAAA;CAC/B,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,SAAS,CAAA;IACf,4DAA4D;IAC5D,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,GAAG,WAAW,GAAG,YAAY,GAAG,cAAc,CAAA;AAEtE;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,gDAAgD;IAChD,QAAQ,EAAE,MAAM,CAAA;IAChB,4CAA4C;IAC5C,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B;;;;;;;;OAQG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IACd;;;;OAIG;IACH,WAAW,CAAC,EAAE,SAAS,CAAA;IACvB;;;;OAIG;IACH,GAAG,CAAC,EAAE,SAAS,YAAY,EAAE,CAAA;IAC7B;;;;;;;OAOG;IACH,GAAG,CAAC,EAAE,SAAS,YAAY,EAAE,CAAA;IAC7B;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;;OAIG;IACH,QAAQ,EAAE,MAAM,CAAA;IAChB;;;OAGG;IACH,QAAQ,EAAE,MAAM,CAAA;IAChB;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAA;IAClB;;;;OAIG;IACH,WAAW,EAAE,eAAe,CAAA;IAC5B;;;;;OAKG;IACH,QAAQ,EAAE,SAAS,CAAA;IACnB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,SAAS,CAAA;IAClB;;;OAGG;IACH,MAAM,CAAC,EAAE,SAAS,CAAA;IAClB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2EG;AACH,wBAAgB,SAAS,CAAC,EACxB,KAAK,EACL,WAAW,EACX,GAAG,EACH,GAAG,EACH,WAAW,EACX,QAAQ,EACR,QAAQ,EACR,UAAU,EACV,WAAW,EACX,MAAM,EACN,MAAM,EACN,SAAS,EACT,QAAQ,GACT,EAAE,cAAc,+BAsFhB;AAwWD,eAAe,SAAS,CAAA"}
+{"version":3,"file":"docs-shell.d.ts","sourceRoot":"","sources":["../../../src/pages/docs-shell/docs-shell.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAOtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAA;IACb,4EAA4E;IAC5E,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,OAAO,CAAA;IACb;;;;;;;;OAQG;IACH,KAAK,EAAE,MAAM,CAAA;IACb;;;;;;;;;;OAUG;IACH,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,0EAA0E;IAC1E,KAAK,EAAE,SAAS,YAAY,EAAE,CAAA;CAC/B,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,SAAS,CAAA;IACf,4DAA4D;IAC5D,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,GAAG,WAAW,GAAG,YAAY,GAAG,cAAc,CAAA;AAEtE;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,gDAAgD;IAChD,QAAQ,EAAE,MAAM,CAAA;IAChB,4CAA4C;IAC5C,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B;;;;;;;;OAQG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IACd;;;;OAIG;IACH,WAAW,CAAC,EAAE,SAAS,CAAA;IACvB;;;;OAIG;IACH,GAAG,CAAC,EAAE,SAAS,YAAY,EAAE,CAAA;IAC7B;;;;;;;OAOG;IACH,GAAG,CAAC,EAAE,SAAS,YAAY,EAAE,CAAA;IAC7B;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;;;;;;;OASG;IACH,QAAQ,EAAE,MAAM,CAAA;IAChB;;;;OAIG;IACH,QAAQ,EAAE,MAAM,CAAA;IAChB;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAA;IAClB;;;;OAIG;IACH,WAAW,EAAE,eAAe,CAAA;IAC5B;;;;;OAKG;IACH,QAAQ,EAAE,SAAS,CAAA;IACnB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,SAAS,CAAA;IAClB;;;OAGG;IACH,MAAM,CAAC,EAAE,SAAS,CAAA;IAClB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsJG;AACH,wBAAgB,SAAS,CAAC,EACxB,KAAK,EACL,WAAW,EACX,GAAG,EACH,GAAG,EACH,WAAW,EACX,QAAQ,EACR,QAAQ,EACR,UAAU,EACV,WAAW,EACX,MAAM,EACN,MAAM,EACN,SAAS,EACT,QAAQ,GACT,EAAE,cAAc,+BA6GhB;AAsgBD,eAAe,SAAS,CAAA"}