@loaders.gl/wkt 4.3.2 → 4.4.0-alpha.2

package/dist/lib/parse-wkt-crs.d.ts

@@ -1,15 +0,0 @@
-export type ParseWKTCRSOptions = {
-    sort?: boolean;
-    keywords?: string[];
-    raw?: boolean;
-    debug?: boolean;
-};
-export type WKTCRS = any;
-/**
- *
- * @param wkt
- * @param options
- * @returns
- */
-export declare function parseWKTCRS(wkt: string, options?: ParseWKTCRSOptions): WKTCRS;
-//# sourceMappingURL=parse-wkt-crs.d.ts.map

package/dist/lib/parse-wkt-crs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse-wkt-crs.d.ts","sourceRoot":"","sources":["../../src/lib/parse-wkt-crs.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG,GAAG,CAAC;AAEzB;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,MAAM,CA2E7E"}

package/dist/lib/parse-wkt-crs.js

@@ -1,120 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-// parse-wkt-crs was forked from https://github.com/DanielJDufour/wkt-crs under Creative Commons CC0 1.0 license.
-/**
- *
- * @param wkt
- * @param options
- * @returns
- */
-export function parseWKTCRS(wkt, options) {
-    if (options?.debug) {
-        console.log('[wktcrs] parse starting with\n', wkt);
-    }
-    // move all keywords into first array item slot
-    // from PARAM[12345, 67890] to ["PARAM", 12345, 67890]
-    wkt = wkt.replace(/[A-Z][A-Z\d_]+\[/gi, (match) => `["${match.substr(0, match.length - 1)}",`);
-    // wrap variables in strings
-    // from [...,NORTH] to [...,"NORTH"]
-    wkt = wkt.replace(/, ?([A-Z][A-Z\d_]+[,\]])/gi, (match, p1) => {
-        const varname = p1.substr(0, p1.length - 1);
-        return ',' + `"${options?.raw ? 'raw:' : ''}${varname}"${p1[p1.length - 1]}`;
-    });
-    if (options?.raw) {
-        // replace all numbers with strings
-        wkt = wkt.replace(/, {0,2}(-?[\.\d]+)(?=,|\])/g, function (match, p1) {
-            return ',' + `"${options?.raw ? 'raw:' : ''}${p1}"`;
-        });
-    }
-    // str should now be valid JSON
-    if (options?.debug) {
-        console.log(`[wktcrs] json'd wkt: '${wkt}'`);
-    }
-    let data;
-    try {
-        data = JSON.parse(wkt);
-    }
-    catch (error) {
-        console.error(`[wktcrs] failed to parse '${wkt}'`);
-        throw error;
-    }
-    if (options?.debug) {
-        console.log(`[wktcrs] json parsed: '${wkt}'`);
-    }
-    function process(data, parent) {
-        const kw = data[0];
-        // after removing the first element with .shift()
-        // data is now just an array of attributes
-        data.forEach(function (it) {
-            if (Array.isArray(it)) {
-                process(it, data);
-            }
-        });
-        const kwarr = `MULTIPLE_${kw}`;
-        if (kwarr in parent) {
-            parent[kwarr].push(data);
-        }
-        else if (kw in parent) {
-            parent[kwarr] = [parent[kw], data];
-            delete parent[kw];
-        }
-        else {
-            parent[kw] = data;
-        }
-        return parent;
-    }
-    const result = process(data, [data]);
-    if (options?.debug) {
-        console.log('[wktcrs] parse returning', result);
-    }
-    if (options?.sort) {
-        sort(result, options);
-    }
-    return result;
-}
-function sort(data, options) {
-    const keys = Object.keys(data).filter((k) => !/\d+/.test(k));
-    const keywords = options?.keywords || [];
-    if (!options?.keywords) {
-        // try to find multiples
-        const counts = {};
-        if (Array.isArray(data)) {
-            data.forEach((it) => {
-                if (Array.isArray(it) && it.length >= 2 && typeof it[1] === 'string') {
-                    const k = it[0];
-                    if (!counts[k])
-                        counts[k] = 0;
-                    counts[k]++;
-                }
-            });
-            for (const k in counts) {
-                if (counts[k] > 0)
-                    keywords.push(k);
-            }
-        }
-    }
-    keys.forEach((key) => {
-        data[key] = sort(data[key]);
-    });
-    keywords.forEach((key) => {
-        const indices = [];
-        const params = [];
-        data.forEach((item, i) => {
-            if (Array.isArray(item) && item[0] === key) {
-                indices.push(i);
-                params.push(item);
-            }
-        });
-        params.sort((a, b) => {
-            a = a[1].toString();
-            b = b[1].toString();
-            return a < b ? -1 : a > b ? 1 : 0;
-        });
-        // replace in order
-        params.forEach((param, i) => {
-            data[indices[i]] = param;
-        });
-    });
-    return data;
-}

