velocious 1.0.108 → 1.0.109

package/dist/src/http-client/index.d.ts

@@ -0,0 +1,57 @@
+export default class HttpClient {
+    /**
+     * @param {object} args
+     * @param {boolean} [args.debug]
+     * @param {Array<import("./header.js").default>} [args.headers]
+     * @param {string} [args.version]
+     */
+    constructor({ debug, headers, version }: {
+        debug?: boolean;
+        headers?: Array<import("./header.js").default>;
+        version?: string;
+    });
+    headers: import("./header.js").default[];
+    logger: Logger;
+    version: string;
+    connect(): Promise<any>;
+    connectionReject: (reason?: any) => void;
+    connection: net.Socket;
+    /**
+     * @param {string} path
+     * @param {object} [options]
+     * @param {Array<import("./header.js").default>} [options.headers]
+     * @returns {Promise<{request: import("./request.js").default, response: import("./response.js").default}>}
+     */
+    get(path: string, { headers }?: {
+        headers?: Array<import("./header.js").default>;
+    }): Promise<{
+        request: import("./request.js").default;
+        response: import("./response.js").default;
+    }>;
+    currentRequestResolve: (value: {
+        request: import("./request.js").default;
+        response: import("./response.js").default;
+    } | PromiseLike<{
+        request: import("./request.js").default;
+        response: import("./response.js").default;
+    }>) => void;
+    currentRequestReject: (reason?: any) => void;
+    currentResponse: Response;
+    currentRequest: Request;
+    /**
+     * @param {Buffer} data
+     */
+    onConnectionData: (data: Buffer) => void;
+    onConnectionEnd: () => void;
+    /**
+     * @param {Error} error
+     */
+    onConnectionError: (error: Error) => void;
+    isConnected(): boolean;
+    onResponseComplete: () => void;
+}
+import { Logger } from "../logger.js";
+import net from "net";
+import Response from "./response.js";
+import Request from "./request.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/http-client/index.js"],"names":[],"mappings":"AAOA;IACE;;;;;OAKG;IACH,yCAJG;QAAuB,KAAK,GAApB,OAAO;QACqC,OAAO,GAAnD,KAAK,CAAC,OAAO,aAAa,EAAE,OAAO,CAAC;QACtB,OAAO,GAArB,MAAM;KAAgB,EAMhC;IAHC,yCAA4B;IAC5B,eAAuC;IACvC,gBAAsB;IAGxB,wBAYC;IAVG,yCAA8B;IAC9B,uBAGE;IAQN;;;;;OAKG;IACH,UALW,MAAM,gBAEd;QAAuD,OAAO,GAAtD,KAAK,CAAC,OAAO,aAAa,EAAE,OAAO,CAAC;KAC5C,GAAU,OAAO,CAAC;QAAC,OAAO,EAAE,OAAO,cAAc,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,OAAO,eAAe,EAAE,OAAO,CAAA;KAAC,CAAC,CA+CzG;IAzCG;iBAN2B,OAAO,cAAc,EAAE,OAAO;kBAAY,OAAO,eAAe,EAAE,OAAO;;iBAAzE,OAAO,cAAc,EAAE,OAAO;kBAAY,OAAO,eAAe,EAAE,OAAO;gBAMhE;IACpC,6CAAkC;IAqBlC,0BAAyF;IAEzF,wBAA6F;IAmBjG;;OAEG;IACH,mBAAoB,MAFT,MAEa,UAIvB;IAED,4BAEC;IAED;;OAEG;IACH,oBAAqB,OAFV,KAEe,UAMzB;IAED,uBAMC;IAED,+BAcC;CACF;uBAjIoB,cAAc;gBAHnB,KAAK;qBAEA,eAAe;oBADhB,cAAc"}

package/dist/src/http-client/index.js

