velocious 1.0.108 → 1.0.109

package/dist/src/http-server/client/params-to-object.js

@@ -0,0 +1,80 @@
+// @ts-check
+export default class ParamsToObject {
+    /**
+     * @param {Record<string, string>} object
+     */
+    constructor(object) {
+        this.object = object;
+    }
+    toObject() {
+        const result = {};
+        for (const key in this.object) {
+            const value = this.object[key];
+            this.treatInitial(key, value, result);
+        }
+        return result;
+    }
+    /**
+     * @param {string} key
+     * @param {string} value
+     * @param {Record<string, any> | any[]} result
+     */
+    treatInitial(key, value, result) {
+        const firstMatch = key.match(/^(.+?)(\[([\s\S]+$))/);
+        if (firstMatch) {
+            const inputName = firstMatch[1];
+            const rest = firstMatch[2];
+            /** @type {Array<any> | Record<string, any>} */
+            let newResult;
+            if (inputName in result) {
+                newResult = result[inputName];
+            }
+            else if (rest == "[]") {
+                newResult = [];
+                result[inputName] = newResult;
+            }
+            else {
+                newResult = {};
+                result[inputName] = newResult;
+            }
+            this.treatSecond(value, rest, newResult);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    /**
+     * @param {string} value
+     * @param {string} rest
+     * @param {Record<string, any> | any[]} result
+     */
+    treatSecond(value, rest, result) {
+        const secondMatch = rest.match(/^\[(.*?)\]([\s\S]*)$/);
+        if (!secondMatch)
+            throw new Error(`Could not parse rest part: ${rest}`);
+        const key = secondMatch[1];
+        const newRest = secondMatch[2];
+        /** @type {Array<any> | Record<string, any>} */
+        let newResult;
+        if (rest == "[]") {
+            result.push(value);
+        }
+        else if (newRest == "") {
+            result[key] = value;
+        }
+        else {
+            if (typeof result == "object" && key in result) {
+                newResult = result[key];
+            }
+            else if (newRest == "[]") {
+                newResult = [];
+                result[key] = newResult;
+            }
+            else {
+                newResult = {};
+                result[key] = newResult;
+            }
+            this.treatSecond(value, newRest, newResult);
+        }
+    }
+}

package/dist/src/http-server/client/request-buffer/form-data-part.d.ts

@@ -0,0 +1,21 @@
+export default class FormDataPart {
+    /** @type {Record<string, import("./header.js").default>} */
+    headers: Record<string, import("./header.js").default>;
+    /** @type {number[]} */
+    body: number[];
+    /**
+     * @param {import("./header.js").default} header
+     */
+    addHeader(header: import("./header.js").default): void;
+    name: string;
+    contentLength: number;
+    finish(): void;
+    value: any;
+    getName(): string;
+    getValue(): any;
+    /**
+     * @param {string} text
+     */
+    removeFromBody(text: string): void;
+}
+//# sourceMappingURL=form-data-part.d.ts.map

package/dist/src/http-server/client/request-buffer/form-data-part.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"form-data-part.d.ts","sourceRoot":"","sources":["../../../../../src/http-server/client/request-buffer/form-data-part.js"],"names":[],"mappings":"AAEA;IACE,4DAA4D;IAC5D,SADW,MAAM,CAAC,MAAM,EAAE,OAAO,aAAa,EAAE,OAAO,CAAC,CAC5C;IAEZ,uBAAuB;IACvB,MADW,MAAM,EAAE,CACV;IAET;;OAEG;IACH,kBAFW,OAAO,aAAa,EAAE,OAAO,QAkBvC;IAPK,aAAoB;IAKtB,sBAA2C;IAI/C,eAEC;IADC,WAAuD;IAGzD,kBAIC;IAED,gBAIC;IAED;;OAEG;IACH,qBAFW,MAAM,QAIhB;CACF"}

package/dist/src/http-server/client/request-buffer/form-data-part.js

@@ -0,0 +1,45 @@
+// @ts-check
+export default class FormDataPart {
+    /** @type {Record<string, import("./header.js").default>} */
+    headers = {};
+    /** @type {number[]} */
+    body = [];
+    /**
+     * @param {import("./header.js").default} header
+     */
+    addHeader(header) {
+        const name = header.formattedName;
+        this.headers[name] = header;
+        if (name == "content-disposition") {
+            const match = header.value.match(/^form-data; name="(.+)"$/);
+            if (match) {
+                this.name = match[1];
+            }
+            else {
+                console.error(`Couldn't match name from content-disposition: ${header.value}`);
+            }
+        }
+        else if (name == "content-length") {
+            this.contentLength = parseInt(header.value);
+        }
+    }
+    finish() {
+        this.value = String.fromCharCode.apply(null, this.body);
+    }
+    getName() {
+        if (!this.name)
+            throw new Error("Name hasn't been set");
+        return this.name;
+    }
+    getValue() {
+        if (!this.value)
+            throw new Error("Value hasn't been set");
+        return this.value;
+    }
+    /**
+     * @param {string} text
+     */
+    removeFromBody(text) {
+        this.body = this.body.slice(0, this.body.length - text.length);
+    }
+}

package/dist/src/http-server/client/request-buffer/header.d.ts

@@ -0,0 +1,15 @@
+export default class Header {
+    /**
+     * @param {string} name
+     * @param {string} value
+     */
+    constructor(name: string, value: string);
+    formattedName: string;
+    name: string;
+    value: string;
+    getName(): string;
+    getFormattedName(): string;
+    getValue(): string;
+    toString(): string;
+}
+//# sourceMappingURL=header.d.ts.map

package/dist/src/http-server/client/request-buffer/header.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"header.d.ts","sourceRoot":"","sources":["../../../../../src/http-server/client/request-buffer/header.js"],"names":[],"mappings":"AAEA;IACE;;;OAGG;IACH,kBAHW,MAAM,SACN,MAAM,EAMhB;IAHC,sBAA8C;IAC9C,aAAgB;IAChB,cAAkB;IAGpB,kBAA8B;IAC9B,2BAAgD;IAChD,mBAAgC;IAChC,mBAA6D;CAC9D"}

package/dist/src/http-server/client/request-buffer/header.js

@@ -0,0 +1,16 @@
+// @ts-check
+export default class Header {
+    /**
+     * @param {string} name
+     * @param {string} value
+     */
+    constructor(name, value) {
+        this.formattedName = name.toLowerCase().trim();
+        this.name = name;
+        this.value = value;
+    }
+    getName() { return this.name; }
+    getFormattedName() { return this.formattedName; }
+    getValue() { return this.value; }
+    toString() { return `${this.getName()}: ${this.getValue()}`; }
+}

package/dist/src/http-server/client/request-buffer/index.d.ts

@@ -0,0 +1,95 @@
+export default class RequestBuffer {
+    /**
+     * @param {object} args
+     * @param {import("../../../configuration.js").default} args.configuration
+     */
+    constructor({ configuration }: {
+        configuration: import("../../../configuration.js").default;
+    });
+    bodyLength: number;
+    /** @type {number[]} */
+    data: number[];
+    events: EventEmitter<[never]>;
+    /** @type {Record<string, Header>} */
+    headersByName: Record<string, Header>;
+    multiPartyFormData: boolean;
+    params: {};
+    readingBody: boolean;
+    state: string;
+    configuration: import("../../../configuration.js").default;
+    logger: Logger;
+    destroy(): void;
+    /**
+     * @param {Buffer} data
+     * @returns {void}
+     */
+    feed(data: Buffer): void;
+    /**
+     * @param {string} name
+     * @returns {Header}
+     */
+    getHeader(name: string): Header;
+    /**
+     * @returns {Record<string, string>}
+     */
+    getHeadersHash(): Record<string, string>;
+    /**
+     * @returns {void}
+     */
+    formDataPartDone(): void;
+    formDataPart: FormDataPart;
+    isMultiPartyFormData(): boolean;
+    /**
+     * @returns {void}
+     */
+    newFormDataPart(): void;
+    /**
+     * @param {string} line
+     * @returns {void}
+     */
+    parse(line: string): void;
+    /**
+     * @param {string} line
+     * @returns {Header | undefined}
+     */
+    readHeaderFromLine(line: string): Header | undefined;
+    /**
+     * @param {Header} header
+     */
+    addHeader(header: Header): void;
+    contentLength: number;
+    /**
+     * @param {string} line
+     * @returns {void}
+     */
+    parseHeader(line: string): void;
+    boundary: string;
+    boundaryLine: string;
+    boundaryLineNext: string;
+    boundaryLineEnd: string;
+    /** @type {number[]} */
+    postBodyChars: number[];
+    /**
+     * @param {string} line
+     * @returns {void}
+     */
+    parseStatusLine(line: string): void;
+    httpMethod: string;
+    httpVersion: string;
+    path: string;
+    postRequestDone(): void;
+    postBody: any;
+    /**
+     * @param {string} newState
+     * @returns {void}
+     */
+    setState(newState: string): void;
+    completeRequest: () => void;
+    parseApplicationJsonParams(): void;
+    parseQueryStringPostParams(): void;
+}
+import { EventEmitter } from "events";
+import Header from "./header.js";
+import { Logger } from "../../../logger.js";
+import FormDataPart from "./form-data-part.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/http-server/client/request-buffer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/http-server/client/request-buffer/index.js"],"names":[],"mappings":"AAUA;IAiBE;;;OAGG;IACH,+BAFG;QAA0D,aAAa,EAA/D,OAAO,2BAA2B,EAAE,OAAO;KACrD,EAIA;IAvBD,mBAAc;IAEd,uBAAuB;IACvB,MADW,MAAM,EAAE,CACV;IAET,8BAA2B;IAE3B,qCAAqC;IACrC,eADW,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CACf;IAElB,4BAA0B;IAE1B,WAAW;IACX,qBAAmB;IACnB,cAAgB;IAOd,2DAAkC;IAClC,eAA8C;IAGhD,gBAEC;IAED;;;OAGG;IACH,WAHW,MAAM,GACJ,IAAI,CAsEhB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;OAEG;IACH,kBAFa,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAalC;IAED;;OAEG;IACH,oBAFa,IAAI,CAWhB;IAJC,2BAA6B;IAM/B,gCAEC;IAED;;OAEG;IACH,mBAFa,IAAI,CAKhB;IAED;;;OAGG;IACH,YAHW,MAAM,GACJ,IAAI,CA6BhB;IAED;;;OAGG;IACH,yBAHW,MAAM,GACJ,MAAM,GAAG,SAAS,CAU9B;IAED;;OAEG;IACH,kBAFW,MAAM,QAQhB;IADwC,sBAAgD;IAGzF;;;OAGG;IACH,kBAHW,MAAM,GACJ,IAAI,CA4ChB;IAzBO,iBAAwB;IACxB,qBAA4C;IAC5C,yBAAoD;IACpD,wBAAiD;IAS/C,uBAAuB;IACvB,eADW,MAAM,EAAE,CACI;IAcjC;;;OAGG;IACH,sBAHW,MAAM,GACJ,IAAI,CAchB;IALC,mBAA0B;IAC1B,oBAA2B;IAC3B,aAAoB;IAKtB,wBASC;IAPG,cAAmE;IASvE;;;OAGG;IACH,mBAHW,MAAM,GACJ,IAAI,CAKhB;IAED,4BAYC;IAED,mCAMC;IAED,mCASC;CACF;6BAtV0B,QAAQ;mBAEhB,aAAa;uBAEX,oBAAoB;yBAHhB,qBAAqB"}