package/dist/lib/parse-wkt.d.ts

@@ -1,30 +0,0 @@
-import { Geometry } from '@loaders.gl/schema';
-export declare const WKT_MAGIC_STRINGS: string[];
-export type ParseWKTOptions = {
-    wkt?: {
-        /** Whether to add any CRS, if found, as undocumented CRS property on the return geometry */
-        crs?: boolean;
-    };
-};
-/**
- * Check if a string is WKT.
- * @param input A potential WKT geometry string
- * @return `true` if input appears to be a WKT geometry string, `false` otherwise
-
- * @note We only support the "geojson" subset of the OGC simple features standard
- * @todo Does not handle leading spaces which appear to be permitted per the spec:
- * "A WKT string contains no white space outside of double quotes.
- * However padding with white space to improve human readability is permitted;
- * the examples of WKT that are included in this document have
- * spaces and line feeds inserted to improve clarity. Any padding is stripped out or ignored by parsers."
- */
-export declare function isWKT(input: string): boolean;
-/**
- * Parse WKT and return GeoJSON.
- * @param input A WKT geometry string
- * @return A GeoJSON geometry object
- *
- * @note We only support the "geojson" subset of the OGC simple features standard
- **/
-export declare function parseWKT(input: string, options?: ParseWKTOptions): Geometry;
-//# sourceMappingURL=parse-wkt.d.ts.map

package/dist/lib/parse-wkt.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse-wkt.d.ts","sourceRoot":"","sources":["../../src/lib/parse-wkt.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,QAAQ,EAAC,MAAM,oBAAoB,CAAC;AAS5C,eAAO,MAAM,iBAAiB,UAS7B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,GAAG,CAAC,EAAE;QACJ,4FAA4F;QAC5F,GAAG,CAAC,EAAE,OAAO,CAAC;KACf,CAAC;CACH,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAE5C;AAED;;;;;;IAMI;AACJ,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,QAAQ,CAG3E"}

package/dist/lib/parse-wkt.js