@@ -0,0 +1,118 @@
+// @ts-check
+import net from "net";
+import Request from "./request.js";
+import Response from "./response.js";
+import { Logger } from "../logger.js";
+export default class HttpClient {
+    /**
+     * @param {object} args
+     * @param {boolean} [args.debug]
+     * @param {Array<import("./header.js").default>} [args.headers]
+     * @param {string} [args.version]
+     */
+    constructor({ debug = false, headers, version = "1.1" }) {
+        this.headers = headers || [];
+        this.logger = new Logger(this, { debug });
+        this.version = version;
+    }
+    connect() {
+        return new Promise((resolve, reject) => {
+            this.connectionReject = reject;
+            this.connection = net.createConnection(3006, "127.0.0.1", () => {
+                this.connectionReject = null;
+                resolve(null);
+            });
+            this.connection.on("data", this.onConnectionData);
+            this.connection.on("end", this.onConnectionEnd);
+            this.connection.on("error", this.onConnectionError);
+        });
+    }
+    /**
+     * @param {string} path
+     * @param {object} [options]
+     * @param {Array<import("./header.js").default>} [options.headers]
+     * @returns {Promise<{request: import("./request.js").default, response: import("./response.js").default}>}
+     */
+    get(path, { headers } = {}) {
+        if (!this.connection)
+            throw new Error("Not connected yet");
+        return new Promise((resolve, reject) => {
+            this.currentRequestResolve = resolve;
+            this.currentRequestReject = reject;
+            const newHeaders = [];
+            if (headers) {
+                for (const header of headers) {
+                    newHeaders.push(header);
+                }
+            }
+            for (const header of this.headers) {
+                const existingNewHeader = newHeaders.find((newHeader) => {
+                    return newHeader.getName().toLowerCase().trim() === header.getName().toLowerCase().trim();
+                });
+                if (!existingNewHeader) {
+                    this.logger.debug(() => [`Pushing header from connection: ${header.toString()}`]);
+                    newHeaders.push(header);
+                }
+            }
+            this.currentResponse = new Response({ method: "GET", onComplete: this.onResponseComplete });
+            this.currentRequest = new Request({ headers: newHeaders, method: "GET", path, version: "1.0" });
+            this.currentRequest.stream((chunk) => {
+                this.logger.debug(() => [`Writing: ${chunk}`]);
+                if (!this.connection) {
+                    throw new Error("No connection to write to");
+                }
+                this.connection.write(chunk, "utf8", (error) => {
+                    if (error) {
+                        if (!this.currentRequestReject)
+                            throw new Error("No current request reject function");
+                        this.currentRequestReject(error);
+                    }
+                });
+            });
+        });
+    }
+    /**
+     * @param {Buffer} data
+     */
+    onConnectionData = (data) => {
+        if (!this.currentResponse)
+            throw new Error("No current response to feed data to");
+        this.currentResponse.feed(data);
+    };
+    onConnectionEnd = () => {
+        this.connection = null;
+    };
+    /**
+     * @param {Error} error
+     */
+    onConnectionError = (error) => {
+        if (this.connectionReject) {
+            this.connectionReject(error);
+        }
+        else {
+            this.logger.error("HttpClient onConnectionError", error);
+        }
+    };
+    isConnected() {
+        if (this.connection) {
+            return true;
+        }
+        return false;
+    }
+    onResponseComplete = () => {
+        if (!this.currentRequestResolve)
+            throw new Error("No current request resolve function");
+        if (!this.currentRequest)
+            throw new Error("No current request");
+        if (!this.currentResponse)
+            throw new Error("No current response");
+        this.currentRequestResolve({
+            request: this.currentRequest,
+            response: this.currentResponse
+        });
+        this.currentRequestResolve = null;
+        this.currentRequestReject = null;
+        this.currentRequest = null;
+        this.currentResponse = null;
+    };
+}

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

