@tstdl/base 0.85.13 → 0.86.0-beta1

package/http/server/node/index.js

@@ -1,19 +1,2 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var node_exports = {};
-module.exports = __toCommonJS(node_exports);
-__reExport(node_exports, require("./module.js"), module.exports);
-__reExport(node_exports, require("./node-http-server.js"), module.exports);
+export * from './module.js';
+export * from './node-http-server.js';

package/http/server/node/module.js

@@ -1,29 +1,9 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var module_exports = {};
-__export(module_exports, {
-  configureNodeHttpServer: () => configureNodeHttpServer
-});
-module.exports = __toCommonJS(module_exports);
-var import_container = require("../../../container/index.js");
-var import_http_server = require("../http-server.js");
-var import_node_http_server = require("./node-http-server.js");
-function configureNodeHttpServer() {
-  import_container.container.registerSingleton(import_http_server.HttpServer, { useToken: import_node_http_server.NodeHttpServer });
+import { container } from '../../../container/index.js';
+import { HttpServer } from '../http-server.js';
+import { NodeHttpServer } from './node-http-server.js';
+/**
+ * registers {@link HttpServer} in global container
+ */
+export function configureNodeHttpServer() {
+    container.registerSingleton(HttpServer, { useToken: NodeHttpServer });
 }

package/http/server/node/node-http-server.js

@@ -1,262 +1,236 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var node_http_server_exports = {};
-__export(node_http_server_exports, {
-  NodeHttpServer: () => NodeHttpServer
-});
-module.exports = __toCommonJS(node_http_server_exports);
-var Http = __toESM(require("node:http"), 1);
-var import_container = require("../../../container/index.js");
-var import_core = require("../../../core.js");
-var import_disposable = require("../../../disposable/index.js");
-var import_http_headers = require("../../../http/http-headers.js");
-var import_http_query = require("../../../http/http-query.js");
-var import_logger = require("../../../logger/index.js");
-var import_cancellation_token = require("../../../utils/cancellation-token.js");
-var import_encoding = require("../../../utils/encoding.js");
-var import_feedable_async_iterable = require("../../../utils/feedable-async-iterable.js");
-var import_readable_stream_adapter = require("../../../utils/stream/readable-stream-adapter.js");
-var import_timer = require("../../../utils/timer.js");
-var import_timing = require("../../../utils/timing.js");
-var import_type_guards = require("../../../utils/type-guards.js");
-var import_rxjs = require("rxjs");
-var import_http_server_request = require("../http-server-request.js");
-var import_http_server = require("../http-server.js");
-var __decorate = function(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
-    r = Reflect.decorate(decorators, target, key, desc);
-  else
-    for (var i = decorators.length - 1; i >= 0; i--)
-      if (d = decorators[i])
-        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
 };
-var __metadata = function(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
-    return Reflect.metadata(k, v);
-};
-var __param = function(paramIndex, decorator) {
-  return function(target, key) {
-    decorator(target, key, paramIndex);
-  };
-};
-let NodeHttpServer = class NodeHttpServer2 extends import_http_server.HttpServer {
-  httpServer;
-  sockets;
-  requestIterable;
-  logger;
-  untrackConnectedSockets;
-  get connectedSocketsCount() {
-    return this.sockets.size;
-  }
-  constructor(logger) {
-    super();
-    this.logger = logger;
-    this.httpServer = new Http.Server();
-    this.sockets = /* @__PURE__ */ new Set();
-    this.requestIterable = new import_feedable_async_iterable.FeedableAsyncIterable();
-    this.httpServer.on("request", (request, response) => {
-      this.logger.verbose(`${request.method} from "${request.socket.remoteAddress}" to "${request.url}"`);
-      this.requestIterable.feed({ request, response });
-    });
-  }
-  [import_container.afterResolve]() {
-    import_core.disposer.add(() => this[import_disposable.disposeAsync]);
-  }
-  async [import_disposable.disposeAsync]() {
-    await this.close(3e3);
-    this.requestIterable.end();
-  }
-  async listen(port) {
-    if (this.httpServer.listening) {
-      throw new Error("http server is already listening");
+import * as Http from 'node:http';
+import { afterResolve, resolveArg, singleton } from '../../../container/index.js';
+import { disposer } from '../../../core.js';
+import { disposeAsync } from '../../../disposable/index.js';
+import { HttpHeaders } from '../../../http/http-headers.js';
+import { HttpQuery } from '../../../http/http-query.js';
+import { Logger } from '../../../logger/index.js';
+import { CancellationToken } from '../../../utils/cancellation-token.js';
+import { encodeUtf8 } from '../../../utils/encoding.js';
+import { FeedableAsyncIterable } from '../../../utils/feedable-async-iterable.js';
+import { getReadableStreamIterable } from '../../../utils/stream/readable-stream-adapter.js';
+import { Timer } from '../../../utils/timer.js';
+import { cancelableTimeout } from '../../../utils/timing.js';
+import { isDefined, isNullOrUndefined, isString } from '../../../utils/type-guards.js';
+import { bindNodeCallback, share } from 'rxjs';
+import { HttpServerRequest } from '../http-server-request.js';
+import { HttpServer } from '../http-server.js';
+export let NodeHttpServer = class NodeHttpServer extends HttpServer {
+    httpServer;
+    sockets;
+    requestIterable;
+    logger;
+    untrackConnectedSockets;
+    get connectedSocketsCount() {
+        return this.sockets.size;
     }
-    this.httpServer.listen(port);
-    return new Promise((resolve, reject) => {
-      let listeningListener;
-      let errorListener;
-      listeningListener = () => {
-        this.logger.info(`Listening on port ${port}`);
-        this.untrackConnectedSockets = trackConnectedSockets(this.httpServer, this.sockets);
-        this.httpServer.removeListener("error", errorListener);
-        resolve();
-      };
-      errorListener = (error) => {
-        this.httpServer.removeListener("listening", listeningListener);
-        reject(error);
-      };
-      this.httpServer.once("listening", listeningListener);
-      this.httpServer.once("error", errorListener);
-    });
-  }
-  async close(timeout) {
-    this.logger.info("Closing http server");
-    const timer = new import_timer.Timer(true);
-    const close$ = (0, import_rxjs.bindNodeCallback)(this.httpServer.close.bind(this.httpServer))().pipe((0, import_rxjs.share)());
-    close$.subscribe();
-    while (true) {
-      const connections = await getConnectionsCount(this.httpServer);
-      if (connections == 0) {
-        break;
-      }
-      if (timer.milliseconds >= timeout) {
-        this.logger.info(`Force closing of ${connections} remaining sockets after waiting for ${timeout} milliseconds`);
-        destroySockets(this.sockets);
-        break;
-      }
-      if (connections > 0) {
-        this.logger.info(`Waiting for ${connections} connections to end`);
-        await (0, import_timing.cancelableTimeout)(250, import_cancellation_token.CancellationToken.from(close$));
-      }
+    constructor(logger) {
+        super();
+        this.logger = logger;
+        this.httpServer = new Http.Server();
+        this.sockets = new Set();
+        this.requestIterable = new FeedableAsyncIterable();
+        this.httpServer.on('request', (request, response) => {
+            this.logger.verbose(`${request.method} from "${request.socket.remoteAddress}" to "${request.url}"`);
+            this.requestIterable.feed({ request, response });
+        });
     }
-    this.untrackConnectedSockets?.();
-    this.untrackConnectedSockets = void 0;
-  }
-  async *[Symbol.asyncIterator]() {
-    for await (const { request, response } of this.requestIterable) {
-      yield this.handleRequest(request, response);
+    [afterResolve]() {
+        disposer.add(() => this[disposeAsync]);
+    }
+    async [disposeAsync]() {
+        await this.close(3000);
+        this.requestIterable.end();
+    }
+    async listen(port) {
+        if (this.httpServer.listening) {
+            throw new Error('http server is already listening');
+        }
+        this.httpServer.listen(port);
+        return new Promise((resolve, reject) => {
+            let listeningListener;
+            let errorListener; // eslint-disable-line prefer-const
+            listeningListener = () => {
+                this.logger.info(`Listening on port ${port}`);
+                this.untrackConnectedSockets = trackConnectedSockets(this.httpServer, this.sockets);
+                this.httpServer.removeListener('error', errorListener);
+                resolve();
+            };
+            errorListener = (error) => {
+                this.httpServer.removeListener('listening', listeningListener);
+                reject(error);
+            };
+            this.httpServer.once('listening', listeningListener);
+            this.httpServer.once('error', errorListener);
+        });
+    }
+    async close(timeout) {
+        this.logger.info('Closing http server');
+        const timer = new Timer(true);
+        const close$ = bindNodeCallback(this.httpServer.close.bind(this.httpServer))().pipe(share());
+        close$.subscribe();
+        while (true) {
+            const connections = await getConnectionsCount(this.httpServer);
+            if (connections == 0) {
+                break;
+            }
+            if (timer.milliseconds >= timeout) {
+                this.logger.info(`Force closing of ${connections} remaining sockets after waiting for ${timeout} milliseconds`);
+                destroySockets(this.sockets);
+                break;
+            }
+            if (connections > 0) {
+                this.logger.info(`Waiting for ${connections} connections to end`);
+                await cancelableTimeout(250, CancellationToken.from(close$));
+            }
+        }
+        this.untrackConnectedSockets?.();
+        this.untrackConnectedSockets = undefined;
+    }
+    async *[Symbol.asyncIterator]() {
+        for await (const { request, response } of this.requestIterable) {
+            yield this.handleRequest(request, response);
+        }
+    }
+    handleRequest(request, response) {
+        const method = request.method;
+        const url = new URL(request.url, `http://${request.headers.host}`);
+        const headers = new HttpHeaders(request.headers);
+        const query = HttpQuery.fromURLSearchParams(url.searchParams);
+        const context = { nodeRequest: request, nodeResponse: response };
+        const httpRequest = new HttpServerRequest({
+            url,
+            method,
+            headers,
+            query,
+            ip: request.socket.remoteAddress,
+            body: request
+        });
+        const item = {
+            request: httpRequest,
+            respond: getResponder(response),
+            context,
+            async close() {
+                return new Promise((resolve) => response.end(resolve));
+            }
+        };
+        return item;
     }
-  }
-  handleRequest(request, response) {
-    const method = request.method;
-    const url = new URL(request.url, `http://${request.headers.host}`);
-    const headers = new import_http_headers.HttpHeaders(request.headers);
-    const query = import_http_query.HttpQuery.fromURLSearchParams(url.searchParams);
-    const context = { nodeRequest: request, nodeResponse: response };
-    const httpRequest = new import_http_server_request.HttpServerRequest({
-      url,
-      method,
-      headers,
-      query,
-      ip: request.socket.remoteAddress,
-      body: request
-    });
-    const item = {
-      request: httpRequest,
-      respond: getResponder(response),
-      context,
-      async close() {
-        return new Promise((resolve) => response.end(resolve));
-      }
-    };
-    return item;
-  }
 };
 NodeHttpServer = __decorate([
-  (0, import_container.singleton)(),
-  __param(0, (0, import_container.resolveArg)("NodeHttpServer")),
-  __metadata("design:paramtypes", [import_logger.Logger])
+    singleton(),
+    __param(0, resolveArg('NodeHttpServer')),
+    __metadata("design:paramtypes", [Logger])
 ], NodeHttpServer);
+// eslint-disable-next-line max-lines-per-function
 function getResponder(httpResponse) {
-  async function respond(response) {
-    writeHeaders(response, httpResponse);
-    return writeResponseBody(response, httpResponse);
-  }
-  return respond;
+    // eslint-disable-next-line max-statements
+    async function respond(response) {
+        writeHeaders(response, httpResponse);
+        return writeResponseBody(response, httpResponse);
+    }
+    return respond;
 }
 function writeHeaders(response, httpResponse) {
-  if ((0, import_type_guards.isDefined)(response.body?.json)) {
-    httpResponse.setHeader("Content-Type", "application/json; charset=utf-8");
-  } else if ((0, import_type_guards.isDefined)(response.body?.text)) {
-    httpResponse.setHeader("Content-Type", "text/plain; charset=utf-8");
-  } else if ((0, import_type_guards.isDefined)(response.body?.buffer)) {
-    httpResponse.setHeader("Content-Type", "application/octet-stream");
-  } else if ((0, import_type_guards.isDefined)(response.body?.stream)) {
-    httpResponse.setHeader("Content-Type", "application/octet-stream");
-  } else if ((0, import_type_guards.isDefined)(response.body?.events)) {
-    httpResponse.setHeader("Content-Type", "text/event-stream");
-  }
-  for (const [name, value] of response.headers.normalizedEntries()) {
-    httpResponse.setHeader(name, value);
-  }
-  if ((0, import_type_guards.isDefined)(response.statusCode)) {
-    httpResponse.statusCode = response.statusCode;
-  }
-  if ((0, import_type_guards.isDefined)(response.statusMessage)) {
-    httpResponse.statusMessage = response.statusMessage;
-  }
+    if (isDefined(response.body?.json)) {
+        httpResponse.setHeader('Content-Type', 'application/json; charset=utf-8');
+    }
+    else if (isDefined(response.body?.text)) {
+        httpResponse.setHeader('Content-Type', 'text/plain; charset=utf-8');
+    }
+    else if (isDefined(response.body?.buffer)) {
+        httpResponse.setHeader('Content-Type', 'application/octet-stream');
+    }
+    else if (isDefined(response.body?.stream)) {
+        httpResponse.setHeader('Content-Type', 'application/octet-stream');
+    }
+    else if (isDefined(response.body?.events)) {
+        httpResponse.setHeader('Content-Type', 'text/event-stream');
+    }
+    for (const [name, value] of response.headers.normalizedEntries()) {
+        httpResponse.setHeader(name, value);
+    }
+    if (isDefined(response.statusCode)) {
+        httpResponse.statusCode = response.statusCode;
+    }
+    if (isDefined(response.statusMessage)) {
+        httpResponse.statusMessage = response.statusMessage;
+    }
 }
 async function writeResponseBody(response, httpResponse) {
-  const simpleData = (0, import_type_guards.isDefined)(response.body?.json) ? JSON.stringify(response.body.json) : (0, import_type_guards.isDefined)(response.body?.text) ? response.body.text : (0, import_type_guards.isDefined)(response.body?.buffer) ? response.body.buffer : void 0;
-  const streamData = (0, import_type_guards.isDefined)(simpleData) ? void 0 : (0, import_type_guards.isDefined)(response.body?.stream) ? response.body.stream : (0, import_type_guards.isDefined)(response.body?.events) ? response.body.events.readable : void 0;
-  if ((0, import_type_guards.isDefined)(simpleData)) {
-    const bytes = (0, import_type_guards.isString)(simpleData) ? (0, import_encoding.encodeUtf8)(simpleData) : simpleData;
-    if (!httpResponse.hasHeader("Content-Length")) {
-      httpResponse.setHeader("Content-Length", bytes.byteLength);
+    const simpleData = isDefined(response.body?.json) ? JSON.stringify(response.body.json)
+        : isDefined(response.body?.text) ? response.body.text
+            : isDefined(response.body?.buffer) ? response.body.buffer
+                : undefined;
+    const streamData = isDefined(simpleData) ? undefined
+        : isDefined(response.body?.stream) ? response.body.stream
+            : isDefined(response.body?.events) ? response.body.events.readable
+                : undefined;
+    if (isDefined(simpleData)) {
+        const bytes = isString(simpleData) ? encodeUtf8(simpleData) : simpleData;
+        if (!httpResponse.hasHeader('Content-Length')) {
+            httpResponse.setHeader('Content-Length', bytes.byteLength);
+        }
+        await write(httpResponse, bytes);
     }
-    await write(httpResponse, bytes);
-  } else if ((0, import_type_guards.isDefined)(streamData)) {
-    for await (const chunk of (0, import_readable_stream_adapter.getReadableStreamIterable)(streamData)) {
-      await write(httpResponse, chunk);
+    else if (isDefined(streamData)) {
+        for await (const chunk of getReadableStreamIterable(streamData)) {
+            await write(httpResponse, chunk);
+        }
     }
-  }
-  return new Promise((resolve) => {
-    httpResponse.end(resolve);
-  });
+    return new Promise((resolve) => {
+        httpResponse.end(resolve);
+    });
 }
 async function write(httpResponse, bytes) {
-  return new Promise((resolve, reject) => {
-    httpResponse.write(bytes, (error) => {
-      if ((0, import_type_guards.isNullOrUndefined)(error)) {
-        resolve();
-      } else {
-        reject(error);
-      }
+    return new Promise((resolve, reject) => {
+        httpResponse.write(bytes, (error) => {
+            if (isNullOrUndefined(error)) {
+                resolve();
+            }
+            else {
+                reject(error);
+            }
+        });
     });
-  });
 }
 function trackConnectedSockets(server, sockets) {
-  const connectionListener = (socket) => {
-    sockets.add(socket);
-    const closeListener = () => {
-      sockets.delete(socket);
-      socket.removeListener("close", closeListener);
+    const connectionListener = (socket) => {
+        sockets.add(socket);
+        const closeListener = () => {
+            sockets.delete(socket);
+            socket.removeListener('close', closeListener);
+        };
+        socket.on('close', closeListener);
     };
-    socket.on("close", closeListener);
-  };
-  server.on("connection", connectionListener);
-  return () => server.removeListener("connection", connectionListener);
+    server.on('connection', connectionListener);
+    return () => server.removeListener('connection', connectionListener);
 }
 async function getConnectionsCount(server) {
-  return new Promise((resolve, reject) => {
-    server.getConnections((error, count) => {
-      if (error != void 0) {
-        reject(error);
-        return;
-      }
-      resolve(count);
+    return new Promise((resolve, reject) => {
+        server.getConnections((error, count) => {
+            if (error != undefined) {
+                reject(error);
+                return;
+            }
+            resolve(count);
+        });
     });
-  });
 }
 function destroySockets(sockets) {
-  for (const socket of sockets) {
-    socket.destroy();
-  }
+    for (const socket of sockets) {
+        socket.destroy();
+    }
 }

package/http/types.js

@@ -1,51 +1,25 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var types_exports = {};
-__export(types_exports, {
-  denormalizeHttpValue: () => denormalizeHttpValue,
-  denormlizeSingleHttpValue: () => denormlizeSingleHttpValue,
-  normalizeHttpValue: () => normalizeHttpValue,
-  normalizeSingleHttpValue: () => normalizeSingleHttpValue
-});
-module.exports = __toCommonJS(types_exports);
-var import_type_guards = require("../utils/type-guards.js");
-function normalizeHttpValue(value) {
-  if ((0, import_type_guards.isArray)(value)) {
-    return value.map(normalizeSingleHttpValue);
-  }
-  return normalizeSingleHttpValue(value);
+import { isArray, isNull } from '../utils/type-guards.js';
+export function normalizeHttpValue(value) {
+    if (isArray(value)) {
+        return value.map(normalizeSingleHttpValue);
+    }
+    return normalizeSingleHttpValue(value);
 }
-function normalizeSingleHttpValue(value) {
-  if ((0, import_type_guards.isNull)(value)) {
-    return "[[null]]";
-  }
-  return value.toString();
+export function normalizeSingleHttpValue(value) {
+    if (isNull(value)) {
+        return '[[null]]';
+    }
+    return value.toString();
 }
-function denormalizeHttpValue(value) {
-  if ((0, import_type_guards.isArray)(value)) {
-    return value.map(denormlizeSingleHttpValue);
-  }
-  return denormlizeSingleHttpValue(value);
+export function denormalizeHttpValue(value) {
+    if (isArray(value)) {
+        return value.map(denormlizeSingleHttpValue);
+    }
+    return denormlizeSingleHttpValue(value);
 }
-function denormlizeSingleHttpValue(value) {
-  if (value == "[[null]]") {
-    return null;
-  }
-  return value;
+export function denormlizeSingleHttpValue(value) {
+    if (value == '[[null]]') {
+        return null;
+    }
+    return value;
 }