@@ -1,288 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-// Fork of https://github.com/mapbox/wellknown under ISC license (MIT/BSD-2-clause equivalent)
-/* eslint-disable */
-// @ts-nocheck
-const numberRegexp = /[-+]?([0-9]*\.[0-9]+|[0-9]+)([eE][-+]?[0-9]+)?/;
-// Matches sequences like '100 100' or '100 100 100'.
-const tuples = new RegExp('^' + numberRegexp.source + '(\\s' + numberRegexp.source + '){1,}');
-export const WKT_MAGIC_STRINGS = [
-    'POINT(',
-    'LINESTRING(',
-    'POLYGON(',
-    'MULTIPOINT(',
-    'MULTILINESTRING(',
-    'MULTIPOLYGON(',
-    'GEOMETRYCOLLECTION('
-    // We only support this "geojson" subset of the OGC simple features standard
-];
-/**
- * Check if a string is WKT.
- * @param input A potential WKT geometry string
- * @return `true` if input appears to be a WKT geometry string, `false` otherwise
-
- * @note We only support the "geojson" subset of the OGC simple features standard
- * @todo Does not handle leading spaces which appear to be permitted per the spec:
- * "A WKT string contains no white space outside of double quotes.
- * However padding with white space to improve human readability is permitted;
- * the examples of WKT that are included in this document have
- * spaces and line feeds inserted to improve clarity. Any padding is stripped out or ignored by parsers."
- */
-export function isWKT(input) {
-    return WKT_MAGIC_STRINGS.some((magicString) => input.startsWith(magicString));
-}
-/**
- * Parse WKT and return GeoJSON.
- * @param input A WKT geometry string
- * @return A GeoJSON geometry object
- *
- * @note We only support the "geojson" subset of the OGC simple features standard
- **/
-export function parseWKT(input, options) {
-    // TODO handle options.wkt.shape
-    return parseWKTToGeometry(input, options);
-}
-/** Parse into GeoJSON geometry */
-function parseWKTToGeometry(input, options) {
-    const parts = input.split(';');
-    let _ = parts.pop();
-    const srid = (parts.shift() || '').split('=').pop();
-    const state = { parts, _, i: 0 };
-    const geometry = parseGeometry(state);
-    return options?.wkt?.crs ? addCRS(geometry, srid) : geometry;
-}
-function parseGeometry(state) {
-    return (parsePoint(state) ||
-        parseLineString(state) ||
-        parsePolygon(state) ||
-        parseMultiPoint(state) ||
-        parseMultiLineString(state) ||
-        parseMultiPolygon(state) ||
-        parseGeometryCollection(state));
-}
-/** Adds a coordinate reference system as an undocumented  */
-function addCRS(obj, srid) {
-    if (obj && srid?.match(/\d+/)) {
-        const crs = {
-            type: 'name',
-            properties: {
-                name: 'urn:ogc:def:crs:EPSG::' + srid
-            }
-        };
-        // @ts-expect-error we assign an undocumented property on the geometry
-        obj.crs = crs;
-    }
-    return obj;
-}
-// GEOMETRIES
-function parsePoint(state) {
-    if (!$(/^(POINT(\sz)?)/i, state)) {
-        return null;
-    }
-    white(state);
-    if (!$(/^(\()/, state)) {
-        return null;
-    }
-    const c = coords(state);
-    if (!c) {
-        return null;
-    }
-    white(state);
-    if (!$(/^(\))/, state)) {
-        return null;
-    }
-    return {
-        type: 'Point',
-        coordinates: c[0]
-    };
-}
-function parseMultiPoint(state) {
-    if (!$(/^(MULTIPOINT)/i, state)) {
-        return null;
-    }
-    white(state);
-    const newCoordsFormat = state._?.substring(state._?.indexOf('(') + 1, state._.length - 1)
-        .replace(/\(/g, '')
-        .replace(/\)/g, '');
-    state._ = 'MULTIPOINT (' + newCoordsFormat + ')';
-    const c = multicoords(state);
-    if (!c) {
-        return null;
-    }
-    white(state);
-    return {
-        type: 'MultiPoint',
-        coordinates: c
-    };
-}
-function parseLineString(state) {
-    if (!$(/^(LINESTRING(\sz)?)/i, state)) {
-        return null;
-    }
-    white(state);
-    if (!$(/^(\()/, state)) {
-        return null;
-    }
-    const c = coords(state);
-    if (!c) {
-        return null;
-    }
-    if (!$(/^(\))/, state)) {
-        return null;
-    }
-    return {
-        type: 'LineString',
-        coordinates: c
-    };
-}
-function parseMultiLineString(state) {
-    if (!$(/^(MULTILINESTRING)/i, state))
-        return null;
-    white(state);
-    const c = multicoords(state);
-    if (!c) {
-        return null;
-    }
-    white(state);
-    return {
-        // @ts-ignore
-        type: 'MultiLineString',
-        // @ts-expect-error
-        coordinates: c
-    };
-}
-function parsePolygon(state) {
-    if (!$(/^(POLYGON(\sz)?)/i, state)) {
-        return null;
-    }
-    white(state);
-    const c = multicoords(state);
-    if (!c) {
-        return null;
-    }
-    return {
-        // @ts-ignore
-        type: 'Polygon',
-        // @ts-expect-error
-        coordinates: c
-    };
-}
-function parseMultiPolygon(state) {
-    if (!$(/^(MULTIPOLYGON)/i, state)) {
-        return null;
-    }
-    white(state);
-    const c = multicoords(state);
-    if (!c) {
-        return null;
-    }
-    return {
-        type: 'MultiPolygon',
-        // @ts-expect-error
-        coordinates: c
-    };
-}
-function parseGeometryCollection(state) {
-    const geometries = [];
-    let geometry;
-    if (!$(/^(GEOMETRYCOLLECTION)/i, state)) {
-        return null;
-    }
-    white(state);
-    if (!$(/^(\()/, state)) {
-        return null;
-    }
-    while ((geometry = parseGeometry(state))) {
-        geometries.push(geometry);
-        white(state);
-        $(/^(,)/, state);
-        white(state);
-    }
-    if (!$(/^(\))/, state)) {
-        return null;
-    }
-    return {
-        type: 'GeometryCollection',
-        geometries: geometries
-    };
-}
-// COORDINATES
-function multicoords(state) {
-    white(state);
-    let depth = 0;
-    const rings = [];
-    const stack = [rings];
-    let pointer = rings;
-    let elem;
-    while ((elem = $(/^(\()/, state) || $(/^(\))/, state) || $(/^(,)/, state) || $(tuples, state))) {
-        if (elem === '(') {
-            stack.push(pointer);
-            pointer = [];
-            stack[stack.length - 1].push(pointer);
-            depth++;
-        }
-        else if (elem === ')') {
-            // For the case: Polygon(), ...
-            if (pointer.length === 0)
-                return null;
-            // @ts-ignore
-            pointer = stack.pop();
-            // the stack was empty, input was malformed
-            if (!pointer)
-                return null;
-            depth--;
-            if (depth === 0)
-                break;
-        }
-        else if (elem === ',') {
-            pointer = [];
-            stack[stack.length - 1].push(pointer);
-        }
-        else if (!elem.split(/\s/g).some(isNaN)) {
-            Array.prototype.push.apply(pointer, elem.split(/\s/g).map(parseFloat));
-        }
-        else {
-            return null;
-        }
-        white(state);
-    }
-    if (depth !== 0)
-        return null;
-    return rings;
-}
-function coords(state) {
-    const list = [];
-    let item;
-    let pt;
-    while ((pt = $(tuples, state) || $(/^(,)/, state))) {
-        if (pt === ',') {
-            list.push(item);
-            item = [];
-        }
-        else if (!pt.split(/\s/g).some(isNaN)) {
-            if (!item)
-                item = [];
-            Array.prototype.push.apply(item, pt.split(/\s/g).map(parseFloat));
-        }
-        white(state);
-    }
-    if (item)
-        list.push(item);
-    else
-        return null;
-    return list.length ? list : null;
-}
-// HELPERS
-function $(regexp, state) {
-    const match = state._?.substring(state.i).match(regexp);
-    if (!match)
-        return null;
-    else {
-        state.i += match[0].length;
-        return match[0];
-    }
-}
-function white(state) {
-    $(/^\s*/, state);
-}

