@quillsql/react 2.12.37 → 2.12.38

package/dist/esm/utils/astProcessing.d.ts

@@ -0,0 +1,26 @@
+import { Column } from '../models/Columns';
+export declare function getSelectFromAST(ast: any): any;
+export declare function processStarColumn(ast: any, columns: Column[]): any;
+export declare function recursiveSearchByKey(node: any, searchKey: string): any;
+export declare function recursiveSearchByKeys(node: any, searchKeys: string[]): any;
+export declare function createTableNameToTableAliasMap(ast: any): {
+    [key: string]: string;
+};
+export declare function getColumnsByTableName(ast: any, tableName: string): {
+    columns: {
+        field: string;
+    }[];
+    name: string;
+};
+export declare function processApostrophe(node: any, searchKeys: string[]): any;
+export declare function recursiveSearchByKeysFindAllOccurances(node: any, searchKeys: string[], results: any[]): any;
+export declare function getColumnAndTableInfo(tableAliasMap: {
+    [alias: string]: string;
+}, column: any, schemaInfo: any): {
+    tableName: string;
+    columnName: string;
+} | undefined;
+export declare function getColumnsByTableFromASTAndSchema(ast: any, tables: any, tableAliasMap: any): {
+    [table: string]: string[];
+};
+//# sourceMappingURL=astProcessing.d.ts.map

package/dist/esm/utils/astProcessing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"astProcessing.d.ts","sourceRoot":"","sources":["../../../src/utils/astProcessing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE3C,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,GAAG,OAQxC;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,OAe5D;AAGD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,GAAG,GAAG,CAgBtE;AAGD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,GAAG,CAgB1E;AAED,wBAAgB,8BAA8B,CAAC,GAAG,EAAE,GAAG;;EA4BtD;AAED,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,GAAG,EACR,SAAS,EAAE,MAAM,GAChB;IAAE,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAahD;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,GAAG,CActE;AAED,wBAAgB,sCAAsC,CACpD,IAAI,EAAE,GAAG,EACT,UAAU,EAAE,MAAM,EAAE,EACpB,OAAO,EAAE,GAAG,EAAE,GACb,GAAG,CAYL;AAED,wBAAgB,qBAAqB,CACnC,aAAa,EAAE;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,EAC1C,MAAM,EAAE,GAAG,EACX,UAAU,EAAE,GAAG,GACd;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAqCvD;AAED,wBAAgB,iCAAiC,CAC/C,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,GAAG,EACX,aAAa,EAAE,GAAG,GACjB;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;CAAE,CAqG/B"}

package/dist/esm/utils/astProcessing.js

