@twobirds/microcomponents 0.2.0 → 0.2.2

package/dist/state/observables.js

@@ -1,108 +1,61 @@
 /**
-@module Observables
-
-
-This module provides reactive data binding capabilities using observables,
-enabling automatic DOM updates when underlying data changes.
-
-## Overview
-
-The observable system allows you to make object properties "observable" so that
-registered callbacks are automatically invoked whenever those properties change.
-It's particularly designed for reactive templating and binding data to HTML elements.
-It can also handle simple object properties like strings, boolean and numbers.
-
-## How `observe()` Works
-
-The main function is {@link observe}, which takes an object and makes its properties
-or a specific property observable.
+Reactive data binding via observables — object properties trigger callbacks and update
+DOM placeholders automatically when their values change. Supports primitives, nested objects,
+and deep-change detection with debounced notifications. Most likely you will only need the first
+variant of the examples below
 
-### Simple properties
+@module Observables
 
-javascript
-```js
-let person = { name: "John", count: 0 };
+@example Plugin — chainable instance methods on DC components
+```ts
+import { DC, defineCE, observePlugin } from '@twobirds/microcomponents';
 
-observe( person ); // all properties inside are now observables
+observePlugin(DC);
 
-person.name.subscribe( (name) => {
-  console.log("Name changed:", name);
-});
+class Counter extends DC {
+    data = { clicks: 1 };
 
-person.count.subscribe( (count) => {
-  console.log("Count changed:", count);
-});
+    oneAssets() {
+        this
+        .subscribe('data', (v) => console.log('data →', v))
+        .bind('data', this.target);
+    }
+}
 
-person.name = "Jane";  // > Name changed: Jane
-person.count += 10;    // > Count changed: 10
+defineCE('mc-counter', Counter);
 ```
 
-### Deep Change Detection
-
-This means that if you modify any of the properties inside an observed object -> all callbacks are triggered.
-
-javascript
-```js
-let obj = { data: { name: "John", count: 0 } };
-
-observe( obj, 'data' ); // make the data property observable
-
-obj.data.subscribe( (data) => {
-  console.log("Data changed:", data);
-});
+@example Basic observe + subscribe on a plain object
+```ts
+import { observe } from '@twobirds/microcomponents';
 
-obj.data.name = "Jane"; // > { data: { name: "Jane", count: 0 } }
-obj.data.count += 10;   // > { data: { name: "Jane", count: 10 } }
+const state = observe({ count: 0, label: 'hi' });
+state.count.subscribe((v) => console.log('count is now', v));
+state.count++; // triggers the callback
 ```
 
-### Debounced Notifications
-
-To prevent excessive updates, notifications are debounced briefly:
+@example Deep change detection on a nested property
+```ts
+import { observe } from '@twobirds/microcomponents';
 
-javascript
-```js
-let obj = observe({ value: 1 });
-for (let i = 0; i < 100; i++) {
-  obj.value++; // Only triggers one callback after all changes complete
-}
+const state = observe({ data: { name: 'John', age: 30 } });
+state.data.subscribe((d) => console.log('data changed:', d));
+state.data.name = 'Jane'; // triggers callback with updated object
 ```
 
-## DOM Binding with Placeholders
-
-The observables integrate tightly with placeholder-based templating:
-
-- Elements with `{placeholder}` syntax are scanned for observable data.
-- When observed data changes, matching placeholders in the DOM are updated automatically.
-
-@example
+@example DOM binding — placeholder tokens update live
+```ts
+import { observe } from '@twobirds/microcomponents';
 
-HTML
-```html
-<div class="model {visibility}">
-  Hello {name}! You have {count} messages.
-</div>
+const state = observe({ user: { name: 'Alice', count: 0 } });
+state.user.bind(document.querySelector('.model'));
+// <span>{user.name}</span> updates automatically when state.user.name changes
 ```
 
-Javascript
-```js
-const div = document.querySelector('.model');
-
-const model = observe({
-  data: { name: "Alice", count: 0 },
-  visibility: ''
-});
-
-if (div) {
-  model.data.bind( div );
-}
-
-model.data.count++; // Automatically updates the DOM with new count value
-model.visibility = 'hidden'; // adds the hidden class to the DOM element
-```
 */
 import { flattenObject, deepEqual, copyGettersSetters, isBrowser } from '../utils/helpers.js';
 import { makePlaceholders } from './placeholders.js';
