@ponchia/ui 0.6.7 → 0.6.9

package/behaviors/tabs.js

@@ -1,4 +1,12 @@
-import { hasDom, resolveHost, noop, bindOnce, nextFieldUid, collectHosts } from './internal.js';
+import {
+  hasDom,
+  resolveHost,
+  noop,
+  bindOnce,
+  nextFieldUid,
+  collectHosts,
+  closestSafe,
+} from './internal.js';
 
 /**
  * Wire `[data-bronto-tabs]` groups for full keyboard a11y. The framework
@@ -24,6 +32,23 @@ export function initTabs({ root } = {}) {
   if (!host) return noop;
   const cleanups = [];
   const groups = collectHosts(host, '[data-bronto-tabs]');
+  const snapshotAttrs = (el, names) => {
+    const out = {};
+    for (const name of names) {
+      out[name] = {
+        had: el.hasAttribute(name),
+        value: el.getAttribute(name),
+      };
+    }
+    return out;
+  };
+  const restoreAttrs = (el, attrs) => {
+    for (const [name, attr] of Object.entries(attrs)) {
+      if (attr.had) el.setAttribute(name, attr.value);
+      else el.removeAttribute(name);
+    }
+  };
+
   for (const group of groups) {
     // Own group only — a tab/panel inside a nested [data-bronto-tabs]
     // belongs to that inner group, not this one.
@@ -31,20 +56,43 @@ export function initTabs({ root } = {}) {
     const tabs = [...group.querySelectorAll('.ui-tab')].filter(owned);
     const panels = [...group.querySelectorAll('.ui-tabs__panel')].filter(owned);
     if (!tabs.length) continue;
-    const list = group.querySelector('.ui-tabs__list');
-    if (list) list.setAttribute('role', 'tablist');
-
-    // APG: bind each tab to its panel (aria-controls) and back
-    // (aria-labelledby), minting stable ids only where absent.
-    for (const t of tabs) {
-      const p = panels.find((x) => x.dataset.panel === t.dataset.tab);
-      if (!p) continue;
-      const n = nextFieldUid();
-      if (!t.id) t.id = `bronto-tab-${n}`;
-      if (!p.id) p.id = `bronto-tabpanel-${n}`;
-      t.setAttribute('aria-controls', p.id);
-      p.setAttribute('aria-labelledby', t.id);
-    }
+    const list = [...group.querySelectorAll('.ui-tabs__list')].find(owned);
+    const rememberState = () => ({
+      list: list ? snapshotAttrs(list, ['role']) : null,
+      tabs: new Map(
+        tabs.map((tab) => [
+          tab,
+          {
+            active: tab.classList.contains('is-active'),
+            attrs: snapshotAttrs(tab, ['id', 'role', 'aria-selected', 'aria-controls', 'tabindex']),
+          },
+        ]),
+      ),
+      panels: new Map(
+        panels.map((panel) => [
+          panel,
+          {
+            hidden: panel.hidden,
+            attrs: snapshotAttrs(panel, ['id', 'role', 'aria-labelledby', 'tabindex']),
+          },
+        ]),
+      ),
+    });
+    const restoreState = (state) => {
+      if (list && state.list) restoreAttrs(list, state.list);
+      for (const tab of tabs) {
+        const tabState = state.tabs.get(tab);
+        if (!tabState) continue;
+        tab.classList.toggle('is-active', tabState.active);
+        restoreAttrs(tab, tabState.attrs);
+      }
+      for (const panel of panels) {
+        const panelState = state.panels.get(panel);
+        if (!panelState) continue;
+        panel.hidden = panelState.hidden;
+        restoreAttrs(panel, panelState.attrs);
+      }
+    };
 
     const select = (tab) => {
       for (const t of tabs) {
@@ -55,14 +103,14 @@ export function initTabs({ root } = {}) {
         t.tabIndex = on ? 0 : -1;
       }
       // Only retarget panels when this tab actually controls one. A panel-less
-      // tab must NOT hide every panel — leave the prior panel visible (C30).
+      // tab must not hide every panel; leave the prior panel visible.
       if (!panels.some((p) => p.dataset.panel === tab.dataset.tab)) return;
       for (const p of panels) {
         p.setAttribute('role', 'tabpanel');
         const shown = p.dataset.panel === tab.dataset.tab;
         p.hidden = !shown;
         // APG: a tabpanel is focusable so keyboard users can reach a text-only
-        // panel; hidden panels drop out of the tab order (C30).
+        // panel; hidden panels drop out of the tab order.
         if (shown) p.tabIndex = 0;
         else p.removeAttribute('tabindex');
       }
@@ -70,14 +118,15 @@ export function initTabs({ root } = {}) {
     const onClick = (e) => {
       // `tabs` is filtered to this group, so membership (not mere DOM
       // containment) is what isolates nested [data-bronto-tabs] groups.
-      const tab = e.target.closest('.ui-tab');
+      const tab = closestSafe(e.target, '.ui-tab');
       if (tab && tabs.includes(tab)) {
+        e.preventDefault();
         select(tab);
         tab.focus();
       }
     };
     const onKey = (e) => {
-      const i = tabs.indexOf(e.target.closest('.ui-tab'));
+      const i = tabs.indexOf(closestSafe(e.target, '.ui-tab'));
       if (i < 0) return;
       let n = i;
       if (e.key === 'ArrowRight' || e.key === 'ArrowDown') n = (i + 1) % tabs.length;
@@ -90,14 +139,29 @@ export function initTabs({ root } = {}) {
       select(tabs[n]);
       tabs[n].focus();
     };
-    select(tabs.find((t) => t.classList.contains('is-active')) || tabs[0]);
     cleanups.push(
       bindOnce(group, 'tabs', () => {
+        const state = rememberState();
+        if (list) list.setAttribute('role', 'tablist');
+
+        // APG: bind each tab to its panel (aria-controls) and back
+        // (aria-labelledby), minting stable ids only where absent.
+        for (const t of tabs) {
+          const p = panels.find((x) => x.dataset.panel === t.dataset.tab);
+          if (!p) continue;
+          const n = nextFieldUid();
+          if (!t.id) t.id = `bronto-tab-${n}`;
+          if (!p.id) p.id = `bronto-tabpanel-${n}`;
+          t.setAttribute('aria-controls', p.id);
+          p.setAttribute('aria-labelledby', t.id);
+        }
+        select(tabs.find((t) => t.classList.contains('is-active')) || tabs[0]);
         group.addEventListener('click', onClick);
         group.addEventListener('keydown', onKey);
         return () => {
           group.removeEventListener('click', onClick);
           group.removeEventListener('keydown', onKey);
+          restoreState(state);
         };
       }),
     );

package/behaviors/theme.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["theme.js"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AAEH;;;;;;;GAOG;AACH,wDAHW,cAAc,GACZ,IAAI,CAahB;AAED;;;;;;;;;;;;;;GAcG;AACH,uDAHW,gBAAgB,GAAG,OAAO,eAAe,EAAE,YAAY,GACrD,OAAO,eAAe,EAAE,OAAO,CAmD3C;;;;;;;;;;6BA5FY,gBAAgB,GAAG;IAAE,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE;;;;;WAIpC,OAAO,GAAG,MAAM"}
+{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["theme.js"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AAEH;;;;;;;GAOG;AACH,wDAHW,cAAc,GACZ,IAAI,CAahB;AAED;;;;;;;;;;;;;;GAcG;AACH,uDAHW,gBAAgB,GAAG,OAAO,eAAe,EAAE,YAAY,GACrD,OAAO,eAAe,EAAE,OAAO,CAuE3C;;;;;;;;;;6BAhHY,gBAAgB,GAAG;IAAE,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE;;;;;WAIpC,OAAO,GAAG,MAAM"}

package/behaviors/theme.js

@@ -1,4 +1,4 @@
-import { hasDom, resolveHost, noop, bindOnce, collectHosts } from './internal.js';
+import { hasDom, resolveHost, noop, bindOnce, collectHosts, closestSafe } from './internal.js';
 
 const THEMES = ['light', 'dark'];
 
@@ -53,7 +53,18 @@ export function initThemeToggle({ storageKey = 'bronto-theme', root } = {}) {
   if (!hasDom()) return noop;
   const host = resolveHost(root);
   if (!host) return noop;
-  const docEl = document.documentElement;
+  const doc = host.nodeType === 9 ? host : host.ownerDocument || document;
+  const docEl = doc.documentElement;
+  const toggleStates = new Map();
+
+  const rememberToggle = (el) => {
+    if (!toggleStates.has(el)) {
+      toggleStates.set(el, {
+        had: el.hasAttribute('aria-pressed'),
+        value: el.getAttribute('aria-pressed'),
+      });
+    }
+  };
 
   const prefersDark = () =>
     typeof matchMedia === 'function' && matchMedia('(prefers-color-scheme: dark)').matches;
@@ -67,6 +78,7 @@ export function initThemeToggle({ storageKey = 'bronto-theme', root } = {}) {
   const reflect = () => {
     const c = current();
     collectHosts(host, '[data-bronto-theme-toggle]').forEach((el) => {
+      rememberToggle(el);
       const forced = el.getAttribute('data-bronto-theme-toggle');
       // A forced control is "pressed" when its theme is the active one;
       // a plain toggle reflects whether dark is active.
@@ -76,8 +88,9 @@ export function initThemeToggle({ storageKey = 'bronto-theme', root } = {}) {
   };
 
   const onClick = (e) => {
-    const trigger = e.target.closest('[data-bronto-theme-toggle]');
+    const trigger = closestSafe(e.target, '[data-bronto-theme-toggle]');
     if (!trigger || !host.contains(trigger)) return;
+    e.preventDefault();
     const forced = trigger.getAttribute('data-bronto-theme-toggle');
     const next = THEMES.includes(forced) ? forced : current() === 'dark' ? 'light' : 'dark';
     docEl.setAttribute('data-theme', next);
@@ -92,10 +105,17 @@ export function initThemeToggle({ storageKey = 'bronto-theme', root } = {}) {
     );
   };
 
-  applyStoredTheme({ storageKey });
+  applyStoredTheme({ storageKey, root: docEl });
   reflect();
   return bindOnce(host, 'themeToggle', () => {
     host.addEventListener('click', onClick);
-    return () => host.removeEventListener('click', onClick);
+    return () => {
+      host.removeEventListener('click', onClick);
+      for (const [el, state] of toggleStates) {
+        if (state.had) el.setAttribute('aria-pressed', state.value);
+        else el.removeAttribute('aria-pressed');
+      }
+      toggleStates.clear();
+    };
   });
 }

package/behaviors/toast.js

@@ -3,7 +3,7 @@ import { hasDom, noop } from './internal.js';
 // The tones that have a `.ui-toast--*` rule. The TS type already unions these,
 // but a plain-JS / LLM caller can pass any string — and an unknown tone built a
 // `.ui-toast--error` class that matches no CSS, yielding a silent neutral toast.
-// Validate so an unknown tone degrades to neutral *and warns*, never lies. (C16)
+// Validate so an unknown tone degrades to neutral *and warns*, never lies.
 const TOAST_TONES = new Set(['accent', 'success', 'warning', 'danger', 'info']);
 
 // First-toast deferral queue. The very first toast on a brand-new stack
@@ -29,7 +29,7 @@ function toastStack(isAssertive) {
       stack.setAttribute('role', 'alert');
       // The assertive region carries one error at a time and must be read whole;
       // aria-atomic ensures the full toast (title + message) announces, not just
-      // the diff. (component audit C38.)
+      // the changed fragment.
       stack.setAttribute('aria-atomic', 'true');
     }
     document.body.appendChild(stack);
@@ -67,7 +67,7 @@ function toastElement(message, { tone, title }) {
   // aria-atomic so a *titled* toast announces title + message as one unit, not
   // disjointly — and unlike aria-atomic on the polite STACK (which would re-read
   // every resident toast on each new one), scoping it to the toast keeps sibling
-  // toasts out of the announcement. (component audit C23.)
+  // toasts out of the announcement.
   el.setAttribute('aria-atomic', 'true');
   if (title) {
     const t = document.createElement('p');
@@ -183,8 +183,8 @@ export function toast(message, { tone, title, duration = 4000, assertive, closab
   // `closable`. The button carries no text node (glyph is a CSS
   // ::before) so the toast's announced/textContent stays the message.
   // Explicitly opting OUT of the close button on a sticky toast strands it with
-  // no in-UI dismissal — warn that the caller must retain and call the returned
-  // dismiss fn. (component audit C37.)
+  // no in-UI dismissal; warn that the caller must retain and call the returned
+  // dismiss function.
   if (duration === 0 && closable === false && typeof console !== 'undefined') {
     console.warn(
       '[bronto] toast(): duration:0 + closable:false has no in-UI dismissal — keep the returned dismiss() and call it yourself, or set closable:true.',

package/classes/index.d.ts

@@ -959,9 +959,22 @@ export interface ValueAttrs {
   'aria-valuemax': number;
   style: { '--value': number };
 }
+export interface MeterValueAttrs extends ValueAttrs {
+  role: 'meter';
+}
+export interface ProgressValueAttrs extends ValueAttrs {
+  role: 'progressbar';
+}
+export interface IndeterminateProgressAttrs {
+  role: 'progressbar';
+  'aria-busy': 'true';
+}
 export interface Attrs {
-  meter(value: number, opts?: ValueRangeOpts): ValueAttrs;
-  progress(value: number, opts?: ValueRangeOpts): ValueAttrs;
+  meter(value: number, opts?: ValueRangeOpts): MeterValueAttrs;
+  progress(value: number, opts?: ValueRangeOpts): ProgressValueAttrs;
+  progress(value?: undefined, opts?: ValueRangeOpts): IndeterminateProgressAttrs;
+  dotbar(value: number, opts?: ValueRangeOpts): ProgressValueAttrs;
+  dotbar(value?: undefined, opts?: ValueRangeOpts): IndeterminateProgressAttrs;
 }
 /** Set the painted value AND its ARIA together so they cannot drift. */
 export declare const attrs: Attrs;

