@bjoernboss/mws 1.0.0

package/dist/handler.d.ts

@@ -0,0 +1,119 @@
+import * as libClient from "./client.js";
+import * as libLog from "./log.js";
+import * as libServer from "./server.js";
+export type PathTranslation = Record<string, string | null>;
+export interface AttachedModule {
+    handle(client: libClient.ClientRequest, options?: {
+        params?: object;
+        translate?: PathTranslation;
+    }): Promise<boolean>;
+    unlink(): Promise<void>;
+    module: ModuleHandler;
+    linked(): boolean;
+    unlinked(): Promise<void>;
+}
+export declare abstract class ModuleHandler extends libLog.Logger {
+    private _stopped;
+    private _config;
+    private _handling;
+    private _attachment;
+    protected constructor(name: string);
+    private _drainTaskQueue;
+    private _pushHandleTask;
+    private _checkIsModuleAttached;
+    private _processIncomingClient;
+    private _performAttachSelf;
+    private _performDetachSelf;
+    private _performAttachToParent;
+    _rootAttachToServer(server: libServer.Server, unlinked: () => void): AttachedModule;
+    protected handleInitialize(server: libServer.Server): Promise<void>;
+    protected abstract handleRequest(client: libClient.ClientRequest, params?: object): Promise<void>;
+    protected handleStop(): Promise<void>;
+    get moduleName(): string;
+    get moduleServer(): libServer.Server | null;
+    tagClients(tag: boolean): this;
+    tagString(tag: string): this;
+    stopOnDetach(stop: boolean): this;
+    linkModule(child: ModuleHandler, unlinked?: () => void, detail?: string): AttachedModule;
+    stop(): Promise<void>;
+}
+export declare function dispatch(map: Record<string, ModuleHandler>, options?: {
+    name?: string;
+}): DispatchModule;
+export declare class DispatchModule extends ModuleHandler {
+    private mapping;
+    constructor(map: Record<string, ModuleHandler>, options?: {
+        name?: string;
+    });
+    protected handleRequest(client: libClient.ClientRequest, _?: object): Promise<void>;
+}
+export declare function host(map: Record<string, ModuleHandler>, options?: {
+    name?: string;
+}): HostModule;
+export declare class HostModule extends ModuleHandler {
+    private mapping;
+    constructor(map: Record<string, ModuleHandler>, options?: {
+        name?: string;
+    });
+    private testSubHost;
+    protected handleRequest(client: libClient.ClientRequest): Promise<void>;
+}
+export declare function bind(handler: ModuleHandler, options?: {
+    params?: object;
+    translate?: PathTranslation;
+    name?: string;
+}): BindModule;
+export declare class BindModule extends ModuleHandler {
+    private handler;
+    private params?;
+    private translate?;
+    constructor(handler: ModuleHandler, options?: {
+        params?: object;
+        translate?: PathTranslation;
+        name?: string;
+    });
+    protected handleRequest(client: libClient.ClientRequest): Promise<void>;
+}
+export declare function check(handler: ModuleHandler, host: string | string[], options?: {
+    name?: string;
+    port?: number;
+}): CheckModule;
+export declare class CheckModule extends ModuleHandler {
+    private handler;
+    private port?;
+    private hosts;
+    constructor(handler: ModuleHandler, host: string | string[], options?: {
+        name?: string;
+        port?: number;
+    });
+    private respondBadEndpoint;
+    protected handleRequest(client: libClient.ClientRequest): Promise<void>;
+}
+export declare function lambda(options?: {
+    attach?: Record<string, ModuleHandler>;
+    setup?: CallbackSetup;
+    handle?: CallbackHandle;
+    stop?: CallbackStop;
+    name?: string;
+}): LambdaModule;
+export declare class LambdaModule extends ModuleHandler {
+    private setupLambda?;
+    private handleLambda?;
+    private stopLambda?;
+    private links;
+    private active;
+    constructor(options?: {
+        attach?: Record<string, ModuleHandler>;
+        setup?: CallbackSetup;
+        handle?: CallbackHandle;
+        stop?: CallbackStop;
+        name?: string;
+    });
+    protected handleInitialize(server: libServer.Server): Promise<void>;
+    protected handleRequest(client: libClient.ClientRequest, params?: object): Promise<void>;
+    protected handleStop(): Promise<void>;
+}
+export type CallbackSetup = (this: ModuleHandler, server: libServer.Server, links: Record<string, AttachedModule>) => Promise<void>;
+export type CallbackHandle = (this: ModuleHandler, client: libClient.ClientRequest, params: object | undefined, links: Record<string, AttachedModule>) => Promise<void>;
+export type CallbackStop = (this: ModuleHandler, links: Record<string, AttachedModule>) => Promise<void>;
+//# sourceMappingURL=handler.d.ts.map