@@ -0,0 +1,39 @@
+export default class Request {
+    /**
+     * @param {object} args
+     * @param {string} [args.body]
+     * @param {string} args.method
+     * @param {Header[]} args.headers
+     * @param {string} args.path
+     * @param {string} args.version
+     */
+    constructor({ body, method, headers, path, version }: {
+        body?: string;
+        method: string;
+        headers: Header[];
+        path: string;
+        version: string;
+    });
+    body: string;
+    headers: Header[];
+    method: string;
+    path: string;
+    version: string;
+    asString(): string;
+    /**
+     * @param {string} name
+     */
+    getHeader(name: string): Header;
+    /**
+     * @param {string} name
+     * @param {string | number} value
+     */
+    addHeader(name: string, value: string | number): void;
+    prepare(): void;
+    /**
+     * @param {function(string) : void} callback
+     */
+    stream(callback: (arg0: string) => void): void;
+}
+import Header from "./header.js";
+//# sourceMappingURL=request.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"request.d.ts","sourceRoot":"","sources":["../../../src/http-client/request.js"],"names":[],"mappings":"AAIA;IACE;;;;;;;OAOG;IACH,sDANG;QAAsB,IAAI,GAAlB,MAAM;QACO,MAAM,EAAnB,MAAM;QACS,OAAO,EAAtB,MAAM,EAAE;QACK,IAAI,EAAjB,MAAM;QACO,OAAO,EAApB,MAAM;KAChB,EAOA;IALC,aAAgB;IAChB,kBAAsB;IACtB,eAAoB;IACpB,aAAgB;IAChB,gBAAsB;IAGxB,mBAQC;IAED;;OAEG;IACH,gBAFW,MAAM,UAchB;IAED;;;OAGG;IACH,gBAHW,MAAM,SACN,MAAM,GAAG,MAAM,QAIzB;IAED,gBAIC;IAED;;OAEG;IACH,iBAFW,CAAS,IAAM,EAAN,MAAM,KAAI,IAAI,QAkBjC;CACF;mBAhFkB,aAAa"}

package/dist/src/http-client/request.js

@@ -0,0 +1,66 @@
+// @ts-check
+import Header from "./header.js";
+export default class Request {
+    /**
+     * @param {object} args
+     * @param {string} [args.body]
+     * @param {string} args.method
+     * @param {Header[]} args.headers
+     * @param {string} args.path
+     * @param {string} args.version
+     */
+    constructor({ body, method = "GET", headers = [], path, version = "1.1" }) {
+        this.body = body;
+        this.headers = headers;
+        this.method = method;
+        this.path = path;
+        this.version = version;
+    }
+    asString() {
+        let requestString = "";
+        this.stream((chunk) => {
+            requestString += chunk;
+        });
+        return requestString;
+    }
+    /**
+     * @param {string} name
+     */
+    getHeader(name) {
+        const compareName = name.toLowerCase().trim();
+        for (const header of this.headers) {
+            const headerCompareName = header.getName().toLowerCase().trim();
+            if (compareName == headerCompareName) {
+                return header;
+            }
+        }
+        throw new Error(`Header ${name} not found`);
+    }
+    /**
+     * @param {string} name
+     * @param {string | number} value
+     */
+    addHeader(name, value) {
+        this.headers.push(new Header(name, value));
+    }
+    prepare() {
+        if (this.body) {
+            this.addHeader("Content-Length", Buffer.from(this.body).byteLength);
+        }
+    }
+    /**
+     * @param {function(string) : void} callback
+     */
+    stream(callback) {
+        this.prepare();
+        const requestString = `${this.method} ${this.path} HTTP/${this.version}\r\n`;
+        callback(requestString);
+        for (const header of this.headers) {
+            callback(`${header.toString()}\r\n`);
+        }
+        callback(`\r\n`);
+        if (this.body) {
+            callback(this.body);
+        }
+    }
+}

package/dist/src/http-client/response.d.ts

@@ -0,0 +1,31 @@
+export default class Response {
+    /**
+     * @param {object} args
+     * @param {string} args.method
+     * @param {function() : void} args.onComplete
+     */
+    constructor({ method, onComplete }: {
+        method: string;
+        onComplete: () => void;
+    });
+    /** @type {Header[]} */
+    headers: Header[];
+    method: string;
+    onComplete: () => void;
+    state: string;
+    /** @type {Buffer} */
+    response: Buffer;
+    /** @param {Buffer} data */
+    feed(data: Buffer): void;
+    /**
+     * @param {string} name
+     * @returns {Header}
+     */
+    getHeader(name: string): Header;
+    json(): any;
+    tryToParse(): void;
+    statusLine: string;
+    completeResponse(): void;
+}
+import Header from "./header.js";
+//# sourceMappingURL=response.d.ts.map

