@pure-ds/core 0.3.0

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./src/js/pds.js";
+export { default } from "./src/js/pds.js";

package/dist/types/packages/pds-configurator/src/figma-export.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Convert a raw PDS token object into a Figma-friendly token structure.
+ *
+ * - Input:  your PDS JSON (colors, spacing, radius, typography, shadows, layout, transitions, zIndex, icons, ...)
+ * - Output: deeply equivalent tree where every primitive leaf becomes:
+ *           { value: ..., type: "color" | "dimension" | "fontSize" | ... }
+ *
+ * This targets Figma / Dev Mode / Tokens Studio style where:
+ *   - leaf tokens have `value` and `type`
+ *   - groups remain nested
+ */
+export function figmafyTokens(rawTokens: any): any;
+//# sourceMappingURL=figma-export.d.ts.map

package/dist/types/packages/pds-configurator/src/figma-export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"figma-export.d.ts","sourceRoot":"","sources":["../../../../../packages/pds-configurator/src/figma-export.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,mDAgIC"}

package/dist/types/packages/pds-configurator/src/pds-config-form.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=pds-config-form.d.ts.map

package/dist/types/packages/pds-configurator/src/pds-config-form.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pds-config-form.d.ts","sourceRoot":"","sources":["../../../../../packages/pds-configurator/src/pds-config-form.js"],"names":[],"mappings":""}

package/dist/types/packages/pds-configurator/src/pds-configurator.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=pds-configurator.d.ts.map

package/dist/types/packages/pds-configurator/src/pds-configurator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pds-configurator.d.ts","sourceRoot":"","sources":["../../../../../packages/pds-configurator/src/pds-configurator.js"],"names":[],"mappings":""}

package/dist/types/packages/pds-configurator/src/pds-demo.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=pds-demo.d.ts.map

package/dist/types/packages/pds-configurator/src/pds-demo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pds-demo.d.ts","sourceRoot":"","sources":["../../../../../packages/pds-configurator/src/pds-demo.js"],"names":[],"mappings":""}

package/dist/types/pds.config.d.ts

@@ -0,0 +1,13 @@
+export namespace config {
+    export let mode: string;
+    export let preset: string;
+    export namespace _static {
+        let root: string;
+    }
+    export { _static as static };
+    export namespace autoDefine {
+        let predefine: string[];
+    }
+    export function log(level: any, message: any, ...data: any[]): void;
+}
+//# sourceMappingURL=pds.config.d.ts.map

package/dist/types/pds.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pds.config.d.ts","sourceRoot":"","sources":["../../pds.config.js"],"names":[],"mappings":";;;;;;;;;;IAaE,oEAEC"}

package/dist/types/pds.d.ts