package/dist/handler.js

@@ -0,0 +1,542 @@
+import * as libLog from "./log.js";
+import * as libBase from "./base.js";
+import * as libServer from "./server.js";
+/*
+*	Modules will be stopped by default, once it is fully unlinked from the server again.
+*	If a module is initialized, or stopped, the stop-handler is called.
+*	An initialization will always be followed by a stop-handler call.
+*	Any request will first happen after successful initialization, and will complete before stop-handlers.
+*	WebSockets will not be automatically closed and must be closed by the module.
+*	Modules can either be attached to other modules (allowing for recursive detaches/cleanups) or to the server.
+*/
+export class ModuleHandler extends libLog.Logger {
+    _stopped;
+    _config;
+    _handling;
+    _attachment;
+    constructor(name) {
+        super(name);
+        this._config = { name, tagClients: true, tagString: '', stopOnDetach: true };
+        this._handling = { active: new Set(), promise: null, resolver: () => { } };
+        this._stopped = null;
+        this._attachment = { links: new Set(), attached: false, server: null, task: { promise: null, order: [], count: 0, resolver: () => { } } };
+    }
+    async _drainTaskQueue(connections, order) {
+        const tasks = this._attachment.task;
+        /* wait for the tasks and connections to drain accordingly */
+        while (true) {
+            const promises = [];
+            if (tasks.promise != null)
+                promises.push(tasks.promise);
+            if (connections && this._handling.promise != null)
+                promises.push(this._handling.promise);
+            const index = (order == null ? tasks.order.length - 1 : tasks.order.indexOf(order) - 1);
+            if (index >= 0)
+                promises.push(tasks.order[index]);
+            if (promises.length == 0)
+                return;
+            await Promise.all(promises);
+        }
+    }
+    _pushHandleTask(promise) {
+        const task = this._attachment.task;
+        if (task.count++ == 0)
+            task.promise = new Promise((res) => task.resolver = res);
+        promise.then(() => {
+            if (--task.count == 0) {
+                task.promise = null;
+                task.resolver();
+            }
+        });
+    }
+    _checkIsModuleAttached(handler) {
+        for (const entry of handler._attachment.links) {
+            if (entry.parent == handler)
+                continue;
+            if (entry.parent != null && !entry.parent._attachment.attached)
+                continue;
+            return true;
+        }
+        return false;
+    }
+    async _processIncomingClient(client, params, translate) {
+        /* check if the client is already being handled or has already
+        *	been handled and otherwise process any outstanding tasks */
+        if (this._handling.active.has(client) || client.claimed)
+            return client.claimed;
+        await this._drainTaskQueue(false, null);
+        /* ensure that the handler is attached and push the mapping and path (client will validate it) */
+        if (!this._attachment.attached)
+            return client.claimed;
+        const mapping = translate ?? { '/': '/' };
+        const logTag = (this._config.tagClients ? (this._config.tagString == '' ? this._config.name : this._config.tagString) : '');
+        const snapshot = client._pushTranslation(mapping, logTag);
+        if (snapshot == null)
+            return client.claimed;
+        /* check if the cleanup handler needs to be setup and push the client in general to be handled right now */
+        if (this._handling.active.size == 0)
+            this._handling.promise = new Promise((res) => this._handling.resolver = res);
+        this._handling.active.add(client);
+        /* handle the client but ensure to catch any exceptions and re-throw them once the handler has been cleaned up */
+        let error = null;
+        try {
+            await this.handleRequest(client, params);
+        }
+        catch (err) {
+            error = err;
+        }
+        /* restore the context, clear the handling promise and remove the client from actively handled clients */
+        this._handling.active.delete(client);
+        client._restoreSnapshot(snapshot);
+        if (this._handling.active.size == 0) {
+            this._handling.promise = null;
+            this._handling.resolver();
+        }
+        if (error != null)
+            throw error;
+        return client.claimed;
+    }
+    async _performAttachSelf(server) {
+        const firstAttachment = (this._attachment.server == null);
+        this._attachment.attached = true;
+        this._attachment.server = server;
+        /* push the next ordered promise, to ensure the attach is fully performed before the next detach */
+        let taskResolver = () => { };
+        const taskPromise = new Promise((res) => taskResolver = res);
+        this._attachment.task.order.push(taskPromise);
+        /* trigger any attach calls (may push new independent tasks) */
+        for (const link of this._attachment.links) {
+            if (link.setup != null)
+                link.setup(taskPromise);
+        }
+        /* drain the current task queue and convert the task back to the unordered next step */
+        await this._drainTaskQueue(true, taskPromise);
+        this._attachment.task.order.shift();
+        this._pushHandleTask(taskPromise);
+        /* notify the module itself about the initialization */
+        try {
+            if (firstAttachment)
+                await this.handleInitialize(this._attachment.server);
+        }
+        catch (err) {
+            this.error(`Unhandled exception while initializing: ${err.message}`);
+            this.stop();
+        }
+        taskResolver();
+        return firstAttachment;
+    }
+    async _performDetachSelf() {
+        if (!this._attachment.attached)
+            return;
+        this._attachment.attached = false;
+        /* push the next ordered promise, to ensure the detach is fully performed before the next attach */
+        let taskResolver = () => { };
+        const taskPromise = new Promise((res) => taskResolver = res);
+        this._attachment.task.order.push(taskPromise);
+        /* trigger the detach of all now detached children */
+        for (const entry of this._attachment.links) {
+            if (entry.parent == this && !this._checkIsModuleAttached(entry.child))
+                this._pushHandleTask(entry.child._performDetachSelf());
+        }
+        /* check if the module should be stopped due to being detached */
+        if (this._config.stopOnDetach)
+            this.stop();
+        /* wait for any current tasks and connections to complete and remove the ordered task */
+        await this._drainTaskQueue(false, taskPromise);
+        this._attachment.task.order.shift();
+        taskResolver();
+        /* check if the module was stopped and await the proper stopping */
+        if (this._stopped != null)
+            await this._stopped;
+    }
+    _performAttachToParent(parent, unlinked, detail) {
+        const recSearchParents = (parent) => {
+            if (parent == this)
+                return false;
+            for (const entry of parent._attachment.links) {
+                if (entry.child == parent && entry.parent != null && !recSearchParents(entry.parent))
+                    return false;
+            }
+            return true;
+        };
+        const validateLinkState = (parentServer) => {
+            if (this._stopped != null) {
+                this.warning(`Stopped module cannot be attached to [${parent.logIdentity}]`);
+                return false;
+            }
+            const thisServer = this._attachment.server;
+            if (thisServer != null && parentServer != null && thisServer != parentServer) {
+                this.warning(`Module attached to server [${thisServer.logIdentity}] cannot be attached to server [${parentServer.logIdentity}]`);
+                return false;
+            }
+            if (parent instanceof libServer.Server)
+                return true;
+            if (parent._stopped != null) {
+                this.warning(`Module cannot be attached to stopped module [${parent.logIdentity}]`);
+                return false;
+            }
+            if (!recSearchParents(parent)) {
+                this.warning('Module cannot be directly or indirectly attach to itself');
+                return false;
+            }
+            return true;
+        };
+        if (detail != '')
+            detail = `: ${detail}`;
+        /* setup the link object and its creation and cleanup methods */
+        let unlinkResolver = () => { }, taskResolver = () => { };
+        const unlinkPromise = new Promise((res) => unlinkResolver = res);
+        const taskPromise = new Promise((res) => taskResolver = res);
+        let logged = false, stopping = false;
+        const link = {
+            parent: (parent instanceof libServer.Server ? null : parent),
+            child: this,
+            setup: async (realized) => {
+                if (stopping)
+                    return;
+                const parentServer = (parent instanceof libServer.Server ? parent : parent._attachment.server);
+                /* check if the attachment is possible in theory */
+                let firstAttachment = false;
+                if (!validateLinkState(parentServer))
+                    link.cleanup();
+                /* check if the attachment is still certain (uncertainty can only happen once on the first time
+                *	attaching, as the second execution is performed after the parent has just been attached) */
+                else if (parentServer != null) {
+                    link.setup = null;
+                    if (!this._attachment.attached) {
+                        if (realized != null)
+                            this._pushHandleTask(realized);
+                        firstAttachment = await this._performAttachSelf(parentServer);
+                    }
+                    logged = !stopping;
+                    if (logged) {
+                        if (parent instanceof libServer.Server || !firstAttachment)
+                            this.info(`Attached to [${parent.logIdentity}]${detail}`);
+                        else
+                            this.info(`Attached to [${parent.logIdentity}] and server [${parentServer.logIdentity}]${detail}`);
+                    }
+                }
+            },
+            cleanup: async () => {
+                if (stopping)
+                    return unlinkPromise;
+                stopping = true, link.setup = null;
+                if (logged)
+                    this.info(`Detached from [${parent.logIdentity}]${detail}`);
+                /* remove the link from the parent and add its cleanup to its task list (cleanup calls are only linked as task to the parent,
+                *	as the child does not care for them; this implies that the module's stop method itself does not await them either) */
+                if (!(parent instanceof libServer.Server)) {
+                    parent._attachment.links.delete(link);
+                    parent._pushHandleTask(taskPromise);
+                }
+                /* remove the link from this handler and check if the object should be detached */
+                this._attachment.links.delete(link);
+                if (!this._checkIsModuleAttached(this))
+                    await this._performDetachSelf();
+                /* start the actual unlink call */
+                process.nextTick(async () => {
+                    try {
+                        unlinked();
+                    }
+                    catch (err) {
+                        this.error(`Unhandled exception while unlinking: ${err.message}`);
+                    }
+                    taskResolver();
+                    /* check if the module was stopped, in which case the stop should be awaited before resolving the cleanup promise */
+                    if (this._stopped != null)
+                        await this._stopped;
+                    unlinkResolver();
+                });
+                return unlinkPromise;
+            }
+        };
+        /* register the link between the parent and this handler */
+        this._attachment.links.add(link);
+        if (!(parent instanceof libServer.Server))
+            parent._attachment.links.add(link);
+        /* try to immediately perform the initial load and setup the attach module interface */
+        link.setup(null);
+        return {
+            handle: (client, options) => (stopping ? Promise.resolve(client.claimed) : this._processIncomingClient(client, options?.params, options?.translate)),
+            unlink: () => link.cleanup(),
+            module: this,
+            linked: () => !stopping,
+            unlinked: () => unlinkPromise
+        };
+    }
+    _rootAttachToServer(server, unlinked) {
+        return this._performAttachToParent(server, unlinked, '');
+    }
+    /* module is attached directly or indirectly to the server (will be the first call being performed before any other calls; will only be called once) */
+    async handleInitialize(server) { }
+    /* module has been stopped (all clients are guaranteed to have left, but accepted WebSockets will be left intact and
+    *	must be closed manually by this module; will only be called once; module should cleanup any resources and timers) */
+    async handleStop() { }
+    /* name of the module */
+    get moduleName() {
+        return this._config.name;
+    }
+    /* server the module has been attached to (null if not yet attached) */
+    get moduleServer() {
+        return this._attachment.server;
+    }
+    /* enable or disable the module tagging the logging of clients [default: true] */
+    tagClients(tag) {
+        this._config.tagClients = tag;
+        return this;
+    }
+    /* set the tagging string the module should use in the logging of clients with empty string being module name [default: ''] */
+    tagString(tag) {
+        this._config.tagString = tag;
+        return this;
+    }
+    /* enable or disable the module being stopped once detached the next time from the server [default: true] */
+    stopOnDetach(stop) {
+        this._config.stopOnDetach = stop;
+        return this;
+    }
+    /* link the child to this module (unlinked will be called once the child has been removed or is identified to not
+    *	be suited for this module; will not be called if this module is not attached or will not be attached anymore;
+    *	unless already destroyed; detail is an additional information to be logged upon linking and unlinking) */
+    linkModule(child, unlinked, detail) {
+        return child._performAttachToParent(this, (unlinked == null ? () => { } : unlinked), detail ?? '');
+    }
+    /* close any connections to the module and stop the module itself (stopping must not
+    *	be awaited while stopping itself or a parent as this can result in deadlocks) */
+    async stop() {
+        if (this._stopped != null)
+            return this._stopped;
+        /* setup the stopped-promise (before performing any operations, as the first operations might otherwise
+        *	call stop again, without the stopped-promise value being set, thereby recursively stopping again) */
+        let resolver = () => { };
+        this._stopped = new Promise((res) => resolver = res);
+        /* kill any connections and kill all links and drain the remaining task queue
+        *	(will not await the unlinked calls of links where this element is the child) */
+        this._performDetachSelf();
+        for (const client of this._handling.active)
+            client.killConnection('Module detached');
+        for (const link of this._attachment.links)
+            link.cleanup();
+        this.info('Handler stopped');
+        await this._drainTaskQueue(true, null);
+        try {
+            await this.handleStop();
+        }
+        catch (err) {
+            this.error(`Unhandled exception while stopping: ${err.message}`);
+        }
+        resolver();
+        return this._stopped;
+    }
+}
+/*
+*	Simple module handler implementation, which dispatches requests to different children based on the request path (longest match).
+*	Stops itself once all children have been unlinked. Own parameters are not forwarded.
+*/
+export function dispatch(map, options) {
+    return new DispatchModule(map, options);
+}
+export class DispatchModule extends ModuleHandler {
+    mapping;
+    constructor(map, options) {
+        super(options?.name ?? 'dispatch');
+        this.mapping = {};
+        for (const [key, handler] of Object.entries(map)) {
+            if (key in this.mapping) {
+                this.warning(`Ignoring duplicate mapping [${key}] by [${handler.logIdentity}]`);
+                continue;
+            }
+            this.mapping[key] = this.linkModule(handler, () => {
+                delete this.mapping[key];
+                if (Object.keys(this.mapping).length == 0)
+                    this.stop();
+            }, `Bound to path [${key}]`);
+        }
+        if (Object.keys(this.mapping).length == 0)
+            this.stop();
+    }
+    async handleRequest(client, _) {
+        let bestMatch = null;
+        /* iterate over the mappings and look for the corresponding best handler */
+        for (const path in this.mapping) {
+            if (!client.isSubPathOf(path))
+                continue;
+            if (bestMatch == null || bestMatch.length < path.length)
+                bestMatch = path;
+        }
+        if (bestMatch != null) {
+            client.trace(`Client dispatched to handler [${this.mapping[bestMatch].module.logIdentity}] for path [${bestMatch}]`);
+            await this.mapping[bestMatch].handle(client, { translate: { [bestMatch]: '/' } });
+        }
+        else
+            client.trace(`Request cannot be dispatched`);
+    }
+}
+/*
+*	Simple module handler implementation, which dispatches requests to different children based on the request hostname (longest match).
+*	Stops itself once all children have been unlinked. Own parameters are not forwarded.
+*/
+export function host(map, options) {
+    return new HostModule(map, options);
+}
+export class HostModule extends ModuleHandler {
+    mapping;
+    constructor(map, options) {
+        super(options?.name ?? 'host');
+        this.mapping = {};
+        for (const [host, handler] of Object.entries(map)) {
+            if (host in this.mapping) {
+                this.warning(`Ignoring duplicate mapping of host [${host}] by [${handler.logIdentity}]`);
+                continue;
+            }
+            this.mapping[host] = this.linkModule(handler, () => {
+                delete this.mapping[host];
+                if (Object.keys(this.mapping).length == 0)
+                    this.stop();
+            }, `Bound to host [${host}]`);
+        }
+        if (Object.keys(this.mapping).length == 0)
+            this.stop();
+    }
+    testSubHost(host, test) {
+        if (host.length > test.length)
+            return false;
+        if (host.length == test.length)
+            return (host == test);
+        if (!test.endsWith(host))
+            return false;
+        return (test[test.length - host.length - 1] == '.' || host.startsWith('.') || host == '');
+    }
+    async handleRequest(client) {
+        let bestMatch = null;
+        /* iterate over the mappings and look for the corresponding best handler */
+        for (const host in this.mapping) {
+            if (!this.testSubHost(host, client.url.hostname))
+                continue;
+            if (bestMatch == null || bestMatch.length < host.length)
+                bestMatch = host;
+        }
+        if (bestMatch != null) {
+            client.trace(`Client dispatched to handler [${this.mapping[bestMatch].module.logIdentity}] for host [${bestMatch}]`);
+            await this.mapping[bestMatch].handle(client);
+        }
+        else
+            client.trace(`Request cannot be dispatched`);
+    }
+}
+/*
+*	Simple module interface implementation, which forwards any requests to a child handler
+*	with optional parameter and translation binding. Stops itself once the child has been unlinked.
+*	Own parameters are not forwarded.
+*/
+export function bind(handler, options) {
+    return new BindModule(handler, options);
+}
+export class BindModule extends ModuleHandler {
+    handler;
+    params;
+    translate;
+    constructor(handler, options) {
+        super(options?.name ?? 'bind');
+        this.handler = this.linkModule(handler, () => this.stop());
+        this.params = options?.params;
+        if (options?.translate != null)
+            this.translate = { ...options?.translate };
+    }
+    async handleRequest(client) {
+        await this.handler.handle(client, { params: this.params, translate: this.translate });
+    }
+}
+/*
+*	Simple module interface implementation, which validates the connected host and port before forwarding the client.
+*	Stops itself once the child has been unlinked. Own parameters are not forwarded.
+*/
+export function check(handler, host, options) {
+    return new CheckModule(handler, host, options);
+}
+export class CheckModule extends ModuleHandler {
+    handler;
+    port;
+    hosts;
+    constructor(handler, host, options) {
+        super(options?.name ?? 'check');
+        this.handler = this.linkModule(handler, () => this.stop());
+        this.hosts = (typeof host == 'string' ? [host] : host);
+        this.port = options?.port;
+    }
+    respondBadEndpoint(client) {
+        client.respond(`No resource found at [${client.url.host}]:[${client.url.pathname}]`, {
+            status: libBase.Status.NotFound,
+            media: libBase.Media.Text,
+            headers: { 'Connection': 'close' }
+        });
+        client.killConnection('Invalid endpoint description');
+    }
+    async handleRequest(client) {
+        let matches = false;
+        /* validate that the host matches */
+        for (const host of this.hosts) {
+            if (host == client.url.hostname) {
+                matches = true;
+                break;
+            }
+        }
+        if (!matches) {
+            client.warning(`Hostname [${client.url.hostname}] not allowed for this endpoint`);
+            return this.respondBadEndpoint(client);
+        }
+        /* validate that the port matches */
+        if (this.port != null && client.url.port) {
+            if (parseInt(client.url.port, 10) != this.port) {
+                client.warning(`Host [${client.url.port}] port does not match [${this.port}]`);
+                return this.respondBadEndpoint(client);
+            }
+        }
+        await this.handler.handle(client);
+    }
+}
+/*
+*	Simple module handler implementation, which allows requests to be handled by lambdas, and child modules to be attached.
+*	Stops itself once all children have been unlinked. Forwards parameter to lambda functions.
+*/
+export function lambda(options) {
+    return new LambdaModule(options);
+}
+export class LambdaModule extends ModuleHandler {
+    setupLambda;
+    handleLambda;
+    stopLambda;
+    links;
+    active;
+    constructor(options) {
+        super(options?.name ?? 'lambda');
+        this.setupLambda = options?.setup;
+        this.handleLambda = options?.handle;
+        this.stopLambda = options?.stop;
+        this.links = {};
+        this.active = 0;
+        if (options?.attach != null)
+            for (const name in options.attach) {
+                ++this.active;
+                this.links[name] = this.linkModule(options.attach[name], () => {
+                    if (--this.active == 0)
+                        this.stop();
+                });
+            }
+        if (options?.attach != null && this.active == 0)
+            this.stop();
+    }
+    async handleInitialize(server) {
+        if (this.setupLambda != null)
+            await this.setupLambda(server, this.links);
+    }
+    async handleRequest(client, params) {
+        if (this.handleLambda != null)
+            await this.handleLambda(client, params, this.links);
+    }
+    async handleStop() {
+        if (this.stopLambda != null)
+            await this.stopLambda(this.links);
+    }
+}
+//# sourceMappingURL=handler.js.map