package/dist/src/http-client/response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../../src/http-client/response.js"],"names":[],"mappings":"AAIA;IACE;;;;OAIG;IACH,oCAHG;QAAqB,MAAM,EAAnB,MAAM;QACkB,UAAU,EAAlC,MAAa,IAAI;KAC3B,EAaA;IATC,uBAAuB;IACvB,SADW,MAAM,EAAE,CACF;IAEjB,eAAyC;IACzC,kBATsB,IAAI,CASE;IAC5B,cAA0B;IAE1B,qBAAqB;IACrB,UADW,MAAM,CACc;IAGjC,2BAA2B;IAC3B,WADY,MAAM,QAIjB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,MAAM,CAclB;IAED,YAaC;IAED,mBAkEC;IAzBS,mBAAsB;IA2BhC,yBAGC;CACF;mBArIkB,aAAa"}

package/dist/src/http-client/response.js

@@ -0,0 +1,119 @@
+// @ts-check
+import Header from "./header.js";
+export default class Response {
+    /**
+     * @param {object} args
+     * @param {string} args.method
+     * @param {function() : void} args.onComplete
+     */
+    constructor({ method = "GET", onComplete }) {
+        if (!method)
+            throw new Error(`Invalid method given: ${method}`);
+        /** @type {Header[]} */
+        this.headers = [];
+        this.method = method.toUpperCase().trim();
+        this.onComplete = onComplete;
+        this.state = "status-line";
+        /** @type {Buffer} */
+        this.response = Buffer.alloc(0);
+    }
+    /** @param {Buffer} data */
+    feed(data) {
+        this.response = Buffer.concat([this.response, data]);
+        this.tryToParse();
+    }
+    /**
+     * @param {string} name
+     * @returns {Header}
+     */
+    getHeader(name) {
+        const compareName = name.toLowerCase().trim();
+        for (const header of this.headers) {
+            const headerCompareName = header.getName().toLowerCase().trim();
+            if (compareName == headerCompareName) {
+                return header;
+            }
+        }
+        throw new Error(`Header ${name} not found`);
+    }
+    json() {
+        const contentTypeHeader = this.getHeader("Content-Type")?.getValue();
+        if (typeof contentTypeHeader != "string")
+            throw new Error(`Content-Type wasn't a string: ${contentTypeHeader}`);
+        if (!contentTypeHeader.toLowerCase().trim().startsWith("application/json")) {
+            throw new Error(`Content-Type is not JSON: ${contentTypeHeader}`);
+        }
+        const body = this.response.toString();
+        const json = JSON.parse(body);
+        return json;
+    }
+    tryToParse() {
+        while (true) {
+            if (this.state == "body") {
+                const contentLengthValue = this.getHeader("Content-Length")?.getValue();
+                if (contentLengthValue === undefined) {
+                    throw new Error("No content length given");
+                }
+                let contentLengthNumber;
+                if (typeof contentLengthValue == "number") {
+                    contentLengthNumber = contentLengthValue;
+                }
+                else if (contentLengthValue == "string") {
+                    contentLengthNumber = parseInt(contentLengthValue);
+                }
+                else {
+                    throw new Error(`Content-Length is not a number: ${contentLengthValue}`);
+                }
+                if (this.response.byteLength >= contentLengthNumber) {
+                    this.completeResponse();
+                    break;
+                }
+            }
+            else {
+                const response = this.response.toString();
+                let lineEndIndex = response.indexOf("\r\n");
+                let lineEndLength = 2;
+                if (lineEndIndex === -1) {
+                    lineEndIndex = response.indexOf("\n");
+                    lineEndLength = 1;
+                }
+                if (lineEndIndex === -1) {
+                    break; // We need to get fed more to continue reading
+                }
+                else {
+                    const line = response.substring(0, lineEndIndex);
+                    this.response = this.response.slice(lineEndIndex + lineEndLength);
+                    if (this.state == "status-line") {
+                        this.statusLine = line;
+                        this.state = "headers";
+                    }
+                    else if (this.state == "headers") {
+                        if (line == "") {
+                            if (this.method == "GET" || this.method == "HEAD") {
+                                this.completeResponse();
+                                break;
+                            }
+                            else if (this.method == "POST") {
+                                this.state = "body";
+                            }
+                        }
+                        else {
+                            const headerMatch = line.match(/^(.+?):\s*(.+)$/);
+                            if (!headerMatch)
+                                throw new Error(`Invalid header: ${line}`);
+                            const header = new Header(headerMatch[1], headerMatch[2]);
+                            this.headers.push(header);
+                        }
+                    }
+                    else {
+                        throw new Error(`Unexpected state: ${this.state}`);
+                    }
+                }
+            }
+        }
+    }
+    completeResponse() {
+        this.state = "done";
+        this.onComplete();
+    }
+}

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

