@mediusinc/mng-commons 5.0.0-rc.0-c31d5206 → 5.0.0-rc.1

package/esm2022/core/data-list/data-list-params-helpers.mjs

@@ -0,0 +1,415 @@
+import { CommonsInternalError } from '../error/error.model';
+import { dateToIsoString } from '../helpers/date';
+import { FilterMatchMode } from './filter-match.model';
+/**
+ * Converts a TableLazyLoadEvent to DataListParams.
+ *
+ * @param {TableLazyLoadEvent} event - The event containing the data to convert.
+ * @return {DataListParams} - The converted DataListParams object.
+ */
+export function fromTableLoadToDataListParams(event) {
+    const params = {};
+    if (event.first != null) {
+        params.offset = event.first;
+    }
+    if (event.rows != null) {
+        params.limit = event.rows;
+    }
+    if (typeof event.globalFilter === 'string') {
+        params.search = event.globalFilter;
+    }
+    else if (Array.isArray(event.globalFilter) && event.globalFilter.length > 0) {
+        params.search = event.globalFilter.join(',');
+    }
+    if (Array.isArray(event.multiSortMeta) && event.multiSortMeta.length > 0) {
+        params.sort = event.multiSortMeta.map(m => ({ property: m.field, ascending: m.order >= 0 }));
+    }
+    if (event.filters) {
+        params.filters = Object.keys(event.filters).reduce((acc, key) => {
+            const filter = {};
+            const eventFilter = event.filters?.[key];
+            if (Array.isArray(eventFilter)) {
+                filter.value = eventFilter[0].value;
+                filter.matchMode = eventFilter[0].matchMode;
+            }
+            else if (eventFilter !== undefined) {
+                filter.value = eventFilter.value;
+                filter.matchMode = eventFilter.matchMode;
+            }
+            return { ...acc, [key]: filter };
+        }, {});
+    }
+    return params;
+}
+/**
+ * Converts the given parameters to URL query parameters.
+ * Sorts are formatted in Medius data API sort query language: `asc:prop1,desc:prop2`, ...
+ * Filter keys are "flattened" in the new object, values are formatted in Medius data API filter query language: `cs:eq:asd`, `in:asd,qwe`, `ex`, ...
+ *
+ * @param {DataListParams} params - The parameters to convert.
+ * @param {DataListParams|null} defaults - The default parameters used if no matching property in params is available. Defaults to { limit: 25, offset: 0 } if not provided.
+ * @returns {Params} - The URL query parameters object.
+ */
+export function dataListParamsToUrlQuery(params, defaults = {
+    limit: 25,
+    offset: 0
+}) {
+    const urlParams = {};
+    if (params.limit && params.limit !== defaults?.limit) {
+        urlParams['limit'] = params.limit;
+    }
+    if (params.offset && params.offset !== defaults?.offset) {
+        urlParams['offset'] = params.offset;
+    }
+    if (params.search && params.search !== defaults?.search) {
+        urlParams['q'] = params.search;
+    }
+    if (params.sort && Array.isArray(params.sort) && params.sort.length > 0) {
+        if (defaults?.sort == null ||
+            !Array.isArray(defaults.sort) ||
+            defaults.sort.length === 0 ||
+            params.sort.length !== defaults.sort.length ||
+            defaults.sort.some((ds, idx) => ds.property !== params.sort[idx].property || (ds.ascending ?? true) !== (params.sort[idx].ascending ?? true))) {
+            urlParams['sort'] = dataListParamsSortToUrlQuery(params);
+        }
+    }
+    if (params.filters) {
+        Object.keys(params.filters).forEach(k => {
+            const paramFilter = params.filters[k];
+            const defaultFilter = defaults?.filters?.[k];
+            if (defaultFilter &&
+                ((Array.isArray(defaultFilter.value) &&
+                    Array.isArray(paramFilter.value) &&
+                    defaultFilter.value.length === paramFilter.value.length &&
+                    defaultFilter.value.every((v, idx) => {
+                        const value = paramFilter.value[idx];
+                        if (value instanceof Date && v instanceof Date)
+                            return value.getTime() === v.getTime();
+                        else
+                            return value === v;
+                    })) || // handle arrays
+                    defaultFilter.value === paramFilter.value) &&
+                defaultFilter.matchMode === paramFilter.matchMode &&
+                (defaultFilter.caseSensitive ?? false) === (paramFilter.caseSensitive ?? false)) {
+                return;
+            }
+            if (paramFilter.value == null && defaultFilter?.value == null) {
+                return;
+            }
+            urlParams[k] = dataListParamsFiltersToUrlQuery(params, k, true);
+        });
+    }
+    if (defaults?.filters) {
+        // add other defaults
+        const paramFilterKeys = params.filters ? Object.keys(params.filters) : [];
+        Object.keys(defaults.filters)
+            .filter(k => paramFilterKeys.indexOf(k) < 0)
+            .forEach(k => {
+            urlParams[k] = dataListParamsFiltersToUrlQuery(defaults, k);
+        });
+    }
+    return urlParams;
+}
+/**
+ * Merges the provided parameters with default values and returns the merged object.
+ *
+ * @param {DataListParams} params - The parameters to merge with defaults.
+ * @param {DataListParams} defaults - The default values to merge with params (optional, default is { limit: 25, offset: 0 }).
+ * @returns {DataListParams} - The merged parameters object.
+ */
+export function mergeDataListParamsWithDefaults(params, defaults = {
+    limit: 25,
+    offset: 0
+}) {
+    const merged = {
+        limit: params.limit ?? defaults.limit,
+        offset: params.offset ?? defaults.offset,
+        search: params.search ?? defaults.search,
+        sort: (params.sort ?? defaults.sort)?.map(s => ({ ...s }))
+    };
+    if (params.filters) {
+        merged.filters = {};
+        Object.entries(params.filters).forEach(([key, value]) => (merged.filters[key] = { ...value }));
+    }
+    if (defaults.filters) {
+        if (!merged.filters)
+            merged.filters = {};
+        Object.entries(defaults.filters).forEach(([key, value]) => {
+            if (merged.filters[key] === undefined) {
+                merged.filters[key] = { ...value };
+            }
+        });
+    }
+    return merged;
+}
+/**
+ * Converts an object of parameters to a URL query string for sorting.
+ * Sorts are formatted in Medius data API sort query language: `asc:prop1,desc:prop2`, ...
+ *
+ * @param {DataListParams} params - An optional object containing sort parameters.
+ * @returns A string representing the URL query or undefined if no sort parameters are provided.
+ */
+export function dataListParamsSortToUrlQuery(params) {
+    return params && Array.isArray(params.sort)
+        ? params.sort.map(s => `${s.ascending === true || s.ascending === undefined ? 'asc' : 'desc'}:${String(s.property)}`).join(',')
+        : undefined;
+}
+/**
+ * Converts a specific filter parameter (by key) from DataListParams object to a URL query string.
+ * Filter keys are "flattened" in the new object, values are formatted in Medius data API filter query language: `cs:eq:asd`, `in:asd,qwe`, `ex`, ...
+ *
+ * @param {DataListParams<any, Filters> | undefined} params - The DataListParams object containing the filters.
+ * @param {Filters} key - The key of the filter to convert.
+ * @param {boolean} [allowNull=false] - Indicates whether to allow null values in the query string.
+ * @return {string | undefined} - The URL query string representing the specified filter, or undefined if the filter is not found.
+ */
+export function dataListParamsFiltersToUrlQuery(params, key, allowNull = false) {
+    const paramFilter = params?.filters?.[key];
+    return dataListParamsFilterToUrlQuery(paramFilter, allowNull);
+}
+/**
+ * Converts a filter to a URL query string.
+ * Filter keys are "flattened" in the new object, values are formatted in Medius data API filter query language: `cs:eq:asd`, `in:asd,qwe`, `ex`, ...
+ *
+ * @param {DataListFilter} paramFilter - The filter object to be converted.
+ * @param {boolean} [allowNull=false] - Indicates whether to allow null values in the filter.
+ * @returns {string|undefined} - The filter converted to a URL query string, or undefined if no filter is provided or the filter has empty or invalid values.
+ * @throws {CommonsInternalError} - If the filter has invalid values.
+ */
+export function dataListParamsFilterToUrlQuery(paramFilter, allowNull = false) {
+    const filterValueAsArray = Array.isArray(paramFilter?.value) ? paramFilter.value.filter(v => v !== undefined && (allowNull || v !== null)) : undefined;
+    if (paramFilter === undefined ||
+        (!allowNull && paramFilter.value == null) ||
+        (typeof paramFilter.value === 'string' && paramFilter.value.length === 0) ||
+        (Array.isArray(filterValueAsArray) && filterValueAsArray.length === 0)) {
+        // no need to include filters for empty values
+        return undefined;
+    }
+    const matchMode = paramFilter.matchMode ?? FilterMatchMode.Equals;
+    if (matchMode === FilterMatchMode.Between && !(Array.isArray(filterValueAsArray) && filterValueAsArray.length === 2)) {
+        throw new CommonsInternalError(`Filter match mode between requires exactly 2 values: ${paramFilter.value}`);
+    }
+    if ((matchMode === FilterMatchMode.In || matchMode === FilterMatchMode.NotIn) && (!Array.isArray(filterValueAsArray) || filterValueAsArray.length === 0)) {
+        throw new CommonsInternalError(`Filter match mode ${matchMode} requires non-empty array: ${paramFilter.value}`);
+    }
+    if ([FilterMatchMode.In, FilterMatchMode.NotIn, FilterMatchMode.Between].indexOf(matchMode) === -1 && Array.isArray(filterValueAsArray)) {
+        throw new CommonsInternalError(`Filter match mode ${matchMode} must not be array: ${paramFilter.value}`);
+    }
+    const noVal = paramFilter.matchMode === FilterMatchMode.Exists || paramFilter.matchMode === FilterMatchMode.DoesNotExist;
+    const urlValuePart = noVal ? '' : `:${dataListParamsFilterValueToUrlString(filterValueAsArray ?? paramFilter.value, allowNull)}`;
+    return `${paramFilter.caseSensitive ? 'cs:' : paramFilter.caseSensitive === false ? 'ci:' : ''}${FilterMatchMode.getAbbreviation(matchMode) ?? matchMode}${urlValuePart}`;
+}
+/**
+ * Converts URL query parameters to a DataListParams object.
+ * Sorts are formatted from Medius data API sort query language: `asc:prop1,desc:prop2`, ...
+ * Filter keys are all keys in Params object that are not matched elsewhere, values are formatted from Medius data API filter query language: `cs:eq:asd`, `in:asd,qwe`, `ex`, ...
+ *
+ * @param {Params} urlParams - The URL query parameters.
+ * @return {DataListParams} - The converted DataListParams object.
+ */
+export function fromUrlQueryToDataListParams(urlParams) {
+    const params = {};
+    Object.entries(urlParams).forEach(([urlParamKey, urlParamValue]) => {
+        if (urlParamKey === 'limit') {
+            params.limit = +urlParamValue;
+            if (isNaN(params.limit) || params.limit < 0) {
+                delete params.limit;
+            }
+        }
+        else if (urlParamKey === 'offset') {
+            params.offset = +urlParamValue;
+            if (isNaN(params.offset) || params.offset < 0) {
+                delete params.offset;
+            }
+        }
+        else if (urlParamKey === 'q') {
+            params.search = urlParamValue;
+        }
+        else if (urlParamKey === 'sort') {
+            if (typeof urlParamValue === 'string') {
+                params.sort = urlParamValue.split(',').map(s => {
+                    const [direction, property] = s.split(':');
+                    return { property: (property ?? direction), ascending: direction !== 'desc' };
+                });
+            }
+            else {
+                throw new CommonsInternalError(`String is expected as value for '${urlParamKey}' when converting from urlParams`);
+            }
+        }
+        else if (typeof urlParamValue === 'string') {
+            if (urlParamValue.length === 0) {
+                // empty string should be ignored
+                return;
+            }
+            const filterParts = urlParamValue.split(':');
+            let partIdx = 0;
+            // case sensitive
+            let caseSensitive = undefined;
+            if (filterParts[partIdx] === 'cs' || filterParts[partIdx] === 'ci') {
+                caseSensitive = filterParts[partIdx++] === 'cs';
+            }
+            // match mode
+            const matchMode = filterParts[partIdx] ? FilterMatchMode.fromAbbreviation(filterParts[partIdx]) ?? filterParts[partIdx] : FilterMatchMode.Equals;
+            partIdx++;
+            const noVal = matchMode === FilterMatchMode.Exists || matchMode === FilterMatchMode.DoesNotExist;
+            // value
+            let value = undefined;
+            if (!noVal) {
+                if (filterParts.length < 2) {
+                    return;
+                }
+                if (partIdx === filterParts.length - 1) {
+                    value = filterParts[partIdx];
+                }
+                else if (partIdx < filterParts.length) {
+                    // array that should not be array, so join back together
+                    value = filterParts.slice(partIdx, filterParts.length).join(':');
+                }
+                if (value === undefined && matchMode !== FilterMatchMode.Exists && matchMode !== FilterMatchMode.DoesNotExist) {
+                    // if value undefined and match mode expects value, then skip
+                    return;
+                }
+                if (value === 'null') {
+                    value = null;
+                }
+                if ((matchMode === FilterMatchMode.In || matchMode === FilterMatchMode.NotIn || matchMode === FilterMatchMode.Between) && typeof value === 'string') {
+                    let arrayVal = [];
+                    // these match modes expect array
+                    if (value.indexOf('"') >= 0) {
+                        const tokens = [];
+                        let currentToken = '';
+                        let explicitQuotes = false; //token is quoted, e.g. in:1,2,"22""",",123"""
+                        let quotesOpened = false; //token has started processing
+                        let quotesExplicitlyClosed = false; //token processing has finished, after single " in quoted mode, or before , in not quoted
+                        for (let i = 0; i < value.length; i++) {
+                            const c = value[i];
+                            // reset the tokenizer when seeing the token separator
+                            // only if either:
+                            // the quotes have not been opened yet (when there are no characters between separators),
+                            // the token has been explicitly closed (when we actually have explicit opening i.e., quotes as the first character)
+                            // or we have implicit quotes (i.e., quotes are not the first character)
+                            if (c === ',' && (!quotesOpened || quotesExplicitlyClosed || !explicitQuotes)) {
+                                tokens.push(currentToken);
+                                currentToken = '';
+                                quotesOpened = false;
+                                quotesExplicitlyClosed = false;
+                                explicitQuotes = false;
+                            }
+                            else if (c == '"') {
+                                // escaped double-quotes
+                                if (explicitQuotes && i + 1 < value.length && value[i + 1] === '"') {
+                                    currentToken += c; // Append one double-quote to the current token
+                                    i++; // Skip the next double-quote
+                                }
+                                // we encounter quotes again after they were the first character => we close the token
+                                else if (explicitQuotes) {
+                                    quotesExplicitlyClosed = true;
+                                }
+                                // implicit quotes
+                                else if (quotesOpened) {
+                                    currentToken += c;
+                                }
+                                // quotes are the first character => explicitly open the token
+                                else {
+                                    currentToken = '';
+                                    quotesOpened = true;
+                                    explicitQuotes = true;
+                                }
+                            }
+                            else {
+                                if (quotesExplicitlyClosed) {
+                                    return;
+                                }
+                                quotesOpened = true;
+                                currentToken += c;
+                            }
+                        }
+                        if (quotesOpened && !quotesExplicitlyClosed && explicitQuotes) {
+                            return;
+                        }
+                        // Append the last token after the loop ends
+                        tokens.push(currentToken.toString());
+                        arrayVal = tokens;
+                    }
+                    else {
+                        arrayVal = value.split(',');
+                    }
+                    if (matchMode === FilterMatchMode.Between && arrayVal.length !== 2) {
+                        return;
+                    }
+                    value = arrayVal;
+                }
+                if ((typeof value === 'string' && value.length === 0) || (Array.isArray(value) && value.length === 0)) {
+                    // filter with empty value is to be ignored
+                    return;
+                }
+            }
+            else {
+                caseSensitive = undefined;
+            }
+            if (!params.filters) {
+                params.filters = {};
+            }
+            params.filters[urlParamKey] = { value: value, matchMode: matchMode, caseSensitive: caseSensitive };
+        }
+    });
+    return params;
+}
+/**
+ * Makes a copy of the given DataListParams object.
+ *
+ * @param {DataListParams<Sorts, Filters>} params - The DataListParams object to be copied.
+ * @returns {DataListParams<Sorts, Filters>} - Returns a new copy of the DataListParams object.
+ */
+export function copyDataListParams(params) {
+    const copy = {
+        offset: params.offset,
+        limit: params.limit,
+        search: params.search
+    };
+    if (params.sort) {
+        copy.sort = params.sort?.map(s => ({ ...s }));
+    }
+    if (params.filters) {
+        copy.filters = Object.entries(params.filters).reduce((acc, [key, value]) => {
+            const filterValue = value;
+            return {
+                ...acc,
+                [key]: {
+                    ...filterValue,
+                    value: Array.isArray(filterValue.value) ? [...filterValue.value] : filterValue.value
+                }
+            };
+        }, {});
+    }
+    return copy;
+}
+/**
+ * Converts a value to a URL query param string representation.
+ *
+ * @param {unknown} value - The value to be converted.
+ * @param {boolean} [allowNull=false] - Indicates whether null values are allowed.
+ * @returns {string} The URL parameter representation of the value.
+ * @throws {CommonsInternalError} If an undefined value is passed without allowNull set to true.
+ * @throws {CommonsInternalError} If the value is an object (excluding Date).
+ */
+export function dataListParamsFilterValueToUrlString(value, allowNull = false) {
+    if (value === null && allowNull)
+        return 'null';
+    if (value == null)
+        throw new CommonsInternalError('Undefined value cannot be converted to url param.'); // this should not happen, should be filtered out earlier
+    if (Array.isArray(value))
+        return value
+            .map(v => dataListParamsFilterValueToUrlString(v, allowNull))
+            .map(v => (v.indexOf(',') >= 0 || v.indexOf('"') >= 0 ? `"${v.replaceAll('"', '""')}"` : v))
+            .join(',');
+    if (typeof value === 'object') {
+        if (value instanceof Date)
+            return dateToIsoString(value, 'dateTime', { utc: true });
+        else {
+            throw new CommonsInternalError('Filter value cannot be object');
+        }
+    }
+    return String(value);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-list-params-helpers.js","sourceRoot":"","sources":["../../../../core/src/data-list/data-list-params-helpers.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,oBAAoB,EAAC,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAC,eAAe,EAAC,MAAM,iBAAiB,CAAC;AAEhD,OAAO,EAAC,eAAe,EAAC,MAAM,sBAAsB,CAAC;AAErD;;;;;GAKG;AACH,MAAM,UAAU,6BAA6B,CAAC,KAAyB;IACnE,MAAM,MAAM,GAAmB,EAAE,CAAC;IAElC,IAAI,KAAK,CAAC,KAAK,IAAI,IAAI,EAAE,CAAC;QACtB,MAAM,CAAC,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC;IAChC,CAAC;IACD,IAAI,KAAK,CAAC,IAAI,IAAI,IAAI,EAAE,CAAC;QACrB,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC;IAC9B,CAAC;IAED,IAAI,OAAO,KAAK,CAAC,YAAY,KAAK,QAAQ,EAAE,CAAC;QACzC,MAAM,CAAC,MAAM,GAAG,KAAK,CAAC,YAAY,CAAC;IACvC,CAAC;SAAM,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI,KAAK,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC5E,MAAM,CAAC,MAAM,GAAG,KAAK,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACjD,CAAC;IAED,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,aAAa,CAAC,IAAI,KAAK,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACvE,MAAM,CAAC,IAAI,GAAG,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAC,QAAQ,EAAE,CAAC,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,EAAC,CAAC,CAAC,CAAC;IAC/F,CAAC;IAED,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;QAChB,MAAM,CAAC,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE;YAC5D,MAAM,MAAM,GAAmB,EAAE,CAAC;YAClC,MAAM,WAAW,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC,GAAmB,CAAC,CAAC;YACzD,IAAI,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,CAAC;gBAC7B,MAAM,CAAC,KAAK,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;gBACpC,MAAM,CAAC,SAAS,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;YAChD,CAAC;iBAAM,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;gBACnC,MAAM,CAAC,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC;gBACjC,MAAM,CAAC,SAAS,GAAG,WAAW,CAAC,SAAS,CAAC;YAC7C,CAAC;YACD,OAAO,EAAC,GAAG,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,MAAM,EAAC,CAAC;QACnC,CAAC,EAAE,EAAE,CAAC,CAAC;IACX,CAAC;IAED,OAAO,MAAM,CAAC;AAClB,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,wBAAwB,CACpC,MAAgC,EAChC,WAA4C;IACxC,KAAK,EAAE,EAAE;IACT,MAAM,EAAE,CAAC;CACZ;IAED,MAAM,SAAS,GAAW,EAAE,CAAC;IAE7B,IAAI,MAAM,CAAC,KAAK,IAAI,MAAM,CAAC,KAAK,KAAK,QAAQ,EAAE,KAAK,EAAE,CAAC;QACnD,SAAS,CAAC,OAAO,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;IACtC,CAAC;IACD,IAAI,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,QAAQ,EAAE,MAAM,EAAE,CAAC;QACtD,SAAS,CAAC,QAAQ,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC;IACxC,CAAC;IACD,IAAI,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,QAAQ,EAAE,MAAM,EAAE,CAAC;QACtD,SAAS,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC;IACnC,CAAC;IACD,IAAI,MAAM,CAAC,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACtE,IACI,QAAQ,EAAE,IAAI,IAAI,IAAI;YACtB,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC;YAC7B,QAAQ,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC;YAC1B,MAAM,CAAC,IAAI,CAAC,MAAM,KAAK,QAAQ,CAAC,IAAI,CAAC,MAAM;YAC3C,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,GAAG,EAAE,EAAE,CAAC,EAAE,CAAC,QAAQ,KAAK,MAAM,CAAC,IAAK,CAAC,GAAG,CAAC,CAAC,QAAQ,IAAI,CAAC,EAAE,CAAC,SAAS,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAK,CAAC,GAAG,CAAC,CAAC,SAAS,IAAI,IAAI,CAAC,CAAC,EACjJ,CAAC;YACC,SAAS,CAAC,MAAM,CAAC,GAAG,4BAA4B,CAAC,MAAM,CAAC,CAAC;QAC7D,CAAC;IACL,CAAC;IACD,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;QACjB,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;YACpC,MAAM,WAAW,GAAG,MAAM,CAAC,OAAQ,CAAC,CAAiB,CAAC,CAAC;YACvD,MAAM,aAAa,GAAG,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAiB,CAAC,CAAC;YAC7D,IACI,aAAa;gBACb,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,KAAK,CAAC;oBAChC,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,KAAK,CAAC;oBAChC,aAAa,CAAC,KAAK,CAAC,MAAM,KAAK,WAAW,CAAC,KAAK,CAAC,MAAM;oBACvD,aAAa,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE;wBACjC,MAAM,KAAK,GAAI,WAAW,CAAC,KAAwC,CAAC,GAAG,CAAC,CAAC;wBACzE,IAAI,KAAK,YAAY,IAAI,IAAI,CAAC,YAAY,IAAI;4BAAE,OAAO,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC;;4BAClF,OAAO,KAAK,KAAK,CAAC,CAAC;oBAC5B,CAAC,CAAC,CAAC,IAAI,gBAAgB;oBACvB,aAAa,CAAC,KAAK,KAAK,WAAW,CAAC,KAAK,CAAC;gBAC9C,aAAa,CAAC,SAAS,KAAK,WAAW,CAAC,SAAS;gBACjD,CAAC,aAAa,CAAC,aAAa,IAAI,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,aAAa,IAAI,KAAK,CAAC,EACjF,CAAC;gBACC,OAAO;YACX,CAAC;YAED,IAAI,WAAW,CAAC,KAAK,IAAI,IAAI,IAAI,aAAa,EAAE,KAAK,IAAI,IAAI,EAAE,CAAC;gBAC5D,OAAO;YACX,CAAC;YAED,SAAS,CAAC,CAAC,CAAC,GAAG,+BAA+B,CAAC,MAAM,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC;QACpE,CAAC,CAAC,CAAC;IACP,CAAC;IACD,IAAI,QAAQ,EAAE,OAAO,EAAE,CAAC;QACpB,qBAAqB;QACrB,MAAM,eAAe,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAC1E,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC;aACxB,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;aAC3C,OAAO,CAAC,CAAC,CAAC,EAAE;YACT,SAAS,CAAC,CAAC,CAAC,GAAG,+BAA+B,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;QAChE,CAAC,CAAC,CAAC;IACX,CAAC;IAED,OAAO,SAAS,CAAC;AACrB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,+BAA+B,CAC3C,MAAsC,EACtC,WAA2C;IACvC,KAAK,EAAE,EAAE;IACT,MAAM,EAAE,CAAC;CACZ;IAED,MAAM,MAAM,GAAmC;QAC3C,KAAK,EAAE,MAAM,CAAC,KAAK,IAAI,QAAQ,CAAC,KAAK;QACrC,MAAM,EAAE,MAAM,CAAC,MAAM,IAAI,QAAQ,CAAC,MAAM;QACxC,MAAM,EAAE,MAAM,CAAC,MAAM,IAAI,QAAQ,CAAC,MAAM;QACxC,IAAI,EAAE,CAAC,MAAM,CAAC,IAAI,IAAI,QAAQ,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAC,GAAG,CAAC,EAAC,CAAC,CAAC;KAC3D,CAAC;IAEF,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;QACjB,MAAM,CAAC,OAAO,GAAG,EAAkC,CAAC;QACpD,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,OAAQ,CAAC,GAAc,CAAC,GAAG,EAAC,GAAI,KAAwB,EAAC,CAAC,CAAC,CAAC;IACjI,CAAC;IACD,IAAI,QAAQ,CAAC,OAAO,EAAE,CAAC;QACnB,IAAI,CAAC,MAAM,CAAC,OAAO;YAAE,MAAM,CAAC,OAAO,GAAG,EAAkC,CAAC;QACzE,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE;YACtD,IAAI,MAAM,CAAC,OAAQ,CAAC,GAAc,CAAC,KAAK,SAAS,EAAE,CAAC;gBAChD,MAAM,CAAC,OAAQ,CAAC,GAAc,CAAC,GAAG,EAAC,GAAI,KAAwB,EAAC,CAAC;YACrE,CAAC;QACL,CAAC,CAAC,CAAC;IACP,CAAC;IAED,OAAO,MAAM,CAAC;AAClB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,4BAA4B,CAAC,MAAiC;IAC1E,OAAO,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC;QACvC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,SAAS,KAAK,IAAI,IAAI,CAAC,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,IAAI,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;QAC/H,CAAC,CAAC,SAAS,CAAC;AACpB,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,+BAA+B,CAC3C,MAAgD,EAChD,GAAY,EACZ,SAAS,GAAG,KAAK;IAEjB,MAAM,WAAW,GAAG,MAAM,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC;IAC3C,OAAO,8BAA8B,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;AAClE,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,8BAA8B,CAAC,WAA4B,EAAE,SAAS,GAAG,KAAK;IAC1F,MAAM,kBAAkB,GAAG,KAAK,CAAC,OAAO,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,WAAY,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,SAAS,IAAI,CAAC,SAAS,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IACxJ,IACI,WAAW,KAAK,SAAS;QACzB,CAAC,CAAC,SAAS,IAAI,WAAW,CAAC,KAAK,IAAI,IAAI,CAAC;QACzC,CAAC,OAAO,WAAW,CAAC,KAAK,KAAK,QAAQ,IAAI,WAAW,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC;QACzE,CAAC,KAAK,CAAC,OAAO,CAAC,kBAAkB,CAAC,IAAI,kBAAkB,CAAC,MAAM,KAAK,CAAC,CAAC,EACxE,CAAC;QACC,8CAA8C;QAC9C,OAAO,SAAS,CAAC;IACrB,CAAC;IAED,MAAM,SAAS,GAAG,WAAW,CAAC,SAAS,IAAI,eAAe,CAAC,MAAM,CAAC;IAElE,IAAI,SAAS,KAAK,eAAe,CAAC,OAAO,IAAI,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,kBAAkB,CAAC,IAAI,kBAAkB,CAAC,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC;QACnH,MAAM,IAAI,oBAAoB,CAAC,wDAAwD,WAAW,CAAC,KAAK,EAAE,CAAC,CAAC;IAChH,CAAC;IAED,IAAI,CAAC,SAAS,KAAK,eAAe,CAAC,EAAE,IAAI,SAAS,KAAK,eAAe,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,kBAAkB,CAAC,IAAI,kBAAkB,CAAC,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC;QACvJ,MAAM,IAAI,oBAAoB,CAAC,qBAAqB,SAAS,8BAA8B,WAAW,CAAC,KAAK,EAAE,CAAC,CAAC;IACpH,CAAC;IAED,IAAK,CAAC,eAAe,CAAC,EAAE,EAAE,eAAe,CAAC,KAAK,EAAE,eAAe,CAAC,OAAO,CAAc,CAAC,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,kBAAkB,CAAC,EAAE,CAAC;QACpJ,MAAM,IAAI,oBAAoB,CAAC,qBAAqB,SAAS,uBAAuB,WAAW,CAAC,KAAK,EAAE,CAAC,CAAC;IAC7G,CAAC;IAED,MAAM,KAAK,GAAG,WAAW,CAAC,SAAS,KAAK,eAAe,CAAC,MAAM,IAAI,WAAW,CAAC,SAAS,KAAK,eAAe,CAAC,YAAY,CAAC;IACzH,MAAM,YAAY,GAAG,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,oCAAoC,CAAC,kBAAkB,IAAI,WAAW,CAAC,KAAK,EAAE,SAAS,CAAC,EAAE,CAAC;IAEjI,OAAO,GAAG,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,WAAW,CAAC,aAAa,KAAK,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,eAAe,CAAC,eAAe,CAAC,SAAS,CAAC,IAAI,SAAS,GAAG,YAAY,EAAE,CAAC;AAC9K,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,4BAA4B,CAAC,SAAiB;IAC1D,MAAM,MAAM,GAAmB,EAAE,CAAC;IAElC,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,WAAW,EAAE,aAAa,CAAC,EAAE,EAAE;QAC/D,IAAI,WAAW,KAAK,OAAO,EAAE,CAAC;YAC1B,MAAM,CAAC,KAAK,GAAG,CAAC,aAAa,CAAC;YAC9B,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,KAAK,GAAG,CAAC,EAAE,CAAC;gBAC1C,OAAO,MAAM,CAAC,KAAK,CAAC;YACxB,CAAC;QACL,CAAC;aAAM,IAAI,WAAW,KAAK,QAAQ,EAAE,CAAC;YAClC,MAAM,CAAC,MAAM,GAAG,CAAC,aAAa,CAAC;YAC/B,IAAI,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC5C,OAAO,MAAM,CAAC,MAAM,CAAC;YACzB,CAAC;QACL,CAAC;aAAM,IAAI,WAAW,KAAK,GAAG,EAAE,CAAC;YAC7B,MAAM,CAAC,MAAM,GAAG,aAAa,CAAC;QAClC,CAAC;aAAM,IAAI,WAAW,KAAK,MAAM,EAAE,CAAC;YAChC,IAAI,OAAO,aAAa,KAAK,QAAQ,EAAE,CAAC;gBACpC,MAAM,CAAC,IAAI,GAAG,aAAa,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE;oBAC3C,MAAM,CAAC,SAAS,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;oBAC3C,OAAO,EAAC,QAAQ,EAAE,CAAC,QAAQ,IAAI,SAAS,CAAiB,EAAE,SAAS,EAAE,SAAS,KAAK,MAAM,EAAC,CAAC;gBAChG,CAAC,CAAC,CAAC;YACP,CAAC;iBAAM,CAAC;gBACJ,MAAM,IAAI,oBAAoB,CAAC,oCAAoC,WAAW,kCAAkC,CAAC,CAAC;YACtH,CAAC;QACL,CAAC;aAAM,IAAI,OAAO,aAAa,KAAK,QAAQ,EAAE,CAAC;YAC3C,IAAI,aAAa,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBAC7B,iCAAiC;gBACjC,OAAO;YACX,CAAC;YAED,MAAM,WAAW,GAAG,aAAa,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YAC7C,IAAI,OAAO,GAAG,CAAC,CAAC;YAEhB,iBAAiB;YACjB,IAAI,aAAa,GAAwB,SAAS,CAAC;YACnD,IAAI,WAAW,CAAC,OAAO,CAAC,KAAK,IAAI,IAAI,WAAW,CAAC,OAAO,CAAC,KAAK,IAAI,EAAE,CAAC;gBACjE,aAAa,GAAG,WAAW,CAAC,OAAO,EAAE,CAAC,KAAK,IAAI,CAAC;YACpD,CAAC;YAED,aAAa;YACb,MAAM,SAAS,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,gBAAgB,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,IAAI,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,MAAM,CAAC;YACjJ,OAAO,EAAE,CAAC;YAEV,MAAM,KAAK,GAAG,SAAS,KAAK,eAAe,CAAC,MAAM,IAAI,SAAS,KAAK,eAAe,CAAC,YAAY,CAAC;YAEjG,QAAQ;YACR,IAAI,KAAK,GAAyC,SAAS,CAAC;YAC5D,IAAI,CAAC,KAAK,EAAE,CAAC;gBACT,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBACzB,OAAO;gBACX,CAAC;gBAED,IAAI,OAAO,KAAK,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBACrC,KAAK,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;gBACjC,CAAC;qBAAM,IAAI,OAAO,GAAG,WAAW,CAAC,MAAM,EAAE,CAAC;oBACtC,wDAAwD;oBACxD,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;gBACrE,CAAC;gBAED,IAAI,KAAK,KAAK,SAAS,IAAI,SAAS,KAAK,eAAe,CAAC,MAAM,IAAI,SAAS,KAAK,eAAe,CAAC,YAAY,EAAE,CAAC;oBAC5G,6DAA6D;oBAC7D,OAAO;gBACX,CAAC;gBAED,IAAI,KAAK,KAAK,MAAM,EAAE,CAAC;oBACnB,KAAK,GAAG,IAAI,CAAC;gBACjB,CAAC;gBAED,IAAI,CAAC,SAAS,KAAK,eAAe,CAAC,EAAE,IAAI,SAAS,KAAK,eAAe,CAAC,KAAK,IAAI,SAAS,KAAK,eAAe,CAAC,OAAO,CAAC,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;oBAClJ,IAAI,QAAQ,GAAa,EAAE,CAAC;oBAC5B,iCAAiC;oBACjC,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;wBAC1B,MAAM,MAAM,GAAa,EAAE,CAAC;wBAC5B,IAAI,YAAY,GAAG,EAAE,CAAC;wBACtB,IAAI,cAAc,GAAG,KAAK,CAAC,CAAC,8CAA8C;wBAC1E,IAAI,YAAY,GAAG,KAAK,CAAC,CAAC,8BAA8B;wBACxD,IAAI,sBAAsB,GAAG,KAAK,CAAC,CAAC,yFAAyF;wBAE7H,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;4BACpC,MAAM,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;4BAEnB,sDAAsD;4BACtD,kBAAkB;4BAClB,yFAAyF;4BACzF,oHAAoH;4BACpH,wEAAwE;4BACxE,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC,YAAY,IAAI,sBAAsB,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC;gCAC5E,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;gCAC1B,YAAY,GAAG,EAAE,CAAC;gCAClB,YAAY,GAAG,KAAK,CAAC;gCACrB,sBAAsB,GAAG,KAAK,CAAC;gCAC/B,cAAc,GAAG,KAAK,CAAC;4BAC3B,CAAC;iCAAM,IAAI,CAAC,IAAI,GAAG,EAAE,CAAC;gCAClB,wBAAwB;gCACxB,IAAI,cAAc,IAAI,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC;oCACjE,YAAY,IAAI,CAAC,CAAC,CAAC,+CAA+C;oCAClE,CAAC,EAAE,CAAC,CAAC,6BAA6B;gCACtC,CAAC;gCACD,sFAAsF;qCACjF,IAAI,cAAc,EAAE,CAAC;oCACtB,sBAAsB,GAAG,IAAI,CAAC;gCAClC,CAAC;gCACD,kBAAkB;qCACb,IAAI,YAAY,EAAE,CAAC;oCACpB,YAAY,IAAI,CAAC,CAAC;gCACtB,CAAC;gCACD,8DAA8D;qCACzD,CAAC;oCACF,YAAY,GAAG,EAAE,CAAC;oCAClB,YAAY,GAAG,IAAI,CAAC;oCACpB,cAAc,GAAG,IAAI,CAAC;gCAC1B,CAAC;4BACL,CAAC;iCAAM,CAAC;gCACJ,IAAI,sBAAsB,EAAE,CAAC;oCACzB,OAAO;gCACX,CAAC;gCAED,YAAY,GAAG,IAAI,CAAC;gCACpB,YAAY,IAAI,CAAC,CAAC;4BACtB,CAAC;wBACL,CAAC;wBAED,IAAI,YAAY,IAAI,CAAC,sBAAsB,IAAI,cAAc,EAAE,CAAC;4BAC5D,OAAO;wBACX,CAAC;wBAED,4CAA4C;wBAC5C,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC,CAAC;wBAErC,QAAQ,GAAG,MAAM,CAAC;oBACtB,CAAC;yBAAM,CAAC;wBACJ,QAAQ,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;oBAChC,CAAC;oBAED,IAAI,SAAS,KAAK,eAAe,CAAC,OAAO,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;wBACjE,OAAO;oBACX,CAAC;oBAED,KAAK,GAAG,QAAQ,CAAC;gBACrB,CAAC;gBAED,IAAI,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAM,CAAC,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC;oBACrG,2CAA2C;oBAC3C,OAAO;gBACX,CAAC;YACL,CAAC;iBAAM,CAAC;gBACJ,aAAa,GAAG,SAAS,CAAC;YAC9B,CAAC;YAED,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;gBAClB,MAAM,CAAC,OAAO,GAAG,EAAE,CAAC;YACxB,CAAC;YAED,MAAM,CAAC,OAAO,CAAC,WAA2B,CAAC,GAAG,EAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,aAAa,EAAE,aAAa,EAAC,CAAC;QACrH,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,OAAO,MAAM,CAAC;AAClB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,kBAAkB,CAAqD,MAAsC;IACzH,MAAM,IAAI,GAAmC;QACzC,MAAM,EAAE,MAAM,CAAC,MAAM;QACrB,KAAK,EAAE,MAAM,CAAC,KAAK;QACnB,MAAM,EAAE,MAAM,CAAC,MAAM;KACxB,CAAC;IAEF,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC;QACd,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAC,GAAG,CAAC,EAAC,CAAC,CAAC,CAAC;IAChD,CAAC;IACD,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;QACjB,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE;YACvE,MAAM,WAAW,GAAG,KAAuB,CAAC;YAC5C,OAAO;gBACH,GAAG,GAAG;gBACN,CAAC,GAAG,CAAC,EAAE;oBACH,GAAG,WAAW;oBACd,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,KAAK;iBACrE;aACtB,CAAC;QACN,CAAC,EAAE,EAAkC,CAAC,CAAC;IAC3C,CAAC;IAED,OAAO,IAAI,CAAC;AAChB,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,oCAAoC,CAAC,KAAc,EAAE,SAAS,GAAG,KAAK;IAClF,IAAI,KAAK,KAAK,IAAI,IAAI,SAAS;QAAE,OAAO,MAAM,CAAC;IAC/C,IAAI,KAAK,IAAI,IAAI;QAAE,MAAM,IAAI,oBAAoB,CAAC,mDAAmD,CAAC,CAAC,CAAC,yDAAyD;IACjK,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QACpB,OAAO,KAAK;aACP,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,oCAAoC,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;aAC5D,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;aAC3F,IAAI,CAAC,GAAG,CAAC,CAAC;IACnB,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC5B,IAAI,KAAK,YAAY,IAAI;YAAE,OAAO,eAAe,CAAC,KAAK,EAAE,UAAU,EAAE,EAAC,GAAG,EAAE,IAAI,EAAC,CAAC,CAAC;aAC7E,CAAC;YACF,MAAM,IAAI,oBAAoB,CAAC,+BAA+B,CAAC,CAAC;QACpE,CAAC;IACL,CAAC;IACD,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;AACzB,CAAC","sourcesContent":["import {Params} from '@angular/router';\n\nimport {TableLazyLoadEvent} from 'primeng/table';\n\nimport {CommonsInternalError} from '../error/error.model';\nimport {dateToIsoString} from '../helpers/date';\nimport {DataListFilter, DataListFilterValueType, DataListFiltersType, DataListParams} from './data-list.model';\nimport {FilterMatchMode} from './filter-match.model';\n\n/**\n * Converts a TableLazyLoadEvent to DataListParams.\n *\n * @param {TableLazyLoadEvent} event - The event containing the data to convert.\n * @return {DataListParams} - The converted DataListParams object.\n */\nexport function fromTableLoadToDataListParams(event: TableLazyLoadEvent): DataListParams {\n    const params: DataListParams = {};\n\n    if (event.first != null) {\n        params.offset = event.first;\n    }\n    if (event.rows != null) {\n        params.limit = event.rows;\n    }\n\n    if (typeof event.globalFilter === 'string') {\n        params.search = event.globalFilter;\n    } else if (Array.isArray(event.globalFilter) && event.globalFilter.length > 0) {\n        params.search = event.globalFilter.join(',');\n    }\n\n    if (Array.isArray(event.multiSortMeta) && event.multiSortMeta.length > 0) {\n        params.sort = event.multiSortMeta.map(m => ({property: m.field, ascending: m.order >= 0}));\n    }\n\n    if (event.filters) {\n        params.filters = Object.keys(event.filters).reduce((acc, key) => {\n            const filter: DataListFilter = {};\n            const eventFilter = event.filters?.[key as keyof object];\n            if (Array.isArray(eventFilter)) {\n                filter.value = eventFilter[0].value;\n                filter.matchMode = eventFilter[0].matchMode;\n            } else if (eventFilter !== undefined) {\n                filter.value = eventFilter.value;\n                filter.matchMode = eventFilter.matchMode;\n            }\n            return {...acc, [key]: filter};\n        }, {});\n    }\n\n    return params;\n}\n\n/**\n * Converts the given parameters to URL query parameters.\n * Sorts are formatted in Medius data API sort query language: `asc:prop1,desc:prop2`, ...\n * Filter keys are \"flattened\" in the new object, values are formatted in Medius data API filter query language: `cs:eq:asd`, `in:asd,qwe`, `ex`, ...\n *\n * @param {DataListParams} params - The parameters to convert.\n * @param {DataListParams|null} defaults - The default parameters used if no matching property in params is available. Defaults to { limit: 25, offset: 0 } if not provided.\n * @returns {Params} - The URL query parameters object.\n */\nexport function dataListParamsToUrlQuery(\n    params: DataListParams<any, any>,\n    defaults: DataListParams<any, any> | null = {\n        limit: 25,\n        offset: 0\n    }\n): Params {\n    const urlParams: Params = {};\n\n    if (params.limit && params.limit !== defaults?.limit) {\n        urlParams['limit'] = params.limit;\n    }\n    if (params.offset && params.offset !== defaults?.offset) {\n        urlParams['offset'] = params.offset;\n    }\n    if (params.search && params.search !== defaults?.search) {\n        urlParams['q'] = params.search;\n    }\n    if (params.sort && Array.isArray(params.sort) && params.sort.length > 0) {\n        if (\n            defaults?.sort == null ||\n            !Array.isArray(defaults.sort) ||\n            defaults.sort.length === 0 ||\n            params.sort.length !== defaults.sort.length ||\n            defaults.sort.some((ds, idx) => ds.property !== params.sort![idx].property || (ds.ascending ?? true) !== (params.sort![idx].ascending ?? true))\n        ) {\n            urlParams['sort'] = dataListParamsSortToUrlQuery(params);\n        }\n    }\n    if (params.filters) {\n        Object.keys(params.filters).forEach(k => {\n            const paramFilter = params.filters![k as keyof object];\n            const defaultFilter = defaults?.filters?.[k as keyof object];\n            if (\n                defaultFilter &&\n                ((Array.isArray(defaultFilter.value) &&\n                    Array.isArray(paramFilter.value) &&\n                    defaultFilter.value.length === paramFilter.value.length &&\n                    defaultFilter.value.every((v, idx) => {\n                        const value = (paramFilter.value as Array<DataListFilterValueType>)[idx];\n                        if (value instanceof Date && v instanceof Date) return value.getTime() === v.getTime();\n                        else return value === v;\n                    })) || // handle arrays\n                    defaultFilter.value === paramFilter.value) &&\n                defaultFilter.matchMode === paramFilter.matchMode &&\n                (defaultFilter.caseSensitive ?? false) === (paramFilter.caseSensitive ?? false)\n            ) {\n                return;\n            }\n\n            if (paramFilter.value == null && defaultFilter?.value == null) {\n                return;\n            }\n\n            urlParams[k] = dataListParamsFiltersToUrlQuery(params, k, true);\n        });\n    }\n    if (defaults?.filters) {\n        // add other defaults\n        const paramFilterKeys = params.filters ? Object.keys(params.filters) : [];\n        Object.keys(defaults.filters)\n            .filter(k => paramFilterKeys.indexOf(k) < 0)\n            .forEach(k => {\n                urlParams[k] = dataListParamsFiltersToUrlQuery(defaults, k);\n            });\n    }\n\n    return urlParams;\n}\n\n/**\n * Merges the provided parameters with default values and returns the merged object.\n *\n * @param {DataListParams} params - The parameters to merge with defaults.\n * @param {DataListParams} defaults - The default values to merge with params (optional, default is { limit: 25, offset: 0 }).\n * @returns {DataListParams} - The merged parameters object.\n */\nexport function mergeDataListParamsWithDefaults<Sorts = any, Filters extends keyof any = any>(\n    params: DataListParams<Sorts, Filters>,\n    defaults: DataListParams<Sorts, Filters> = {\n        limit: 25,\n        offset: 0\n    }\n): DataListParams<Sorts, Filters> {\n    const merged: DataListParams<Sorts, Filters> = {\n        limit: params.limit ?? defaults.limit,\n        offset: params.offset ?? defaults.offset,\n        search: params.search ?? defaults.search,\n        sort: (params.sort ?? defaults.sort)?.map(s => ({...s}))\n    };\n\n    if (params.filters) {\n        merged.filters = {} as DataListFiltersType<Filters>;\n        Object.entries(params.filters).forEach(([key, value]) => (merged.filters![key as Filters] = {...(value as DataListFilter)}));\n    }\n    if (defaults.filters) {\n        if (!merged.filters) merged.filters = {} as DataListFiltersType<Filters>;\n        Object.entries(defaults.filters).forEach(([key, value]) => {\n            if (merged.filters![key as Filters] === undefined) {\n                merged.filters![key as Filters] = {...(value as DataListFilter)};\n            }\n        });\n    }\n\n    return merged;\n}\n\n/**\n * Converts an object of parameters to a URL query string for sorting.\n * Sorts are formatted in Medius data API sort query language: `asc:prop1,desc:prop2`, ...\n *\n * @param {DataListParams} params - An optional object containing sort parameters.\n * @returns A string representing the URL query or undefined if no sort parameters are provided.\n */\nexport function dataListParamsSortToUrlQuery(params?: DataListParams<any, any>): string | undefined {\n    return params && Array.isArray(params.sort)\n        ? params.sort.map(s => `${s.ascending === true || s.ascending === undefined ? 'asc' : 'desc'}:${String(s.property)}`).join(',')\n        : undefined;\n}\n\n/**\n * Converts a specific filter parameter (by key) from DataListParams object to a URL query string.\n * Filter keys are \"flattened\" in the new object, values are formatted in Medius data API filter query language: `cs:eq:asd`, `in:asd,qwe`, `ex`, ...\n *\n * @param {DataListParams<any, Filters> | undefined} params - The DataListParams object containing the filters.\n * @param {Filters} key - The key of the filter to convert.\n * @param {boolean} [allowNull=false] - Indicates whether to allow null values in the query string.\n * @return {string | undefined} - The URL query string representing the specified filter, or undefined if the filter is not found.\n */\nexport function dataListParamsFiltersToUrlQuery<Filters extends keyof any = string>(\n    params: DataListParams<any, Filters> | undefined,\n    key: Filters,\n    allowNull = false\n): string | undefined {\n    const paramFilter = params?.filters?.[key];\n    return dataListParamsFilterToUrlQuery(paramFilter, allowNull);\n}\n\n/**\n * Converts a filter to a URL query string.\n * Filter keys are \"flattened\" in the new object, values are formatted in Medius data API filter query language: `cs:eq:asd`, `in:asd,qwe`, `ex`, ...\n *\n * @param {DataListFilter} paramFilter - The filter object to be converted.\n * @param {boolean} [allowNull=false] - Indicates whether to allow null values in the filter.\n * @returns {string|undefined} - The filter converted to a URL query string, or undefined if no filter is provided or the filter has empty or invalid values.\n * @throws {CommonsInternalError} - If the filter has invalid values.\n */\nexport function dataListParamsFilterToUrlQuery(paramFilter?: DataListFilter, allowNull = false): string | undefined {\n    const filterValueAsArray = Array.isArray(paramFilter?.value) ? paramFilter!.value.filter(v => v !== undefined && (allowNull || v !== null)) : undefined;\n    if (\n        paramFilter === undefined ||\n        (!allowNull && paramFilter.value == null) ||\n        (typeof paramFilter.value === 'string' && paramFilter.value.length === 0) ||\n        (Array.isArray(filterValueAsArray) && filterValueAsArray.length === 0)\n    ) {\n        // no need to include filters for empty values\n        return undefined;\n    }\n\n    const matchMode = paramFilter.matchMode ?? FilterMatchMode.Equals;\n\n    if (matchMode === FilterMatchMode.Between && !(Array.isArray(filterValueAsArray) && filterValueAsArray.length === 2)) {\n        throw new CommonsInternalError(`Filter match mode between requires exactly 2 values: ${paramFilter.value}`);\n    }\n\n    if ((matchMode === FilterMatchMode.In || matchMode === FilterMatchMode.NotIn) && (!Array.isArray(filterValueAsArray) || filterValueAsArray.length === 0)) {\n        throw new CommonsInternalError(`Filter match mode ${matchMode} requires non-empty array: ${paramFilter.value}`);\n    }\n\n    if (([FilterMatchMode.In, FilterMatchMode.NotIn, FilterMatchMode.Between] as string[]).indexOf(matchMode) === -1 && Array.isArray(filterValueAsArray)) {\n        throw new CommonsInternalError(`Filter match mode ${matchMode} must not be array: ${paramFilter.value}`);\n    }\n\n    const noVal = paramFilter.matchMode === FilterMatchMode.Exists || paramFilter.matchMode === FilterMatchMode.DoesNotExist;\n    const urlValuePart = noVal ? '' : `:${dataListParamsFilterValueToUrlString(filterValueAsArray ?? paramFilter.value, allowNull)}`;\n\n    return `${paramFilter.caseSensitive ? 'cs:' : paramFilter.caseSensitive === false ? 'ci:' : ''}${FilterMatchMode.getAbbreviation(matchMode) ?? matchMode}${urlValuePart}`;\n}\n\n/**\n * Converts URL query parameters to a DataListParams object.\n * Sorts are formatted from Medius data API sort query language: `asc:prop1,desc:prop2`, ...\n * Filter keys are all keys in Params object that are not matched elsewhere, values are formatted from Medius data API filter query language: `cs:eq:asd`, `in:asd,qwe`, `ex`, ...\n *\n * @param {Params} urlParams - The URL query parameters.\n * @return {DataListParams} - The converted DataListParams object.\n */\nexport function fromUrlQueryToDataListParams(urlParams: Params): DataListParams {\n    const params: DataListParams = {};\n\n    Object.entries(urlParams).forEach(([urlParamKey, urlParamValue]) => {\n        if (urlParamKey === 'limit') {\n            params.limit = +urlParamValue;\n            if (isNaN(params.limit) || params.limit < 0) {\n                delete params.limit;\n            }\n        } else if (urlParamKey === 'offset') {\n            params.offset = +urlParamValue;\n            if (isNaN(params.offset) || params.offset < 0) {\n                delete params.offset;\n            }\n        } else if (urlParamKey === 'q') {\n            params.search = urlParamValue;\n        } else if (urlParamKey === 'sort') {\n            if (typeof urlParamValue === 'string') {\n                params.sort = urlParamValue.split(',').map(s => {\n                    const [direction, property] = s.split(':');\n                    return {property: (property ?? direction) as keyof object, ascending: direction !== 'desc'};\n                });\n            } else {\n                throw new CommonsInternalError(`String is expected as value for '${urlParamKey}' when converting from urlParams`);\n            }\n        } else if (typeof urlParamValue === 'string') {\n            if (urlParamValue.length === 0) {\n                // empty string should be ignored\n                return;\n            }\n\n            const filterParts = urlParamValue.split(':');\n            let partIdx = 0;\n\n            // case sensitive\n            let caseSensitive: boolean | undefined = undefined;\n            if (filterParts[partIdx] === 'cs' || filterParts[partIdx] === 'ci') {\n                caseSensitive = filterParts[partIdx++] === 'cs';\n            }\n\n            // match mode\n            const matchMode = filterParts[partIdx] ? FilterMatchMode.fromAbbreviation(filterParts[partIdx]) ?? filterParts[partIdx] : FilterMatchMode.Equals;\n            partIdx++;\n\n            const noVal = matchMode === FilterMatchMode.Exists || matchMode === FilterMatchMode.DoesNotExist;\n\n            // value\n            let value: string | string[] | undefined | null = undefined;\n            if (!noVal) {\n                if (filterParts.length < 2) {\n                    return;\n                }\n\n                if (partIdx === filterParts.length - 1) {\n                    value = filterParts[partIdx];\n                } else if (partIdx < filterParts.length) {\n                    // array that should not be array, so join back together\n                    value = filterParts.slice(partIdx, filterParts.length).join(':');\n                }\n\n                if (value === undefined && matchMode !== FilterMatchMode.Exists && matchMode !== FilterMatchMode.DoesNotExist) {\n                    // if value undefined and match mode expects value, then skip\n                    return;\n                }\n\n                if (value === 'null') {\n                    value = null;\n                }\n\n                if ((matchMode === FilterMatchMode.In || matchMode === FilterMatchMode.NotIn || matchMode === FilterMatchMode.Between) && typeof value === 'string') {\n                    let arrayVal: string[] = [];\n                    // these match modes expect array\n                    if (value.indexOf('\"') >= 0) {\n                        const tokens: string[] = [];\n                        let currentToken = '';\n                        let explicitQuotes = false; //token is quoted, e.g. in:1,2,\"22\"\"\",\",123\"\"\"\n                        let quotesOpened = false; //token has started processing\n                        let quotesExplicitlyClosed = false; //token processing has finished, after single \" in quoted mode, or before , in not quoted\n\n                        for (let i = 0; i < value.length; i++) {\n                            const c = value[i];\n\n                            // reset the tokenizer when seeing the token separator\n                            // only if either:\n                            // the quotes have not been opened yet (when there are no characters between separators),\n                            // the token has been explicitly closed (when we actually have explicit opening i.e., quotes as the first character)\n                            // or we have implicit quotes (i.e., quotes are not the first character)\n                            if (c === ',' && (!quotesOpened || quotesExplicitlyClosed || !explicitQuotes)) {\n                                tokens.push(currentToken);\n                                currentToken = '';\n                                quotesOpened = false;\n                                quotesExplicitlyClosed = false;\n                                explicitQuotes = false;\n                            } else if (c == '\"') {\n                                // escaped double-quotes\n                                if (explicitQuotes && i + 1 < value.length && value[i + 1] === '\"') {\n                                    currentToken += c; // Append one double-quote to the current token\n                                    i++; // Skip the next double-quote\n                                }\n                                // we encounter quotes again after they were the first character => we close the token\n                                else if (explicitQuotes) {\n                                    quotesExplicitlyClosed = true;\n                                }\n                                // implicit quotes\n                                else if (quotesOpened) {\n                                    currentToken += c;\n                                }\n                                // quotes are the first character => explicitly open the token\n                                else {\n                                    currentToken = '';\n                                    quotesOpened = true;\n                                    explicitQuotes = true;\n                                }\n                            } else {\n                                if (quotesExplicitlyClosed) {\n                                    return;\n                                }\n\n                                quotesOpened = true;\n                                currentToken += c;\n                            }\n                        }\n\n                        if (quotesOpened && !quotesExplicitlyClosed && explicitQuotes) {\n                            return;\n                        }\n\n                        // Append the last token after the loop ends\n                        tokens.push(currentToken.toString());\n\n                        arrayVal = tokens;\n                    } else {\n                        arrayVal = value.split(',');\n                    }\n\n                    if (matchMode === FilterMatchMode.Between && arrayVal.length !== 2) {\n                        return;\n                    }\n\n                    value = arrayVal;\n                }\n\n                if ((typeof value === 'string' && value.length === 0) || (Array.isArray(value) && value!.length === 0)) {\n                    // filter with empty value is to be ignored\n                    return;\n                }\n            } else {\n                caseSensitive = undefined;\n            }\n\n            if (!params.filters) {\n                params.filters = {};\n            }\n\n            params.filters[urlParamKey as keyof object] = {value: value, matchMode: matchMode, caseSensitive: caseSensitive};\n        }\n    });\n\n    return params;\n}\n\n/**\n * Makes a copy of the given DataListParams object.\n *\n * @param {DataListParams<Sorts, Filters>} params - The DataListParams object to be copied.\n * @returns {DataListParams<Sorts, Filters>} - Returns a new copy of the DataListParams object.\n */\nexport function copyDataListParams<Sorts = string, Filters extends keyof any = string>(params: DataListParams<Sorts, Filters>): DataListParams<Sorts, Filters> {\n    const copy: DataListParams<Sorts, Filters> = {\n        offset: params.offset,\n        limit: params.limit,\n        search: params.search\n    };\n\n    if (params.sort) {\n        copy.sort = params.sort?.map(s => ({...s}));\n    }\n    if (params.filters) {\n        copy.filters = Object.entries(params.filters).reduce((acc, [key, value]) => {\n            const filterValue = value as DataListFilter;\n            return {\n                ...acc,\n                [key]: {\n                    ...filterValue,\n                    value: Array.isArray(filterValue.value) ? [...filterValue.value] : filterValue.value\n                } as DataListFilter\n            };\n        }, {} as DataListFiltersType<Filters>);\n    }\n\n    return copy;\n}\n\n/**\n * Converts a value to a URL query param string representation.\n *\n * @param {unknown} value - The value to be converted.\n * @param {boolean} [allowNull=false] - Indicates whether null values are allowed.\n * @returns {string} The URL parameter representation of the value.\n * @throws {CommonsInternalError} If an undefined value is passed without allowNull set to true.\n * @throws {CommonsInternalError} If the value is an object (excluding Date).\n */\nexport function dataListParamsFilterValueToUrlString(value: unknown, allowNull = false): string {\n    if (value === null && allowNull) return 'null';\n    if (value == null) throw new CommonsInternalError('Undefined value cannot be converted to url param.'); // this should not happen, should be filtered out earlier\n    if (Array.isArray(value))\n        return value\n            .map(v => dataListParamsFilterValueToUrlString(v, allowNull))\n            .map(v => (v.indexOf(',') >= 0 || v.indexOf('\"') >= 0 ? `\"${v.replaceAll('\"', '\"\"')}\"` : v))\n            .join(',');\n    if (typeof value === 'object') {\n        if (value instanceof Date) return dateToIsoString(value, 'dateTime', {utc: true});\n        else {\n            throw new CommonsInternalError('Filter value cannot be object');\n        }\n    }\n    return String(value);\n}\n"]}

package/esm2022/core/data-list/data-list.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YS1saXN0Lm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vY29yZS9zcmMvZGF0YS1saXN0L2RhdGEtbGlzdC5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtGaWx0ZXJNYXRjaE1vZGVFeHRlbmRlZFR5cGV9IGZyb20gJy4vZmlsdGVyLW1hdGNoLm1vZGVsJztcblxuZXhwb3J0IGludGVyZmFjZSBEYXRhTGlzdFBhcmFtczxTb3J0cyA9IHN0cmluZywgRmlsdGVycyBleHRlbmRzIGtleW9mIGFueSA9IHN0cmluZz4ge1xuICAgIG9mZnNldD86IG51bWJlcjtcbiAgICBsaW1pdD86IG51bWJlcjtcbiAgICBzb3J0PzogRGF0YUxpc3RTb3J0PFNvcnRzPltdO1xuICAgIHNlYXJjaD86IHN0cmluZztcbiAgICBmaWx0ZXJzPzogRGF0YUxpc3RGaWx0ZXJzVHlwZTxGaWx0ZXJzPjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBEYXRhTGlzdFNvcnQ8UHJvcGVydHkgPSBzdHJpbmc+IHtcbiAgICBwcm9wZXJ0eTogUHJvcGVydHk7XG4gICAgYXNjZW5kaW5nPzogYm9vbGVhbjtcbn1cblxuZXhwb3J0IHR5cGUgRGF0YUxpc3RGaWx0ZXJCYXNlVmFsdWVUeXBlID0gc3RyaW5nIHwgbnVtYmVyIHwgYm9vbGVhbiB8IERhdGUgfCB1bmRlZmluZWQgfCBudWxsO1xuZXhwb3J0IHR5cGUgRGF0YUxpc3RGaWx0ZXJWYWx1ZVR5cGUgPSBEYXRhTGlzdEZpbHRlckJhc2VWYWx1ZVR5cGUgfCBEYXRhTGlzdEZpbHRlckJhc2VWYWx1ZVR5cGVbXSB8IHVuZGVmaW5lZCB8IG51bGw7XG5leHBvcnQgdHlwZSBEYXRhTGlzdEZpbHRlckZyb21VcmxWYWx1ZVR5cGUgPSBzdHJpbmcgfCBzdHJpbmdbXSB8IHVuZGVmaW5lZCB8IG51bGw7XG5cbmV4cG9ydCB0eXBlIERhdGFMaXN0RmlsdGVyc1R5cGU8RmlsdGVycyBleHRlbmRzIGtleW9mIGFueSA9IHN0cmluZz4gPSB7XG4gICAgW1Byb3AgaW4gRmlsdGVyc106IERhdGFMaXN0RmlsdGVyO1xufTtcblxuZXhwb3J0IGludGVyZmFjZSBEYXRhTGlzdEZpbHRlcjxWYWx1ZSA9IERhdGFMaXN0RmlsdGVyVmFsdWVUeXBlPiB7XG4gICAgdmFsdWU/OiBWYWx1ZTtcbiAgICBtYXRjaE1vZGU/OiBGaWx0ZXJNYXRjaE1vZGVFeHRlbmRlZFR5cGU7XG4gICAgY2FzZVNlbnNpdGl2ZT86IGJvb2xlYW47XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgRGF0YUxpc3RSZXN1bHQ8SXRlbSA9IGFueT4ge1xuICAgIGRhdGE6IEl0ZW1bXTtcbiAgICB0b3RhbENvdW50PzogbnVtYmVyO1xufVxuIl19