@bjoernboss/mws 1.0.0 → 1.1.0

package/dist/handler.d.ts

@@ -1,17 +1,40 @@
 import * as libClient from "./client.js";
 import * as libLog from "./log.js";
 import * as libServer from "./server.js";
+import * as libCache from "./cache.js";
+/**
+*	Translation to be applied for nested children and reversed for any paths produced by the children.
+*	Paths are matched by longest path. A null translation is considered not being mapped and will not be forwarded.
+*/
 export type PathTranslation = Record<string, string | null>;
+/** Request and handler specific parameters to be passed to the corresponding handler */
+export type Params = Record<string, any>;
 export interface AttachedModule {
+    /** forward the given client to the module, and translate the paths and logging accordingly, if the module
+     *	is designated for the client; returns false if the client is still unhandled after the handler; params
+     *	are passed on to the module without modification; no translation is equivalent to [/] => [/] */
     handle(client: libClient.ClientRequest, options?: {
-        params?: object;
+        params?: Params;
         translate?: PathTranslation;
     }): Promise<boolean>;
+    /** detach the module from the parent module handler (registered unlinked callback will be invoked before this promise
+     *	is completed; clients dispatched to the module will not be disconnected directly any may still be active) */
     unlink(): Promise<void>;
+    /** original module that was attached */
     module: ModuleHandler;
+    /** check if the link is still valid (i.e. no unlink has been initiated) */
     linked(): boolean;
+    /** resolves once the module has been unlinked */
     unlinked(): Promise<void>;
 }
+/**
+*	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 declare abstract class ModuleHandler extends libLog.Logger {
     private _stopped;
     private _config;
@@ -26,17 +49,38 @@ export declare abstract class ModuleHandler extends libLog.Logger {
     private _performDetachSelf;
     private _performAttachToParent;
     _rootAttachToServer(server: libServer.Server, unlinked: () => void): AttachedModule;
+    /** 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) */
     protected handleInitialize(server: libServer.Server): Promise<void>;
-    protected abstract handleRequest(client: libClient.ClientRequest, params?: object): Promise<void>;
+    /** handle the client request (guaranteed to not have been claimed yet; if the promise resolves, client must either have been handled or must
+     *	not be handled anymore; long-running handlers must check 'client.claimed' or await 'client.responded' to allow timely server shutdown) */
+    protected abstract handleRequest(client: libClient.ClientRequest, params?: Params): Promise<void>;
+    /** 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) */
     protected handleStop(): Promise<void>;
-    get moduleName(): string;
-    get moduleServer(): libServer.Server | null;
+    /** name of the module */
+    get name(): string;
+    /** server the module has been attached to (null if not yet initialized) */
+    get server(): libServer.Server | null;
+    /** [throws] cache host to be used by this module (throws if not yet initialized) */
+    get cache(): libCache.CacheHost;
+    /** enable or disable the module tagging the logging of clients [default: true] */
     tagClients(tag: boolean): this;
+    /** set the tagging string the module should use in the logging of clients with empty string being module log identity [default: ''] */
     tagString(tag: string): this;
+    /** enable or disable the module being stopped once detached the next time from the server [default: true] */
     stopOnDetach(stop: boolean): 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: ModuleHandler, unlinked?: () => void, detail?: string): AttachedModule;
+    /** 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) */
     stop(): Promise<void>;
 }