@@ -0,0 +1,254 @@
+export function getSelectFromAST(ast) {
+    if (Array.isArray(ast)) {
+        return ast[0];
+    }
+    else if (ast.select) {
+        return ast.select;
+    }
+    else {
+        return ast;
+    }
+}
+export function processStarColumn(ast, columns) {
+    if (ast.columns === '*') {
+        ast.columns = columns.map((column) => {
+            return {
+                type: 'expr',
+                expr: {
+                    type: 'column_ref',
+                    table: null,
+                    column: column.field,
+                },
+                as: null,
+            };
+        });
+    }
+    return ast;
+}
+// a useful function to search for a specific keywork and return the value
+export function recursiveSearchByKey(node, searchKey) {
+    let result = undefined;
+    if (!node || typeof node !== 'object') {
+        return undefined;
+    }
+    if (node[searchKey]) {
+        return node[searchKey];
+    }
+    const keys = Object.keys(node);
+    for (const key of keys) {
+        result = recursiveSearchByKey(node[key], searchKey);
+        if (result) {
+            return result;
+        }
+    }
+    return result;
+}
+// If the object has all the requested keys, return the object
+export function recursiveSearchByKeys(node, searchKeys) {
+    let result = undefined;
+    if (!node || typeof node !== 'object') {
+        return undefined;
+    }
+    const nodeKeys = Object.keys(node);
+    if (searchKeys.every((key) => nodeKeys.includes(key))) {
+        return node;
+    }
+    for (const key of nodeKeys) {
+        result = recursiveSearchByKeys(node[key], searchKeys);
+        if (result) {
+            return result;
+        }
+    }
+    return result;
+}
+export function createTableNameToTableAliasMap(ast) {
+    const tableNameToTableAliasMap = {};
+    if (ast.from) {
+        for (const table of ast.from) {
+            const tableObject = recursiveSearchByKeys(table, ['table', 'as']);
+            if (tableObject.as) {
+                tableNameToTableAliasMap[tableObject.as] = tableObject.table;
+            }
+            else {
+                tableNameToTableAliasMap[tableObject.table] = tableObject.table;
+            }
+        }
+    }
+    if (ast.with) {
+        for (const withStmt of ast.with) {
+            const astFrom = withStmt.stmt.from ?? withStmt.stmt.ast.from;
+            if (astFrom) {
+                for (const table of astFrom) {
+                    const tableObject = recursiveSearchByKeys(table, ['table', 'as']);
+                    if (tableObject.as) {
+                        tableNameToTableAliasMap[tableObject.as] = tableObject.table;
+                    }
+                    else {
+                        tableNameToTableAliasMap[tableObject.table] = tableObject.table;
+                    }
+                }
+            }
+        }
+    }
+    return tableNameToTableAliasMap;
+}
+export function getColumnsByTableName(ast, tableName) {
+    const tableNameToTableAliasMap = createTableNameToTableAliasMap(ast);
+    const columns = [];
+    ast.columns.forEach((col) => {
+        const columnInfo = recursiveSearchByKeys(col, ['table', 'column']);
+        if (columnInfo.table === tableName ||
+            columnInfo.table === tableNameToTableAliasMap[tableName]) {
+            columns.push({ field: columnInfo.column });
+        }
+    });
+    return { columns, name: tableName };
+}
+export function processApostrophe(node, searchKeys) {
+    if (!node || typeof node !== 'object') {
+        return;
+    }
+    const nodeKeys = Object.keys(node);
+    if (searchKeys.every((key) => nodeKeys.includes(key))) {
+        if (node.type === 'single_quote_string') {
+            node.value = node.value.replace("''", "'").replace("\\'", "'");
+        }
+    }
+    for (const key of nodeKeys) {
+        processApostrophe(node[key], searchKeys);
+    }
+    return;
+}
+export function recursiveSearchByKeysFindAllOccurances(node, searchKeys, results) {
+    if (!node || typeof node !== 'object') {
+        return;
+    }
+    const nodeKeys = Object.keys(node);
+    if (searchKeys.every((key) => nodeKeys.includes(key))) {
+        return results.push(node);
+    }
+    for (const key of nodeKeys) {
+        recursiveSearchByKeysFindAllOccurances(node[key], searchKeys, results);
+    }
+    return results;
+}
+export function getColumnAndTableInfo(tableAliasMap, column, schemaInfo) {
+    let columnsInfo = recursiveSearchByKeys(column, ['table', 'column']);
+    if (!columnsInfo) {
+        const quoteStringColumn = recursiveSearchByKeys(column, ['type', 'value']);
+        columnsInfo = { table: null, column: quoteStringColumn.value };
+    }
+    let columnName = columnsInfo.column;
+    if (columnsInfo.column &&
+        columnsInfo.column.expr &&
+        typeof columnsInfo.column !== 'string') {
+        columnName = columnsInfo.column.expr.value;
+    }
+    let tableName = '';
+    if (columnsInfo.table) {
+        tableName = tableAliasMap[columnsInfo.table];
+    }
+    else {
+        // If there is no column name search through the schemaInfo to find an accurate table name
+        const tableNames = Object.values(tableAliasMap);
+        for (const table of tableNames) {
+            const tableInfo = schemaInfo.find((tableInfo) => tableInfo.name === table);
+            if (!tableInfo)
+                continue;
+            const columnNames = tableInfo.columns.map((column) => column.name);
+            if (columnNames.includes(columnName)) {
+                tableName = table;
+                break;
+            }
+        }
+    }
+    // const tableName = columnsInfo.table
+    //   ? tableAliasMap[columnsInfo.table]
+    //   : //@ts-ignore
+    //     tableAliasMap[Object.keys(tableAliasMap)[0]];
+    return { tableName, columnName };
+}
+export function getColumnsByTableFromASTAndSchema(ast, tables, tableAliasMap) {
+    const referencedColumns = {};
+    if (ast.columns === '*' || ast.columns[0].expr.column === '*') {
+        // Be sure to select everything from stars
+        const tableList = ast.from.map((table) => recursiveSearchByKey(table, 'table'));
+        tableList.forEach((table) => {
+            const tableInfo = tables.find((tableInfo) => tableInfo.name === table);
+            if (tableInfo) {
+                if (!referencedColumns[table]) {
+                    referencedColumns[table] = [];
+                }
+                referencedColumns[table] = tableInfo.columns.map((column) => column.name || '');
+            }
+        });
+    }
+    else {
+        // look through all the columns
+        ast.columns.forEach((column) => {
+            const result = getColumnAndTableInfo(tableAliasMap, column, tables);
+            if (!result || !result.tableName)
+                return;
+            if (!referencedColumns[result.tableName]) {
+                referencedColumns[result.tableName] = [];
+            }
+            // @ts-ignore
+            referencedColumns[result.tableName].push(result.columnName);
+        });
+    }
+    // Look through every join reference
+    if (ast.from) {
+        const allColumnReferncesInFrom = recursiveSearchByKeysFindAllOccurances(ast.from, ['column', 'table'], []);
+        allColumnReferncesInFrom.forEach((column) => {
+            const result = getColumnAndTableInfo(tableAliasMap, column, tables);
+            if (!result || !result.tableName)
+                return;
+            if (!referencedColumns[result.tableName]) {
+                referencedColumns[result.tableName] = [];
+            }
+            // @ts-ignore
+            referencedColumns[result.tableName].push(result.columnName);
+        });
+    }
+    // Look through the where's
+    if (ast.where) {
+        let allColumnReferncesInWhere = recursiveSearchByKeysFindAllOccurances(ast.where, ['column', 'table'], []);
+        allColumnReferncesInWhere.forEach((column) => {
+            const result = getColumnAndTableInfo(tableAliasMap, column, tables);
+            if (!result || !result.tableName || !result.columnName)
+                return;
+            if (!referencedColumns[result.tableName]) {
+                referencedColumns[result.tableName] = [];
+            }
+            // @ts-ignore
+            referencedColumns[result.tableName].push(result.columnName);
+        });
+        // NEED TO SEARCH FOR ALL DOUBLE QUOTE STRINGS AS WELL
+        allColumnReferncesInWhere = recursiveSearchByKeysFindAllOccurances(ast.where, ['type', 'value'], []);
+        allColumnReferncesInWhere.forEach((column) => {
+            if (column.type === 'double_quote_string') {
+                let tableName = '';
+                const tableNames = Object.values(tableAliasMap);
+                for (const table of tableNames) {
+                    const tableInfo = tables.find((tableInfo) => tableInfo.name === table);
+                    if (!tableInfo)
+                        continue;
+                    const columnNames = tableInfo.columns.map((column) => column.name);
+                    if (columnNames.includes(column.value)) {
+                        tableName = table;
+                        break;
+                    }
+                }
+                if (!referencedColumns[tableName]) {
+                    referencedColumns[tableName] = [];
+                }
+                // @ts-ignore
+                referencedColumns[tableName].push(column.value);
+            }
+        });
+    }
+    for (const table in referencedColumns) {
+        referencedColumns[table] = Array.from(new Set(referencedColumns[table]));
+    }
+    return referencedColumns;
+}