-import { trigger } from '../core/events.js';
+import { trigger } from '../utils/events.js';
 /**
 Determines if a value is an observable object.
 
@@ -380,3 +333,90 @@ export function observe(target, propertyName) {
     });
     return target;
 }
+/**
+Attaches convenience methods `notify()`, `subscribe()`, and `bind()` to the prototype of a
+microcomponent class so that observable properties can be controlled directly on the instance.
+
+All three methods return the component instance, so you can chain them fluently.
+
+Call it once at module level before defining any component classes. The plugin is idempotent —
+subsequent calls are no-ops.
+
+@param Class - A constructor function whose prototype chain includes {@link McBase}.
+
+@example
+```ts
+class Counter extends DC {
+    data = { clicks: 1 };
+
+    oneAssets() {
+        this
+        .subscribe('data', (v) => console.log('data →', v))
+        .bind('data', this.target);
+    }
+}
+```
+*/
+export function observePlugin(Class) {
+    const McBaseProto = Object.getPrototypeOf(Class.prototype);
+    function makePropObservable(obj, propName) {
+        const obs = obj[propName];
+        if (!isAlreadyObserved(obs)) {
+            observe(obj, propName);
+        }
+    }
+    if (!Object.hasOwn(McBaseProto, 'notify')) {
+        Object.assign(McBaseProto, {
+            /**
+* Manually trigger a notification on an observable property.
+* Ensures the property is observed first if it hasn't been yet.
+* @param propName - The name of the observable property to notify.
+* @returns This instance for chaining.
+
+@example
+```ts
+this.notify('count');
+```
+            */
+            notify: function (propName) {
+                makePropObservable(this, propName);
+                this[propName].notify();
+                return this; // chainable
+            },
+            /**
+* Subscribe a callback to changes on an observable property.
+* Ensures the property is observed first if it hasn't been yet.
+* @param propName - The name of the observable property.
+* @param callback - Function invoked with the new value on every change.
+* @returns This instance for chaining.
+
+@example
+```ts
+this.subscribe('count', (v) => console.log('count →', v));
+```
+            */
+            subscribe: function (propName, callback) {
+                makePropObservable(this, propName);
+                this[propName].subscribe(callback);
+                return this; // chainable
+            },
+            /**
+* Bind an observable property to a DOM target so that `{placeholder}` tokens are updated live.
+* Ensures the property is observed first if it hasn't been yet.
+* @param propName - The name of the observable property.
+* @param target - HTMLElement, ShadowRoot, or DocumentFragment containing placeholders.
+* @returns This instance for chaining.
+
+@example
+```ts
+this.bind('data', this.target);
+```
+            */
+            bind: function (propName, target) {
+                makePropObservable(this, propName);
+                this[propName].bind(target);
+                return this; // chainable
+            },
+        });
+    }
+}

package/dist/utils/autoload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autoload.d.ts","sourceRoot":"","sources":["../../src/utils/autoload.ts"],"names":[],"mappings":"AAAA;;;;;;;;;EASE;AAoJF;;;;;;;;;;;;EAYE;AACF,MAAM,WAAW,QAAQ;IACxB;;;;;;;;;;;;;IAaG;IACH,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC;IAC5B;;;;;IAKG;IACH,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACnB;AAED,OAAO,CAAC,MAAM,CAAC;IACd,UAAU,MAAM;QACf,QAAQ,CAAC,EAAE,QAAQ,CAAC;KACpB;CACD;AAID,eAAO,MAAM,QAAQ,EAAE,QAuBtB,CAAC"}