package/dist/src/http-server/client/request-buffer/index.js

@@ -0,0 +1,305 @@
+// @ts-check
+import { EventEmitter } from "events";
+import FormDataPart from "./form-data-part.js";
+import Header from "./header.js";
+import { incorporate } from "incorporator";
+import { Logger } from "../../../logger.js";
+import ParamsToObject from "../params-to-object.js";
+import querystring from "querystring";
+export default class RequestBuffer {
+    bodyLength = 0;
+    /** @type {number[]} */
+    data = [];
+    events = new EventEmitter();
+    /** @type {Record<string, Header>} */
+    headersByName = {};
+    multiPartyFormData = false;
+    params = {};
+    readingBody = false;
+    state = "status";
+    /**
+     * @param {object} args
+     * @param {import("../../../configuration.js").default} args.configuration
+     */
+    constructor({ configuration }) {
+        this.configuration = configuration;
+        this.logger = new Logger(this, { debug: false });
+    }
+    destroy() {
+        // Do nothing for now...
+    }
+    /**
+     * @param {Buffer} data
+     * @returns {void}
+     */
+    feed(data) {
+        for (const char of data) {
+            if (this.readingBody)
+                this.bodyLength += 1;
+            switch (this.state) {
+                case "status":
+                case "headers":
+                case "multi-part-form-data":
+                case "multi-part-form-data-header":
+                    this.data.push(char);
+                    if (char == 10) {
+                        const line = String.fromCharCode.apply(null, this.data);
+                        this.data = [];
+                        this.parse(line);
+                    }
+                    break;
+                case "multi-part-form-data-body":
+                    if (!this.formDataPart)
+                        throw new Error("FormData part not initialized");
+                    if (!this.boundaryLineEnd)
+                        throw new Error("Boundary line end not initialized");
+                    if (!this.boundaryLineNext)
+                        throw new Error("Boundary line next not initialized");
+                    const body = this.formDataPart.body; // eslint-disable-line no-case-declarations
+                    body.push(char);
+                    const possibleBoundaryEndPosition = body.length - this.boundaryLineEnd.length; // eslint-disable-line no-case-declarations
+                    const possibleBoundaryEndChars = body.slice(possibleBoundaryEndPosition, body.length); // eslint-disable-line no-case-declarations
+                    const possibleBoundaryEnd = String.fromCharCode.apply(null, possibleBoundaryEndChars); // eslint-disable-line no-case-declarations
+                    const possibleBoundaryNextPosition = body.length - this.boundaryLineNext.length; // eslint-disable-line no-case-declarations
+                    const possibleBoundaryNextChars = body.slice(possibleBoundaryNextPosition, body.length); // eslint-disable-line no-case-declarations
+                    const possibleBoundaryNext = String.fromCharCode.apply(null, possibleBoundaryNextChars); // eslint-disable-line no-case-declarations
+                    if (possibleBoundaryEnd == this.boundaryLineEnd) {
+                        this.formDataPart.removeFromBody(possibleBoundaryEnd);
+                        this.formDataPartDone();
+                        this.completeRequest();
+                    }
+                    else if (possibleBoundaryNext == this.boundaryLineNext) {
+                        this.formDataPart.removeFromBody(possibleBoundaryNext);
+                        this.formDataPartDone();
+                        this.newFormDataPart();
+                    }
+                    else if (this.contentLength && this.bodyLength >= this.contentLength) {
+                        this.formDataPartDone();
+                        this.completeRequest();
+                    }
+                    else if (this.formDataPart.contentLength && this.bodyLength >= this.formDataPart.contentLength) {
+                        this.formDataPartDone();
+                        throw new Error("stub");
+                    }
+                    break;
+                case "post-body":
+                    if (!this.postBodyChars)
+                        throw new Error("postBodyChars not initialized");
+                    this.postBodyChars[this.bodyLength - 1] = char;
+                    if (this.contentLength && this.bodyLength >= this.contentLength) {
+                        this.postRequestDone();
+                    }
+                    break;
+                default:
+                    console.error(`Unknown state for request buffer: ${this.state}`);
+            }
+        }
+    }
+    /**
+     * @param {string} name
+     * @returns {Header}
+     */
+    getHeader(name) {
+        const result = this.headersByName[name.toLowerCase().trim()];
+        this.logger.debug(() => [`getHeader ${name}`, { result: result?.toString() }]);
+        return result;
+    }
+    /**
+     * @returns {Record<string, string>}
+     */
+    getHeadersHash() {
+        /** @type {Record<string, string>} */
+        const result = {};
+        for (const headerFormattedName in this.headersByName) {
+            const header = this.headersByName[headerFormattedName];
+            result[header.getName()] = header.getValue();
+        }
+        return result;
+    }
+    /**
+     * @returns {void}
+     */
+    formDataPartDone() {
+        const formDataPart = this.formDataPart;
+        if (!formDataPart)
+            throw new Error("formDataPart wasnt set");
+        this.formDataPart = undefined;
+        formDataPart.finish();
+        this.events.emit("form-data-part", formDataPart);
+    }
+    isMultiPartyFormData() {
+        return this.multiPartyFormData;
+    }
+    /**
+     * @returns {void}
+     */
+    newFormDataPart() {
+        this.formDataPart = new FormDataPart();
+        this.setState("multi-part-form-data-header");
+    }
+    /**
+     * @param {string} line
+     * @returns {void}
+     */
+    parse(line) {
+        if (this.state == "status") {
+            this.parseStatusLine(line);
+        }
+        else if (this.state == "headers") {
+            this.parseHeader(line);
+        }
+        else if (this.state == "multi-part-form-data") {
+            if (line == this.boundaryLine) {
+                this.newFormDataPart();
+            }
+            else if (line == "\r\n") {
+                this.setState("done");
+            }
+            else {
+                throw new Error(`Expected boundary line but didn't get it: ${line}`);
+            }
+        }
+        else if (this.state == "multi-part-form-data-header") {
+            const header = this.readHeaderFromLine(line);
+            if (header) {
+                if (!this.formDataPart)
+                    throw new Error("formDataPart not set");
+                this.formDataPart.addHeader(header);
+                //this.state == "multi-part-form-data"
+            }
+            else if (line == "\r\n") {
+                this.setState("multi-part-form-data-body");
+            }
+        }
+        else {
+            throw new Error(`Unknown state parsing line: ${this.state}`);
+        }
+    }
+    /**
+     * @param {string} line
+     * @returns {Header | undefined}
+     */
+    readHeaderFromLine(line) {
+        const match = line.match(/^(.+): (.+)\r\n/);
+        if (match) {
+            const header = new Header(match[1], match[2]);
+            return header;
+        }
+    }
+    /**
+     * @param {Header} header
+     */
+    addHeader(header) {
+        const formattedName = header.getFormattedName();
+        this.headersByName[formattedName] = header;
+        if (formattedName == "content-length")
+            this.contentLength = parseInt(header.getValue());
+    }
+    /**
+     * @param {string} line
+     * @returns {void}
+     */
+    parseHeader(line) {
+        const header = this.readHeaderFromLine(line);
+        if (header) {
+            this.logger.debug(() => [`Parsed header: ${header.toString()}`]);
+            this.addHeader(header);
+            this.events.emit("header", header);
+        }
+        else if (line == "\r\n") {
+            if (this.httpMethod?.toUpperCase() == "GET" || this.httpMethod?.toUpperCase() == "OPTIONS") {
+                this.completeRequest();
+            }
+            else if (this.httpMethod?.toUpperCase() == "POST") {
+                this.readingBody = true;
+                this.bodyLength = 0;
+                const match = this.getHeader("content-type")?.value?.match(/^multipart\/form-data;\s*boundary=(.+)$/i);
+                if (match) {
+                    this.boundary = match[1];
+                    this.boundaryLine = `--${this.boundary}\r\n`;
+                    this.boundaryLineNext = `\r\n--${this.boundary}\r\n`;
+                    this.boundaryLineEnd = `\r\n--${this.boundary}--`;
+                    this.multiPartyFormData = true;
+                    this.setState("multi-part-form-data");
+                }
+                else {
+                    if (this.contentLength === 0) {
+                        this.completeRequest();
+                    }
+                    else if (!this.contentLength) {
+                        throw new Error("Content length hasn't been set");
+                    }
+                    else {
+                        /** @type {number[]} */
+                        this.postBodyChars = [];
+                        // this.postBodyBuffer = new ArrayBuffer(this.contentLength)
+                        // this.postBodyChars = new Uint8Array(this.postBodyBuffer)
+                        this.setState("post-body");
+                    }
+                }
+            }
+            else {
+                throw new Error(`Unknown HTTP method: ${this.httpMethod}`);
+            }
+        }
+    }
+    /**
+     * @param {string} line
+     * @returns {void}
+     */
+    parseStatusLine(line) {
+        const match = line.match(/^(GET|OPTIONS|POST) (.+?) HTTP\/(.+)\r\n/);
+        if (!match) {
+            throw new Error(`Couldn't match status line from: ${line}`);
+        }
+        this.httpMethod = match[1];
+        this.httpVersion = match[3];
+        this.path = match[2];
+        this.setState("headers");
+        this.logger.debug(() => ["Parsed status line", { httpMethod: this.httpMethod, httpVersion: this.httpVersion, path: this.path }]);
+    }
+    postRequestDone() {
+        if (this.postBodyChars) {
+            this.postBody = String.fromCharCode.apply(null, this.postBodyChars);
+        }
+        delete this.postBodyChars;
+        // delete this.postBodyBuffer
+        this.completeRequest();
+    }
+    /**
+     * @param {string} newState
+     * @returns {void}
+     */
+    setState(newState) {
+        this.logger.debug(() => [`Changing state from ${this.state} to ${newState}`]);
+        this.state = newState;
+    }
+    completeRequest = () => {
+        this.state = "status"; // Reset state to new request
+        if (this.getHeader("content-type")?.value?.startsWith("application/json")) {
+            this.parseApplicationJsonParams();
+        }
+        else if (this.multiPartyFormData) {
+            // Done after each new form data part
+        }
+        else {
+            this.parseQueryStringPostParams();
+        }
+        this.events.emit("completed");
+    };
+    parseApplicationJsonParams() {
+        if (this.postBody) {
+            const newParams = JSON.parse(this.postBody);
+            incorporate(this.params, newParams);
+        }
+    }
+    parseQueryStringPostParams() {
+        if (this.postBody) {
+            /** @type {Record<string, any>} */
+            const unparsedParams = querystring.parse(this.postBody);
+            const paramsToObject = new ParamsToObject(unparsedParams);
+            const newParams = paramsToObject.toObject();
+            incorporate(this.params, newParams);
+        }
+    }
+}