@@ -0,0 +1,37 @@
+export default class VeoliciousHttpServerClient {
+    /**
+     * @param {object} args
+     * @param {number} args.clientCount
+     * @param {import("../../configuration.js").default} args.configuration
+     */
+    constructor({ clientCount, configuration }: {
+        clientCount: number;
+        configuration: import("../../configuration.js").default;
+    });
+    events: EventEmitter<[never]>;
+    state: string;
+    logger: Logger;
+    clientCount: number;
+    configuration: import("../../configuration.js").default;
+    /** @type {RequestRunner[]} */
+    requestRunners: RequestRunner[];
+    executeCurrentRequest: () => void;
+    /**
+     * @param {Buffer} data
+     * @returns {void}
+     */
+    onWrite(data: Buffer): void;
+    currentRequest: Request;
+    requestDone: () => void;
+    sendDoneRequests(): void;
+    /**
+     * @param {RequestRunner} requestRunner
+     * @returns {void}
+     */
+    sendResponse(requestRunner: RequestRunner): void;
+}
+import { EventEmitter } from "events";
+import { Logger } from "../../logger.js";
+import RequestRunner from "./request-runner.js";
+import Request from "./request.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/http-server/client/index.js"],"names":[],"mappings":"AAQA;IAIE;;;;OAIG;IACH,4CAHG;QAAqB,WAAW,EAAxB,MAAM;QACyC,aAAa,EAA5D,OAAO,wBAAwB,EAAE,OAAO;KAClD,EAUA;IAjBD,8BAA2B;IAC3B,cAAiB;IAUf,eAA8B;IAC9B,oBAA8B;IAC9B,wDAAkC;IAElC,8BAA8B;IAC9B,gBADW,aAAa,EAAE,CACF;IAG1B,kCAiBC;IAED;;;OAGG;IACH,cAHW,MAAM,GACJ,IAAI,CAehB;IAXG,wBAAoF;IAaxF,wBAEC;IAED,yBAqBC;IAED;;;OAGG;IACH,4BAHW,aAAa,GACX,IAAI,CAwChB;CACF;6BArI0B,QAAQ;uBACd,iBAAiB;0BAEZ,qBAAqB;oBAD3B,cAAc"}

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