package/dist/{core → utils}/autoload.js

@@ -8,8 +8,8 @@ side-effect-bearing DOM machinery (`MutationObserver`, script injection):
 importing `DC`/`MC` never pulls a DOM observer into the bundle unless
 {@link autoload} itself is imported.
 */
-import { DC } from './MC.js';
-import { isMcDOM } from './mcGuards.js';
+import { DC } from '../core/MC.js';
+import { isMcDOM } from '../core/mcGuards.js';
 const loadingDCs = new Set();
 /**
 Creates a closure that attaches DOM elements with the specified tag name to

package/dist/{core → utils}/events.d.ts

@@ -57,6 +57,7 @@ off( grandParent, 'dataReady', grandParentHandler );
 ```
 */
 import type { BubbleDirections, McBubbleController, McEventHandler } from '../types/mcTypes.js';
+export type { BubbleDirections } from '../types/mcTypes.js';
 /**
  * Converts a standard event name to its microcomponent-prefixed variant.
  *
@@ -71,6 +72,27 @@ import type { BubbleDirections, McBubbleController, McEventHandler } from '../ty
  * ```
  */
 export declare function getMcEventName(eventName: string): string;
+/**
+ * Returns the correct event name to listen for on a DOM element.
+ *
+ * If `eventName` (case-insensitive) matches a native HTML event handler property
+ * (`'on' + eventName.toLowerCase()`) on the target, returns the lowercase native
+ * name so that standard DOM events like `'click'` are listened to correctly.
+ * Otherwise, prefixes with `_mc` for microcomponent custom events.
+ *
+ * @hidden
+ * @param target - The DOM element whose native event support is checked.
+ * @param eventName - The event name as provided by the caller (e.g., `'click'`, `'Update'`).
+ * @returns The resolved event name: lowercase native or `_mc`-prefixed custom.
+ *
+ * @example
+ * ```ts
+ * const btn = document.createElement('button');
+ * trueEventName(btn, 'Click');   // 'click'  — native handler exists
+ * trueEventName(btn, 'Update');  // '_mcUpdate' — custom event
+ * ```
+ */
+export declare function trueEventName(target: HTMLElement, eventName: string): string;
 /**
  * A query selector string used to match one or more DOM elements.
  *

package/dist/utils/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/utils/events.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyDE;AAIF,OAAO,KAAK,EACX,gBAAgB,EAChB,kBAAkB,EAElB,cAAc,EACd,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAExD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAK5E;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC;AAEzC;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,YAAY,GAAG,WAAW,GAAG,mBAAmB,GAAG,SAAS,GAAG,IAAI,CAAC;AAEhF;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,GAAG,CAAC,CAAC,GAAG,OAAO,EAC9B,MAAM,EAAE,YAAY,EACpB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,GACxB,IAAI,CAAC;AACR,wBAAgB,GAAG,CAClB,MAAM,EAAE,YAAY,EACpB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,kCAAkC,GACzC,IAAI,CAAC;AA0BR;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,EAAE,CAAC,CAAC,GAAG,OAAO,EAC7B,MAAM,EAAE,YAAY,EACpB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,EAC1B,IAAI,CAAC,EAAE,OAAO,GACZ,cAAc,CAAC,CAAC,CAAC,CAAC;AACrB,wBAAgB,EAAE,CACjB,MAAM,EAAE,YAAY,EACpB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,kCAAkC,EAC3C,IAAI,CAAC,EAAE,OAAO,GACZ,kCAAkC,CAAC;AA8BtC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,GAAG,CAAC,CAAC,GAAG,OAAO,EAC9B,MAAM,EAAE,YAAY,EACpB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,GACxB,cAAc,CAAC,CAAC,CAAC,CAAC;AACrB,wBAAgB,GAAG,CAClB,MAAM,EAAE,YAAY,EACpB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,kCAAkC,GACzC,kCAAkC,CAAC;AAsBtC;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,gBAAiB,YAAW,kBAAkB;IAC1D,OAAO,UAAS;;IAEhB;;;;;;;;;;;;;;;OAeG;IACH,IAAI;CAGJ;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,OAAO,CAAC,CAAC,GAAG,OAAO,EAClC,MAAM,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,EAC/C,KAAK,EAAE,MAAM,EACb,IAAI,GAAE,CAAW,EACjB,MAAM,GAAE,gBAAsB,EAAE,wBAAwB;AACxD,UAAU,CAAC,EAAE,gBAAgB,QA+C7B"}

package/dist/{core → utils}/events.js

@@ -57,7 +57,6 @@ off( grandParent, 'dataReady', grandParentHandler );
 ```
 */
 'use strict';
