af-db-ts 2.0.19 → 2.0.73

package/src/pg/utils-pg.ts

@@ -0,0 +1,97 @@
+import { TDataTypePg, TArrayTypesPg } from '../@types/i-data-types-pg';
+
+export const getJsTypeByTypePg = (dataType?: TDataTypePg, arrayType?: TDataTypePg): string => {
+  switch (dataType) {
+    case 'boolean':
+      return 'boolean';
+    case 'bigint':
+      return 'string | number';
+    case 'integer':
+    case 'numeric':
+    case 'real':
+    case 'smallint':
+      return 'number';
+    case 'text':
+    case 'character':
+    case 'varchar':
+    case 'uuid':
+      return 'string';
+    case 'json':
+    case 'jsonb':
+      return 'any';
+    case 'date':
+    case 'timestamptz':
+    case 'timestamp':
+      return 'string | Date | number';
+    case 'USER_DEFINED':
+      return 'string';
+    case 'ARRAY': {
+      const jsType = getJsTypeByTypePg(arrayType);
+      return `${jsType}[]`;
+    }
+    default:
+      return 'string';
+  }
+};
+
+const udtNames2TypeMap: { [udtName: string]: TDataTypePg } = {
+  _bit: 'bit',
+  _bool: 'bool',
+  _box: 'box',
+  _bytea: 'bytea',
+  _char: 'char',
+  _circle: 'circle',
+  _date: 'date',
+  _float4: 'real',
+  _float8: 'double precision',
+  _inet: 'inet',
+  _int2: 'smallint',
+  _int4: 'int',
+  _int8: 'bigint',
+  _interval: 'interval',
+  _lseg: 'lseg',
+  _macaddr: 'macaddr',
+  _money: 'money',
+  _numeric: 'numeric',
+  _path: 'path',
+  _point: 'point',
+  _polygon: 'polygon',
+  _text: 'text',
+  _time: 'time',
+  _timestamp: 'timestamp',
+  _timestamptz: 'timestamptz',
+  _timetz: 'timetz',
+  _uuid: 'uuid',
+  _varchar: 'varchar',
+  _xml: 'xml',
+  // _oid: 'oid',
+  // _abstime: 'abstime',
+  // _name: 'name',
+};
+export const getTypeByUdtNamePg = (udtName: TArrayTypesPg): TDataTypePg => {
+  const dataType = udtNames2TypeMap[udtName];
+  return dataType || 'varchar';
+};
+
+const typeNormalizationMap: { [pgDataType: string]: TDataTypePg } = {
+  bool: 'boolean',
+  int2: 'smallint',
+  integer: 'int',
+  int4: 'int',
+  int8: 'bigint',
+  serial2: 'smallserial',
+  serial4: 'serial',
+  serial8: 'bigserial',
+  decimal: 'numeric',
+  float4: 'real',
+  float8: 'double precision',
+  character: 'char',
+  'character varying': 'varchar',
+  'timestamp with time zone': 'timestamptz',
+  'timestamp without time zone': 'timestamp',
+  'time without time zone': 'time',
+  'time with time zone': 'timetz',
+  'bit varying': 'varbit',
+};
+
+export const getNormalizedTypePg = (pgDataType: TDataTypePg): TDataTypePg => typeNormalizationMap[pgDataType] || pgDataType;

package/src/utils/utils-array.ts