+/**
+*	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 declare function dispatch(map: Record<string, ModuleHandler>, options?: {
     name?: string;
 }): DispatchModule;
@@ -45,8 +89,12 @@ export declare class DispatchModule extends ModuleHandler {
     constructor(map: Record<string, ModuleHandler>, options?: {
         name?: string;
     });
-    protected handleRequest(client: libClient.ClientRequest, _?: object): Promise<void>;
+    protected handleRequest(client: libClient.ClientRequest): Promise<void>;
 }
+/**
+*	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 declare function host(map: Record<string, ModuleHandler>, options?: {
     name?: string;
 }): HostModule;
@@ -58,8 +106,13 @@ export declare class HostModule extends ModuleHandler {
     private testSubHost;
     protected handleRequest(client: libClient.ClientRequest): Promise<void>;
 }
+/**
+*	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 declare function bind(handler: ModuleHandler, options?: {
-    params?: object;
+    params?: Params;
     translate?: PathTranslation;
     name?: string;
 }): BindModule;
@@ -68,12 +121,16 @@ export declare class BindModule extends ModuleHandler {
     private params?;
     private translate?;
     constructor(handler: ModuleHandler, options?: {
-        params?: object;
+        params?: Params;
         translate?: PathTranslation;
         name?: string;
     });
     protected handleRequest(client: libClient.ClientRequest): Promise<void>;
 }
+/**
+*	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 declare function check(handler: ModuleHandler, host: string | string[], options?: {
     name?: string;
     port?: number;
@@ -89,6 +146,10 @@ export declare class CheckModule extends ModuleHandler {
     private respondBadEndpoint;
     protected handleRequest(client: libClient.ClientRequest): Promise<void>;
 }
+/**
+*	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 declare function lambda(options?: {
     attach?: Record<string, ModuleHandler>;
     setup?: CallbackSetup;
@@ -110,10 +171,10 @@ export declare class LambdaModule extends ModuleHandler {
         name?: string;
     });
     protected handleInitialize(server: libServer.Server): Promise<void>;
-    protected handleRequest(client: libClient.ClientRequest, params?: object): Promise<void>;
+    protected handleRequest(client: libClient.ClientRequest, params?: Params): 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 CallbackHandle = (this: ModuleHandler, client: libClient.ClientRequest, params: Params | 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

@@ -1,7 +1,7 @@
 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.
@@ -60,17 +60,13 @@ export class ModuleHandler extends libLog.Logger {
         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;
+        /* ensure that any outstanding tasks have completed and then check if the client can be processed by this module */
         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)
+        if (!this._attachment.attached || this._handling.active.has(client) || client.claimed || client.server != this._attachment.server)
             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);