package/dist/esm/utils/axisFormatter.d.ts

@@ -0,0 +1,20 @@
+type Field = {
+    _id: string;
+    label: string;
+    field: string;
+    format: 'percent';
+};
+type Props = {
+    value: string | number | boolean | undefined | null;
+    field: string | undefined | null;
+    fields: Field[];
+};
+/**
+ * Pretty-prints the given values to their nice-looking string form.
+ *
+ * The axis formatter will print a shorter version of the valueFormatter, which
+ * fits nicely along the X or Y axes.
+ */
+export declare const axisFormatter: ({ value, field, fields, }: Props) => string | number | boolean;
+export {};
+//# sourceMappingURL=axisFormatter.d.ts.map

package/dist/esm/utils/axisFormatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"axisFormatter.d.ts","sourceRoot":"","sources":["../../../src/utils/axisFormatter.ts"],"names":[],"mappings":"AAGA,KAAK,KAAK,GAAG;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,SAAS,CAAC;CACnB,CAAC;AAEF,KAAK,KAAK,GAAG;IACX,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,GAAG,IAAI,CAAC;IACpD,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;IACjC,MAAM,EAAE,KAAK,EAAE,CAAC;CACjB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,aAAa,8BAIvB,KAAK,KAAG,MAAM,GAAG,MAAM,GAAG,OAgC5B,CAAC"}