@@ -0,0 +1,133 @@
+import * as sql from 'mssql';
+import { getBool } from 'af-tools-ts';
+import { NULL } from '../common';
+import { parseFloatNumber, parseIntNumberS, prepareBigIntNumber } from './utils-num';
+import { TDataTypeMs } from '../@types/i-data-types-ms';
+import { TDataTypePg } from '../@types/i-data-types-pg';
+import { prepareUUID } from './utils';
+
+const elementString = (value: any[]): string[] => {
+  // noinspection UnnecessaryLocalVariableJS
+  const arr: string[] = value.map((v) => {
+    if (v === '') {
+      return '';
+    }
+    return v == null ? null : v;
+  }).map((v) => (v == null ? NULL : `"${v}"`));
+  return arr;
+};
+
+const elementUuid = (
+  value: any[],
+  toLower: boolean = false,
+): string[] => value.map((v) => prepareUUID(v, toLower, true)).map((v) => (v === NULL ? NULL : `"${v}"`));
+
+export const arrayToJsonList = (value: any, arrayType?: TDataTypeMs | TDataTypePg): string | typeof NULL => {
+  if (value == null) {
+    return NULL;
+  }
+  if (!Array.isArray(value)) {
+    return NULL;
+  }
+  let arr: any[] = [];
+  if (Array.isArray(value) && value.length) {
+    switch (arrayType) {
+      case 'bool':
+      case 'boolean': // VVQ
+        arr = value.map((v) => (v == null ? NULL : getBool(v)));
+        break;
+      case sql.Bit:
+        // eslint-disable-next-line no-nested-ternary
+        arr = value.map((v) => (v == null ? NULL : (getBool(v) ? 1 : 0)));
+        break;
+      case 'tinyint':
+      case sql.TinyInt:
+        arr = value.map((v) => parseIntNumberS(v, 'tinyint'));
+        break;
+      case 'smallint':
+      case sql.SmallInt:
+        arr = value.map((v) => parseIntNumberS(v, 'smallint'));
+        break;
+      case 'bigint':
+      case sql.BigInt:
+        arr = value.map((v) => prepareBigIntNumber(v));
+        break;
+      case 'int':
+      case 'integer':
+      case sql.Int:
+        arr = value.map((v) => parseIntNumberS(v, 'int'));
+        break;
+      case 'number':
+      case 'decimal':
+      case 'numeric':
+      case 'real':
+      case 'money':
+      case 'smallmoney':
+      case 'float':
+      case sql.SmallMoney:
+      case sql.Money:
+      case sql.Float:
+      case sql.Numeric:
+      case sql.Decimal:
+      case sql.Real:
+        arr = value.map((v) => parseFloatNumber(v));
+        break;
+      case 'uid':
+      case 'uuid': // VVQ
+        arr = elementUuid(value, true);
+        break;
+      case 'uniqueIdentifier':
+      case sql.UniqueIdentifier:
+        arr = elementUuid(value, false);
+        break;
+
+      case 'string':
+      case 'char':
+      case 'nchar':
+      case 'text':
+      case 'ntext':
+      case 'varchar':
+      case 'nvarchar':
+      case 'xml':
+      case sql.Char:
+      case sql.NChar:
+      case sql.NText:
+      case sql.VarChar:
+      case sql.NVarChar:
+      case sql.Text:
+        arr = elementString(value);
+        break;
+
+      case 'date':
+      case sql.Date:
+      case 'time':
+      case sql.Time:
+      case 'datetime':
+      case sql.DateTime:
+      case 'datetime2':
+      case sql.DateTime2:
+      case 'smalldatetime':
+      case sql.SmallDateTime:
+      case 'datetimeoffset':
+      case sql.DateTimeOffset:
+        arr = elementString(value);
+        break;
+      // 'binary'
+      // 'varbinary'
+      // 'image'
+      // 'udt'
+      // 'geography'
+      // 'geometry'
+      // 'variant'
+      // 'array'
+      default: {
+        try {
+          return JSON.stringify(value.map((v) => (v == null ? null : v))).replace(/^\[(.+?)]$/, '$1');
+        } catch (err) {
+          return NULL;
+        }
+      }
+    }
+  }
+  return arr.join(',');
+};

package/src/utils/utils-dt.ts

