@neovici/cosmoz-omnitable 14.14.2 → 14.15.0

package/dist/cosmoz-omnitable-column-list-data.js

@@ -0,0 +1,123 @@
+import { translatable } from '@neovici/cosmoz-i18next';
+import { mixin, Template } from '@neovici/cosmoz-utils';
+import { PolymerElement } from '@polymer/polymer/polymer-element';
+import { html } from '@polymer/polymer/lib/utils/html-tag';
+window.Cosmoz = window.Cosmoz || {};
+/**
+ * @polymer
+ * @customElement
+ * @appliesMixin translatable
+ */
+class OmnitableColumnListData extends translatable(mixin(Template, PolymerElement)) {
+    static get template() {
+        return html `
+			<style>
+				:host {
+					display: block;
+				}
+
+				:host a {
+					color: var(--primary-link-color, inherit);
+				}
+
+				[hidden] {
+					display: none;
+				}
+
+				ul {
+					list-style-type: none;
+					margin: 0.3em 0;
+					padding-left: 0;
+				}
+
+				li {
+					text-overflow: ellipsis;
+					overflow: hidden;
+				}
+			</style>
+
+			<ul hidden$="[[ isEmpty(items) ]]">
+				<li>
+					<span>[[ _firstItem(items) ]]</span>
+				</li>
+				<li class="see-more" hidden$="[[_hideExpand(items, _expanded)]]">
+					<a href="#" on-tap="_toggleExpand"
+						>[[ _('and {0} more', _othersCount, t) ]]</a
+					>
+				</li>
+				<template
+					is="dom-repeat"
+					items="[[ _otherItems(items, _expanded) ]]"
+					as="item"
+				>
+					<li>
+						<span class="item">[[ item ]]</span>
+					</li>
+				</template>
+				<li class="see-less" hidden$="[[ _hideCollapse(items, _expanded) ]]">
+					<a href="#" on-tap="_toggleExpand">[[ _('See less', t) ]]</a>
+				</li>
+			</ul>
+		`;
+    }
+    static get is() {
+        return 'cosmoz-omnitable-column-list-data';
+    }
+    static get properties() {
+        return {
+            items: {
+                type: Array,
+            },
+            _expanded: {
+                type: Boolean,
+                value: false,
+            },
+            _othersCount: {
+                type: Number,
+                computed: '_computeOthersCount(items)',
+            },
+        };
+    }
+    static get observers() {
+        return ['_itemsLengthChanged(items.length)'];
+    }
+    _itemsLengthChanged() {
+        requestAnimationFrame(() => this.dispatchEvent(new CustomEvent('expand', { bubbles: true })));
+    }
+    _firstItem(items) {
+        if (items !== undefined && items !== null && items.length > 0) {
+            return items[0];
+        }
+    }
+    _hideExpand(items, expanded) {
+        if (items !== undefined && items.length !== null) {
+            return items.length <= 2 || expanded;
+        }
+        return true;
+    }
+    _hideCollapse(items, expanded) {
+        if (items !== undefined && items.length !== null) {
+            return items.length <= 2 || !expanded;
+        }
+        return true;
+    }
+    _otherItems(items, expanded) {
+        if (items !== undefined && items !== null) {
+            if (items.length <= 2 || expanded) {
+                return items.slice(1);
+            }
+        }
+    }
+    _computeOthersCount(items) {
+        if (items !== undefined && items !== null) {
+            return items.length - 1;
+        }
+    }
+    _toggleExpand(event) {
+        this._expanded = !this._expanded;
+        event.stopPropagation();
+        event.preventDefault();
+    }
+}
+customElements.define(OmnitableColumnListData.is, OmnitableColumnListData);
+//# sourceMappingURL=cosmoz-omnitable-column-list-data.js.map

package/dist/cosmoz-omnitable-column-list-horizontal.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cosmoz-omnitable-column-list-horizontal.d.ts.map

package/dist/cosmoz-omnitable-column-list-horizontal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cosmoz-omnitable-column-list-horizontal.d.ts","sourceRoot":"","sources":["../src/cosmoz-omnitable-column-list-horizontal.js"],"names":[],"mappings":""}

package/{cosmoz-omnitable-column-list-horizontal.js → dist/cosmoz-omnitable-column-list-horizontal.js}