package/dist/src/http-server/client/request-parser.d.ts

@@ -0,0 +1,52 @@
+export default class VelociousHttpServerClientRequestParser {
+    /**
+     * @param {object} args
+     * @param {import("../../configuration.js").default} args.configuration
+     */
+    constructor({ configuration }: {
+        configuration: import("../../configuration.js").default;
+    });
+    configuration: import("../../configuration.js").default;
+    data: any[];
+    events: EventEmitter<[never]>;
+    params: {};
+    requestBuffer: RequestBuffer;
+    destroy(): void;
+    /**
+     * @param {import("./request-buffer/form-data-part.js").default} formDataPart
+     * @returns {void}
+     */
+    onFormDataPart: (formDataPart: import("./request-buffer/form-data-part.js").default) => void;
+    /**
+     * @param {Buffer} data
+     */
+    feed: (data: Buffer) => void;
+    /**
+     * @param {string} name
+     */
+    getHeader(name: string): string;
+    getHeaders(): Record<string, string>;
+    /**
+     * @returns {string}
+     */
+    getHttpMethod(): string;
+    /**
+     * @returns {string}
+     */
+    getHttpVersion(): string;
+    _getHostMatch(): {
+        protocol: string;
+        host: string;
+        port: string;
+    };
+    getHost(): string;
+    getPath(): any;
+    getPort(): number;
+    getProtocol(): string;
+    getRequestBuffer(): RequestBuffer;
+    requestDone: () => void;
+    state: string;
+}
+import { EventEmitter } from "events";
+import RequestBuffer from "./request-buffer/index.js";
+//# sourceMappingURL=request-parser.d.ts.map

