@nanisoft/prism-ui 0.16.1 → 1.1.0

package/dist/blocks/activity-feed-01/activity-feed-01.d.ts

@@ -1,104 +1,14 @@
 import type { ReactNode } from 'react';
 import { type HeadingLevel } from '../../components/ui/section.js';
-import { type StatusTone } from '../../components/ui/status.js';
-/**
- * One thing that happened: who did it, what they did, to what, and when.
- *
- * **`actor`, `action`, `target` and `at` are four fields because a record of what
- * happened has four parts and no others.** Every other surface in this repository
- * that shows a record of an event has arrived at the same four by a different route,
- * and each has added a fifth: a source, a category, a severity, a free text field. A
- * fifth field is a claim about the reader's product, because a Block cannot know
- * whether a fifth thing is required, and a caller who has one composes it in
- * `detail`, which is a node. So the shape is closed at four and the rest is a slot.
- *
- * `id` is a key and is never rendered, for the reason `ContentGrid01Entry`'s id is: a
- * feed is reordered by a consumer as often as it is read, and a key made of the
- * words means a rename in the copy is a rename in the key.
- */
-export type ActivityFeed01Event = {
-    /** A key unique within the feed, carried on the markup as `data-event`. */
-    id: string;
-    /**
-     * Who did it, in the words a reader would use for them.
-     *
-     * A `string` rather than a node because a feed is scanned down this edge and a
-     * column that wraps is a column that does not line up. A caller whose actor is a
-     * person with an avatar composes the avatar into `detail` instead.
-     */
-    actor: string;
-    /**
-     * What they did, in the product's own verb.
-     *
-     * A verb and not a sentence, because the three fields are drawn as one run of
-     * words: the actor, then this, then the target. A caller whose event needs a full
-     * clause writes the clause here and the run reads as one, which is the same thing
-     * with a different boundary.
-     */
-    action: string;
-    /**
-     * What they did it to: a run, a document, a setting, a person.
-     *
-     * Optional because a record of what happened sometimes has nothing to point at: a
-     * sign-in, a logout, a nightly job that names no document. A caller with a target
-     * passes one; a caller whose target is a node composes it into `detail`.
-     */
-    target?: string;
-    /**
-     * When it happened, printed exactly as passed.
-     *
-     * A `number` or a `string` and never a `Date`, and the reason is the one
-     * `ContentGrid01Entry`'s `at` gives: a Block ships no formatting, so the reading a
-     * reader should see is the caller's own. A number is epoch milliseconds and is
-     * printed as a number, which is honest and almost never what was wanted; a string
-     * is printed as written, so `2026-09-30`, `30 September` and `Q3` are all readings
-     * a caller writes and this Block parses none of them. The machine value is still
-     * there, on the `time` element's `dateTime`, so a crawler and a screen reader get a
-     * timestamp whatever the visible reading says.
-     *
-     * A caller who wants a localised reading and a relative phrase composes
-     * `relative-time` beside it and passes the node in `detail`, which is the one node
-     * slot a row has, so the reading sits under the record rather than inside it. See
-     * the Block's JSDoc for the whole of that argument.
-     */
-    at: number | string;
-    /**
-     * The line under the record, for whatever the caller wants said about it: the
-     * reason, the payload, the diff, a composed `relative-time` reading.
-     *
-     * A node rather than a `string` for exactly that last reason. A caller with four
-     * words of context passes four words; a caller with a table, a code block or a
-     * timestamp passes the Component.
-     */
-    detail?: ReactNode;
-    /**
-     * The tone of the event, drawn as a `Status` beside the record.
-     *
-     * See the Block's JSDoc for why a tone arrives without a label: the label this
-     * Block draws is the machine value itself, which is what `Changelog01` does with a
-     * change's kind, and the alternative is a coloured dot with nothing beside it,
-     * which is a mark only a reader who can separate the tones can see.
-     */
-    tone?: StatusTone;
-    /** Where the record is kept. Its presence puts a link on the row. */
-    href?: string;
-    /**
-     * The words on the link, and required whenever `href` is.
-     *
-     * A link whose only words are the record's own three fields tells a reader nothing
-     * about what following it does, and a feed of ten links all reading "Open" is ten
-     * identical controls.
-     */
-    hrefLabel?: string;
-};
+import type { EventSpec } from '../../lib/spec.js';
 /**
  * The props an ActivityFeed01 takes, as a union over whether the feed is grouped.
  *
  * A union rather than an optional `dayLabel` beside an optional `groupBy`, for the
- * reason `HeroAction` is the reference: a `dayLabel` that is optional in the ungrouped
- * arm and required in the grouped one is a prop whose absence is sometimes a mistake
- * and sometimes a decision, and a caller who writes `groupBy="day"` and forgets the
- * label should not compile.
+ * reason `HeroAction` is the reference: a `dayLabel` that is optional in the
+ * ungrouped arm and required in the grouped one is a prop whose absence is
+ * sometimes a mistake and sometimes a decision, and a caller who writes
+ * `groupBy="day"` and forgets the label should not compile.
  */
 export type ActivityFeed01Props = {
     /** Optional label above the section title. See the No-Default-Eyebrow Rule. */
@@ -108,41 +18,57 @@ export type ActivityFeed01Props = {
     /** One or two sentences under the title. */
     description?: string;
     /**
-     * The events, newest first unless the product says otherwise.
+     * The events, from the shared event specification, newest first unless the
+     * product says otherwise.
+     *
+     * The entries are `EventSpec` from `@nanisoft/prism-ui/spec`, which is the one
+     * declaration of a dated attributed occurrence every Block in this package
+     * takes, so a shipment scan, a sign in and a permission change are one shape and
+     * no second event type is minted here. Each entry carries a stable `key`, a
+     * moment printed exactly as passed, a required `actor` and `action`, an optional
+     * `target`, an optional `detail` node, a `tone` with its required `toneLabel`,
+     * and an `href` with its required `hrefLabel`.
+     *
+     * **It names no vocabulary of what happened.** There is no `kind` member,
+     * because an event's kind would name what somebody's product calls a thing that
+     * happened, and no enumeration of those is this package's to publish: a caller
+     * needing one puts the word in `action` or composes a status into `detail`. It
+     * carries no progress figure, no severity, no duration and no role, each refused
+     * for a reason rather than left out. See the specification module's own JSDoc.
      *
-     * The Block does not sort, and the reason is the one `StatusLedger01` gives for its
-     * rows: order is a claim about what happened first, and a feed that sorted itself
-     * would be making that claim on the caller's behalf. A caller's order is also the
-     * only order that can express the exceptions, because a feed is where a pinned
-     * record lives and a Block cannot know an event is pinned.
+     * The Block does not sort, and the reason is the one `StatusLedger01` gives for
+     * its rows: order is a claim about what happened first, and a feed that sorted
+     * itself would be making that claim on the caller's behalf. A caller's order is
+     * also the only order that can express the exceptions, because a feed is where a
+     * pinned record lives and a Block cannot know an event is pinned.
      */
-    events: ActivityFeed01Event[];
+    events: EventSpec[];
     /**
-     * Called with an event's id when its row is activated, and the only reason a row is
-     * a control at all.
+     * Called with an event's key when its row is activated, and the only reason a row
+     * is a control at all.
      *
-     * A row with no handler is a `li`, which is a record a reader reads; a row with one
-     * is a `button`, which is a thing a reader does. That is the whole of the rule, and
-     * it is why a feed is a list first and a set of controls second. The alternative
-     * was to make every row a button, which is a feed of forty tab stops where a reader
-     * tabbing through the page lands on the fortieth record before reaching anything
-     * after the feed.
+     * A row with no handler is a `li`, which is a record a reader reads; a row with
+     * one is a `button`, which is a thing a reader does. That is the whole of the
+     * rule, and it is why a feed is a list first and a set of controls second. The
+     * alternative was to make every row a button, which is a feed of forty tab stops
+     * where a reader tabbing through the page lands on the fortieth record before
+     * reaching anything after the feed.
      *
      * An event's destination is a separate control with the caller's own words, so a
      * row can be selectable and linked at once, and that is the arrangement a feed
      * actually wants: a reader activates the row to open the thing and the caller
      * marks it read on the way past.
      */
-    onSelect?: (id: string) => void;
+    onSelect?: (key: string) => void;
     /**
      * How many of the events to draw.
      *
-     * Optional, and the cost is the honest one: a capped feed that says nothing about
-     * what it left out is a feed a reader believes is complete. So the words that would
-     * say it are the caller's, and the caller's way of saying them is to pass a limit it
-     * can stand behind and put the rest behind its own link. The alternative was a
-     * `truncatedLabel` prop beside this one, which is a sentence Prism would ship into
-     * every consumer's product.
+     * Optional, and the cost is the honest one: a capped feed that says nothing
+     * about what it left out is a feed a reader believes is complete. So the words
+     * that would say it are the caller's, and the caller's way of saying them is to
+     * pass a limit it can stand behind and put the rest behind its own link. The
+     * alternative was a `truncatedLabel` prop beside this one, which is a sentence
+     * Prism would ship into every consumer's product.
      */
     limit?: number;
     /**
@@ -150,8 +76,8 @@ export type ActivityFeed01Props = {
      *
      * Required, and it is the one line a reader with a question and no answer is
      * guaranteed to read. It is also the sentence Prism is least entitled to write:
-     * "Nothing has happened yet" is a claim about a product and a period, and both are
-     * the caller's.
+     * "Nothing has happened yet" is a claim about a product and a period, and both
+     * are the caller's.
      */
     empty: ReactNode;
     /** Heading level for the section title. See `HeadingLevel`. */
@@ -165,20 +91,21 @@ export type ActivityFeed01Props = {
     /**
      * Group the events under a heading per day.
      *
-     * A day heading is a heading and not a divider, because a reader who navigates
-     * by heading is looking for the day they want and a rule between two groups is
-     * invisible to them.
+     * A day heading is a heading and not a divider, because a reader who
+     * navigates by heading is looking for the day they want and a rule between
+     * two groups is invisible to them.
      */
     groupBy: 'day';
     /**
      * The words for a day, given the day.
      *
      * Required in this arm, and a function rather than a string, because "Today",
-     * "Yesterday" and "Tuesday" are the product's sentences and the key is a fact.
-     * The key is an ISO calendar date in the runtime's own zone, so a caller hands
-     * it to `Intl.DateTimeFormat` and gets their locale's reading of it, or writes
-     * their own. The rejected alternative was the Block calling `Intl` itself, which
-     * would put a locale this package does not own into every consumer's feed.
+     * "Yesterday" and "Tuesday" are the product's sentences and the key is a
+     * fact. The key is an ISO calendar date in the runtime's own zone, so a
+     * caller hands it to `Intl.DateTimeFormat` and gets their locale's reading of
+     * it, or writes their own. The rejected alternative was the Block calling
+     * `Intl` itself, which would put a locale this package does not own into
+     * every consumer's feed.
      */
     dayLabel: (key: string) => string;
 } | {
@@ -188,83 +115,86 @@ export type ActivityFeed01Props = {
     dayLabel?: never;
 });
 /**
- * A chronological list of what happened: an actor, an action, a target, a moment,
- * and an optional line under the record.
+ * A chronological list of what happened: the shared event specification, one record
+ * per entry, with an optional line under each.
  *
- * **The words are the caller's and the shape is Prism's, and that is the whole of the
- * design.** A feed that composed the sentence would ship English into every
- * consumer's product: "Ada published a release four hours ago" is a word order, an
- * article, an inflected verb and a relative phrase, and a Block that assembled it
- * would have assembled the English one and given the consumer no way to translate
- * it, inflect it or reorder it, because the string would be inside a package rather
- * than inside their own code. So this Block takes the three parts as three props and
- * draws them as one run of words, which is the most a design system can do without
- * writing a sentence.
+ * **The trail's entry declaration is `EventSpec`, and this Block mints no second
+ * event shape beside it.** `@nanisoft/prism-ui/spec` is the one declaration of a
+ * dated attributed occurrence in this package, so a shipment scan, a sign in and a
+ * permission change are one type and the vocabulary a consumer learns on this Block
+ * is the vocabulary everywhere an occurrence is drawn. An event carries a stable
+ * `key` that is never the words of a label, a moment printed exactly as the caller
+ * passed it with the machine value on the element, a required `actor` and `action`,
+ * an optional `target`, an optional `detail` node for the diff, the payload or the
+ * composed reading that four fields cannot hold, a `tone` whose label is required
+ * wherever the tone is set, and a destination whose words are required wherever it
+ * is set.
  *
- * **The four fields are four because a record of what happened has four parts and no
- * others.** Who, what they did, to what, and when. Each is required except the target,
- * and the target's absence is a real state rather than a gap: a sign-in, a logout, a
- * nightly job that names no document. The fifth field every similar surface reaches
- * for, a source or a category or a severity, is `tone` and `detail`, both optional
- * and one of them a node. A closed shape of four with two slots is the answer to a
- * feed that has grown a sixth field because the Block could not say no.
+ * **It names no vocabulary of what happened, and there is no `kind` member.** An
+ * event's kind would name what somebody's product calls a thing that happened, and
+ * no enumeration of those is this package's to publish: a member on a Prism type
+ * would be promising that every consumer's world is this one. A caller needing one
+ * puts the word in `action` or composes a `Status` into `detail`. It carries no
+ * `progress`, no `severity`, no `duration` and no `role`, each refused for a reason
+ * rather than left out, and the specification module's own JSDoc is the whole of
+ * that argument.
+ *
+ * **The words are the caller's and the shape is Prism's.** A feed that composed the
+ * sentence would ship English into every consumer's product: "Ada published a
+ * release four hours ago" is a word order, an article, an inflected verb and a
+ * relative phrase, and a Block that assembled it would have assembled the English
+ * one and given the consumer no way to translate it, inflect it or reorder it. So
+ * this Block takes the parts as the caller's own nodes and draws them as one run of
+ * words, which is the most a design system can do without writing a sentence.
  *
  * **`at` is printed exactly as passed, and the Block formats no moment.** A Block
  * that formatted one would have to pick a locale, a calendar and a granularity, and
- * `relative-time` already holds that decision and holds it well: it formats the
- * absolute reading with the platform and hands the sentence back rather than writing
- * it, which is the only arrangement a shared package can offer a product shipping in
- * more than one language. So this Block prints the caller's value, puts the ISO form
- * on the `time` element's `dateTime` so a crawler and a screen reader get a timestamp
- * whatever the visible reading says, and says in the prop's own note that a caller
- * who wants a relative phrase composes the node beside the record in `detail`. The
- * cost is named rather than hidden: a caller who passes epoch milliseconds gets epoch
- * milliseconds, which is honest and almost never what was wanted.
+ * `relative-time` already holds that decision: it formats the absolute reading with
+ * the platform and hands the sentence back. So this Block prints the caller's value,
+ * puts the ISO form on the `time` element's `dateTime` so a crawler and a screen
+ * reader get a timestamp whatever the visible reading says, and a caller who wants a
+ * relative phrase composes the node beside the record in `detail`.
+ *
+ * **A vertical arrangement's only spatial claim is order, and this Block draws no
+ * length.** There is no scale, no range, no bar and no axis: a bar's length is a
+ * claim about a difference between two caller moments, and time as an axis belongs
+ * to a screen that composes `Gantt01` or `Calendar01` instead. Append only is a
+ * rendering fact and nothing more: what is rendered is the entries it was handed, in
+ * the order it was handed, with no control that edits one, removes one or reorders
+ * one, and that absence is what append only means. What the Block cannot render is
+ * that the record is immutable, tamper evident, signed, sealed or retained, because
+ * a Block has no authority over the store behind it: so there is no `immutable`
+ * prop, no seal glyph and no verification mark, and no retention window, archive,
+ * purge, legal hold, export, freshness or as-of clock. A consumer whose domain
+ * requires one enforces it in its own store and shows what the store says.
  *
- * **A row is a control only when there is something for it to do.** An event with no
- * handler renders as a `li`, which is a record a reader reads and not a thing they
- * act on. The destination is a separate control carrying the caller's own words, so a
- * row can be selectable and linked at once, which is the arrangement a feed actually
- * wants: a reader activates the row to open the thing, and the caller marks it read on
- * the way past. The alternative was to make every row a link, and a feed of forty
- * links is a page where the tab order runs down the whole feed before it reaches
- * anything after it.
+ * **A row is a control only when there is something for it to do.** An event with
+ * no handler renders as a `li`, which is a record a reader reads and not a thing
+ * they act on. The destination is a separate control carrying the caller's own
+ * words, so a row can be selectable and linked at once, which is the arrangement a
+ * feed actually wants: a reader activates the row to open the thing, and the caller
+ * marks it read on the way past.
  *
  * **A day group is a list item holding a heading and a nested list, and not a merged
  * row.** The structure is an `ol` of `li` and each `li` is a heading plus its own
  * `ol`, because a reader moving by list item should hear how many days there are and
- * then how many records are in the day they are reading. The alternative was a table
- * with a row spanning every column, which is a table and not a feed, and which would
- * have given four unrelated fields column semantics they do not have. The day heading
- * is at `childLevel(headingLevel)`, so a feed embedded one level deeper carries its
- * outline with it, and the day groups themselves are not headings at the same level,
- * which is what makes a list of days a list rather than a flat run of headings.
- *
- * **The order is the caller's and the Block never sorts.** A feed is the surface
- * where the exceptions live: a pinned event, a run that arrived late, a record the
- * caller wants beside its own retry. A Block that sorted by moment would move the
- * pin, and the caller would have to add a flag and this Block would have to know what
- * the flag meant. The groups follow the order the days first appear, so a pinned
- * event from yesterday puts yesterday first, which is the only arrangement that
- * survives a pin.
+ * then how many records are in the day they are reading. The day heading is at
+ * `childLevel(headingLevel)`, so a feed embedded one level deeper carries its outline
+ * with it, and the groups follow the order the days first appear, so a pinned event
+ * from yesterday keeps yesterday where the caller put it.
  *
- * **The tone is a mark with a machine word beside it, and the cost is that word.** A
- * feed is a scanning surface, so the mark has to be there, and a mark that is colour
- * alone is invisible to a reader who cannot separate the tones and unreadable to a
- * screen reader whatever the tones are. So the tone is drawn by `Status` with the
- * machine value as its label, which is what `Changelog01` does with a change's kind
- * and the reason is the same: a tone is a judgement about urgency that only the
- * caller can make, and a Block that wrote the sentence for it would be picking an
- * alarm for four products at once. A caller whose product words these states
- * differently composes its own mark into `detail` and leaves `tone` unset. That is
- * the cost of the split, stated rather than hidden.
+ * **The order is the caller's and the Block never sorts, groups or aggregates.** A
+ * feed is the surface where the exceptions live: a pinned event, a run that arrived
+ * late, a record the caller wants beside its own retry. The day grouping is content
+ * rather than structure, a caller-supplied key with a caller-supplied label, and the
+ * Block owns no count, no rate and no elapsed figure. It owns no navigation and no
+ * address, so the only route out of an entry is the caller's `href`, and it holds no
+ * selection state, because a trail is read and the index holds the set a batch action
+ * acts on.
  *
  * It is a client Component, and the reason is the handler rather than the state, as
  * in `data-table-01`: `onSelect` is a function, a function is a piece of state, and
- * state is a client module. The cost is stated rather than implied: a feed with no
- * `onSelect` is a static list that ships this file's client runtime for nothing, and
- * the fix for a consumer who needs that surface to be static is a `ReactNode` slot of
- * their own rather than a Block that attaches a handler to every row.
+ * state is a client module.
  */
 export declare function ActivityFeed01({ eyebrow, title, description, events, onSelect, limit, empty, groupBy, dayLabel, headingLevel, className, }: ActivityFeed01Props): import("react").JSX.Element;
 export default ActivityFeed01;

package/dist/blocks/activity-feed-01/activity-feed-01.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"activity-feed-01.d.ts","sourceRoot":"","sources":["../../../src/blocks/activity-feed-01/activity-feed-01.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAGtC,OAAO,EAIL,KAAK,YAAY,EAClB,MAAM,6BAA6B,CAAA;AACpC,OAAO,EAAU,KAAK,UAAU,EAAE,MAAM,4BAA4B,CAAA;AAGpE;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,2EAA2E;IAC3E,EAAE,EAAE,MAAM,CAAA;IACV;;;;;;OAMG;IACH,KAAK,EAAE,MAAM,CAAA;IACb;;;;;;;OAOG;IACH,MAAM,EAAE,MAAM,CAAA;IACd;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;;;;;;;;;;;;;;;OAgBG;IACH,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;IACnB;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,SAAS,CAAA;IAClB;;;;;;;OAOG;IACH,IAAI,CAAC,EAAE,UAAU,CAAA;IACjB,qEAAqE;IACrE,IAAI,CAAC,EAAE,MAAM,CAAA;IACb;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAgCD;;;;;;;;GAQG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,+EAA+E;IAC/E,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,4EAA4E;IAC5E,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,4CAA4C;IAC5C,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;;;;;;OAQG;IACH,MAAM,EAAE,mBAAmB,EAAE,CAAA;IAC7B;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAA;IAC/B;;;;;;;;;OASG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IACd;;;;;;;OAOG;IACH,KAAK,EAAE,SAAS,CAAA;IAChB,+DAA+D;IAC/D,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,GAAG,CACA;IACE;;;;;;OAMG;IACH,OAAO,EAAE,KAAK,CAAA;IACd;;;;;;;;;OASG;IACH,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAA;CAClC,GACD;IACE,4DAA4D;IAC5D,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,KAAK,CAAA;CACjB,CACJ,CAAA;AAkHD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AACH,wBAAgB,cAAc,CAAC,EAC7B,OAAO,EACP,KAAK,EACL,WAAW,EACX,MAAM,EACN,QAAQ,EACR,KAAK,EACL,KAAK,EACL,OAAgB,EAChB,QAAQ,EACR,YAAmB,EACnB,SAAS,GACV,EAAE,mBAAmB,+BAmGrB;AAED,eAAe,cAAc,CAAA"}
+{"version":3,"file":"activity-feed-01.d.ts","sourceRoot":"","sources":["../../../src/blocks/activity-feed-01/activity-feed-01.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAGtC,OAAO,EAIL,KAAK,YAAY,EAClB,MAAM,6BAA6B,CAAA;AAEpC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AA4C/C;;;;;;;;GAQG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,+EAA+E;IAC/E,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,4EAA4E;IAC5E,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,4CAA4C;IAC5C,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,MAAM,EAAE,SAAS,EAAE,CAAA;IACnB;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;IAChC;;;;;;;;;OASG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IACd;;;;;;;OAOG;IACH,KAAK,EAAE,SAAS,CAAA;IAChB,+DAA+D;IAC/D,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,GAAG,CACA;IACE;;;;;;OAMG;IACH,OAAO,EAAE,KAAK,CAAA;IACd;;;;;;;;;;OAUG;IACH,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAA;CAClC,GACD;IACE,4DAA4D;IAC5D,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,KAAK,CAAA;CACjB,CACJ,CAAA;AAiHD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiFG;AACH,wBAAgB,cAAc,CAAC,EAC7B,OAAO,EACP,KAAK,EACL,WAAW,EACX,MAAM,EACN,QAAQ,EACR,KAAK,EACL,KAAK,EACL,OAAgB,EAChB,QAAQ,EACR,YAAmB,EACnB,SAAS,GACV,EAAE,mBAAmB,+BAkGrB;AAED,eAAe,cAAc,CAAA"}