@loaders.gl/shapefile 4.0.0-alpha.5 → 4.0.0-alpha.7

package/dist/lib/parsers/parse-dbf.js

@@ -1,299 +1,344 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { Schema, Field, Bool, Utf8, Float64, TimestampMillisecond } from '@loaders.gl/schema';
-import BinaryChunkReader from '../streaming/binary-chunk-reader';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDBFInBatches = exports.parseDBF = void 0;
+const binary_chunk_reader_1 = __importDefault(require("../streaming/binary-chunk-reader"));
 const LITTLE_ENDIAN = true;
 const DBF_HEADER_SIZE = 32;
 var STATE;
-
 (function (STATE) {
-  STATE[STATE["START"] = 0] = "START";
-  STATE[STATE["FIELD_DESCRIPTORS"] = 1] = "FIELD_DESCRIPTORS";
-  STATE[STATE["FIELD_PROPERTIES"] = 2] = "FIELD_PROPERTIES";
-  STATE[STATE["END"] = 3] = "END";
-  STATE[STATE["ERROR"] = 4] = "ERROR";
+    STATE[STATE["START"] = 0] = "START";
+    STATE[STATE["FIELD_DESCRIPTORS"] = 1] = "FIELD_DESCRIPTORS";
+    STATE[STATE["FIELD_PROPERTIES"] = 2] = "FIELD_PROPERTIES";
+    STATE[STATE["END"] = 3] = "END";
+    STATE[STATE["ERROR"] = 4] = "ERROR";
 })(STATE || (STATE = {}));