@@ -0,0 +1,123 @@
+import { DateTime } from 'luxon';
+import { IFieldDefMs } from '../@types/i-ms';
+import { IFieldDefPg } from '../@types/i-pg';
+import { IFieldDef } from '../@types/i-common';
+import { NULL } from '../common';
+import { q } from './utils';
+
+export const getTypeOfDateInput = (v: any): 'string' | 'number' | 'date' | 'luxon' | 'moment' | 'any' | 'null' => {
+  const type = typeof v;
+  if (type === 'string' || type === 'number') {
+    return type;
+  }
+  if (type === 'boolean' || !v) {
+    return 'null';
+  }
+  if (type === 'object') {
+    if (Object.prototype.toString.call(v) === '[object Date]') {
+      return 'date';
+    }
+    if (v.isLuxonDateTime) {
+      return 'luxon';
+    }
+    if (v._isAMomentObject) {
+      return 'moment';
+    }
+  }
+  return 'any';
+};
+
+export const getLuxonDT = (value: any, fieldDef: IFieldDefMs | IFieldDefPg): DateTime | null => {
+  const { inputDateFormat, dateTimeOptions } = fieldDef;
+  const { fromZone, setZone, correctionMillis = 0 } = dateTimeOptions || {};
+
+  let v: any;
+  let millis: number | null = null;
+  const inputType = getTypeOfDateInput(value); // 'number' | 'string' | 'date' | 'luxon' | 'moment' | 'any' | 'null'
+
+  if (inputType === 'null') {
+    millis = null;
+  } else if (inputType === 'number' || inputType === 'date') {
+    millis = +value;
+  } else if (inputType === 'string' || inputType === 'any') {
+    v = String(value);
+    let dt: DateTime;
+
+    const zoneOpts = fromZone ? { zone: fromZone } : undefined;
+    if (inputDateFormat) {
+      dt = DateTime.fromFormat(v, inputDateFormat, zoneOpts);
+    } else {
+      v = v
+        .replace(/^(\d{4}-\d\d-\d\d) (\d)/, '$1T$2')
+        .replace(/(\d) +Z/, '$1Z')
+        .replace(/(\d) +([+-])/, '$1$2');
+      dt = DateTime.fromISO(v, zoneOpts);
+    }
+    millis = dt.isValid ? dt.toMillis() : null;
+  } else if (inputType === 'luxon') {
+    millis = value.isValid ? value.toMillis() : null;
+  } else if (inputType === 'moment') {
+    millis = value.isValid() ? +value : null;
+  }
+  if (millis == null) {
+    return null;
+  }
+  if (correctionMillis) {
+    millis += correctionMillis;
+  }
+  let ld = DateTime.fromMillis(millis);
+  if (setZone) {
+    ld = ld.setZone(setZone);
+  }
+  return ld;
+};
+
+export const dateTimeValue = (value: any, fieldDef: IFieldDef, fn: Function): string | typeof NULL => {
+  const luxonDate = getLuxonDT(value, fieldDef);
+  if (!luxonDate) {
+    return NULL;
+  }
+  const v = fn(luxonDate);
+  return q(v, fieldDef.noQuotes);
+};
+
+export const getDatetimeWithPrecisionAndOffset = (arg: {
+  value: any,
+  fieldDef: IFieldDef,
+  defaultDtPrecision?: number,
+  stripTrailingZeros?: boolean,
+}): string | typeof NULL => {
+  const { value, fieldDef, defaultDtPrecision = 3, stripTrailingZeros = false } = arg;
+  const dt = getLuxonDT(value, fieldDef);
+  if (!dt) {
+    return NULL;
+  }
+  const isoZ = dt.toISO({ includeOffset: true }) || ''; // 2000-01-22T14:59:59.123+03:00
+  const iso = isoZ.substring(0, 19); // 2000-01-22T14:59:59
+
+  // Миллисекунды
+  let sss = '';
+  if (typeof value === 'string') {
+    // Если во входных данных строка с миллисекундами, то берем их с той же точностью.
+    const re = /\.(\d+)(?=[^.]*$)/;
+    const [, fracSeconds = ''] = re.exec(value) || [];
+    sss = `${fracSeconds}0000000`.substring(0, 7);
+  } else {
+    sss = `${isoZ.substring(20, 23)}0000`;
+  }
+  const dtPrecision = fieldDef.dtPrecision == null ? defaultDtPrecision : fieldDef.dtPrecision;
+  let dotMillis = !dtPrecision ? '' : `.${sss}`.substring(0, dtPrecision + 1);
+  if (dotMillis && stripTrailingZeros) {
+    dotMillis = dotMillis.replace(/([^0])0+$/, '$1');
+    if (dotMillis === '.') {
+      dotMillis = '';
+    } else if (dotMillis.length < 4) {
+      dotMillis = (`${dotMillis}000`).substring(0, 4);
+    }
+  }
+  const { includeOffset = true } = fieldDef.dateTimeOptions || {};
+  const offset = includeOffset ? isoZ.substring(23, isoZ.length) : ''; // +03:00
+
+  const str = `${iso}${dotMillis}${offset}`;
+  return q(str, fieldDef.noQuotes);
+};