package/dist/esm/utils/axisFormatter.js

@@ -0,0 +1,179 @@
+import { endOfWeek, format, getWeek, isValid, startOfWeek } from 'date-fns';
+import { utcToZonedTime } from 'date-fns-tz';
+/**
+ * Pretty-prints the given values to their nice-looking string form.
+ *
+ * The axis formatter will print a shorter version of the valueFormatter, which
+ * fits nicely along the X or Y axes.
+ */
+export const axisFormatter = ({ value, field, fields, }) => {
+    if (field === undefined || field === null)
+        return '';
+    if (value === undefined || value === null)
+        return '';
+    const fieldInfo = fields.find((f) => f.field === field);
+    if (!fieldInfo)
+        return '';
+    const HANDLERS = {
+        percent: formatPercent,
+        dollar_amount: formatDollarAmount,
+        dollar_cents: formatDollarAmount, // no cents for axis format
+        whole_number: formatWholeNumber,
+        one_decimal_place: formatWholeNumber, // no decimals for axis format
+        two_decimal_places: formatWholeNumber, // no decimals for axis format
+        string: formatString,
+        yyyy: format_YYYY,
+        MMM_yyyy: format_MMM_yyyy,
+        MMM_dd: format_MMM_dd,
+        MMM_dd_yyyy: format_MMM_dd_yyyy,
+        MMM_ww_yyyy: format_MMM_ww_yyyy,
+        hh_ap_pm: format_hh_ap_pm,
+        'MMM_dd-MMM_dd': format_MMM_dd_MMM_dd,
+        'MMM_dd_hh:mm_ap_pm': format_MMM_dd_hh_mm_ap_pm,
+        'wo, yyyy': format_wo_yyyy,
+    };
+    // try to handle this value using the associated formatType handler
+    const formatType = fieldInfo.format;
+    if (Object.keys(HANDLERS).includes(formatType)) {
+        return HANDLERS[formatType](value);
+    }
+    return formatString(value); // by default make this value a string
+};
+/**
+ * HELPER FUNCTION DEFINITIONS
+ **/
+/**
+ * Formats the value as a string using the built-in converstion.
+ */
+const formatString = (value) => {
+    if (typeof value === 'object') {
+        return JSON.stringify(value);
+    }
+    return value.toString();
+};
+// Formats large numbers like 12345.67 ->  $12K
+const formatterBigDollars = new Intl.NumberFormat('en-US', {
+    style: 'currency',
+    currency: 'USD',
+    minimumSignificantDigits: 1,
+    maximumSignificantDigits: 2,
+    notation: 'compact',
+    compactDisplay: 'short',
+});
+// Formats to dollars like 1234.56 -> $1235
+const formatterDollar = new Intl.NumberFormat('en-US', {
+    style: 'currency',
+    currency: 'USD',
+    maximumFractionDigits: 0,
+});
+/**
+ * Formats the value as a (rounded) currency amount in dollars.  If value is
+ * zero, returns '$0' with no cents. If value is greater than or equal to 1000,
+ * it will not show cents and shorten the value with a suffix such as K
+ * (for thousands) or M (for millions).
+ *
+ * @example format(1,234,567) => "$1.2M"
+ * @example format(1234.567) => "$1.2K"
+ * @example format(5000) => "$5K"
+ * @example format(123.45) => "$123"
+ * @example format(0.00) => "$0"
+ */
+const formatDollarAmount = (value) => {
+    const num = Number(value ?? 0);
+    if (num >= 1000 || num === 0) {
+        return formatterBigDollars.format(num);
+    }
+    else {
+        return formatterDollar.format(num);
+    }
+};
+const formatterBigWholeNumber = new Intl.NumberFormat('en-US', {
+    minimumSignificantDigits: 1,
+    maximumSignificantDigits: 2,
+    notation: 'compact',
+    compactDisplay: 'short',
+});
+/**
+ * Formats the value as a (rounded) integer.
+ *
+ * @example format(1234.567) => "1.2K"
+ */
+const formatWholeNumber = (value) => {
+    return formatterBigWholeNumber.format(Number(value));
+};
+/**
+ * Formats the value as a percentage.
+ *
+ * @example format(0.1234) => "12%"
+ * @example format(0.99) => "99%"
+ *
+ * NOTE: This function expects that the value is already a percentage value, and
+ * does not try to guess whether the percentage is represented as a whole number
+ * or a decimal.
+ *
+ * @example format(1234.567) => "120K%"
+ * @example format(99) => "9.9K%"
+ */
+const formatPercent = (value) => {
+    const formatter = new Intl.NumberFormat('en-US', {
+        style: 'percent',
+        minimumSignificantDigits: 2,
+        maximumSignificantDigits: 2,
+        notation: 'compact',
+        compactDisplay: 'short',
+    });
+    return formatter.format(Number(value));
+};
+// Converts the value to a UTC date with the given format string. If the
+// resulting date is invalid, it returns "Invalid date".
+const _getUTCDateHelper = (value, fmt) => {
+    const utcDate = utcToZonedTime(new Date(value), 'UTC');
+    if (!isValid(utcDate))
+        return 'Invalid date';
+    return format(utcDate, fmt);
+};
+const format_YYYY = (value) => _getUTCDateHelper(value, 'yyyy');
+const format_MMM_dd = (value) => _getUTCDateHelper(value, 'dd MMM');
+const format_MMM_yyyy = (value) => _getUTCDateHelper(value, 'MMM yyyy');
+const format_hh_ap_pm = (value) => _getUTCDateHelper(value, 'hh:mm aa');
+const format_MMM_dd_yyyy = (value) => _getUTCDateHelper(value, 'dd MMM yyyy');
+const format_MMM_dd_MMM_dd = (value) => {
+    const utcDate = utcToZonedTime(new Date(value), 'UTC');
+    if (!isValid(utcDate))
+        return 'Invalid date';
+    const monday = startOfWeek(utcDate, { weekStartsOn: 1 });
+    const sunday = endOfWeek(utcDate, { weekStartsOn: 1 });
+    // Check if start and end are in the same month
+    if (format(monday, 'MMM') === format(sunday, 'MMM')) {
+        return `${format(monday, 'MMM dd')} - ${format(sunday, 'dd')}`;
+    }
+    else {
+        return `${format(monday, 'MMM dd')} - ${format(sunday, 'MMM dd')}`;
+    }
+};
+const format_MMM_ww_yyyy = (value) => {
+    const utcDate = utcToZonedTime(new Date(value), 'UTC');
+    if (!isValid(utcDate))
+        return 'Invalid date';
+    const startOfWeekDate = startOfWeek(utcDate, { weekStartsOn: 1 });
+    const endOfWeekDate = endOfWeek(utcDate, { weekStartsOn: 1 });
+    const month = format(utcDate, 'MMM');
+    const startDay = format(startOfWeekDate, 'd');
+    const endDay = format(endOfWeekDate, 'd');
+    const year = format(utcDate, 'yyyy');
+    return `${month}, ${startDay}-${endDay}, ${year}`;
+};
+const format_MMM_dd_hh_mm_ap_pm = (value) => {
+    const utcDate = utcToZonedTime(new Date(value), 'UTC');
+    if (!isValid(utcDate))
+        return 'Invalid date';
+    const formatStr = utcDate.getMinutes() === 0 ? 'MMM do h a' : 'MMM do h:mm a';
+    const res = format(utcDate, formatStr);
+    return res.slice(0, -2) + res.slice(-2).toLowerCase();
+};
+const format_wo_yyyy = (value) => {
+    const utcDate = utcToZonedTime(new Date(value), 'UTC');
+    if (!isValid(utcDate))
+        return 'Invalid date';
+    return `${getWeek(utcDate)},${utcDate.getFullYear()}`;
+};