@@ -0,0 +1,116 @@
+// @ts-check
+import { digg } from "diggerize";
+import { EventEmitter } from "events";
+import { Logger } from "../../logger.js";
+import Request from "./request.js";
+import RequestRunner from "./request-runner.js";
+export default class VeoliciousHttpServerClient {
+    events = new EventEmitter();
+    state = "initial";
+    /**
+     * @param {object} args
+     * @param {number} args.clientCount
+     * @param {import("../../configuration.js").default} args.configuration
+     */
+    constructor({ clientCount, configuration }) {
+        if (!configuration)
+            throw new Error("No configuration given");
+        this.logger = new Logger(this);
+        this.clientCount = clientCount;
+        this.configuration = configuration;
+        /** @type {RequestRunner[]} */
+        this.requestRunners = [];
+    }
+    executeCurrentRequest = () => {
+        this.logger.debug("executeCurrentRequest");
+        if (!this.currentRequest)
+            throw new Error("No current request");
+        // We are done parsing the given request and can theoretically start parsing a new one, before the current request is done - so reset the state.
+        this.state = "initial";
+        const requestRunner = new RequestRunner({
+            configuration: this.configuration,
+            request: this.currentRequest
+        });
+        this.requestRunners.push(requestRunner);
+        requestRunner.events.on("done", this.requestDone);
+        requestRunner.run();
+    };
+    /**
+     * @param {Buffer} data
+     * @returns {void}
+     */
+    onWrite(data) {
+        if (this.state == "initial") {
+            this.currentRequest = new Request({ client: this, configuration: this.configuration });
+            this.currentRequest.requestParser.events.on("done", this.executeCurrentRequest);
+            this.currentRequest.feed(data);
+            this.state = "requestStarted";
+        }
+        else if (this.state == "requestStarted") {
+            if (!this.currentRequest)
+                throw new Error("No current request");
+            this.currentRequest.feed(data);
+        }
+        else {
+            throw new Error(`Unknown state for client: ${this.state}`);
+        }
+    }
+    requestDone = () => {
+        this.sendDoneRequests();
+    };
+    sendDoneRequests() {
+        while (true) {
+            const requestRunner = this.requestRunners[0];
+            const request = requestRunner?.getRequest();
+            if (requestRunner?.getState() == "done") {
+                const httpVersion = request.httpVersion();
+                const connectionHeader = request.header("connection")?.toLowerCase()?.trim();
+                this.requestRunners.shift();
+                this.sendResponse(requestRunner);
+                this.logger.debug(() => ["sendDoneRequests", { clientCount: this.clientCount, connectionHeader, httpVersion }]);
+                if (httpVersion == "1.0" && connectionHeader != "keep-alive") {
+                    this.logger.debug(() => [`Closing the connection because ${httpVersion} and connection header ${connectionHeader}`, { clientCount: this.clientCount }]);
+                    this.events.emit("close");
+                }
+            }
+            else {
+                break;
+            }
+        }
+    }
+    /**
+     * @param {RequestRunner} requestRunner
+     * @returns {void}
+     */
+    sendResponse(requestRunner) {
+        if (!this.currentRequest)
+            throw new Error("No current request");
+        const response = digg(requestRunner, "response");
+        const request = requestRunner.getRequest();
+        const body = response.getBody();
+        const date = new Date();
+        const connectionHeader = request.header("connection")?.toLowerCase()?.trim();
+        const httpVersion = request.httpVersion();
+        this.logger.debug("sendResponse", { clientCount: this.clientCount, connectionHeader, httpVersion });
+        if (httpVersion == "1.0" && connectionHeader == "keep-alive") {
+            response.setHeader("Connection", "Keep-Alive");
+        }
+        else {
+            response.setHeader("Connection", "Close");
+        }
+        const contentLength = new TextEncoder().encode(body).length;
+        response.setHeader("Content-Length", contentLength);
+        response.setHeader("Date", date.toUTCString());
+        response.setHeader("Server", "Velocious");
+        let headers = "";
+        headers += `HTTP/${this.currentRequest.httpVersion()} ${response.getStatusCode()} ${response.getStatusMessage()}\r\n`;
+        for (const headerKey in response.headers) {
+            for (const headerValue of response.headers[headerKey]) {
+                headers += `${headerKey}: ${headerValue}\r\n`;
+            }
+        }
+        headers += "\r\n";
+        this.events.emit("output", headers);
+        this.events.emit("output", body);
+    }
+}

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

@@ -0,0 +1,21 @@
+export default class ParamsToObject {
+    /**
+     * @param {Record<string, string>} object
+     */
+    constructor(object: Record<string, string>);
+    object: Record<string, string>;
+    toObject(): {};
+    /**
+     * @param {string} key
+     * @param {string} value
+     * @param {Record<string, any> | any[]} result
+     */
+    treatInitial(key: string, value: string, result: Record<string, any> | any[]): void;
+    /**
+     * @param {string} value
+     * @param {string} rest
+     * @param {Record<string, any> | any[]} result
+     */
+    treatSecond(value: string, rest: string, result: Record<string, any> | any[]): void;
+}
+//# sourceMappingURL=params-to-object.d.ts.map

package/dist/src/http-server/client/params-to-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"params-to-object.d.ts","sourceRoot":"","sources":["../../../../src/http-server/client/params-to-object.js"],"names":[],"mappings":"AAEA;IACE;;OAEG;IACH,oBAFW,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAIhC;IADC,+BAAoB;IAGtB,eAUC;IAED;;;;OAIG;IACH,kBAJW,MAAM,SACN,MAAM,UACN,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,EAAE,QA0BrC;IAED;;;;OAIG;IACH,mBAJW,MAAM,QACN,MAAM,UACN,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,EAAE,QA8BrC;CACF"}