@@ -0,0 +1,408 @@
+/**
+ * Runtime registry singleton that controls live vs static behavior.
+ * Consumers can call `registry.setDesigner(designer)` to enable live mode
+ * or `registry.setStaticMode(paths)` to point to static asset modules.
+ */
+export interface PDSRegistry {
+  /** Attach a designer instance and switch the registry to live mode. */
+  setDesigner(designer: any, meta?: { presetName?: string }): void;
+  /** Switch to static mode and override static paths (keys: tokens, primitives, components, utilities, styles) */
+  setStaticMode(paths?: Record<string, string>): void;
+  /** Return a constructable stylesheet for the requested layer or null on failure. */
+  getStylesheet(layer: string): Promise<CSSStyleSheet | null>;
+  /** Return a BLOB URL (live mode only) for layer imports used in CSS */
+  getBlobURL(layer: string): string | null;
+  /** 'live' or 'static' */
+  readonly mode: string;
+  /** true when a live designer instance is registered */
+  readonly isLive: boolean;
+  /** true when a designer instance exists */
+  readonly hasDesigner: boolean;
+}
+
+/** A small shape describing component metadata used by the PDS ontology. */
+export interface ComponentDef {
+  /** canonical name of the component (e.g., 'Button') */
+  name: string;
+  /** optional HTML tag name for the component ('pds-button') */
+  tag?: string;
+  /** documented props and their types/metadata */
+  props?: Record<string, any>;
+  /** human-friendly description used by the designer */
+  description?: string;
+}
+
+/** Layer information with CSS content and metadata */
+export interface CompiledLayer {
+  css: string;
+  size: number;
+  sizeKB: string;
+}
+
+/** Complete compiled state of the design system */
+export interface CompiledState {
+  /** Core token groups - the source data used to generate CSS */
+  tokens: {
+    colors: Record<string, any>;
+    spacing: Record<string, any>;
+    radius: Record<string, any>;
+    borderWidths: Record<string, any>;
+    typography: Record<string, any>;
+    shadows: Record<string, any>;
+    layout: Record<string, any>;
+    transitions: Record<string, any>;
+    zIndex: Record<string, any>;
+    icons: Record<string, any>;
+  };
+
+  /** Layer information - CSS content and metadata for each layer */
+  layers: {
+    tokens: CompiledLayer;
+    primitives: CompiledLayer;
+    components: CompiledLayer;
+    utilities: CompiledLayer;
+    combined: CompiledLayer;
+  };
+
+  /** Configuration snapshot - what was used to generate this state */
+  config: {
+    design: any;
+    preset: string | null;
+    debug: boolean;
+  };
+
+  /** Runtime capabilities and environment */
+  capabilities: {
+    constructableStylesheets: boolean;
+    blobURLs: boolean;
+    shadowDOM: boolean;
+  };
+
+  /** References to design system metadata */
+  references: {
+    ontology: any;
+    enums: any;
+  };
+
+  /** Computed metadata about the generated design system */
+  meta: {
+    generatedAt: string;
+    totalSize: number;
+    totalSizeKB: string;
+    layerCount: number;
+    tokenGroups: number;
+  };
+
+  /** Introspection helpers - methods to query the compiled state */
+  helpers: {
+    getColorScales(): Array<{ name: string; scale: any }>;
+    getColorScale(name: string): any;
+    getSpacingValues(): Array<{ key: string; value: any }>;
+    getTypography(): any;
+    getLayerCSS(layer: 'tokens' | 'primitives' | 'components' | 'utilities'): string;
+    usesEnumValue(enumGroup: string, value: any): boolean;
+  };
+}
+
+/**
+ * Generator - programmatic API to produce tokens, layered CSS and helper modules from a config.
+ * Typical usage:
+ * const g = new PDS.Generator({ example: true });
+ * // tokens may be returned synchronously or via a Promise
+ * const tokens = await g.generateTokens?.();
+ * const css = await g.generateCSS?.();
+ */
+export class Generator {
+  constructor(options?: any);
+  /** runtime options / config passed to the generator */
+  options: any;
+  /** generated token object */
+  tokens: Record<string, any>;
+  /** concatenated CSS (layered) */
+  css: string;
+  /** Complete compiled representation of the design system state */
+  readonly compiled: CompiledState;
+  /** Generate the token map (may be async in some implementations) */
+  generateTokens?(): Record<string, any> | Promise<Record<string, any>>;
+  /** Generate the CSS string (may be async) */
+  generateCSS?(): string | Promise<string>;
+}
+
+/** Public runtime surface exported as `PDS` */
+export interface PDSEventMap {
+  'pds:ready': CustomEvent<{ mode: 'live' | 'static'; generator?: Generator; config: any; theme: string; autoDefiner?: any }>;
+  'pds:error': CustomEvent<{ error: any }>;
+  'pds:theme:changed': CustomEvent<{ theme: string; requested?: string; source: 'system' | 'programmatic' }>;
+  'pds:design:updated': CustomEvent<{ config: any; designer?: any }>;
+  'pds:design:field:changed': CustomEvent<{ field: string; config: any }>;
+  'pds:inspector:mode:changed': CustomEvent<{ active: boolean }>;
+  'pds:inspector:deactivate': CustomEvent<{}>;
+  'pds:docs:view': CustomEvent<{ file: string }>;
+}
+
+export class PDS extends EventTarget {
+  // Static surface
+  static Generator: typeof Generator;
+  static registry: PDSRegistry;
+  static presets: Record<string, any>;
+  static ontology: any;
+  static adoptLayers: (shadowRoot: ShadowRoot, layers?: string[], additionalSheets?: CSSStyleSheet[]) => Promise<void>;
+  static adoptPrimitives: (shadowRoot: ShadowRoot, additionalSheets?: CSSStyleSheet[]) => Promise<void>;
+  static createStylesheet: (css: string) => CSSStyleSheet;
+  static isLiveMode: () => boolean;
+  static findComponentForElement: (el: Element) => ComponentDef | null;
+  static validateDesign: (designConfig: any, options?: { minContrast?: number }) => { ok: boolean; issues: Array<{ path: string; message: string; ratio: number; min: number; context?: string }> };
+  static validateDesigns: (designs: Array<any> | Record<string, any>, options?: { minContrast?: number }) => { ok: boolean; results: Array<{ name?: string; ok: boolean; issues: Array<{ path: string; message: string; ratio: number; min: number; context?: string }> }> };
+  
+  /** 
+   * Current configuration after PDS.start() completes - read-only, frozen after initialization.
+   * Contains the complete configuration used to initialize PDS, including mode, design, preset, and theme.
+   */
+  static readonly currentConfig: any;
+  
+  /**
+   * Compiled design system state - provides structured access to all generated tokens,
+   * layers, and metadata. Available in live mode when a generator is active.
+   * Returns null if not in live mode or if no generator is present.
+   */
+  static readonly compiled: CompiledState | null;
+
+  // Static EventTarget-like facade for default instance
+  static addEventListener<K extends keyof PDSEventMap>(type: K, listener: (ev: PDSEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+  static removeEventListener<K extends keyof PDSEventMap>(type: K, listener: (ev: PDSEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+  static dispatchEvent(event: PDSEventMap[keyof PDSEventMap] | Event): boolean;
+
+  // Static entry point
+  static start(config?: {
+    mode?: 'live' | 'static';
+    preset?: string;
+    design?: any;
+    autoDefine?: {
+      baseURL?: string;
+      predefine?: string[];
+  mapper?: (tag: string) => string | undefined | null | false;
+      scanExisting?: boolean;
+      observeShadows?: boolean;
+      patchAttachShadow?: boolean;
+      debounceMs?: number;
+      onError?: (tag: string, err: any) => void;
+    };
+    applyGlobalStyles?: boolean;
+    manageTheme?: boolean;
+    themeStorageKey?: string;
+    public?: {
+      root?: string;
+    };
+    // live-only
+    preloadStyles?: boolean;
+    criticalLayers?: string[];
+    // static-only
+    staticPaths?: Record<string, string>;
+    enhancers?: Array<any>;
+  }): Promise<PDS>;
+
+  constructor();
+
+  // Instance state
+  readonly mode: 'live' | 'static';
+  readonly generator?: Generator;
+  readonly config: any;
+  readonly theme: string;
+  readonly autoDefiner?: any;
+
+  // Instance helpers
+  setTheme(theme: 'light' | 'dark' | 'system', options?: { storageKey?: string; persist?: boolean }): Promise<string>;
+  preloadCritical(config: any, options?: { theme?: string; layers?: string[] }): void;
+}
+
+export { PDS as default };
+
+// ===== pds-jsonform Types =====
+
+export interface JsonFormOptions {
+  widgets?: {
+    booleans?: 'toggle' | 'checkbox';
+    numbers?: 'input' | 'range';
+    selects?: 'standard' | 'dropdown';
+  };
+  layouts?: {
+    fieldsets?: 'default' | 'flex' | 'grid' | 'accordion' | 'tabs' | 'card';
+    arrays?: 'default' | 'compact';
+  };
+  enhancements?: {
+    icons?: boolean;
+    datalists?: boolean;
+    rangeOutput?: boolean;
+  };
+  validation?: {
+    showErrors?: boolean;
+    validateOnChange?: boolean;
+  };
+  // Path-specific options (JSON Pointer paths)
+  [path: string]: any;
+}
+
+export interface UISchema {
+  // Field-level UI customization (JSON Pointer paths as keys)
+  [path: string]: {
+    'ui:widget'?: string;
+    'ui:layout'?: 'default' | 'flex' | 'grid' | 'accordion' | 'tabs';
+    'ui:columns'?: number | 'auto';
+    'ui:autoSize'?: 'sm' | 'md' | 'lg' | 'xl';
+    'ui:gap'?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    'ui:wrap'?: boolean;
+    'ui:direction'?: 'row' | 'column';
+    'ui:surface'?: 'card' | 'elevated' | 'dialog';
+    'ui:accordion'?: boolean;
+    'ui:tabs'?: boolean;
+    'ui:defaultOpen'?: number[];
+    'ui:dialog'?: boolean;
+    'ui:dialogButton'?: string;
+    'ui:dialogSize'?: 'sm' | 'lg' | 'xl' | 'full';
+    'ui:submitLabel'?: string;
+    'ui:cancelLabel'?: string;
+    'ui:help'?: string;
+    'ui:placeholder'?: string;
+    'ui:icon'?: string;
+    'ui:iconPosition'?: 'start' | 'end';
+    'ui:datalist'?: string[];
+    'ui:rows'?: number;
+    'ui:min'?: number;
+    'ui:max'?: number;
+    'ui:dropdown'?: boolean;
+    'ui:autocomplete'?: string;
+    'ui:accept'?: string;
+    'ui:multiple'?: boolean;
+    'ui:maxFiles'?: number;
+    'ui:maxSize'?: number;
+    'ui:submitOnEnter'?: boolean;
+    'ui:spellcheck'?: boolean;
+    'ui:order'?: string[];
+  };
+}
+
+export interface JsonFormEvent<T = any> extends CustomEvent {
+  detail: T;
+}
+
+export interface JsonFormSubmitDetail {
+  json: any;
+  formData: FormData;
+  valid: boolean;
+  issues: Array<{ path?: string; message: string }>;
+}
+
+export interface JsonFormValueChangeDetail {
+  name: string;
+  value: any;
+  validity: { valid: boolean };
+}
+
+export interface JsonFormArrayEventDetail {
+  path: string;
+  index?: number;
+  from?: number;
+  to?: number;
+}
+
+export interface JsonFormDialogEventDetail {
+  path: string;
+  schema?: any;
+  value?: any;
+}
+
+export interface JsonFormRendererContext {
+  id: string;
+  path: string;
+  label: string;
+  value: any;
+  required: boolean;
+  ui: any;
+  schema: any;
+  get: (path?: string) => any;
+  set: (value: any, path?: string) => void;
+  attrs: {
+    placeholder?: string;
+    minLength?: number;
+    maxLength?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    pattern?: string;
+    readOnly?: boolean;
+    required?: boolean;
+    autocomplete?: string;
+    list?: string;
+  };
+  host: any;
+}
+
+export type JsonFormRenderer = (context: JsonFormRendererContext) => any;
+
+export interface JsonFormEventMap {
+  'pw:schema-resolve': JsonFormEvent<{ schema: any }>;
+  'pw:compile-node': JsonFormEvent<{ path: string; schema: any; ui: any; node?: any }>;
+  'pw:choose-widget': JsonFormEvent<{ path: string; schema: any; ui: any; widget: string | null }>;
+  'pw:before-render-field': JsonFormEvent<{ path: string; schema: any; ui: any; mount?: any; render?: () => any }>;
+  'pw:render-field': JsonFormEvent<{ path: string; schema: any; node: any }>;
+  'pw:after-render-field': JsonFormEvent<{ path: string; schema: any }>;
+  'pw:value-change': JsonFormEvent<JsonFormValueChangeDetail>;
+  'pw:array-add': JsonFormEvent<JsonFormArrayEventDetail>;
+  'pw:array-remove': JsonFormEvent<JsonFormArrayEventDetail>;
+  'pw:array-reorder': JsonFormEvent<JsonFormArrayEventDetail>;
+  'pw:serialize': JsonFormEvent<JsonFormSubmitDetail>;
+  'pw:submit': JsonFormEvent<JsonFormSubmitDetail>;
+  'pw:dialog-open': JsonFormEvent<JsonFormDialogEventDetail>;
+  'pw:dialog-submit': JsonFormEvent<JsonFormDialogEventDetail>;
+}
+
+declare global {
+  interface HTMLElementTagNameMap {
+    'pds-jsonform': SchemaForm;
+  }
+}
+
+export class SchemaForm extends HTMLElement {
+  // Properties
+  jsonSchema: any;
+  uiSchema: UISchema;
+  options: JsonFormOptions;
+  values: any;
+  action?: string;
+  method: 'get' | 'post' | 'dialog';
+  disabled: boolean;
+  hideActions: boolean;
+  submitLabel: string;
+  resetLabel: string;
+  hideReset: boolean;
+  hideSubmit: boolean;
+
+  // Methods
+  defineRenderer(widgetKey: string, renderer: JsonFormRenderer): void;
+  useValidator(validator: (data: any, schema: any) => Promise<{ valid: boolean; errors?: Array<{ path?: string; message: string }> }>): void;
+  getValuesFlat(): Record<string, any>;
+  serialize(): { json: any; formData: FormData };
+  submit(): Promise<JsonFormSubmitDetail>;
+
+  // Event listeners
+  addEventListener<K extends keyof JsonFormEventMap>(
+    type: K,
+    listener: (ev: JsonFormEventMap[K]) => any,
+    options?: boolean | AddEventListenerOptions
+  ): void;
+  addEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | AddEventListenerOptions
+  ): void;
+  removeEventListener<K extends keyof JsonFormEventMap>(
+    type: K,
+    listener: (ev: JsonFormEventMap[K]) => any,
+    options?: boolean | EventListenerOptions
+  ): void;
+  removeEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | EventListenerOptions
+  ): void;
+}

package/dist/types/public/assets/js/app.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=app.d.ts.map

package/dist/types/public/assets/js/app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../../../../../public/assets/js/app.js"],"names":[],"mappings":""}

package/dist/types/public/assets/js/pds.d.ts

@@ -0,0 +1,23 @@
+declare var PDS2: {
+    addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+    dispatchEvent(event: Event): boolean;
+    removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+};
+export function validateDesign(designConfig?: {}, options?: {}): {
+    ok: boolean;
+    issues: ({
+        path: string;
+        message: string;
+        ratio: number;
+        min: number;
+        context: string;
+    } | {
+        path: string;
+        message: string;
+        ratio: number;
+        min: number;
+        context?: undefined;
+    })[];
+};
+export { PDS2 as PDS };
+//# sourceMappingURL=pds.d.ts.map

package/dist/types/public/assets/js/pds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pds.d.ts","sourceRoot":"","sources":["../../../../../public/assets/js/pds.js"],"names":[],"mappings":"AA+iRA;;;;EAAyB;AAuKzB;;;;;;;;;;;;;;;EA+GC"}

package/dist/types/public/assets/pds/components/pds-calendar.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Simple class for efficient HTML string building
+ * @private
+ */
+export class HTMLBuilder {
+    /**
+     * Constructor
+     * @param {String} container - use '{html}' for the built-up string to be placed in
+     */
+    constructor(container?: string);
+    /**
+     * Adds a string to the builder
+     * @param {String} htmlPart
+     */
+    add(htmlPart: string): void;
+    /**
+     * Returns the built-up string, optionally using the given container for enclosing.
+     * @returns {String} html string
+     */
+    toHTML(): string;
+    #private;
+}
+//# sourceMappingURL=pds-calendar.d.ts.map

package/dist/types/public/assets/pds/components/pds-calendar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pds-calendar.d.ts","sourceRoot":"","sources":["../../../../../../public/assets/pds/components/pds-calendar.js"],"names":[],"mappings":"AAKA;;;GAGG;AACH;IAIE;;;OAGG;IACH,gCAEC;IAED;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,iBAMC;;CACF"}

package/dist/types/public/assets/pds/components/pds-drawer.d.ts

@@ -0,0 +1,2 @@
+declare const PDS: any;
+//# sourceMappingURL=pds-drawer.d.ts.map

package/dist/types/public/assets/pds/components/pds-drawer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pds-drawer.d.ts","sourceRoot":"","sources":["../../../../../../public/assets/pds/components/pds-drawer.js"],"names":[],"mappings":"AAAA,uBAAuB"}

package/dist/types/public/assets/pds/components/pds-icon.d.ts

@@ -0,0 +1,53 @@
+/**
+ * SVG Icon Web Component
+ *
+ * @element pds-icon
+ *
+ * @attr {string} icon - Icon name from the sprite sheet
+ * @attr {string|number} size - Icon size in pixels or named size (xs, sm, md, lg, xl, 2xl)
+ * @attr {string} color - Icon color (CSS color value, default: currentColor)
+ * @attr {string} label - Accessible label for the icon (adds role="img")
+ * @attr {string} sprite - Override sprite sheet path
+ * @attr {number} rotate - Rotation angle in degrees
+ * @attr {boolean} no-sprite - Force fallback icon rendering
+ *
+ * @example
+ * <pds-icon icon="house"></pds-icon>
+ * <pds-icon icon="gear" size="32"></pds-icon>
+ * <pds-icon icon="heart" color="red" label="Favorite"></pds-icon>
+ * <pds-icon icon="list" size="lg"></pds-icon>
+ */
+export class SvgIcon extends HTMLElement {
+    static observedAttributes: string[];
+    static "__#private@#fallbackIcons": {
+        x: string;
+        house: string;
+        list: string;
+        gear: string;
+        'magnifying-glass': string;
+        info: string;
+        'check-circle': string;
+        warning: string;
+        missing: string;
+    };
+    static spritePromises: Map<any, any>;
+    static inlineSprites: Map<any, any>;
+    static instances: Set<any>;
+    static "__#private@#spriteSupport": boolean;
+    static "__#private@#detectSpriteSupport"(): boolean;
+    static ensureInlineSprite(spriteURL: any): Promise<any>;
+    static notifyInstances(): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: any, oldValue: any, newValue: any): void;
+    render(): void;
+    /**
+     * Check if sprite sheet is available
+     * @method spriteAvailable
+     * @public
+     * @returns {boolean} True if sprite sheet should be used
+     */
+    public spriteAvailable(): boolean;
+    #private;
+}
+//# sourceMappingURL=pds-icon.d.ts.map

package/dist/types/public/assets/pds/components/pds-icon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pds-icon.d.ts","sourceRoot":"","sources":["../../../../../../public/assets/pds/components/pds-icon.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH;IACE,oCAAyE;IAGzE;;;;;;;;;;MAkBE;IAEF,qCAAkC;IAClC,oCAAiC;IAEjC,2BAA6B;IAE7B,4CAA8B;IAO9B,oDA2CC;IAmJD,wDA8EC;IACD,+BAMC;IAjOD,0BAGC;IAED,6BAEC;IAED,wEAIC;IAED,eA6GC;IAMD;;;;;OAKG;IACH,0BAFa,OAAO,CAInB;;CAwFF"}