-
 class DBFParser {
-  constructor(options) {
-    _defineProperty(this, "binaryReader", new BinaryChunkReader());
-
-    _defineProperty(this, "textDecoder", void 0);
-
-    _defineProperty(this, "state", STATE.START);
-
-    _defineProperty(this, "result", {
-      data: []
-    });
-
-    this.textDecoder = new TextDecoder(options.encoding);
-  }
-
-  write(arrayBuffer) {
-    this.binaryReader.write(arrayBuffer);
-    this.state = parseState(this.state, this.result, this.binaryReader, this.textDecoder);
-  }
-
-  end() {
-    this.binaryReader.end();
-    this.state = parseState(this.state, this.result, this.binaryReader, this.textDecoder);
-
-    if (this.state !== STATE.END) {
-      this.state = STATE.ERROR;
-      this.result.error = 'DBF incomplete file';
+    constructor(options) {
+        this.binaryReader = new binary_chunk_reader_1.default();
+        this.state = STATE.START;
+        this.result = {
+            data: []
+        };
+        this.textDecoder = new TextDecoder(options.encoding);
+    }
+    /**
+     * @param arrayBuffer
+     */
+    write(arrayBuffer) {
+        this.binaryReader.write(arrayBuffer);
+        this.state = parseState(this.state, this.result, this.binaryReader, this.textDecoder);
+        // this.result.progress.bytesUsed = this.binaryReader.bytesUsed();
+        // important events:
+        // - schema available
+        // - first rows available
+        // - all rows available
+    }
+    end() {
+        this.binaryReader.end();
+        this.state = parseState(this.state, this.result, this.binaryReader, this.textDecoder);
+        // this.result.progress.bytesUsed = this.binaryReader.bytesUsed();
+        if (this.state !== STATE.END) {
+            this.state = STATE.ERROR;
+            this.result.error = 'DBF incomplete file';
+        }
     }
-  }
-
 }
-
-export function parseDBF(arrayBuffer, options = {}) {
-  const loaderOptions = options.dbf || {};
-  const {
-    encoding
-  } = loaderOptions;
-  const dbfParser = new DBFParser({
-    encoding
-  });
-  dbfParser.write(arrayBuffer);
-  dbfParser.end();
-  const {
-    data,
-    schema
-  } = dbfParser.result;
-
-  switch (options.tables && options.tables.format) {
-    case 'table':
-      return {
-        schema,
-        rows: data
-      };
-
-    case 'rows':
-    default:
-      return data;
-  }
+/**
+ * @param arrayBuffer
+ * @param options
+ * @returns DBFTable or rows
+ */
+function parseDBF(arrayBuffer, options = {}) {
+    const { encoding = 'latin1' } = options.dbf || {};
+    const dbfParser = new DBFParser({ encoding });
+    dbfParser.write(arrayBuffer);
+    dbfParser.end();
+    const { data, schema } = dbfParser.result;
+    const shape = options?.tables?.format || options?.dbf?.shape;
+    switch (shape) {
+        case 'object-row-table': {
+            const table = {
+                shape: 'object-row-table',
+                schema,
+                data
+            };
+            return table;
+        }
+        case 'table':
+            return { schema, rows: data };
+        case 'rows':
+        default:
+            return data;
+    }
 }
-export async function* parseDBFInBatches(asyncIterator, options = {}) {
-  const loaderOptions = options.dbf || {};
-  const {
-    encoding
-  } = loaderOptions;
-  const parser = new DBFParser({
-    encoding
-  });
-  let headerReturned = false;
-
-  for await (const arrayBuffer of asyncIterator) {
-    parser.write(arrayBuffer);
-
-    if (!headerReturned && parser.result.dbfHeader) {
-      headerReturned = true;
-      yield parser.result.dbfHeader;
+exports.parseDBF = parseDBF;
+/**
+ * @param asyncIterator
+ * @param options
+ */
+async function* parseDBFInBatches(asyncIterator, options = {}) {
+    const { encoding = 'latin1' } = options.dbf || {};
+    const parser = new DBFParser({ encoding });
+    let headerReturned = false;
+    for await (const arrayBuffer of asyncIterator) {
+        parser.write(arrayBuffer);
+        if (!headerReturned && parser.result.dbfHeader) {
+            headerReturned = true;
+            yield parser.result.dbfHeader;
+        }
+        if (parser.result.data.length > 0) {
+            yield parser.result.data;
+            parser.result.data = [];
+        }
     }
-
+    parser.end();
     if (parser.result.data.length > 0) {
-      yield parser.result.data;
-      parser.result.data = [];
+        yield parser.result.data;
     }
-  }
-
-  parser.end();
-
-  if (parser.result.data.length > 0) {
-    yield parser.result.data;
-  }
 }
-
+exports.parseDBFInBatches = parseDBFInBatches;
+/**
+ * https://www.dbase.com/Knowledgebase/INT/db7_file_fmt.htm
+ * @param state
+ * @param result
+ * @param binaryReader
+ * @param textDecoder
+ * @returns
+ */
+/* eslint-disable complexity, max-depth */
 function parseState(state, result, binaryReader, textDecoder) {
-  while (true) {
-    try {
-      switch (state) {
-        case STATE.ERROR:
-        case STATE.END:
-          return state;
-
-        case STATE.START:
-          const dataView = binaryReader.getDataView(DBF_HEADER_SIZE, 'DBF header');
-
-          if (!dataView) {
-            return state;
-          }
-
-          result.dbfHeader = parseDBFHeader(dataView);
-          result.progress = {
-            bytesUsed: 0,
-            rowsTotal: result.dbfHeader.nRecords,
-            rows: 0
-          };
-          state = STATE.FIELD_DESCRIPTORS;
-          break;
-
-        case STATE.FIELD_DESCRIPTORS:
-          const fieldDescriptorView = binaryReader.getDataView(result.dbfHeader.headerLength - DBF_HEADER_SIZE, 'DBF field descriptors');
-
-          if (!fieldDescriptorView) {
-            return state;
-          }
-
-          result.dbfFields = parseFieldDescriptors(fieldDescriptorView, textDecoder);
-          result.schema = new Schema(result.dbfFields.map(dbfField => makeField(dbfField)));
-          state = STATE.FIELD_PROPERTIES;
-          binaryReader.skip(1);
-          break;
-
-        case STATE.FIELD_PROPERTIES:
-          const {
-            recordLength = 0,
-            nRecords = 0
-          } = (result === null || result === void 0 ? void 0 : result.dbfHeader) || {};
-
-          while (result.data.length < nRecords) {
-            const recordView = binaryReader.getDataView(recordLength - 1);
-
-            if (!recordView) {
-              return state;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        try {
+            switch (state) {
+                case STATE.ERROR:
+                case STATE.END:
+                    return state;
+                case STATE.START:
+                    // Parse initial file header
+                    // DBF Header
+                    const dataView = binaryReader.getDataView(DBF_HEADER_SIZE);
+                    if (!dataView) {
+                        return state;
+                    }
+                    result.dbfHeader = parseDBFHeader(dataView);
+                    result.progress = {
+                        bytesUsed: 0,
+                        rowsTotal: result.dbfHeader.nRecords,
+                        rows: 0
+                    };
+                    state = STATE.FIELD_DESCRIPTORS;
+                    break;
+                case STATE.FIELD_DESCRIPTORS:
+                    // Parse DBF field descriptors (schema)
+                    const fieldDescriptorView = binaryReader.getDataView(
+                    // @ts-ignore
+                    result.dbfHeader.headerLength - DBF_HEADER_SIZE);
+                    if (!fieldDescriptorView) {
+                        return state;
+                    }
+                    result.dbfFields = parseFieldDescriptors(fieldDescriptorView, textDecoder);
+                    result.schema = {
+                        fields: result.dbfFields.map((dbfField) => makeField(dbfField)),
+                        metadata: {}
+                    };
+                    state = STATE.FIELD_PROPERTIES;
+                    // TODO(kyle) Not exactly sure why start offset needs to be headerLength + 1?
+                    // parsedbf uses ((fields.length + 1) << 5) + 2;
+                    binaryReader.skip(1);
+                    break;
+                case STATE.FIELD_PROPERTIES:
+                    const { recordLength = 0, nRecords = 0 } = result?.dbfHeader || {};
+                    while (result.data.length < nRecords) {
+                        const recordView = binaryReader.getDataView(recordLength - 1);
+                        if (!recordView) {
+                            return state;
+                        }
+                        // Note: Avoid actually reading the last byte, which may not be present
+                        binaryReader.skip(1);
+                        // @ts-ignore
+                        const row = parseRow(recordView, result.dbfFields, textDecoder);
+                        result.data.push(row);
+                        // @ts-ignore
+                        result.progress.rows = result.data.length;
+                    }
+                    state = STATE.END;
+                    break;
+                default:
+                    state = STATE.ERROR;
+                    result.error = `illegal parser state ${state}`;
+                    return state;
             }
-
-            binaryReader.skip(1);
-            const row = parseRow(recordView, result.dbfFields, textDecoder);
-            result.data.push(row);
-            result.progress.rows = result.data.length;
-          }
-
-          state = STATE.END;
-          break;
-
-        default:
-          state = STATE.ERROR;
-          result.error = "illegal parser state ".concat(state);
-          return state;
-      }
-    } catch (error) {
-      state = STATE.ERROR;
-      result.error = "DBF parsing failed: ".concat(error.message);
-      return state;
+        }
+        catch (error) {
+            state = STATE.ERROR;
+            result.error = `DBF parsing failed: ${error.message}`;
+            return state;
+        }
     }
-  }
 }
-
+/**
+ * @param headerView
+ */
 function parseDBFHeader(headerView) {
-  return {
-    year: headerView.getUint8(1) + 1900,
-    month: headerView.getUint8(2),
-    day: headerView.getUint8(3),
-    nRecords: headerView.getUint32(4, LITTLE_ENDIAN),
-    headerLength: headerView.getUint16(8, LITTLE_ENDIAN),
-    recordLength: headerView.getUint16(10, LITTLE_ENDIAN),
-    languageDriver: headerView.getUint8(29)
-  };
+    return {
+        // Last updated date
+        year: headerView.getUint8(1) + 1900,
+        month: headerView.getUint8(2),
+        day: headerView.getUint8(3),
+        // Number of records in data file
+        nRecords: headerView.getUint32(4, LITTLE_ENDIAN),
+        // Length of header in bytes
+        headerLength: headerView.getUint16(8, LITTLE_ENDIAN),
+        // Length of each record
+        recordLength: headerView.getUint16(10, LITTLE_ENDIAN),
+        // Not sure if this is usually set
+        languageDriver: headerView.getUint8(29)
+    };
 }
-
+/**
+ * @param view
+ */
 function parseFieldDescriptors(view, textDecoder) {
-  const nFields = (view.byteLength - 1) / 32;
-  const fields = [];
-  let offset = 0;
-
-  for (let i = 0; i < nFields; i++) {
-    const name = textDecoder.decode(new Uint8Array(view.buffer, view.byteOffset + offset, 11)).replace(/\u0000/g, '');
-    fields.push({
-      name,
-      dataType: String.fromCharCode(view.getUint8(offset + 11)),
-      fieldLength: view.getUint8(offset + 16),
-      decimal: view.getUint8(offset + 17)
-    });
-    offset += 32;
+    // NOTE: this might overestimate the number of fields if the "Database
+    // Container" container exists and is included in the headerLength
+    const nFields = (view.byteLength - 1) / 32;
+    const fields = [];
+    let offset = 0;
+    for (let i = 0; i < nFields; i++) {
+        const name = textDecoder
+            .decode(new Uint8Array(view.buffer, view.byteOffset + offset, 11))
+            // eslint-disable-next-line no-control-regex
+            .replace(/\u0000/g, '');
+        fields.push({
+            name,
+            dataType: String.fromCharCode(view.getUint8(offset + 11)),
+            fieldLength: view.getUint8(offset + 16),
+            decimal: view.getUint8(offset + 17)
+        });
+        offset += 32;
+    }
+    return fields;
+}
+/*
+ * @param {BinaryChunkReader} binaryReader
+function parseRows(binaryReader, fields, nRecords, recordLength, textDecoder) {
+  const rows = [];
+  for (let i = 0; i < nRecords; i++) {
+    const recordView = binaryReader.getDataView(recordLength - 1);
+    binaryReader.skip(1);
+    // @ts-ignore
+    rows.push(parseRow(recordView, fields, textDecoder));
   }
-
-  return fields;
+  return rows;
 }
-
+ */
+/**
+ *
+ * @param view
+ * @param fields
+ * @param textDecoder
+ * @returns
+ */
 function parseRow(view, fields, textDecoder) {
-  const out = {};
-  let offset = 0;
-
-  for (const field of fields) {
-    const text = textDecoder.decode(new Uint8Array(view.buffer, view.byteOffset + offset, field.fieldLength));
-    out[field.name] = parseField(text, field.dataType);
-    offset += field.fieldLength;
-  }
-
-  return out;
+    const out = {};
+    let offset = 0;
+    for (const field of fields) {
+        const text = textDecoder.decode(new Uint8Array(view.buffer, view.byteOffset + offset, field.fieldLength));
+        out[field.name] = parseField(text, field.dataType);
+        offset += field.fieldLength;
+    }
+    return out;
 }
-
+/**
+ * Should NaN be coerced to null?
+ * @param text
+ * @param dataType
+ * @returns Field depends on a type of the data
+ */
 function parseField(text, dataType) {
-  switch (dataType) {
-    case 'B':
-      return parseNumber(text);
-
-    case 'C':
-      return parseCharacter(text);
-
-    case 'F':
-      return parseNumber(text);
-
-    case 'N':
-      return parseNumber(text);
-
-    case 'O':
-      return parseNumber(text);
-
-    case 'D':
-      return parseDate(text);
-
-    case 'L':
-      return parseBoolean(text);
-
-    default:
-      throw new Error('Unsupported data type');
-  }
+    switch (dataType) {
+        case 'B':
+            return parseNumber(text);
+        case 'C':
+            return parseCharacter(text);
+        case 'F':
+            return parseNumber(text);
+        case 'N':
+            return parseNumber(text);
+        case 'O':
+            return parseNumber(text);
+        case 'D':
+            return parseDate(text);
+        case 'L':
+            return parseBoolean(text);
+        default:
+            throw new Error('Unsupported data type');
+    }
 }
-
+/**
+ * Parse YYYYMMDD to date in milliseconds
+ * @param str YYYYMMDD
+ * @returns new Date as a number
+ */
 function parseDate(str) {
-  return Date.UTC(str.slice(0, 4), parseInt(str.slice(4, 6), 10) - 1, str.slice(6, 8));
+    return Date.UTC(str.slice(0, 4), parseInt(str.slice(4, 6), 10) - 1, str.slice(6, 8));
 }
-
+/**
+ * Read boolean value
+ * any of Y, y, T, t coerce to true
+ * any of N, n, F, f coerce to false
+ * otherwise null
+ * @param value
+ * @returns boolean | null
+ */
 function parseBoolean(value) {
-  return /^[nf]$/i.test(value) ? false : /^[yt]$/i.test(value) ? true : null;
+    return /^[nf]$/i.test(value) ? false : /^[yt]$/i.test(value) ? true : null;
 }
-
+/**
+ * Return null instead of NaN
+ * @param text
+ * @returns number | null
+ */
 function parseNumber(text) {
-  const number = parseFloat(text);
-  return isNaN(number) ? null : number;
+    const number = parseFloat(text);
+    return isNaN(number) ? null : number;
 }
-
+/**
+ *
+ * @param text
+ * @returns string | null
+ */
 function parseCharacter(text) {
-  return text.trim() || null;
+    return text.trim() || null;
 }
-
-function makeField({
-  name,
-  dataType,
-  fieldLength,
-  decimal
-}) {
-  switch (dataType) {
-    case 'B':
-      return new Field(name, new Float64(), true);
-
-    case 'C':
-      return new Field(name, new Utf8(), true);
-
-    case 'F':
-      return new Field(name, new Float64(), true);
-
-    case 'N':
-      return new Field(name, new Float64(), true);
-
-    case 'O':
-      return new Field(name, new Float64(), true);
-
-    case 'D':
-      return new Field(name, new TimestampMillisecond(), true);
-
-    case 'L':
-      return new Field(name, new Bool(), true);
-
-    default:
-      throw new Error('Unsupported data type');
-  }
+/**
+ * Create a standard Arrow-style `Field` from field descriptor.
+ * TODO - use `fieldLength` and `decimal` to generate smaller types?
+ * @param param0
+ * @returns Field
+ */
+// eslint-disable
+function makeField({ name, dataType, fieldLength, decimal }) {
+    switch (dataType) {
+        case 'B':
+            return { name, type: 'float64', nullable: true, metadata: {} };
+        case 'C':
+            return { name, type: 'utf8', nullable: true, metadata: {} };
+        case 'F':
+            return { name, type: 'float64', nullable: true, metadata: {} };
+        case 'N':
+            return { name, type: 'float64', nullable: true, metadata: {} };
+        case 'O':
+            return { name, type: 'float64', nullable: true, metadata: {} };
+        case 'D':
+            return { name, type: 'timestamp-millisecond', nullable: true, metadata: {} };
+        case 'L':
+            return { name, type: 'bool', nullable: true, metadata: {} };
+        default:
+            throw new Error('Unsupported data type');
+    }
 }
-//# sourceMappingURL=parse-dbf.js.map

package/dist/lib/parsers/parse-shapefile.d.ts

@@ -1,6 +1,7 @@
 import type { SHXOutput } from './parse-shx';
 import type { SHPHeader } from './parse-shp-header';
 import type { LoaderContext } from '@loaders.gl/loader-utils';
+import type { ShapefileLoaderOptions } from './types';
 interface ShapefileOutput {
     encoding?: string;
     prj?: string;
@@ -10,12 +11,8 @@ interface ShapefileOutput {
 }
 /**
  * Parsing of file in batches
- *
- * @param asyncIterator
- * @param options
- * @param context
  */
-export declare function parseShapefileInBatches(asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>, options?: any, context?: LoaderContext): AsyncIterable<ShapefileOutput>;
+export declare function parseShapefileInBatches(asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>, options?: ShapefileLoaderOptions, context?: LoaderContext): AsyncIterable<ShapefileOutput>;
 /**
  * Parse shapefile
  *
@@ -24,9 +21,7 @@ export declare function parseShapefileInBatches(asyncIterator: AsyncIterable<Arr
  * @param context
  * @returns output of shapefile
  */
-export declare function parseShapefile(arrayBuffer: ArrayBuffer, options?: {
-    [key: string]: any;
-}, context?: LoaderContext): Promise<ShapefileOutput>;
+export declare function parseShapefile(arrayBuffer: ArrayBuffer, options?: ShapefileLoaderOptions, context?: LoaderContext): Promise<ShapefileOutput>;
 /**
  *
  * @param options

package/dist/lib/parsers/parse-shapefile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-shapefile.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-shapefile.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,oBAAoB,CAAC;AAClD,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAU5D,UAAU,eAAe;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,SAAS,CAAC;IAChB,MAAM,EAAE,SAAS,CAAC;IAClB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AACD;;;;;;GAMG;AAEH,wBAAuB,uBAAuB,CAC5C,aAAa,EAAE,aAAa,CAAC,WAAW,CAAC,GAAG,QAAQ,CAAC,WAAW,CAAC,EACjE,OAAO,CAAC,EAAE,GAAG,EACb,OAAO,CAAC,EAAE,aAAa,GACtB,aAAa,CAAC,eAAe,CAAC,CAmEhC;AAED;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAClC,WAAW,EAAE,WAAW,EACxB,OAAO,CAAC,EAAE;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAC,EAC9B,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,eAAe,CAAC,CAgC1B;AAwDD;;;;;GAKG;AAEH,wBAAsB,yBAAyB,CAC7C,OAAO,CAAC,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC;IACT,GAAG,CAAC,EAAE,SAAS,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC,CAkCD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAQ1E"}
+{"version":3,"file":"parse-shapefile.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-shapefile.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,oBAAoB,CAAC;AAClD,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAC,sBAAsB,EAAC,MAAM,SAAS,CAAC;AAUpD,UAAU,eAAe;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,SAAS,CAAC;IAChB,MAAM,EAAE,SAAS,CAAC;IAClB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AACD;;GAEG;AAEH,wBAAuB,uBAAuB,CAC5C,aAAa,EAAE,aAAa,CAAC,WAAW,CAAC,GAAG,QAAQ,CAAC,WAAW,CAAC,EACjE,OAAO,CAAC,EAAE,sBAAsB,EAChC,OAAO,CAAC,EAAE,aAAa,GACtB,aAAa,CAAC,eAAe,CAAC,CAmEhC;AAED;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAClC,WAAW,EAAE,WAAW,EACxB,OAAO,CAAC,EAAE,sBAAsB,EAChC,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,eAAe,CAAC,CAgC1B;AAwDD;;;;;GAKG;AAEH,wBAAsB,yBAAyB,CAC7C,OAAO,CAAC,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC;IACT,GAAG,CAAC,EAAE,SAAS,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC,CAkCD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAQ1E"}