@opra/common 0.10.2 → 0.12.0

package/esm/http/http-request.js

@@ -1,100 +1,85 @@
-import { HTTPParser } from 'http-parser-js';
-import { Readable } from 'stream';
-const crlfBuffer = Buffer.from('\r\n');
-const kHeaders = Symbol('kHeaders');
-const kHeadersCount = Symbol('kHeadersCount');
-const kTrailers = Symbol('kTrailers');
-const kTrailersCount = Symbol('kTrailersCount');
-export class HttpRequest extends Readable {
-    constructor() {
-        super(...arguments);
-        this.aborted = false;
+/// <reference lib="dom" />
+import { OpraURL } from '../url/index.js';
+import { HttpHeaders } from './http-headers.js';
+const directCopyProperties = ['cache', 'credentials', 'destination', 'headers', 'integrity',
+    'keepalive', 'mode', 'redirect', 'referrer', 'referrerPolicy'];
+export class HttpRequest {
+    constructor(init) {
+        this.cache = init?.cache || 'default';
+        this.credentials = init?.credentials || 'same-origin';
+        this.destination = init?.destination || '';
+        this.headers = new HttpHeaders(init?.headers);
+        this.integrity = init?.integrity || '';
+        this.keepalive = init?.keepalive ?? false;
+        this.method = (init?.method || 'GET').toUpperCase();
+        this.mode = init?.mode || 'cors';
+        this.redirect = init?.redirect || 'follow';
+        this.mode = init?.mode || 'cors';
+        this.referrer = init?.referrer || '';
+        this.referrerPolicy = init?.referrerPolicy || '';
+        this.signal = init?.signal || new AbortController().signal;
+        this.body = init?.body;
+        this.urlInstance = new OpraURL(init?.url);
+        if (init?.params)
+            this.params.appendAll(init.params);
     }
-    get headers() {
-        if (!this[kHeaders])
-            this[kHeaders] = arrayToHeaders(this.rawHeaders);
-        return this[kHeaders];
+    /** Returns the URL of request as a string. */
+    get url() {
+        return this.urlInstance.href;
     }
-    get headersCount() {
-        return this[kHeadersCount];
+    set url(value) {
+        this.urlInstance.parse(value);
     }
-    get trailers() {
-        if (!this[kTrailers])
-            this[kTrailers] = arrayToHeaders(this.rawTrailers);
-        return this[kTrailers];
+    /** Returns the searchParams of the URL as OpraURLSearchParams */
+    get params() {
+        return this.urlInstance.searchParams;
     }
-    get trailersCount() {
-        return this[kTrailersCount];
+    /** Returns the path part of URL as OpraURLPath */
+    get path() {
+        return this.urlInstance.path;
     }
-    _read() {
-        if (this.data) {
-            this.push(this.data);
-        }
-        this.push(null);
-    }
-    static parse(input) {
-        const parser = new HTTPParser(HTTPParser.REQUEST);
+    clone(...update) {
         const out = new HttpRequest();
-        const bodyChunks = [];
-        parser[HTTPParser.kOnHeadersComplete] = function (req) {
-            out.shouldKeepAlive = req.shouldKeepAlive;
-            out.upgrade = req.upgrade;
-            out.method = HTTPParser.methods[req.method];
-            out.url = req.url;
-            out.originalUrl = req.url;
-            out.httpVersionMajor = req.versionMajor;
-            out.httpVersionMinor = req.versionMinor;
-            out.httpVersion = req.versionMajor + '.' + req.versionMinor;
-            out.rawHeaders = req.headers;
-            out[kHeadersCount] = Math.ceil(req.headers.length / 2);
-            out[kTrailersCount] = 0;
-        };
-        parser[HTTPParser.kOnBody] = function (chunk, offset, length) {
-            bodyChunks.push(chunk.subarray(offset, offset + length));
-        };
-        // This is actually the event for trailers, go figure.
-        parser[HTTPParser.kOnHeaders] = function (t) {
-            out.rawTrailers = t;
-            out[kTrailersCount] = Math.ceil(t.length / 2);
-        };
-        parser[HTTPParser.kOnMessageComplete] = function () {
-            out.complete = true;
-        };
-        // Since we are sending the entire Buffer at once here all callbacks above happen synchronously.
-        // The parser does not do _anything_ asynchronous.
-        // However, you can of course call execute() multiple times with multiple chunks, e.g. from a stream.
-        // But then you have to refactor the entire logic to be async (e.g. resolve a Promise in kOnMessageComplete and add timeout logic).
-        parser.execute(input);
-        if (!out.complete)
-            parser.execute(crlfBuffer);
-        parser.finish();
-        if (!out.complete) {
-            throw new Error('Could not parse request');
+        out.merge(this);
+        for (const upd of update) {
+            out.merge(upd);
         }
-        out.rawTrailers = out.rawTrailers || [];
-        if (bodyChunks.length)
-            out.data = Buffer.concat(bodyChunks);
-        out.resume();
         return out;
     }
-}
-function arrayToHeaders(arr) {
-    const headers = {};
-    for (let i = 0; i < arr.length; i++) {
-        const k = arr[i].toLowerCase();
-        const v = arr[++i];
-        const trgV = headers[k];
-        // Array header -- only Set-Cookie at the moment
-        if (trgV && k === 'set-cookie') {
-            const a = Array.isArray(trgV) ? trgV : [trgV];
-            a.push(v);
-            headers[k] = a;
+    merge(update) {
+        directCopyProperties.forEach(k => {
+            if (update[k] != null)
+                this[k] = update[k];
+        });
+        if (update.headers) {
+            const h = update.headers instanceof HttpHeaders
+                ? update.headers
+                : new HttpHeaders(update.headers);
+            h.forEach((v, k) => {
+                if (k.toLowerCase() === 'set-cookie') {
+                    this.headers.append(k, v);
+                }
+                else
+                    this.headers.set(k, v);
+            });
         }
-        else if (typeof trgV === 'string') {
-            headers[k] += (k === 'cookie' ? '; ' : ', ') + v;
+    }
+    inset(src) {
+        directCopyProperties.forEach(k => {
+            if (this[k] == null && src[k] != null)
+                this[k] = src[k];
+        });
+        if (src.headers) {
+            const h = src.headers instanceof HttpHeaders
+                ? src.headers
+                : new HttpHeaders(src.headers);
+            h.forEach((v, k) => {
+                if (k.toLowerCase() === 'set-cookie') {
+                    this.headers.append(k, v);
+                }
+                else if (!this.headers.has(k))
+                    this.headers.set(k, v);
+            });
         }
-        else
-            headers[k] = v;
     }
-    return headers;
 }

package/esm/http/http-response.d.ts

@@ -0,0 +1,41 @@
+import { HttpHeaders, HttpHeadersInit } from './http-headers.js';
+export interface HttpResponseInit {
+    headers?: HttpHeadersInit;
+    status?: number;
+    statusText?: string;
+    url?: string;
+    body?: any;
+    hasBody?: boolean;
+}
+export declare class HttpResponse<TBody = any> {
+    /**
+     *  Contains the Headers object associated with the response.
+     */
+    readonly headers: HttpHeaders;
+    /**
+     *  Contains a Boolean stating whether the response was successful (status in the range 200-299) or not.
+     */
+    readonly ok: boolean;
+    /**
+     * Contains the HTTP status codes of the response
+     */
+    readonly status: number;
+    /**
+     * Contains the status message corresponding to the HTTP status code in status property
+     */
+    readonly statusText: string;
+    /**
+     * Contains the URL of the response
+     */
+    readonly url: string | null;
+    /**
+     * Body contents
+     */
+    readonly body: TBody | null;
+    /**
+     * Returns true if response has body to be received
+     */
+    readonly hasBody: boolean;
+    constructor(init?: HttpResponseInit);
+    clone(update?: HttpResponseInit): HttpResponse;
+}

package/esm/http/http-response.js

@@ -0,0 +1,19 @@
+import { HttpHeaders } from './http-headers.js';
+export class HttpResponse {
+    constructor(init) {
+        /**
+         * Returns true if response has body to be received
+         */
+        this.hasBody = false;
+        this.headers = new HttpHeaders(init?.headers);
+        this.status = init?.status || 200;
+        this.statusText = init?.statusText || 'OK';
+        this.url = init?.url || null;
+        this.ok = this.status >= 200 && this.status < 300;
+        this.body = init?.body;
+        this.hasBody = init?.body != null || !!init?.hasBody;
+    }
+    clone(update) {
+        return new HttpResponse({ ...this, ...update });
+    }
+}

package/esm/http/index.d.ts

@@ -1,6 +1,17 @@
+export * from './http-request-node.js';
+export * from './http-headers.js';
 export * from './http-request.js';
-export * from './enums/http-headers.enum.js';
-export * from './enums/http-status.enum.js';
+export * from './http-response.js';
+export * from './http-params.js';
+export * from './http-param-codec.js';
+export * from './enums/http-headers-codes.enum.js';
+export * from './enums/http-status-codes.enum.js';
 export * from './interfaces/client-http-headers.interface.js';
 export * from './interfaces/server-http-headers.interface.js';
+export * from './param-codec/date-codec.js';
+export * from './param-codec/boolean-codec.js';
+export * from './param-codec/filter-codec.js';
+export * from './param-codec/integer-codec.js';
+export * from './param-codec/number-codec.js';
+export * from './param-codec/string-codec.js';
 export * from './utils/normalize-headers.js';

package/esm/http/index.js

@@ -1,6 +1,17 @@
+export * from './http-request-node.js';
+export * from './http-headers.js';
 export * from './http-request.js';
-export * from './enums/http-headers.enum.js';
-export * from './enums/http-status.enum.js';
+export * from './http-response.js';
+export * from './http-params.js';
+export * from './http-param-codec.js';
+export * from './enums/http-headers-codes.enum.js';
+export * from './enums/http-status-codes.enum.js';
 export * from './interfaces/client-http-headers.interface.js';
 export * from './interfaces/server-http-headers.interface.js';
+export * from './param-codec/date-codec.js';
+export * from './param-codec/boolean-codec.js';
+export * from './param-codec/filter-codec.js';
+export * from './param-codec/integer-codec.js';
+export * from './param-codec/number-codec.js';
+export * from './param-codec/string-codec.js';
 export * from './utils/normalize-headers.js';

package/esm/http/interfaces/client-http-headers.interface.d.ts

@@ -1,4 +1,4 @@
-export declare type ClientHttpHeaders = Record<string, string | string[]> & {
+export type ClientHttpHeaders = Record<string, string | string[]> & {
     accept?: string;
     'accept-language'?: string;
     'accept-patch'?: string;

package/esm/http/interfaces/server-http-headers.interface.d.ts

@@ -1 +1 @@
-export declare type ServerHttpHeaders = Record<string, string | string[]> & {};
+export type ServerHttpHeaders = Record<string, string | string[]> & {};

package/esm/http/multipart/batch-multipart.d.ts

@@ -4,7 +4,7 @@
 import { Readable } from 'stream';
 import { HttpRequestContent, IHttpRequestContent } from './http-request-content.js';
 import { HttpResponseContent, IHttpResponseContent } from './http-response-content.js';
-declare type Part = {
+type Part = {
     headers: Record<string, string | string[]>;
     contentId?: string;
     content: HttpRequestContent | HttpResponseContent | BatchMultipart;

package/esm/http/multipart/batch-multipart.js

@@ -1,8 +1,8 @@
 import Highland from 'highland';
 import { uid } from 'uid';
 import { isReadable } from '../../utils/type-guards.js';
-import { HttpHeaders } from '../enums/http-headers.enum.js';
-import { HttpStatus } from '../enums/http-status.enum.js';
+import { HttpHeaderCodes } from '../enums/http-headers-codes.enum.js';
+import { HttpStatusCodes } from '../enums/http-status-codes.enum.js';
 import { normalizeHeaders } from '../utils/normalize-headers.js';
 import { HttpRequestContent } from './http-request-content.js';
 import { HttpResponseContent } from './http-response-content.js';
@@ -16,11 +16,11 @@ export class BatchMultipart {
     addRequestPart(content, part) {
         const headers = {
             ...normalizeHeaders(part?.headers || {}, true),
-            [HttpHeaders.Content_Type]: 'application/http',
-            [HttpHeaders.Content_Transfer_Encoding]: 'binary'
+            [HttpHeaderCodes.Content_Type]: 'application/http',
+            [HttpHeaderCodes.Content_Transfer_Encoding]: 'binary'
         };
         if (part?.contentId)
-            headers[HttpHeaders.Content_ID] = part.contentId;
+            headers[HttpHeaderCodes.Content_ID] = part.contentId;
         this._parts.push({
             headers,
             contentId: part?.contentId,
@@ -31,11 +31,11 @@ export class BatchMultipart {
     addHttpResponse(content, part) {
         const headers = {
             ...normalizeHeaders(part?.headers || {}, true),
-            [HttpHeaders.Content_Type]: 'application/http',
-            [HttpHeaders.Content_Transfer_Encoding]: 'binary'
+            [HttpHeaderCodes.Content_Type]: 'application/http',
+            [HttpHeaderCodes.Content_Transfer_Encoding]: 'binary'
         };
         if (part?.contentId)
-            headers[HttpHeaders.Content_ID] = part.contentId;
+            headers[HttpHeaderCodes.Content_ID] = part.contentId;
         this._parts.push({
             headers,
             contentId: part?.contentId,
@@ -46,11 +46,11 @@ export class BatchMultipart {
     addBatch(batch, part) {
         const headers = {
             ...normalizeHeaders(part?.headers || {}, true),
-            [HttpHeaders.Content_Type]: 'application/http',
-            [HttpHeaders.Content_Transfer_Encoding]: 'binary'
+            [HttpHeaderCodes.Content_Type]: 'application/http',
+            [HttpHeaderCodes.Content_Transfer_Encoding]: 'binary'
         };
         if (part?.contentId)
-            headers[HttpHeaders.Content_ID] = part.contentId;
+            headers[HttpHeaderCodes.Content_ID] = part.contentId;
         this._parts.push({
             headers,
             contentId: part?.contentId,
@@ -122,7 +122,7 @@ export class BatchMultipart {
                 if (part.content instanceof HttpRequestContent)
                     s += (part.content.method || 'GET').toUpperCase() + ' ' + part.content.url + ' HTTP/1.1' + CRLF;
                 else
-                    s += 'HTTP/1.1 ' + part.content.status + (HttpStatus[part.content.status] || 'Unknown') + CRLF;
+                    s += 'HTTP/1.1 ' + part.content.status + (HttpStatusCodes[part.content.status] || 'Unknown') + CRLF;
                 if (part.content.headers) {
                     for (const [k, v] of Object.entries(part.content.headers)) {
                         if (v === '' || v == null)

package/esm/http/multipart/http-request-content.d.ts

@@ -1,4 +1,4 @@
-export declare type IHttpRequestContent = Pick<HttpRequestContent, 'method' | 'url' | 'headers' | 'data'>;
+export type IHttpRequestContent = Pick<HttpRequestContent, 'method' | 'url' | 'headers' | 'data'>;
 export declare class HttpRequestContent {
     method: string;
     url: string;

package/esm/http/multipart/http-response-content.d.ts

@@ -1,4 +1,4 @@
-export declare type IHttpResponseContent = Pick<HttpResponseContent, 'status' | 'headers' | 'data'>;
+export type IHttpResponseContent = Pick<HttpResponseContent, 'status' | 'headers' | 'data'>;
 export declare class HttpResponseContent {
     status: number;
     headers?: Record<string, string | string[]>;

package/esm/http/param-codec/boolean-codec.d.ts

@@ -0,0 +1,5 @@
+import { HttpParamCodec } from '../http-param-codec.js';
+export declare class BooleanCodec extends HttpParamCodec {
+    decode(value: string): boolean;
+    encode(value: any): string;
+}

package/esm/http/param-codec/boolean-codec.js

@@ -0,0 +1,21 @@
+import { HttpParamCodec } from '../http-param-codec.js';
+const trueValues = ['true', 't', 'yes', 'y', '1'];
+const falseValues = ['false', 'f', 'no', 'n', '0'];
+export class BooleanCodec extends HttpParamCodec {
+    decode(value) {
+        if (value === '')
+            return true;
+        // noinspection SuspiciousTypeOfGuard
+        if (typeof value === 'boolean')
+            return value;
+        if (trueValues.includes(value.toLowerCase()))
+            return true;
+        if (falseValues.includes(value.toLowerCase()))
+            return false;
+        throw new TypeError(`"${value}" is not a valid boolean`);
+    }
+    encode(value) {
+        return typeof value === 'boolean' ?
+            (value ? 'true' : 'false') : '';
+    }
+}

package/esm/http/param-codec/date-codec.d.ts

@@ -0,0 +1,16 @@
+import { HttpParamCodec } from '../http-param-codec.js';
+export interface DateCodecOptions {
+    time?: boolean;
+    timeZone?: boolean;
+    min?: string;
+    max?: string;
+}
+export declare class DateCodec extends HttpParamCodec {
+    time: boolean;
+    timeZone: boolean;
+    min?: string;
+    max?: string;
+    constructor(options?: DateCodecOptions);
+    decode(value: string): string;
+    encode(value: any): string;
+}

package/esm/http/param-codec/date-codec.js

@@ -0,0 +1,40 @@
+/* eslint-disable max-len */
+import { HttpParamCodec } from '../http-param-codec.js';
+// noinspection RegExpUnnecessaryNonCapturingGroup
+const DATE_FORMAT_PATTERN = /^(\d{4})(?:-?(0[1-9]|1[012])(?:-?([123]0|[012][1-9]|31))?)?(?:[T ]?([01][0-9]|2[0-3]):?([0-5][0-9]):?([0-5][0-9])?(?:\.(\d+))?(?:(Z)|(?:([+-])([01]?[0-9]|2[0-3]):?([0-5][0-9])?))?)?$/;
+export class DateCodec extends HttpParamCodec {
+    constructor(options) {
+        super();
+        this.max = options?.max ? coerceToDateString(options.max) : undefined;
+        this.min = options?.min ? coerceToDateString(options.min) : undefined;
+        this.time = options?.time ?? true;
+        this.timeZone = options?.timeZone ?? true;
+    }
+    decode(value) {
+        const v = coerceToDateString(value, this.time, this.timeZone);
+        if (this.min != null && v < this.min)
+            throw new TypeError(`Value must be ${this.min} or greater.`);
+        if (this.max != null && v > this.max)
+            throw new TypeError(`Value must be ${this.max} or less.`);
+        return v;
+    }
+    encode(value) {
+        return coerceToDateString(value, this.time, this.timeZone);
+    }
+}
+function coerceToDateString(value, time, timeZone) {
+    if (value === '' || value == null)
+        return '';
+    const m = value.match(DATE_FORMAT_PATTERN);
+    if (!m)
+        throw new TypeError(`"${value}" is not a valid date.`);
+    let v = m[1] + '-' + (m[2] || '01') + '-' + (m[3] || '01');
+    if (time) {
+        v += 'T' + (m[4] || '00') + ':' + (m[5] || '00') + ':' + (m[6] || '00') +
+            (m[7] ? '.' + m[7] : '');
+        if (timeZone)
+            v += m[8] ? 'Z' :
+                (m[9] ? (m[9] + (m[10] || '00') + ':' + (m[11] || '00')) : '');
+    }
+    return v;
+}

package/esm/http/param-codec/filter-codec.d.ts

@@ -0,0 +1,6 @@
+import { Ast, Expression } from '../../filter/ast/index.js';
+import { HttpParamCodec } from '../http-param-codec.js';
+export declare class FilterCodec extends HttpParamCodec {
+    decode(value: string | Expression): object;
+    encode(value: Ast): string;
+}

package/esm/http/param-codec/filter-codec.js

@@ -0,0 +1,14 @@
+import { Expression } from '../../filter/ast/index.js';
+import { parseFilter } from '../../filter/parse.js';
+import { HttpParamCodec } from '../http-param-codec.js';
+export class FilterCodec extends HttpParamCodec {
+    decode(value) {
+        if (value instanceof Expression)
+            return value;
+        return parseFilter(value);
+    }
+    encode(value) {
+        // @ts-ignore
+        return value ? '' + value : '';
+    }
+}

package/esm/http/param-codec/integer-codec.d.ts

@@ -0,0 +1,9 @@
+import { NumberCodec, NumberFormatOptions } from './number-codec.js';
+export interface IntegerFormatOptions extends NumberFormatOptions {
+    enum?: number[];
+}
+export declare class IntegerCodec extends NumberCodec {
+    enum?: number[];
+    constructor(options?: IntegerFormatOptions);
+    decode(value: string): number;
+}

package/esm/http/param-codec/integer-codec.js

@@ -0,0 +1,15 @@
+import { NumberCodec } from './number-codec.js';
+export class IntegerCodec extends NumberCodec {
+    constructor(options) {
+        super(options);
+        this.enum = options?.enum;
+    }
+    decode(value) {
+        const v = super.decode(value);
+        if (!Number.isInteger(v))
+            throw new TypeError(`"${value}" is not a valid integer`);
+        if (this.enum && !this.enum.includes(v))
+            throw new TypeError(`"${value}" is not one of allowed enum values (${this.enum}).`);
+        return v;
+    }
+}

package/esm/http/param-codec/number-codec.d.ts

@@ -0,0 +1,12 @@
+import { HttpParamCodec } from '../http-param-codec.js';
+export interface NumberFormatOptions {
+    max?: number;
+    min?: number;
+}
+export declare class NumberCodec extends HttpParamCodec {
+    max?: number;
+    min?: number;
+    constructor(options?: NumberFormatOptions);
+    decode(value: string): number;
+    encode(value: any): string;
+}

package/esm/http/param-codec/number-codec.js

@@ -0,0 +1,22 @@
+import { HttpParamCodec } from '../http-param-codec.js';
+export class NumberCodec extends HttpParamCodec {
+    constructor(options) {
+        super();
+        this.max = options?.max;
+        this.min = options?.min;
+    }
+    decode(value) {
+        // noinspection SuspiciousTypeOfGuard
+        const v = typeof value === 'number' ? value : parseFloat(value);
+        if (isNaN(v))
+            throw new TypeError(`"${value}" is not a valid number`);
+        if (this.min != null && v < this.min)
+            throw new TypeError(`Value must be ${this.min} or greater.`);
+        if (this.max != null && v > this.max)
+            throw new TypeError(`Value must be ${this.max} or less.`);
+        return v;
+    }
+    encode(value) {
+        return typeof value === 'number' ? '' + value : '';
+    }
+}

package/esm/http/param-codec/string-codec.d.ts

@@ -0,0 +1,14 @@
+import { HttpParamCodec } from '../http-param-codec.js';
+export interface StringFormatOptions {
+    maxLength?: number;
+    minLength?: number;
+    enum?: string[];
+}
+export declare class StringCodec extends HttpParamCodec {
+    maxLength?: number;
+    minLength?: number;
+    enum?: string[];
+    constructor(options?: StringFormatOptions);
+    decode(value: string): string;
+    encode(value: any): string;
+}

package/esm/http/param-codec/string-codec.js

@@ -0,0 +1,21 @@
+import { HttpParamCodec } from '../http-param-codec.js';
+export class StringCodec extends HttpParamCodec {
+    constructor(options) {
+        super();
+        this.maxLength = options?.maxLength;
+        this.minLength = options?.minLength;
+        this.enum = options?.enum;
+    }
+    decode(value) {
+        if (this.minLength != null && value.length < this.minLength)
+            throw new TypeError(`Value must be at least ${this.minLength} character${this.minLength > 1 ? 's' : ''} long.`);
+        if (this.maxLength != null && value.length > this.maxLength)
+            throw new TypeError(`Value can be up to ${this.maxLength} character${this.maxLength > 1 ? 's' : ''} long.`);
+        if (this.enum && !this.enum.includes(value))
+            throw new TypeError(`"${value}" is not one of allowed enum values (${this.enum}).`);
+        return value;
+    }
+    encode(value) {
+        return value == null ? '' : '' + value;
+    }
+}

package/esm/http/utils/encodeURIParam.d.ts

@@ -0,0 +1 @@
+export declare function encodeURIParam(v: string): string;

package/esm/http/utils/encodeURIParam.js

@@ -0,0 +1,17 @@
+/**
+ * Encode input string with standard encodeURIComponent and then un-encode specific characters.
+ */
+const ENCODING_REGEX = /%(\d[a-f0-9])/gi;
+const ENCODING_REPLACEMENTS = {
+    '2C': ',',
+    '2F': '/',
+    '24': '$',
+    '3A': ':',
+    '3B': ';',
+    '3D': '=',
+    '3F': '?',
+    '40': '@'
+};
+export function encodeURIParam(v) {
+    return encodeURIComponent(v).replace(ENCODING_REGEX, (s, t) => ENCODING_REPLACEMENTS[t] ?? s);
+}

package/esm/http/utils/normalize-headers.js

@@ -1,5 +1,5 @@
-import { HttpHeaders } from '../enums/http-headers.enum.js';
-const knownKeys = Object.keys(HttpHeaders);
+import { HttpHeaderCodes } from '../enums/http-headers-codes.enum.js';
+const knownKeys = Object.keys(HttpHeaderCodes);
 const knownKeysLower = knownKeys.map(x => x.toLowerCase());
 export function normalizeHeaders(headers, normalCase) {
     if (!headers)

package/esm/i18n/i18n.d.ts

@@ -1,15 +1,15 @@
 import { FallbackLng, Formatter as I18nextFormatter, i18n, InitOptions as I18nextInitOptions, Resource as I18nextResource, TFunction as I18nextTFunction, TOptions } from 'i18next';
 import * as I18next from 'i18next';
 import { Type } from 'ts-gems';
-export declare type BaseI18n = Type<I18next.i18n>;
+export type BaseI18n = Type<I18next.i18n>;
 export declare const BaseI18n: BaseI18n;
-export declare type DeepTranslateOptions = TOptions & {
+export type DeepTranslateOptions = TOptions & {
     ignore?: (input: any, inst: i18n) => boolean;
 };
-export declare type InitCallback = I18next.Callback;
-export declare type TranslateFunction = I18nextTFunction;
-export declare type Formatter = I18nextFormatter;
-export declare type LanguageResource = I18nextResource;
+export type InitCallback = I18next.Callback;
+export type TranslateFunction = I18nextTFunction;
+export type Formatter = I18nextFormatter;
+export type LanguageResource = I18nextResource;
 export type { FallbackLng };
 export interface InitOptions extends I18nextInitOptions {
     resourceDirs?: string[];