package/dist/src/http-server/client/request-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-parser.d.ts","sourceRoot":"","sources":["../../../../src/http-server/client/request-parser.js"],"names":[],"mappings":"AAQA;IACE;;;OAGG;IACH,+BAFG;QAAuD,aAAa,EAA5D,OAAO,wBAAwB,EAAE,OAAO;KAClD,EAaA;IATC,wDAAkC;IAClC,YAAc;IACd,8BAAgC;IAChC,WAAgB;IAEhB,6BAAuD;IAMzD,gBAKC;IAED;;;OAGG;IACH,iBAAkB,cAHP,OAAO,oCAAoC,EAAE,OAG1B,KAFjB,IAAI,CAYhB;IAED;;OAEG;IACH,OAAQ,MAFG,MAEC,UAAkC;IAE9C;;OAEG;IACH,gBAFW,MAAM,UAEmD;IACpE,qCAA2D;IAE3D;;OAEG;IACH,iBAFa,MAAM,CAEiD;IAEpE;;OAEG;IACH,kBAFa,MAAM,CAEmD;IAEtE;;;;MAcC;IAED,kBAIC;IAED,eAAwD;IAExD,kBAWC;IAED,sBAAuD;IACvD,kCAAgD;IAEhD,wBAKC;IAFC,cAAmB;CAGtB;6BAlH0B,QAAQ;0BAGT,2BAA2B"}