package/src/utils/utils-num.ts

@@ -0,0 +1,131 @@
+import { rn } from 'af-tools-ts';
+import { NULL } from '../common';
+
+export const parseFloatNumber = (value: any): number | null => {
+  if (value == null) {
+    return null;
+  }
+  if (typeof value === 'number') {
+    return value;
+  }
+  if (typeof value === 'object') {
+    try {
+      value = JSON.stringify(value);
+    } catch (err) {
+      //
+    }
+  }
+  value = String(value).trim();
+  if (!value) {
+    return null;
+  }
+  const v: any = parseFloat(value);
+  if (Number.isNaN(v)) {
+    return null;
+  }
+  return v;
+};
+
+export const prepareFloatNumber = (value: any): string | typeof NULL => `${parseFloatNumber(value)}`;
+
+export const parseIntNumber = (value: any, min: number, max: number): number | typeof NULL => {
+  if (value == null) {
+    return NULL;
+  }
+  let v: any = parseFloatNumber(value);
+  if (v == null) {
+    return NULL;
+  }
+  v = Math.round(v);
+  if (v < min) {
+    v = min;
+  }
+  if (v > max) {
+    v = max;
+  }
+  return Math.floor(v);
+};
+
+export const parseIntNumberS = (
+  value: any,
+  type: 'tinyint' |
+    'smallint' | '_int2' |
+    'int' | 'integer' | '_int4' |
+    'bigint' | '_int8',
+): number | typeof NULL => {
+  switch (type) {
+    case 'tinyint':
+      return parseIntNumber(value, 0, 255);
+    case 'smallint':
+    case '_int2':
+      return parseIntNumber(value, -32768, 32767);
+    case 'int':
+    case 'integer':
+    case '_int4':
+      return parseIntNumber(value, -2147483648, 2147483647);
+    case 'bigint':
+    case '_int8':
+      return parseIntNumber(value, -2147483648, 2147483647);
+    default:
+      return parseIntNumber(value, -2147483648, 2147483647);
+  }
+};
+
+export const prepareIntNumber = (
+  value: any,
+  min: number,
+  max: number,
+): string | typeof NULL => `${parseIntNumber(value, min, max)}`;
+
+export const prepareBigIntNumber = (value: any): string | typeof NULL => {
+  if (value == null) {
+    return NULL;
+  }
+  if (typeof value === 'bigint') {
+    return `${value}`;
+  }
+  let bi: BigInt;
+  try {
+    if (typeof value === 'number') {
+      const v = Math.floor(value);
+      bi = BigInt(v);
+      return `${bi}`;
+    }
+    if (typeof value === 'string') {
+      const v = value.replace(/^\++/, '').split(/[^\d-]/)[0].trim();
+      return v ? `${BigInt(v)}` : NULL;
+    }
+  } catch (err) {
+    //
+  }
+  return NULL;
+};
+
+export const prepareNumeric = (value: any, precision?: number, scale?: number): string | typeof NULL => {
+  if (value == null) {
+    return NULL;
+  }
+  if (!precision) {
+    if (typeof value === 'bigint') {
+      return `${value}`;
+    }
+    return prepareFloatNumber(value);
+  }
+  if (typeof value === 'bigint') {
+    return `${value}`.substring(0, precision);
+  }
+  let vn = parseFloatNumber(value);
+  if (vn == null) {
+    return NULL;
+  }
+  const maxValue = (10 ** precision - 1) / (10 ** (scale || 0));
+  const minValue = -maxValue;
+  if (vn > maxValue) {
+    return `${maxValue}`;
+  }
+  if (vn < minValue) {
+    return `${minValue}`;
+  }
+  vn = rn(vn, scale);
+  return `${vn}`;
+};

package/src/utils/utils.ts