+        /* setup the new mapping and path translation and check if the translation can be applied */
+        const logTag = (this._config.tagClients ? (this._config.tagString == '' ? this.identity : this._config.tagString) : '');
+        const snapshot = client._pushTranslation(translate ?? null, 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 */
@@ -114,16 +110,17 @@ export class ModuleHandler extends libLog.Logger {
         this._attachment.task.order.shift();
         this._pushHandleTask(taskPromise);
         /* notify the module itself about the initialization */
-        try {
-            if (firstAttachment)
+        if (firstAttachment) {
+            try {
                 await this.handleInitialize(this._attachment.server);
-        }
-        catch (err) {
-            this.error(`Unhandled exception while initializing: ${err.message}`);
-            this.stop();
+            }
+            catch (err) {
+                this.error(`Unhandled exception while initializing: ${err.message}`);
+                this.stop();
+            }
+            this.info(`Handler initialized to server [${this._attachment.server.identity}]`);
         }
         taskResolver();
-        return firstAttachment;
     }
     async _performDetachSelf() {
         if (!this._attachment.attached)
@@ -161,18 +158,18 @@ export class ModuleHandler extends libLog.Logger {
         };
         const validateLinkState = (parentServer) => {
             if (this._stopped != null) {
-                this.warning(`Stopped module cannot be attached to [${parent.logIdentity}]`);
+                this.warning(`Stopped module cannot be attached to [${parent.identity}]`);
                 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}]`);
+                this.warning(`Module attached to server [${thisServer.identity}] cannot be attached to server [${parentServer.identity}]`);
                 return false;
             }
             if (parent instanceof libServer.Server)
                 return true;
             if (parent._stopped != null) {
-                this.warning(`Module cannot be attached to stopped module [${parent.logIdentity}]`);
+                this.warning(`Module cannot be attached to stopped module [${parent.identity}]`);
                 return false;
             }
             if (!recSearchParents(parent)) {
@@ -196,7 +193,6 @@ export class ModuleHandler extends libLog.Logger {
                     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
@@ -206,15 +202,11 @@ export class ModuleHandler extends libLog.Logger {
                     if (!this._attachment.attached) {
                         if (realized != null)
                             this._pushHandleTask(realized);
-                        firstAttachment = await this._performAttachSelf(parentServer);
+                        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}`);
-                    }
+                    if (logged)
+                        this.info(`Attached to [${parent.identity}]${detail}`);
                 }
             },
             cleanup: async () => {
@@ -222,7 +214,7 @@ export class ModuleHandler extends libLog.Logger {
                     return unlinkPromise;
                 stopping = true, link.setup = null;
                 if (logged)
-                    this.info(`Detached from [${parent.logIdentity}]${detail}`);
+                    this.info(`Detached from [${parent.identity}]${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)) {
@@ -267,69 +259,77 @@ export class ModuleHandler extends libLog.Logger {
     _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) */
+    /** 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) */
+    /** 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() {
+    /** name of the module */
+    get name() {
         return this._config.name;
     }
-    /* server the module has been attached to (null if not yet attached) */
-    get moduleServer() {
+    /** server the module has been attached to (null if not yet initialized) */
+    get server() {
         return this._attachment.server;
     }
-    /* enable or disable the module tagging the logging of clients [default: true] */
+    /** [throws] cache host to be used by this module (throws if not yet initialized) */
+    get cache() {
+        if (this._attachment.server == null)
+            throw new Error('Not yet initialized');
+        return this._attachment.server.cache;
+    }
+    /** 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: ''] */
+    /** set the tagging string the module should use in the logging of clients with empty string being module log identity [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] */
+    /** 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) */
+    /** 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() {
+    /** 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) */
+    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();
+        (async () => {
+            /* 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();
+            await this._drainTaskQueue(true, null);
+            try {
+                await this.handleStop();
+            }
+            catch (err) {
+                this.error(`Unhandled exception while stopping: ${err.message}`);
+            }
+            this.info('Handler stopped');
+            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.
 */
@@ -343,7 +343,7 @@ export class DispatchModule extends ModuleHandler {
         this.mapping = {};
         for (const [key, handler] of Object.entries(map)) {
             if (key in this.mapping) {
-                this.warning(`Ignoring duplicate mapping [${key}] by [${handler.logIdentity}]`);
+                this.warning(`Ignoring duplicate mapping [${key}] by [${handler.identity}]`);
                 continue;
             }
             this.mapping[key] = this.linkModule(handler, () => {
@@ -355,7 +355,7 @@ export class DispatchModule extends ModuleHandler {
         if (Object.keys(this.mapping).length == 0)
             this.stop();
     }
-    async handleRequest(client, _) {
+    async handleRequest(client) {
         let bestMatch = null;
         /* iterate over the mappings and look for the corresponding best handler */
         for (const path in this.mapping) {
@@ -365,14 +365,14 @@ export class DispatchModule extends ModuleHandler {
                 bestMatch = path;
         }
         if (bestMatch != null) {
-            client.trace(`Client dispatched to handler [${this.mapping[bestMatch].module.logIdentity}] for path [${bestMatch}]`);
+            client.trace(`Client dispatched to handler [${this.mapping[bestMatch].module.identity}] 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.
 */
@@ -386,7 +386,7 @@ export class HostModule extends ModuleHandler {
         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}]`);
+                this.warning(`Ignoring duplicate mapping of host [${host}] by [${handler.identity}]`);
                 continue;
             }
             this.mapping[host] = this.linkModule(handler, () => {
@@ -417,14 +417,14 @@ export class HostModule extends ModuleHandler {
                 bestMatch = host;
         }
         if (bestMatch != null) {
-            client.trace(`Client dispatched to handler [${this.mapping[bestMatch].module.logIdentity}] for host [${bestMatch}]`);
+            client.trace(`Client dispatched to handler [${this.mapping[bestMatch].module.identity}] 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.
@@ -447,7 +447,7 @@ export class BindModule extends ModuleHandler {
         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.
 */
@@ -495,7 +495,7 @@ export class CheckModule extends ModuleHandler {
         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.
 */

package/dist/helper.d.ts

@@ -1,8 +1,13 @@
 import * as libBase from "./base.js";
+/** lookup the encoding for a given name */
 export declare function lookupEncoding(name: string): libBase.EncodingType | null;
+/** list of all supported encodings */
 export declare function supportedEncodingNames(): string[];
+/** map extension of file-path/file-name to media type (null if no match was found) */
 export declare function lookupMediaTypeFromFile(filePath: string): libBase.MediaType | null;
+/** format the media type to the proper http header identifier */
 export declare function buildMediaTypeIdentifier(media: libBase.MediaType): string;
+/** does not respect 'no-identity' encoding requests; unknown at-least-size is considered valid (defaults 'identity' to null) */
 export declare function negotiateEncoding(accept: string | null, atLeastSize: number | null, media: libBase.MediaType): libBase.EncodingType | null;
 export declare enum RangeState {
     noRange = 0,
@@ -10,24 +15,42 @@ export declare enum RangeState {
     issue = 2,
     malformed = 3
 }
+/** parse an http header range request (first and last are correct for all valid range states; will be [0,-1] for an emtpy file) */
 export declare function parseRangeHeader(range: string | null, fileSize: number): {
     first: number;
     last: number;
     state: RangeState;
 };
+/** check if the [etag] matches the list (i.e. in list or list is '*'), will not match for undefined list; if [strong]
+*	comparison, both must be non-weak, opaque-tags equal (strip W/ prefix and compare opaque-tags regardless of weakness) */
 export declare function etagMatchesList(etag: string, header: string | null, strong: boolean): boolean;
+/** returns null on invalid times, [>0] for a being greater, [<0] for a being smaller, [=0] for same time */
 export declare function timestampCompare(a: string, b: string): number | null;
+/** split a list value while removing whitespace and optionally respecting quotes (returns empty list on validly quoted strings) */
 export declare function splitAndTrimList(content: string | null, separator: string, quotesAware: boolean): string[];
+/** escape all html-special characters to prevent injection when embedding untrusted values */
 export declare function escapeHtml(content: string): string;
+/** expand the placeholders in the content (format: {#name}, with '{#' being escaped as '{##'; optionally html-escape values) */
 export declare function expandPlaceholders(content: string, args: Record<string, string>, htmlEscape: boolean): string;
+/** escape all placeholders in the content */
 export declare function escapePlaceholders(content: string): string;
+/** sanitize path and remove relative path components and convert it to an absolute path */
 export declare function sanitize(path: string, relative: boolean): string;
+/** join two paths into the sanitized absolute server path-environment */
 export declare function joinSanitized(a: string, b: string): string;
+/** check if the sanitized path is a sub-path of or equal to the sanitized base path (can be /base or /base/...) */
 export declare function isSubPath(base: string, path: string): boolean;
+/** check if the sanitized path is a true sub-path of the sanitized base path (must be truly inside: /base/...) */
 export declare function isInside(base: string, path: string): boolean;
+/** return the remaining path for the sub directory path in base (must be a true sub-directory) */
 export declare function childPath(base: string, path: string): string;
+/** rebase the path from the old base directory onto the new base (must be a true sub-directory) */
 export declare function rebasePath(oldBase: string, newBase: string, path: string): string;
+/** create path-creator, which returns sanitized paths relative to [path] */
 export declare function createPathLocation(path: string): (path: string) => string;
-export declare function createPathSelf(urlFilePath: string, path?: string | null): (path: string) => string;
+/** create path-creator, which returns paths relative to the file url path (like the script itself using 'import.meta.url') and optionally changed by relative [path] */
+export declare function createPathSelf(urlFilePath: string, path?: string): (path: string) => string;
+/** split the path in three components ['/base/', 'name', '.extension'] (extension will be empty if the path
+*	does not contain a distinct extension; path will be empty if the path does not contain a distinct path) */
 export declare function splitFilePath(path: string): [string, string, string];
 //# sourceMappingURL=helper.d.ts.map