-import { trueEventName } from '../utils/helpers.js';
 /**
  * Converts a standard event name to its microcomponent-prefixed variant.
  *
@@ -74,6 +73,32 @@ import { trueEventName } from '../utils/helpers.js';
 export function getMcEventName(eventName) {
     return '_mc' + eventName[0].toUpperCase() + eventName.substring(1);
 }
+/**
+ * Returns the correct event name to listen for on a DOM element.
+ *
+ * If `eventName` (case-insensitive) matches a native HTML event handler property
+ * (`'on' + eventName.toLowerCase()`) on the target, returns the lowercase native
+ * name so that standard DOM events like `'click'` are listened to correctly.
+ * Otherwise, prefixes with `_mc` for microcomponent custom events.
+ *
+ * @hidden
+ * @param target - The DOM element whose native event support is checked.
+ * @param eventName - The event name as provided by the caller (e.g., `'click'`, `'Update'`).
+ * @returns The resolved event name: lowercase native or `_mc`-prefixed custom.
+ *
+ * @example
+ * ```ts
+ * const btn = document.createElement('button');
+ * trueEventName(btn, 'Click');   // 'click'  — native handler exists
+ * trueEventName(btn, 'Update');  // '_mcUpdate' — custom event
+ * ```
+ */
+export function trueEventName(target, eventName) {
+    const lower = eventName.toLowerCase();
+    if ('on' + lower in target)
+        return lower;
+    return '_mc' + eventName[0].toUpperCase() + eventName.substring(1);
+}
 export function off(target, eventName, handler) {
     /* v8 ignore next */
     if (!target)

package/dist/utils/helpers.d.ts

@@ -5,6 +5,7 @@ Small runtime-agnostic utilities shared across the library: environment
 detection, object flattening/comparison, debouncing, accessor copying, and
 kebab-to-PascalCase conversion.
 */
+import type { McController } from '../types/mcTypes.js';
 /**
  * Determines whether the current runtime environment is a web browser.
  *
@@ -147,6 +148,7 @@ export declare function debounce<A extends unknown[]>(func: (...args: A) => unkn
 /**
  * Parses an HTML string and returns an array of DOM elements.
  * Handles self-closing tags (XHTML style) by converting them to full closing tags first.
+ * @hidden
  * @param html - The HTML string to parse.
  * @returns An array of HTMLElement objects representing the parsed HTML nodes.
  *
@@ -157,29 +159,10 @@ export declare function debounce<A extends unknown[]>(func: (...args: A) => unkn
  * ```
  */
 export declare function htmlToElements(html: string): HTMLElement[];
-/**
- * Returns the correct event name to listen for on a DOM element.
- *
- * If `eventName` (case-insensitive) matches a native HTML event handler property
- * (`'on' + eventName.toLowerCase()`) on the target, returns the lowercase native
- * name so that standard DOM events like `'click'` are listened to correctly.
- * Otherwise, prefixes with `_mc` for microcomponent custom events.
- *
- * @param target - The DOM element whose native event support is checked.
- * @param eventName - The event name as provided by the caller (e.g., `'click'`, `'Update'`).
- * @returns The resolved event name: lowercase native or `_mc`-prefixed custom.
- *
- * @example
- * ```ts
- * const btn = document.createElement('button');
- * trueEventName(btn, 'Click');   // 'click'  — native handler exists
- * trueEventName(btn, 'Update');  // '_mcUpdate' — custom event
- * ```
- */
-export declare function trueEventName(target: HTMLElement, eventName: string): string;
 /**
  * Copies all getter and setter properties from a source object to a target object.
  * Does not copy methods or regular data properties—only accessor properties (get/set).
+ * @hidden
  * @param source - The source object with getters and/or setters to copy.
  * @param target - The target object to which the accessors will be copied.
  *
@@ -192,4 +175,106 @@ export declare function trueEventName(target: HTMLElement, eventName: string): s
  * ```
  */
 export declare function copyGettersSetters(source: object, target: object): void;
+/**
+ * Injects a CSS string into the given scope (document or shadow root) as an adopted stylesheet.
+ * Enables css-in-js so that every custom element is self-contained and importable.
+ *
+ * @hidden
+ * @param target - The scope to inject styles into: `document` for global styles, or a `ShadowRoot` for encapsulated component internals.
+ * @param css - The CSS string to inject.
+ * @returns The created `CSSStyleSheet` instance that was adopted into the target scope.
+ *
+ * When targeting **document**: selectors like `:host`, `::slotted()`, and shadow-internal classes are **not allowed** — they have no effect outside a shadow root. Use only global selectors, element tags, or layout presets.
+ * When targeting **shadowRoot**: use `:host` for the custom element itself, standard selectors (`.inner`, `#id`) for internal structure, and `::slotted()` for projected light-DOM content.
+ *
+ * @example Inject global styles into the document:
+ * ```ts
+ * import { injectCSS } from '@twobirds/mc/utils/helpers';
+ * injectCSS(document, 'body { display: block; }');
+ * ```
+ *
+ * @example Inject global styles for a micro component into the document:
+ * ```ts
+ * import { injectCSS } from '@twobirds/mc/utils/helpers';
+ * injectCSS(document, 'my-microcomponent { display: block; }');
+ * ```
+ *
+ * @example Inject scoped styles into a shadow root:
+ * ```ts
+ * const shadow = element.attachShadow({ mode: 'open' });
+ * injectCSS(shadow, ':host { color: var(--text); } .inner { padding: 8px; }');
+ * ```
+ * Styles can also be added using a compound innerHTML statement: `shadow.innerHTML = \`<style>${style}</style>${template}\``
+ */
+export declare function injectCSS(target: Document | ShadowRoot, css: string): CSSStyleSheet;
+/**
+ * Processes a record of asset strings and applies them to the given target element.
+ * Supports injecting CSS into document or shadow root, and setting innerHTML for
+ * both target and shadow DOM. Automatically attaches a shadow root if any key starts
+ * with `'shadow'`.
+ *
+ * Recognized keys: `'css'`, `'targetCss'` (document-level styles), `'shadowCss'`
+ * (shadow-root styles), `'shadowHtml'` (shadow innerHTML), `'targetHtml'` (target innerHTML).
+ *
+ * @param target - The HTMLElement to apply assets onto.
+ * @param assets - A record mapping asset type keys to their string content.
+ *
+ * @example
+ * ```ts
+ * processAssets(this, {
+ *   css: 'body { margin: 0; }',
+ *   shadowCss: ':host { display: block; }',
+ *   shadowHtml: '<slot></slot>'
+ * });
+ * ```
+ */
+export declare function processAssets(instance: McController, assets: Record<string, string>): void;
+/**
+ * Loads companion asset files (CSS, HTML) for a given component basename from the server.
+ *
+ * Each entry in `assets` encodes an optional variant and extension in camelCase, e.g. `'shadowCss'` → `{name}.shadow.css`,
+ * `'targetHtml'` → `{name}.target.html`. Plain entries like `'css'` or `'html'` resolve to
+ * `{name}.css` / `{name}.html`.
+ *
+ * In bundled mode the Vite plugin replaces this call with an inline array literal, so `.then()`
+ * fires synchronously — no async overhead.
+ *
+ * @hidden
+ * @param name - The component basename (e.g. `'shop-catalog'`).
+ * @param assets - Array of asset descriptors such as `'shadowCss'`, `'targetHtml'`, `'shadowHtml'`, `'css'`, `'html'`.
+ * @returns A promise resolving to an array of file contents in the same order as `assets`. If a file is not found, the corresponding entry is `'file not found: ' + filename`.
+ *
+ * @example
+ * ```ts
+ * export const MyComponent = loadAssets('my-component', ['shadowCss', 'shadowHtml']).then(([shadowCss, shadowHtml]) => {
+ *   class _MyComponent extends DC { ... }
+ *   defineCE('my-component', _MyComponent);
+ *   return _MyComponent;
+ * });
+ * ```
+ */
+export declare function loadAssets(name: string, assets: string[]): Promise<Array<any>>;
+/**
+ * Binds declarative event attributes in a template fragment to microcomponent triggers.
+ *
+ * Scans all elements under `root` for attributes whose names correspond to native DOM
+ * events (e.g. `click`, `submit`, `change`). The attribute value encodes the target and
+ * handler method in the form `target|methodName`:
+ *
+ * - `this|myHandler` — triggers locally on the component attached to this element.
+ * - `other-comp|submit` — resolves elements via `querySelectorAll('other-comp')` and
+ *   triggers the event on each matched host's `_mc`.
+ *
+ * An optional sibling `payload` attribute supplies the data argument for `trigger()`.
+ * After binding, both the event attribute and the payload attribute are removed from the DOM.
+ *
+ * @param root - The container element whose descendants should be scanned for bindings.
+ *
+ * @example
+ * ```html
+ * <button click='this|onSubmit|{"action":"go"}'>Submit</button>
+ * <input change="|cart-form|refresh">
+ * ```
+ */
+export declare function bindTemplateEvents(rootElement: HTMLElement | ShadowRoot, instance: McController): void;
 //# sourceMappingURL=helpers.d.ts.map

package/dist/utils/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/utils/helpers.ts"],"names":[],"mappings":"AAAA;;;;;;EAME;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAEnC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAE/E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAiB1E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,GAAE,OAAc,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAqB7F;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAiCzD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,GAAG,GAAE,MAAW,GAAG,OAAO,CAe1E;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,KAAK,CAAC,CAAC,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,EAAE,EACpD,QAAQ,EAAE,CAAC,EACX,SAAS,EAAE,MAAM,EACjB,GAAG,IAAI,EAAE,OAAO,EAAE,GAChB,CAAC,CAgCH;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,UAKxC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,OAAO,EAAE,EAC3C,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,OAAO,EAC7B,YAAY,EAAE,MAAM,GAClB,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,IAAI,CAStB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,EAAE,CAU1D;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAK5E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAOvE"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/utils/helpers.ts"],"names":[],"mappings":"AAAA;;;;;;EAME;AAEF,OAAO,KAAK,EAAE,YAAY,EAAU,MAAM,qBAAqB,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAEnC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAE/E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAiB1E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,GAAE,OAAc,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAqB7F;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAiCzD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,GAAG,GAAE,MAAW,GAAG,OAAO,CAe1E;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,KAAK,CAAC,CAAC,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,EAAE,EACpD,QAAQ,EAAE,CAAC,EACX,SAAS,EAAE,MAAM,EACjB,GAAG,IAAI,EAAE,OAAO,EAAE,GAChB,CAAC,CAgCH;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,UAKxC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,OAAO,EAAE,EAC3C,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,OAAO,EAC7B,YAAY,EAAE,MAAM,GAClB,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,IAAI,CAStB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,EAAE,CAU1D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAOvE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,QAAQ,GAAG,UAAU,EAAE,GAAG,EAAE,MAAM,GAAG,aAAa,CAOnF;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CA4B1F;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAiC9E;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,WAAW,GAAG,UAAU,EAAE,QAAQ,EAAE,YAAY,GAAG,IAAI,CA2CtG"}