@@ -0,0 +1,64 @@
+/* eslint-disable no-restricted-syntax */
+
+import { NULL } from '../common';
+
+const toSchemaTableCommon = (s: string): string => s.replace(/["[\]]/g, '');
+const toSchemaTableSpec = (s: string, dbType: 'mssql' | 'ms' | 'pg'): string => {
+  const [schema, table] = toSchemaTableCommon(s).split('.');
+  return dbType === 'pg' ? `"${schema}"."${table}"` : `[${schema}].[${table}]`;
+};
+
+export const schemaTable = {
+  to: {
+    common: toSchemaTableCommon,
+    spec: toSchemaTableSpec,
+    pg: (s: string): string => toSchemaTableSpec(s, 'pg'),
+    ms: (s: string): string => toSchemaTableSpec(s, 'ms'),
+  },
+};
+
+export const removePairBrackets = (s: string): string => {
+  if (!s) {
+    return s;
+  }
+  s = s.trim().replace(/\s*\(\s*/sg, '(');
+  s = s.replace(/\s*\)s*/sg, ')');
+  const [, leadB = ''] = /^(\(+)/.exec(s) || [];
+  if (!leadB) {
+    return s;
+  }
+  const [, trailB = ''] = /(\)+)$/.exec(s) || [];
+  const cnt = Math.min(leadB.length, trailB.length);
+  for (let c = 0; c < cnt; c++) {
+    s = s.substring(1, s.length - 1);
+  }
+  return s;
+};
+
+/**
+ * Оборачивает строку в одинарные кавычки, если второй аргумент не true
+ */
+export const q = (val: string, noQuotes?: boolean): string => (noQuotes ? val : `'${val}'`);
+
+export const prepareJSON = (value: any): string | typeof NULL => {
+  if (value == null) {
+    return NULL;
+  }
+  try {
+    value = JSON.stringify(value);
+  } catch (err) {
+    return NULL;
+  }
+  return value;
+};
+
+export const binToHexString = (value: any): string | null => (value ? `0x${value.toString('hex').toUpperCase()}` : null);
+
+export const prepareUUID = (v: any, toLower: boolean = false, noQuotes: boolean = false): string | typeof NULL => {
+  if (v && typeof v === 'string' && /^[A-F\d]{8}(-[A-F\d]{4}){4}[A-F\d]{8}/i.test(v)) {
+    v = v.substring(0, 36);
+    v = toLower ? v.toLowerCase() : v.toUpperCase();
+    return q(v, noQuotes);
+  }
+  return NULL;
+};

package/dist/cjs/__tests__/02_getValueForSqlMs.spec.js

@@ -1,50 +0,0 @@
-"use strict";
-/* eslint-disable max-len */
-/* eslint-disable no-console */
-Object.defineProperty(exports, "__esModule", { value: true });
-// "America/Toronto"  -05:00
-// "Europe/Berlin"    +01:00
-// "Europe/Moscow"    +03:00
-const src_1 = require("../src");
-describe('sql.getValueForSqlMs() should work properly', () => {
-    describe('should parse date properly', () => {
-        const testArr = [
-            ['2000-01-22T11:59:59.123', '2000-01-22T11:59:59.123'],
-            ['2000-01-22T11:59:59.12', '2000-01-22T11:59:59.120'],
-            ['2000-01-22T11:59:59', '2000-01-22T11:59:59.000'],
-            ['2000-01-22T11:59', '2000-01-22T11:59:00.000'],
-            ['2000-01-22 11:59:59.123', '2000-01-22T11:59:59.123'],
-            ['2000-01-22 11:59:59.12', '2000-01-22T11:59:59.120'],
-            ['2000-01-22 11:59:59.1', '2000-01-22T11:59:59.100'],
-            ['2000-01-22 11:59:59', '2000-01-22T11:59:59.000'],
-            ['2000-01-22 11:59', '2000-01-22T11:59:00.000'],
-            ['2000-01-22 11:2', '2000-01-22T11:02:00.000'],
-            ['2000-01-22 2:2', '2000-01-22T02:02:00.000'],
-            ['2000-1-2 02:02', '2000-01-02T02:02:00.000'],
-            ['2019-8-9 5:16:14 AM', '2019-08-09T05:16:14.000'],
-            ['2019-8-9 5:16:14 PM', '2019-08-09T17:16:14.000'],
-        ];
-        testArr.forEach((pair) => {
-            test(`- like '${pair[0]}'`, () => {
-                const dateStrOut = (0, src_1.getValueForSqlMs)({ value: pair[0], fieldSchema: 'datetime' });
-                expect(dateStrOut).toBe(`'${pair[1]}'`);
-            });
-        });
-    });
-    describe('should work with timezone properly', () => {
-        describe('should parse date properly', () => {
-            const testArr = [
-                ['2000-01-22T11:59:59.123Z', '2000-01-22T14:59:59.123'],
-                ['2000-01-22T11:59:59.123+0300', '2000-01-22T11:59:59.123'],
-                ['Thu Aug 08 2019 05:16:14 GMT+0300 (GMT+03:00)', '2019-08-08T05:16:14.000'],
-            ];
-            testArr.forEach((pair) => {
-                test(`- like '${pair[0]}'`, () => {
-                    const dateStrOut = (0, src_1.getValueForSqlMs)({ value: pair[0], fieldSchema: 'datetime' });
-                    expect(dateStrOut).toBe(`'${pair[1]}'`);
-                });
-            });
-        });
-    });
-});
-//# sourceMappingURL=02_getValueForSqlMs.spec.js.map

package/dist/cjs/__tests__/02_getValueForSqlMs.spec.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"02_getValueForSqlMs.spec.js","sourceRoot":"","sources":["../../../__tests__/02_getValueForSqlMs.spec.ts"],"names":[],"mappings":";AAAA,4BAA4B;AAC5B,+BAA+B;;AAE/B,4BAA4B;AAC5B,4BAA4B;AAC5B,4BAA4B;AAE5B,gCAA0C;AAE1C,QAAQ,CAAC,6CAA6C,EAAE,GAAG,EAAE;IAC3D,QAAQ,CAAC,4BAA4B,EAAE,GAAG,EAAE;QAC1C,MAAM,OAAO,GAAG;YACd,CAAC,yBAAyB,EAAE,yBAAyB,CAAC;YACtD,CAAC,wBAAwB,EAAE,yBAAyB,CAAC;YACrD,CAAC,qBAAqB,EAAE,yBAAyB,CAAC;YAClD,CAAC,kBAAkB,EAAE,yBAAyB,CAAC;YAC/C,CAAC,yBAAyB,EAAE,yBAAyB,CAAC;YACtD,CAAC,wBAAwB,EAAE,yBAAyB,CAAC;YACrD,CAAC,uBAAuB,EAAE,yBAAyB,CAAC;YACpD,CAAC,qBAAqB,EAAE,yBAAyB,CAAC;YAClD,CAAC,kBAAkB,EAAE,yBAAyB,CAAC;YAC/C,CAAC,iBAAiB,EAAE,yBAAyB,CAAC;YAC9C,CAAC,gBAAgB,EAAE,yBAAyB,CAAC;YAC7C,CAAC,gBAAgB,EAAE,yBAAyB,CAAC;YAC7C,CAAC,qBAAqB,EAAE,yBAAyB,CAAC;YAClD,CAAC,qBAAqB,EAAE,yBAAyB,CAAC;SACnD,CAAC;QACF,OAAO,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;YACvB,IAAI,CAAC,WAAW,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE;gBAC/B,MAAM,UAAU,GAAG,IAAA,sBAAgB,EAAC,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,UAAU,EAAE,CAAC,CAAC;gBACjF,MAAM,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;YAC1C,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,oCAAoC,EAAE,GAAG,EAAE;QAClD,QAAQ,CAAC,4BAA4B,EAAE,GAAG,EAAE;YAC1C,MAAM,OAAO,GAAG;gBACd,CAAC,0BAA0B,EAAE,yBAAyB,CAAC;gBACvD,CAAC,8BAA8B,EAAE,yBAAyB,CAAC;gBAC3D,CAAC,+CAA+C,EAAE,yBAAyB,CAAC;aAC7E,CAAC;YACF,OAAO,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;gBACvB,IAAI,CAAC,WAAW,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE;oBAC/B,MAAM,UAAU,GAAG,IAAA,sBAAgB,EAAC,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,UAAU,EAAE,CAAC,CAAC;oBACjF,MAAM,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;gBAC1C,CAAC,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}