package/dist/esm/utils/color.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Generates an array of colors by interpolating between colors in the given array.
+ * @param colors - The array of colors to interpolate between.
+ * @param length - The desired length of the resulting array.
+ */
+export declare function generateArrayFromColor(colors: string | string[], length: number): string[];
+declare const colorValues: readonly ["red", "orange", "amber", "yellow", "lime", "green", "emerald", "teal", "cyan", "sky", "blue", "indigo", "violet", "purple", "fuchsia", "pink", "rose"];
+export type Color = (typeof colorValues)[number];
+/**
+ * Selects a color from the list of colors based on the element's index. If
+ * the element is a comparison range, it will select the color and then
+ * transform it to be grayscale.
+ * @param element the chart element to select the color for
+ * @param colors a list of colors to choose from
+ * @param index the index of this element in colors
+ */
+export declare function selectColor(element: any, colors: string[], index: number): string;
+export declare function namedColorToHex(color: string): string;
+/**
+ * Converts an RGB color value to HSL. Conversion formula
+ * adapted from http://en.wikipedia.org/wiki/HSL_color_space.
+ * Assumes r, g, and b are contained in the set [0, 255] and
+ * returns h, s, and l in the set [0, 1].
+ *
+ * @param   Number  r       The red color value
+ * @param   Number  g       The green color value
+ * @param   Number  b       The blue color value
+ * @return  Array           The HSL representation
+ */
+export declare function rgbToHsl(r: any, g: any, b: any): number[];
+/**
+ * Converts an HSL color value to RGB. Conversion formula
+ * adapted from http://en.wikipedia.org/wiki/HSL_color_space.
+ * Assumes h, s, and l are contained in the set [0, 1] and
+ * returns r, g, and b in the set [0, 255].
+ *
+ * @param   Number  h       The hue
+ * @param   Number  s       The saturation
+ * @param   Number  l       The lightness
+ * @return  Array           The RGB representation
+ */
+export declare function HSLtoRGB(h: any, s: any, l: any): number[];
+export {};
+//# sourceMappingURL=color.d.ts.map

package/dist/esm/utils/color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"color.d.ts","sourceRoot":"","sources":["../../../src/utils/color.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,EACzB,MAAM,EAAE,MAAM,GACb,MAAM,EAAE,CAwBV;AA6ED,QAAA,MAAM,WAAW,mKAkBP,CAAC;AAEX,MAAM,MAAM,KAAK,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjD;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,UAuBxE;AAyDD,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,UAK5C;AAwJD;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,YA4B9C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,YAuB9C"}