package/dist/lib/utils/base64-encoder.d.ts

@@ -1,5 +0,0 @@
-export declare class Base64Encoder {
-    getDecodedLength(array: Uint8Array): number;
-    decode(array: Uint8Array, target?: ArrayBuffer): void;
-}
-//# sourceMappingURL=base64-encoder.d.ts.map

package/dist/lib/utils/base64-encoder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"base64-encoder.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/base64-encoder.ts"],"names":[],"mappings":"AA0BA,qBAAa,aAAa;IACxB,gBAAgB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM;IAI3C,MAAM,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,WAAW;CAC/C"}

package/dist/lib/utils/base64-encoder.js

@@ -1,153 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-/*
-const binary_to_b64_map = [
-  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
-  'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
-  'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a',
-  'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
-  'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
-  't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1',
-  '2', '3', '4', '5', '6', '7', '8', '9', '+',
-  '/', '='
-];
-const b64_to_binary_map = {
-  '0': 52, '1': 53, '2': 54, '3': 55, '4': 56, '5': 57, '6': 58, '7': 59, '8': 60, '9': 61,
-  A: 0, B: 1, C: 2, D: 3, E: 4, F: 5, G: 6, H: 7, I: 8, J: 9, K: 10, L: 11, M: 12, N: 13, O: 14,
-  P: 15, Q: 16, R: 17, S: 18, T: 19, U: 20, V: 21, W: 22, X: 23, Y: 24, Z: 25, a: 26, b: 27,
-  c: 28, d: 29, e: 30, f: 31, g: 32, h: 33, i: 34, j: 35, k: 36, l: 37, m: 38, n: 39, o: 40,
-  p: 41, q: 42, r: 43, s: 44, t: 45, u: 46, v: 47, w: 48, x: 49, y: 50, z: 51, '+': 62, '/': 63,
-  '=': 64
-};
-
-*/
-export class Base64Encoder {
-    getDecodedLength(array) {
-        return Math.ceil(array.byteLength / 4) * 3;
-    }
-    decode(array, target) { } // eslint-disable-line
-}
-/*
-
-//generates an array iterator that returns 3 elements at a time. Use to loop through the Uint8Array Array Buffer
-// to be converted to Base64.  (binary array buffer) 8bits * 3 = 6bits * 4 (base64 representation)
-const generateTripleIterator = (arr) => {
-  return {
-      *[Symbol.iterator]() {
-          for(let n = 0; n < arr.length; n+=3) {
-              let result = [];
-              result.push(arr[n]);
-
-              if(n+1 < arr.length)
-                  result.push(arr[n+1]);
-              if(n+2 < arr.length)
-                  result.push(arr[n+2]);
-
-              yield result;
-          }
-      }
-  };
-};
-
-//generates an array iterator that returns 4 elements at a time.  Use to loop through
-// Base64 string because Base64 string is multiples of 4 characters.
-const generateQuadrupleIterator = (arr) => {
-  return {
-      *[Symbol.iterator]() {
-          for(let n = 0; n < arr.length; n+=4) {
-              yield [...arr.slice(n, n+4)];
-          }
-      }
-  };
-};
-
-// Converts a triple of 8 bits into a quadruple of 6 bits.  use to convert binary to base64 representation
-const tripleConvert = (first, second, third) => {
-  let [] = triple;
-  let binary = null, a = null, b = null, c = null, d = null;
-  if (triple.length === 1) {
-      binary = (first << 4);
-      a = ((binary & 4032) >>> 6);
-      b = (binary & 63);
-      c = 64;
-      d = 64;
-  } else if (triple.length === 2) {
-      binary = ((first << 10) | (second << 2));
-      a = ((binary & 258048) >>> 12);
-      b = ((binary & 4032) >>> 6);
-      c = (binary & 63);
-      d = 64;
-  } else {
-      binary = ((first << 16) | (second << 8) | third);
-      a = ((binary & 16515072) >>> 18);
-      b = ((binary & 258048) >>> 12);
-      c = ((binary & 4032) >>> 6);
-      d = (binary & 63);
-  }
-
-  return [a, b, c, d];
-};
-
-// Converts a quadruple of 6 bits into a triple of 8 bits.  use to convert base64 representation into binary
-const quadrupleConvert = (quadruple) => {
-  let [a, b, c, d] = quadruple;
-  let binary = null, first = null, second = null, third = null;
-
-  if(c === 64 && d === 64) {
-      //two padding
-      binary = ((a << 6) | b);
-      first = (binary >> 4);   //shift off 4 bits, 2 bits per padding
-  } else if(d === 64) {
-      //one padding
-      binary = ((a << 12) | (b << 6) | c );
-      binary = (binary >> 2); //shift off 2 bits
-      first = binary >> 8;
-      second = ((binary << 24) >>> 24);
-  } else {
-      //no padding
-      binary = ((a << 18) | (b << 12) | (c << 6) | d );
-      first = (binary >>> 16);
-      second = ((binary << 16) >>> 24);
-      third = ((binary << 24) >>> 24);
-  }
-
-  return [first, second, third];
-};
-
-// Convert 8Bits Array Buffer to Base64 string
-export const ab2b64 = (buffer) => {
-  const b64strArray = [];
-  const view = new Uint8Array(buffer);
-  let iterator = generateTripleIterator(view);
-  for(let triple of iterator) {
-      b64strArray.push(...tripleConvert(triple));
-  }
-  return b64strArray.map(b64CharCodePoint => binary_to_b64_map[b64CharCodePoint]).join("");
-};
-
-// Convert Base64 String to 8Bits Array Buffer
-export const b642ab = (b64str) => {
-  let buffer_length = (b64str.length / 4) * 3;
-  if(b64str.slice(-2) === '==') {
-      buffer_length -= 2;
-  } else if(b64str.slice(-1) === '=') {
-      buffer_length -= 1;
-  }
-
-  let buffer = new ArrayBuffer(buffer_length);
-  const view = new Uint8Array(buffer);
-  let iterator = generateQuadrupleIterator(b64str.split("").map(b64char => b64_to_binary_map[b64char]));
-  let byteIndex = 0;
-  for(let quadruple of iterator) {
-      quadrupleConvert(quadruple).forEach(byte => {
-          if(byte != null) {
-              view[byteIndex] = byte;
-              byteIndex++;
-          }
-      });
-  }
-  return buffer;
-};
-
-*/