package/classes/index.js

@@ -212,7 +212,7 @@ export const cls = Object.freeze({
   tableLined: 'ui-table--lined',
   tableBreakAnywhere: 'ui-table--break-anywhere',
   tableWrap: 'ui-table-wrap',
-  // Loading state goes on the WRAP, so the modifier is named for the wrap (C19).
+  // Loading state goes on the wrap, so the modifier is named for the wrap.
   tableLoading: 'ui-table-wrap--loading',
   tableEmpty: 'ui-table__empty',
   tableSort: 'ui-table__sort',
@@ -467,7 +467,6 @@ export const cls = Object.freeze({
   crosshairLineX: 'ui-crosshair__line--x',
   crosshairLineY: 'ui-crosshair__line--y',
   crosshairBadge: 'ui-crosshair__badge',
-  readout: 'ui-readout',
   // selection-state vocabulary (cross-cutting — css/selection.css)
   sel: 'ui-sel',
   selOn: 'ui-sel--on',
@@ -740,14 +739,14 @@ const srcTone = (state) =>
   })[state] || '';
 
 // Component tone → modifier class. Same object-literal idiom as srcTone/stateTone
-// (still grep-by-class-name; the modifier set differs per component). (Q9.)
+// while keeping modifier classes grep-friendly.
 //
 // The set differs PER COMPONENT on purpose — `muted` is a badge/num tone, not an
 // alert/toast/meter/dot one — so a caller extrapolating a universal tone (e.g.
 // `ui.alert({ tone: 'muted' })`) used to get a silent no-op: a bare, untoned
 // element with no signal that the tone was dropped. Warn at dev time instead, so
 // that "validates-but-no-ops" trap is loud rather than invisible. An omitted tone
-// is fine (returns no modifier). (component audit C12.)
+// is fine and returns no modifier.
 const toneClass = (component, map, tone) => {
   if (tone == null) return '';
   const hit = map[tone];
@@ -853,6 +852,43 @@ const claimStatus = (status) =>
     status,
   );
 
+const valueClass = (map, value) => (value == null ? '' : map[value] || '');
+
+const annotationVariants = Object.freeze({
+  label: cls.annotationLabelVariant,
+  callout: cls.annotationCallout,
+  elbow: cls.annotationElbow,
+  curve: cls.annotationCurve,
+  circle: cls.annotationCircle,
+  rect: cls.annotationRect,
+  threshold: cls.annotationThreshold,
+  badge: cls.annotationBadgeVariant,
+  bracket: cls.annotationBracket,
+  band: cls.annotationBand,
+  slope: cls.annotationSlope,
+  compare: cls.annotationCompare,
+  cluster: cls.annotationCluster,
+  axis: cls.annotationAxis,
+  timeline: cls.annotationTimeline,
+  evidence: cls.annotationEvidence,
+});
+
+const annotationTones = Object.freeze({
+  accent: cls.annotationAccent,
+  muted: cls.annotationMuted,
+  success: cls.annotationSuccess,
+  warning: cls.annotationWarning,
+  danger: cls.annotationDanger,
+  info: cls.annotationInfo,
+});
+
+const annotationMotions = Object.freeze({
+  draw: cls.annotationDraw,
+  pulse: cls.annotationPulse,
+  reveal: cls.annotationReveal,
+  focus: cls.annotationFocus,
+});
+
 export const ui = {
   button: ({ variant, icon, size } = {}) =>
     j(
@@ -928,7 +964,7 @@ export const ui = {
     j(
       cls.legendSwatch,
       // Series 1–8 map to ui-legend__swatch--N; the explicit bounds-check keeps a
-      // 0/9/non-integer from coining a class the stylesheet never defines. (Q9.)
+      // 0/9/non-integer from coining a class the stylesheet never defines.
       Number.isInteger(series) && series >= 1 && series <= 8 && cls[`legendSwatch${series}`],
       shape === 'circle' && cls.legendSwatchCircle,
       shape === 'line' && cls.legendSwatchLine,
@@ -936,32 +972,9 @@ export const ui = {
   annotation: ({ variant = 'callout', tone = 'accent', motion } = {}) =>
     j(
       cls.annotation,
-      variant === 'label' && cls.annotationLabelVariant,
-      variant === 'callout' && cls.annotationCallout,
-      variant === 'elbow' && cls.annotationElbow,
-      variant === 'curve' && cls.annotationCurve,
-      variant === 'circle' && cls.annotationCircle,
-      variant === 'rect' && cls.annotationRect,
-      variant === 'threshold' && cls.annotationThreshold,
-      variant === 'badge' && cls.annotationBadgeVariant,
-      variant === 'bracket' && cls.annotationBracket,
-      variant === 'band' && cls.annotationBand,
-      variant === 'slope' && cls.annotationSlope,
-      variant === 'compare' && cls.annotationCompare,
-      variant === 'cluster' && cls.annotationCluster,
-      variant === 'axis' && cls.annotationAxis,
-      variant === 'timeline' && cls.annotationTimeline,
-      variant === 'evidence' && cls.annotationEvidence,
-      tone === 'accent' && cls.annotationAccent,
-      tone === 'muted' && cls.annotationMuted,
-      tone === 'success' && cls.annotationSuccess,
-      tone === 'warning' && cls.annotationWarning,
-      tone === 'danger' && cls.annotationDanger,
-      tone === 'info' && cls.annotationInfo,
-      motion === 'draw' && cls.annotationDraw,
-      motion === 'pulse' && cls.annotationPulse,
-      motion === 'reveal' && cls.annotationReveal,
-      motion === 'focus' && cls.annotationFocus,
+      valueClass(annotationVariants, variant),
+      valueClass(annotationTones, tone),
+      valueClass(annotationMotions, motion),
     ),
   mark: ({ style, tone, motion } = {}) =>
     j(
@@ -1050,7 +1063,7 @@ export const ui = {
 // UNITLESS `--value` (0–100) and AT needs role + aria-valuenow/min/max. This sets
 // the painted value and its announced value together so they can't drift, and
 // normalizes an arbitrary {min,max} to the 0–100 `--value` the CSS expects while
-// keeping aria-valuenow in the caller's real units. (component audit C8.)
+// keeping aria-valuenow in the caller's real units.
 // `busyWhenIndeterminate` — a progressbar advertises aria-busy when its value is
 // unknown; a meter is never indeterminate so it passes false. (Kept a boolean
 // flag rather than testing the role string, so check:recipe-types doesn't read it
@@ -1065,7 +1078,7 @@ const valueAttrs = (role, value, min, max, busyWhenIndeterminate) => {
   // advertises aria-busy; a meter has no indeterminate state, so a non-finite
   // value there is a caller error we still fail safe on by omitting the
   // misleading 0. Pair with `ui.progress({ indeterminate: true })` for the CSS
-  // sweep. (component audit C9.)
+  // sweep.
   if (!Number.isFinite(raw)) {
     return busyWhenIndeterminate ? { role, 'aria-busy': 'true' } : { role };
   }
@@ -1087,13 +1100,13 @@ const valueAttrs = (role, value, min, max, busyWhenIndeterminate) => {
  *   </div>
  * `value` is in your own units; pass `{ min, max }` (default 0–100) and the
  * `--value` width is normalized for you. Call `attrs.progress()` with no value
- * for an indeterminate bar (omits aria-valuenow, sets aria-busy). (audit C9.)
+ * for an indeterminate bar (omits aria-valuenow, sets aria-busy).
  *
  * `attrs.dotbar(value)` is the segmented analogue of `attrs.progress`: a
  * determinate `.ui-dotbar` carries the same progress data as `.ui-progress` but,
  * without this, was eight empty `<span>`s to AT (the segments are decorative —
  * mark them `aria-hidden`). Same progressbar role + aria-valuenow/min/max;
- * call with no value for the indeterminate sweep. (component audit C10.)
+ * call with no value for the indeterminate sweep.
  */
 export const attrs = Object.freeze({
   meter: (value, { min = 0, max = 100 } = {}) => valueAttrs('meter', value, min, max, false),

package/connectors/index.d.ts

@@ -1,9 +1,42 @@
-export function finite(name: any, value: any, fallback: any): any;
-export function dimension(name: any, value: any, fallback: any): any;
-export function roundNumber(value: any): number;
-export function fmt(value: any): string;
-export function point(x: any, y: any): string;
-export function clamp(value: any, min: any, max: any): any;
+/**
+ * Resolve a numeric option with an optional fallback.
+ * @param {string} name
+ * @param {number | null | undefined} value
+ * @param {number | null | undefined} [fallback]
+ * @returns {number}
+ */
+export function finite(name: string, value: number | null | undefined, fallback?: number | null | undefined): number;
+/**
+ * Resolve a non-negative numeric option with an optional fallback.
+ * @param {string} name
+ * @param {number | null | undefined} value
+ * @param {number | null | undefined} [fallback]
+ * @returns {number}
+ */
+export function dimension(name: string, value: number | null | undefined, fallback?: number | null | undefined): number;
+/**
+ * @param {number} value
+ * @returns {number}
+ */
+export function roundNumber(value: number): number;
+/**
+ * @param {number} value
+ * @returns {string}
+ */
+export function fmt(value: number): string;
+/**
+ * @param {number} x
+ * @param {number} y
+ * @returns {string}
+ */
+export function point(x: number, y: number): string;
+/**
+ * @param {number} value
+ * @param {number} min
+ * @param {number} max
+ * @returns {number}
+ */
+export function clamp(value: number, min: number, max: number): number;
 /**
  * A point on a rect's edge (or centre). `rect` is `{ x, y, width, height }`.
  * @param {Rect} rect
@@ -70,8 +103,8 @@ export function arrowHead(p: Point, angle: number, size?: number, spread?: numbe
 export function dotMark(p: Point, radius?: number): string;
 /**
  * An axis-aligned rectangle path from its corners (callers derive the corners
- * from a centre or a top-left as they need). Shared by the annotation
- * rect/band and evidence-marker subjects. (code-quality audit Q5.)
+ * from a centre or a top-left as they need). Shared by annotation rect/band
+ * and evidence-marker subjects.
  * @param {number} left
  * @param {number} top
  * @param {number} right

package/connectors/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":"AAkDA,kEAIC;AAED,qEAIC;AAKD,gDAGC;AAED,wCAEC;AAED,8CAEC;AAID,2DAGC;AAED;;;;;GAKG;AACH,kCAJW,IAAI,SACJ,IAAI,GACF,KAAK,CAoBjB;AAED;;;;;GAKG;AACH,mCAJW,KAAK,MACL,KAAK,GACH,MAAM,CAOlB;AAED;;;;;GAKG;AACH,mCAJW,KAAK,MACL,KAAK,GACH,MAAM,CAOlB;AAED;;;;;;GAMG;AACH,gCALW,KAAK,MACL,KAAK,SACL;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GACd,MAAM,CAgBlB;AAED;;;;;;GAMG;AACH,gCALW,KAAK,MACL,KAAK,SACL;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GACpB,MAAM,CAclB;AAED;;;;GAIG;AACH,qCAHW,oBAAoB,GAClB,MAAM,CAOlB;AAED;;;;;;;;GAQG;AACH,6BAPW,KAAK,SACL,MAAM,SACN,MAAM,WACN,MAAM,GAEJ,MAAM,CAalB;AAED;;;;;GAKG;AACH,2BAJW,KAAK,WACL,MAAM,GACJ,MAAM,CAUlB;AAED;;;;;;;;;GASG;AACH,+BANW,MAAM,OACN,MAAM,SACN,MAAM,UACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;GAKG;AACH,oCAJW,IAAI,UACJ,IAAI,GACF;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,EAAE,EAAE,IAAI,CAAA;CAAE,CAWpC;AAED;;;;;;;;GAQG;AACH,sCALW,KAAK,MACL,KAAK,UACL,cAAc,GACZ,MAAM,CAQlB;AAED;;;;;;GAMG;AACH,oCAHW,mBAAmB,GACjB,kBAAkB,CAW9B;AAvSD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAMH,wBAAyB,IAAI,CAAC;oBAhCjB;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE;mBACxB;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE;mBACvD,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,GAAG,QAAQ;6BAC9C,UAAU,GAAG,OAAO,GAAG,OAAO;;UAG7B,KAAK;QACL,KAAK;;;;;;;;;;;;cAML,IAAI;YACJ,IAAI;;;;;;;;;;;;;;OAQJ,MAAM;UACN,KAAK;QACL,KAAK;;;;WACL,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":"AAiDA;;;;;;GAMG;AACH,6BALW,MAAM,SACN,MAAM,GAAG,IAAI,GAAG,SAAS,aACzB,MAAM,GAAG,IAAI,GAAG,SAAS,GACvB,MAAM,CAMlB;AAED;;;;;;GAMG;AACH,gCALW,MAAM,SACN,MAAM,GAAG,IAAI,GAAG,SAAS,aACzB,MAAM,GAAG,IAAI,GAAG,SAAS,GACvB,MAAM,CAMlB;AAID;;;GAGG;AACH,mCAHW,MAAM,GACJ,MAAM,CAKlB;AAED;;;GAGG;AACH,2BAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,yBAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAIlB;AAGD;;;;;GAKG;AACH,6BALW,MAAM,OACN,MAAM,OACN,MAAM,GACJ,MAAM,CAKlB;AAqBD;;;;;GAKG;AACH,kCAJW,IAAI,SACJ,IAAI,GACF,KAAK,CAoBjB;AAED;;;;;GAKG;AACH,mCAJW,KAAK,MACL,KAAK,GACH,MAAM,CAOlB;AAED;;;;;GAKG;AACH,mCAJW,KAAK,MACL,KAAK,GACH,MAAM,CAOlB;AAED;;;;;;GAMG;AACH,gCALW,KAAK,MACL,KAAK,SACL;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GACd,MAAM,CAgBlB;AAED;;;;;;GAMG;AACH,gCALW,KAAK,MACL,KAAK,SACL;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GACpB,MAAM,CAclB;AAED;;;;GAIG;AACH,qCAHW,oBAAoB,GAClB,MAAM,CAQlB;AAED;;;;;;;;GAQG;AACH,6BAPW,KAAK,SACL,MAAM,SACN,MAAM,WACN,MAAM,GAEJ,MAAM,CAalB;AAED;;;;;GAKG;AACH,2BAJW,KAAK,WACL,MAAM,GACJ,MAAM,CAUlB;AAED;;;;;;;;;GASG;AACH,+BANW,MAAM,OACN,MAAM,SACN,MAAM,UACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;GAKG;AACH,oCAJW,IAAI,UACJ,IAAI,GACF;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,EAAE,EAAE,IAAI,CAAA;CAAE,CAWpC;AAED;;;;;;;;GAQG;AACH,sCALW,KAAK,MACL,KAAK,UACL,cAAc,GACZ,MAAM,CASlB;AAED;;;;;;GAMG;AACH,oCAHW,mBAAmB,GACjB,kBAAkB,CAe9B;AA9VD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAKH,wBAAyB,IAAI,CAAC;oBA/BjB;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE;mBACxB;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE;mBACvD,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,GAAG,QAAQ;6BAC9C,UAAU,GAAG,OAAO,GAAG,OAAO;;UAG7B,KAAK;QACL,KAAK;;;;;;;;;;;;cAML,IAAI;YACJ,IAAI;;;;;;;;;;;;;;OAQJ,MAAM;UACN,KAAK;QACL,KAAK;;;;WACL,MAAM"}