package/dist/helper.d.ts

@@ -0,0 +1,33 @@
+import * as libBase from "./base.js";
+export declare function lookupEncoding(name: string): libBase.EncodingType | null;
+export declare function supportedEncodingNames(): string[];
+export declare function lookupMediaTypeFromFile(filePath: string): libBase.MediaType | null;
+export declare function buildMediaTypeIdentifier(media: libBase.MediaType): string;
+export declare function negotiateEncoding(accept: string | null, atLeastSize: number | null, media: libBase.MediaType): libBase.EncodingType | null;
+export declare enum RangeState {
+    noRange = 0,
+    valid = 1,
+    issue = 2,
+    malformed = 3
+}
+export declare function parseRangeHeader(range: string | null, fileSize: number): {
+    first: number;
+    last: number;
+    state: RangeState;
+};
+export declare function etagMatchesList(etag: string, header: string | null, strong: boolean): boolean;
+export declare function timestampCompare(a: string, b: string): number | null;
+export declare function splitAndTrimList(content: string | null, separator: string, quotesAware: boolean): string[];
+export declare function escapeHtml(content: string): string;
+export declare function expandPlaceholders(content: string, args: Record<string, string>, htmlEscape: boolean): string;
+export declare function escapePlaceholders(content: string): string;
+export declare function sanitize(path: string, relative: boolean): string;
+export declare function joinSanitized(a: string, b: string): string;
+export declare function isSubPath(base: string, path: string): boolean;
+export declare function isInside(base: string, path: string): boolean;
+export declare function childPath(base: string, path: string): string;
+export declare function rebasePath(oldBase: string, newBase: string, path: string): string;
+export declare function createPathLocation(path: string): (path: string) => string;
+export declare function createPathSelf(urlFilePath: string, path?: string | null): (path: string) => string;
+export declare function splitFilePath(path: string): [string, string, string];
+//# sourceMappingURL=helper.d.ts.map