package/dist/lib/utils/binary-reader.d.ts

@@ -1,18 +0,0 @@
-/** A DataView that tracks byte offset when reading. */
-export declare class BinaryReader {
-    arrayBuffer: ArrayBuffer;
-    dataView: DataView;
-    byteOffset: number;
-    littleEndian: boolean;
-    constructor(arrayBuffer: ArrayBuffer, isBigEndian?: boolean);
-    readUInt8(): number;
-    readUInt16(): number;
-    readUInt32(): number;
-    readInt8(): number;
-    readInt16(): number;
-    readInt32(): number;
-    readFloat(): number;
-    readDouble(): number;
-    readVarInt(): number;
-}
-//# sourceMappingURL=binary-reader.d.ts.map

package/dist/lib/utils/binary-reader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"binary-reader.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/binary-reader.ts"],"names":[],"mappings":"AAIA,uDAAuD;AACvD,qBAAa,YAAY;IACvB,WAAW,EAAE,WAAW,CAAC;IACzB,QAAQ,EAAE,QAAQ,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;gBAEV,WAAW,EAAE,WAAW,EAAE,WAAW,GAAE,OAAe;IAOlE,SAAS;IAKT,UAAU;IAKV,UAAU;IAKV,QAAQ;IAKR,SAAS;IAKT,SAAS;IAKT,SAAS;IAKT,UAAU;IAMV,UAAU;CAgBX"}