@@ -1,34 +1,20 @@
 import '@neovici/cosmoz-autocomplete';
 import '@neovici/cosmoz-spinner';
-
 import { PolymerElement } from '@polymer/polymer/polymer-element';
 import { html } from 'lit-html';
 import { when } from 'lit-html/directives/when.js';
-
 import { columnMixin } from './cosmoz-omnitable-column-mixin';
-import {
-	getTexts,
-	listColumnMixin,
-	onChange,
-	onFocus,
-	onText,
-} from './cosmoz-omnitable-column-list-mixin';
-
+import { getTexts, listColumnMixin, onChange, onFocus, onText, } from './cosmoz-omnitable-column-list-mixin';
 /**
  * @polymer
  * @customElement
  * @appliesMixin listColumnMixin
  * @appliesMixin columnMixin
  */
-class OmnitableColumnListHorizontal extends listColumnMixin(
-	columnMixin(PolymerElement),
-) {
-	renderCell({ valuePath, textProperty }, { item }) {
-		const list = getTexts(item, valuePath, textProperty).map(
-			(item) => html`<li>${item}</li>`,
-		);
-
-		return html`
+class OmnitableColumnListHorizontal extends listColumnMixin(columnMixin(PolymerElement)) {
+    renderCell({ valuePath, textProperty }, { item }) {
+        const list = getTexts(item, valuePath, textProperty).map((item) => html `<li>${item}</li>`);
+        return html `
 			<style>
 				ul {
 					padding: 0;
@@ -49,14 +35,12 @@ class OmnitableColumnListHorizontal extends listColumnMixin(
 				${list}
 			</ul>
 		`;
-	}
-
-	renderEditCell() {
-		return 'not implemented';
-	}
-
-	renderHeader(column, { filter, query }, setState, source) {
-		return html`<cosmoz-autocomplete-ui
+    }
+    renderEditCell() {
+        return 'not implemented';
+    }
+    renderHeader(column, { filter, query }, setState, source) {
+        return html `<cosmoz-autocomplete-ui
 			class="external-values-${column.externalValues}"
 			.label=${column.title}
 			.source=${source}
@@ -66,15 +50,9 @@ class OmnitableColumnListHorizontal extends listColumnMixin(
 			.onChange=${onChange(setState)}
 			.onFocus=${onFocus(setState)}
 			.onText=${onText(setState)}
-			>${when(
-				column.loading,
-				() => html`<cosmoz-spinner slot="suffix"></cosmoz-spinner>`,
-			)}</cosmoz-autocomplete-ui
+			>${when(column.loading, () => html `<cosmoz-spinner slot="suffix"></cosmoz-spinner>`)}</cosmoz-autocomplete-ui
 		> `;
-	}
+    }
 }
-
-customElements.define(
-	'cosmoz-omnitable-column-list-horizontal',
-	OmnitableColumnListHorizontal,
-);
+customElements.define('cosmoz-omnitable-column-list-horizontal', OmnitableColumnListHorizontal);
+//# sourceMappingURL=cosmoz-omnitable-column-list-horizontal.js.map

package/dist/cosmoz-omnitable-column-list-mixin.d.ts

@@ -0,0 +1,59 @@
+export function unique(values: any, valueProperty: any): any;
+export function getTexts(item: any, valuePath: any, textProperty: any): any;
+export function getString({ valuePath, textProperty }: {
+    valuePath: any;
+    textProperty: any;
+}, item: any): any;
+export function toXlsxValue({ valuePath, textProperty }: {
+    valuePath: any;
+    textProperty: any;
+}, item: any): any;
+export function applyMultiFilter({ valueProperty, valuePath, emptyValue, emptyProperty }: {
+    valueProperty: any;
+    valuePath: any;
+    emptyValue: any;
+    emptyProperty: any;
+}, filters: any): (item: any) => any;
+export function onChange(setState: any): (value: any) => any;
+export function onFocus(setState: any): (focused: any) => any;
+export function onText(setState: any): (text: any) => any;
+export function computeSource(column: any, data: any): any;
+export function toAutocompleteSource(values: any, valueProperty: any, textProperty: any): any;
+export function listColumnMixin(base: any): {
+    new (): {
+        [x: string]: any;
+        getConfig(column: any): {
+            emptyProperty: any;
+        };
+        getString(column: any, item: any): any;
+        toXlsxValue(column: any, item: any): any;
+        cellTitleFn(column: any, item: any): any;
+        getComparableValue({ valuePath, valueProperty }: {
+            valuePath: any;
+            valueProperty: any;
+        }, item: any): any;
+        getFilterFn(column: any, filters: any): ((item: any) => any) | undefined;
+        serializeFilter(column: any, filter: any): string | null;
+        deserializeFilter(column: any, filter: any): any;
+        computeSource(column: any, data: any): any;
+    };
+    [x: string]: any;
+    get properties(): {
+        textProperty: {
+            type: StringConstructor;
+        };
+        valueProperty: {
+            type: StringConstructor;
+        };
+        emptyLabel: {
+            type: StringConstructor;
+        };
+        emptyValue: {
+            type: ObjectConstructor;
+        };
+        emptyProperty: {
+            type: StringConstructor;
+        };
+    };
+};
+//# sourceMappingURL=cosmoz-omnitable-column-list-mixin.d.ts.map

package/dist/cosmoz-omnitable-column-list-mixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cosmoz-omnitable-column-list-mixin.d.ts","sourceRoot":"","sources":["../src/cosmoz-omnitable-column-list-mixin.js"],"names":[],"mappings":"AAMA,6DAiLG;AAjLH,4EAiLG;AAjLH;;;mBAiLG;AAjLH;;;mBAiLG;AAjLH;;;;;mBAsEG,SAAI,SA2GJ;AAjLH,0CAgF2B,UAAK,SAiG7B;AAjLH,yCAkF0B,YAAO,SA+F9B;AAjLH,wCAoFyB,SAAI,SA6F1B;AAjLH,2DAiLG;AAjLH,8FAiLG;AAjLH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiLG"}

package/dist/cosmoz-omnitable-column-list-mixin.js

@@ -0,0 +1,139 @@
+import { prop } from '@neovici/cosmoz-utils/object';
+import { array } from '@neovici/cosmoz-utils/array';
+import { invoke } from '@neovici/cosmoz-utils/function';
+import { get } from '@polymer/polymer/lib/utils/path';
+import { valuesFrom } from './lib/utils-data';
+const unique = (values, valueProperty) => {
+    if (!Array.isArray(values)) {
+        return;
+    }
+    const used = [];
+    return values
+        .reduce((acc, cur) => {
+        if (Array.isArray(cur)) {
+            cur.forEach((subcur) => {
+                acc.push(subcur);
+            });
+            return acc;
+        }
+        acc.push(cur);
+        return acc;
+    }, [])
+        .filter((item, index, array) => {
+        if (array.indexOf(item) !== index) {
+            return false;
+        }
+        if (valueProperty) {
+            const value = get(item, valueProperty);
+            if (used.indexOf(value) !== -1) {
+                return false;
+            }
+            used.push(value);
+        }
+        return true;
+    });
+}, toAutocompleteSource = (values, valueProperty, textProperty) => {
+    if (values == null) {
+        return [];
+    }
+    if (Array.isArray(values)) {
+        return unique(values, valueProperty);
+    }
+    if (typeof values === 'object') {
+        const valProp = valueProperty ?? 'id', textProp = textProperty ?? 'label';
+        return Object.entries(values)
+            .map(([id, label]) => ({
+            [valProp]: id,
+            [textProp]: label,
+        }))
+            .sort((a, b) => {
+            if (a[textProp] < b[textProp]) {
+                return -1;
+            }
+            if (a[textProp] > b[textProp]) {
+                return 1;
+            }
+            return 0;
+        });
+    }
+    return [];
+}, getTexts = (item, valuePath, textProperty) => array(valuePath && get(item, valuePath)).map(prop(textProperty)), getString = ({ valuePath, textProperty }, item) => {
+    return getTexts(item, valuePath, textProperty)
+        .filter((i) => i != null)
+        .join(', ');
+}, toXlsxValue = getString, applyMultiFilter = ({ valueProperty, valuePath, emptyValue, emptyProperty }, filters) => (item) => {
+    const val = prop(valueProperty), values = array(get(item, valuePath));
+    return filters.some((filter) => (values.length === 0 &&
+        prop(emptyProperty || valueProperty)(filter) === emptyValue) ||
+        values.some((value) => val(value) === val(filter)));
+}, onChange = (setState) => (value) => setState((state) => ({ ...state, filter: value })), onFocus = (setState) => (focused) => setState((state) => ({ ...state, headerFocused: focused })), onText = (setState) => (text) => setState((state) => ({ ...state, query: text })), computeValues = ({ emptyValue, emptyLabel, emptyProperty, textProperty, valueProperty }, rawSource) => {
+    const source = toAutocompleteSource(rawSource, valueProperty, textProperty);
+    if (!emptyLabel ||
+        emptyValue === undefined ||
+        !textProperty ||
+        !(emptyProperty || valueProperty) ||
+        !source) {
+        return source;
+    }
+    return [
+        {
+            [textProperty]: emptyLabel,
+            [emptyProperty || valueProperty]: emptyValue,
+        },
+        ...source,
+    ];
+}, computeSource = (column, data) => computeValues(column, valuesFrom(data, column.valuePath)), listColumnMixin = (base) => class extends base {
+    static get properties() {
+        return {
+            textProperty: { type: String },
+            valueProperty: { type: String },
+            emptyLabel: { type: String },
+            emptyValue: { type: Object },
+            emptyProperty: { type: String },
+        };
+    }
+    getConfig(column) {
+        return {
+            emptyProperty: column.emptyProperty,
+        };
+    }
+    getString(column, item) {
+        return getString(column, item);
+    }
+    toXlsxValue(column, item) {
+        return toXlsxValue(column, item);
+    }
+    cellTitleFn(column, item) {
+        return getString(column, item);
+    }
+    getComparableValue({ valuePath, valueProperty }, item) {
+        const value = get(item, valuePath);
+        if (valueProperty == null) {
+            return value;
+        }
+        const subValues = array(value).reduce((acc, subItem) => {
+            acc.push(get(subItem, valueProperty));
+            return acc;
+        }, []);
+        return subValues.sort().join(' ');
+    }
+    getFilterFn(column, filters) {
+        if (!filters || !Array.isArray(filters) || filters.length === 0) {
+            return;
+        }
+        return applyMultiFilter(column, filters);
+    }
+    serializeFilter(column, filter) {
+        return filter.length === 0 ? null : JSON.stringify(filter);
+    }
+    deserializeFilter(column, filter) {
+        return JSON.parse(decodeURIComponent(filter));
+    }
+    computeSource(column, data) {
+        return column.externalValues || typeof column.values === 'function'
+            ? async (...args) => computeValues(column, await Promise.resolve(invoke(column.values, ...args)))
+            : computeSource(column, data);
+    }
+};
+export { unique, getTexts, getString, toXlsxValue, applyMultiFilter, onChange, onFocus, onText, computeSource, toAutocompleteSource, listColumnMixin, };
+//# sourceMappingURL=cosmoz-omnitable-column-list-mixin.js.map

package/dist/cosmoz-omnitable-column-list.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cosmoz-omnitable-column-list.d.ts.map

package/dist/cosmoz-omnitable-column-list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cosmoz-omnitable-column-list.d.ts","sourceRoot":"","sources":["../src/cosmoz-omnitable-column-list.js"],"names":[],"mappings":""}

package/{cosmoz-omnitable-column-list.js → dist/cosmoz-omnitable-column-list.js}

@@ -1,21 +1,11 @@
 import './cosmoz-omnitable-column-list-data';
-
 import { PolymerElement } from '@polymer/polymer/polymer-element';
 import { html } from 'lit-html';
 import { when } from 'lit-html/directives/when.js';
-
 import { columnMixin } from './cosmoz-omnitable-column-mixin';
-import {
-	getString,
-	getTexts,
-	listColumnMixin,
-	onChange,
-	onFocus,
-	onText,
-} from './cosmoz-omnitable-column-list-mixin';
+import { getString, getTexts, listColumnMixin, onChange, onFocus, onText, } from './cosmoz-omnitable-column-list-mixin';
 import '@neovici/cosmoz-autocomplete';
 import { columnSymbol } from './lib/use-dom-columns';
-
 /**
  * @polymer
  * @customElement
@@ -23,43 +13,37 @@ import { columnSymbol } from './lib/use-dom-columns';
  * @appliesMixin columnMixin
  */
 class OmnitableColumnList extends listColumnMixin(columnMixin(PolymerElement)) {
-	static get properties() {
-		return {
-			keepOpened: { type: Boolean, value: true },
-			keepQuery: { type: Boolean },
-			textual: { type: Function },
-		};
-	}
-
-	getConfig(column) {
-		return {
-			...super.getConfig?.(column),
-			keepOpened: column.keepOpened,
-			keepQuery: column.keepQuery,
-			textual: column.textual,
-		};
-	}
-
-	renderCell({ valuePath, textProperty }, { item }) {
-		return html`<cosmoz-omnitable-column-list-data
+    static get properties() {
+        return {
+            keepOpened: { type: Boolean, value: true },
+            keepQuery: { type: Boolean },
+            textual: { type: Function },
+        };
+    }
+    getConfig(column) {
+        return {
+            ...super.getConfig?.(column),
+            keepOpened: column.keepOpened,
+            keepQuery: column.keepQuery,
+            textual: column.textual,
+        };
+    }
+    renderCell({ valuePath, textProperty }, { item }) {
+        return html `<cosmoz-omnitable-column-list-data
 			.items=${getTexts(item, valuePath, textProperty)}
 		></cosmoz-omnitable-column-list-data>`;
-	}
-
-	renderEditCell(column, { item }, onItemChange) {
-		const onChange = (event) =>
-			onItemChange(event.target.value.split(/,\s*/gu));
-
-		return html`<cosmoz-input
+    }
+    renderEditCell(column, { item }, onItemChange) {
+        const onChange = (event) => onItemChange(event.target.value.split(/,\s*/gu));
+        return html `<cosmoz-input
 			no-label-float
 			type="text"
 			.value=${getString(column, item)}
 			@change=${onChange}
 		></cosmoz-input>`;
-	}
-
-	renderHeader(column, { filter, query }, setState, source) {
-		return html`<cosmoz-autocomplete-ui
+    }
+    renderHeader(column, { filter, query }, setState, source) {
+        return html `<cosmoz-autocomplete-ui
 			class="external-values-${column.externalValues}"
 			?keep-opened=${column.keepOpened}
 			?keep-query=${column.keepQuery}
@@ -75,12 +59,9 @@ class OmnitableColumnList extends listColumnMixin(columnMixin(PolymerElement)) {
 			.onChange=${onChange(setState)}
 			.onFocus=${onFocus(setState)}
 			.onText=${onText(setState)}
-			>${when(
-				column.loading,
-				() => html`<cosmoz-spinner slot="suffix"></cosmoz-spinner>`,
-			)}</cosmoz-autocomplete-ui
+			>${when(column.loading, () => html `<cosmoz-spinner slot="suffix"></cosmoz-spinner>`)}</cosmoz-autocomplete-ui
 		>`;
-	}
+    }
 }
-
 customElements.define('cosmoz-omnitable-column-list', OmnitableColumnList);
+//# sourceMappingURL=cosmoz-omnitable-column-list.js.map

package/dist/cosmoz-omnitable-column-mixin.d.ts

@@ -0,0 +1,161 @@
+export function getString({ valuePath }: {
+    valuePath: any;
+}, item: any): any;
+export function toXlsxValue({ valuePath }: {
+    valuePath: any;
+}, item: any): any;
+export function getComparableValue({ valuePath }: {
+    valuePath: any;
+}, item: any): any;
+export function applySingleFilter({ valuePath }: {
+    valuePath: any;
+}, filter: any): (item: any) => any;
+export function serializeFilter(column: any, filter: any): any;
+export function columnMixin(base: any): {
+    new (): {
+        [x: string]: any;
+        notifyFilterChange(filter: any): void;
+        legacyFilterToState(filter: any): {
+            filter: any;
+        };
+        /**
+         * Override this in column elements if you need a different default width
+         */
+        getFilterFn(): void;
+        getString(column: any, item: any): any;
+        toXlsxValue(column: any, item: any): any;
+        cellTitleFn(column: any, item: any): any;
+        serializeFilter(column: any, filter: any): any;
+        deserializeFilter(column: any, filter: any): any;
+        getComparableValue(column: any, item: any): any;
+        computeSource(column: any, data: any): any;
+        _propertiesChanged(currentProps: any, changedProps: any, oldProps: any): void;
+    };
+    [x: string]: any;
+    get properties(): {
+        /**
+         * Used to indicate that an element using this behavior is a column definition that can be used
+         * in cosmoz-omnitable
+         */
+        isOmnitableColumn: {
+            type: BooleanConstructor;
+            value: boolean;
+        };
+        title: {
+            type: StringConstructor;
+        };
+        valuePath: {
+            type: StringConstructor;
+            notify: boolean;
+        };
+        values: {
+            type: ArrayConstructor;
+            notify: boolean;
+        };
+        filter: {
+            type: ObjectConstructor;
+        };
+        noLocalFilter: {
+            type: BooleanConstructor;
+        };
+        /**
+         * If the column should be disabled until enabled with enabledColumns
+         */
+        disabled: {
+            type: BooleanConstructor;
+            value: boolean;
+            notify: boolean;
+        };
+        /**
+         * If true, the column will be editable by using an input element for rendering.
+         */
+        editable: {
+            type: BooleanConstructor;
+            notify: boolean;
+        };
+        /**
+         * Indicate that the column is loading/performing work
+         */
+        loading: {
+            type: BooleanConstructor;
+            value: boolean;
+            notify: boolean;
+        };
+        externalValues: {
+            type: BooleanConstructor;
+            value: boolean;
+            notify: boolean;
+        };
+        /**
+         * Column name for use with enabledColumns
+         */
+        name: {
+            type: StringConstructor;
+        };
+        sortOn: {
+            type: StringConstructor;
+        };
+        groupOn: {
+            type: StringConstructor;
+        };
+        width: {
+            type: StringConstructor;
+            value: string;
+        };
+        minWidth: {
+            type: StringConstructor;
+            value: string;
+        };
+        flex: {
+            type: StringConstructor;
+            value: string;
+        };
+        cellClass: {
+            type: StringConstructor;
+            value: string;
+        };
+        headerCellClass: {
+            type: StringConstructor;
+            value: string;
+        };
+        priority: {
+            type: NumberConstructor;
+            value: number;
+        };
+        hidden: {
+            type: BooleanConstructor;
+            notify: boolean;
+        };
+        preferredDropdownHorizontalAlign: {
+            type: StringConstructor;
+            value: string;
+        };
+        renderHeader: {
+            type: FunctionConstructor;
+        };
+        renderCell: {
+            type: FunctionConstructor;
+        };
+        renderEditCell: {
+            type: FunctionConstructor;
+        };
+        renderGroup: {
+            type: FunctionConstructor;
+        };
+        /**
+         * The priority of the column in the mini mode. If missing the column is disabled in the mini mode.
+         */
+        mini: {
+            type: NumberConstructor;
+            value: null;
+        };
+        /**
+         * An alternative render to use in mini mode. Takes the same params as `renderCell`.
+         */
+        renderMini: {
+            type: FunctionConstructor;
+        };
+    };
+    get observers(): string[];
+};
+//# sourceMappingURL=cosmoz-omnitable-column-mixin.d.ts.map

package/dist/cosmoz-omnitable-column-mixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cosmoz-omnitable-column-mixin.d.ts","sourceRoot":"","sources":["../src/cosmoz-omnitable-column-mixin.js"],"names":[],"mappings":"AAEO;;mBAkJJ;AAlJI;;mBAkJJ;AAlJI;;mBAkJJ;AAlJI;;kBAKJ,SAAI,SA6IJ;AAlJI,+DAkJJ;AAlJI;;;;;;;QAkGJ;;WAEG;;;;;;;;;;;;;QA9ED;;;WAGG;;;;;;;;;;;;;;;;;;;;;;QAOH;;WAEG;;;;;;QAEH;;WAEG;;;;;QAEH;;WAEG;;;;;;;;;;;QAGH;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAiBH;;WAEG;;;;;QAEH;;WAEG;;;;;;EA4EL"}