@ev-core/core 0.6.1 → 0.6.2

package/dist/esm/html/element-attributer.d.ts

@@ -0,0 +1,7 @@
+export declare function addAttrs(el?: HTMLElement, attrs?: {
+    [key: string]: string;
+}): void;
+export declare function removeAttrs(el?: HTMLElement, attrs?: {
+    [key: string]: string;
+}): void;
+//# sourceMappingURL=element-attributer.d.ts.map

package/dist/esm/html/element-attributer.js

@@ -0,0 +1,15 @@
+export function addAttrs(el, attrs) {
+    if (el && attrs) {
+        Object.keys(attrs).forEach(k => {
+            el.setAttribute(k, attrs[k]);
+        });
+    }
+}
+export function removeAttrs(el, attrs) {
+    if (el && attrs) {
+        Object.keys(attrs).forEach(k => {
+            el.removeAttribute(k);
+        });
+    }
+}
+//# sourceMappingURL=element-attributer.js.map

package/dist/esm/html/element-classer.d.ts

@@ -0,0 +1,3 @@
+export declare function removeClasses(el?: HTMLElement, classes?: string[] | string): void;
+export declare function addClasses(el?: HTMLElement, classes?: string[] | string): void;
+//# sourceMappingURL=element-classer.d.ts.map

package/dist/esm/html/element-classer.js

@@ -0,0 +1,13 @@
+export function removeClasses(el, classes) {
+    if (el && classes?.length) {
+        let list = typeof classes == 'string' ? classes.split(' ') : classes;
+        el.classList.remove(...list);
+    }
+}
+export function addClasses(el, classes) {
+    if (el && classes?.length) {
+        let list = typeof classes == 'string' ? classes.split(' ') : classes;
+        el.classList.add(...list);
+    }
+}
+//# sourceMappingURL=element-classer.js.map

package/dist/esm/html/element-listening.d.ts

@@ -0,0 +1,8 @@
+export declare function removeEventListeners(el?: HTMLElement, events?: IElementTogglerListener[]): void;
+export declare function addEventListeners(el?: HTMLElement, events?: IElementTogglerListener[]): void;
+export interface IElementTogglerListener {
+    key: string;
+    event: <K extends keyof HTMLElementEventMap>(ev: HTMLElementEventMap[K]) => any;
+    options?: boolean | AddEventListenerOptions;
+}
+//# sourceMappingURL=element-listening.d.ts.map

package/dist/esm/html/element-listening.js

@@ -0,0 +1,13 @@
+export function removeEventListeners(el, events) {
+    if (el && events?.length) {
+        events.forEach(e => {
+            el?.removeEventListener(e.key, e.event, e.options);
+        });
+    }
+}
+export function addEventListeners(el, events) {
+    if (el && events?.length) {
+        events.forEach(e => el.addEventListener(e.key, e.event, e.options));
+    }
+}
+//# sourceMappingURL=element-listening.js.map

package/dist/esm/html/element-manager.d.ts

@@ -0,0 +1,42 @@
+import { IElementTogglerListener } from "./element-listening";
+export declare class ElementManager implements IElementTogglerArgs {
+    private _counter;
+    get counter(): number;
+    el?: HTMLElement;
+    attrs: {
+        [key: string]: string;
+    };
+    css: Partial<CSSStyleDeclaration>;
+    classes: string[];
+    listeners: IElementTogglerListener[];
+    data: any;
+    static create: (args: IElementTogglerArgs) => ElementManager;
+    private constructor();
+    private setProperties;
+    private get mutableProperties();
+    get properties(): IElementTogglerArgs;
+    setElement(el: HTMLElement, cleanPrevious?: boolean): void;
+    apply(cb?: (args: IElementTogglerArgs) => void, cleanPrevious?: boolean): this;
+    private count;
+    remove(): this;
+    dispose(): void;
+    private removeListeners;
+    private removeClass;
+    private removeCss;
+    private removeAttrs;
+    private applyListeners;
+    private applyClass;
+    private applyCss;
+    private applyAttrs;
+}
+export interface IElementTogglerArgs {
+    el?: HTMLElement;
+    attrs?: {
+        [key: string]: string;
+    };
+    css?: Partial<CSSStyleDeclaration>;
+    classes?: string[];
+    listeners?: IElementTogglerListener[];
+    data?: any;
+}
+//# sourceMappingURL=element-manager.d.ts.map

package/dist/esm/html/element-manager.js

@@ -0,0 +1,115 @@
+import { addAttrs, removeAttrs } from "./element-attributer";
+import { addClasses, removeClasses } from "./element-classer";
+import { addEventListeners, removeEventListeners } from "./element-listening";
+import { addStyles, removeStyles } from "./element-styler";
+export class ElementManager {
+    get counter() { return this._counter; }
+    constructor(args) {
+        this._counter = 0;
+        this.setProperties(args);
+    }
+    setProperties(args) {
+        this.el = args.el;
+        this.css = args.css ?? {};
+        this.classes = args?.classes ?? [];
+        this.attrs = args?.attrs ?? {};
+        this.data = args?.data;
+    }
+    get mutableProperties() {
+        return {
+            el: this.el,
+            attrs: this.attrs,
+            classes: this.classes,
+            css: this.css,
+            listeners: this.listeners,
+            data: this.data,
+        };
+    }
+    ;
+    get properties() {
+        return {
+            attrs: Object.assign({}, this.attrs ?? {}),
+            classes: this.classes?.slice() ?? [],
+            css: Object.assign({}, this.css ?? {}),
+            data: this.data
+        };
+    }
+    setElement(el, cleanPrevious = true) {
+        if (cleanPrevious) {
+            this.remove();
+        }
+        this.el = el;
+    }
+    apply(cb, cleanPrevious = true) {
+        let current = this.mutableProperties;
+        if (cb) {
+            cb(current);
+        }
+        if (cleanPrevious) {
+            this.remove();
+        }
+        this.setProperties(current);
+        this
+            .applyListeners()
+            .applyClass()
+            .applyCss()
+            .applyAttrs()
+            .count();
+        return this;
+    }
+    count() {
+        this._counter++;
+        return this;
+    }
+    remove() {
+        return this
+            .removeListeners()
+            .removeClass()
+            .removeCss()
+            .removeAttrs();
+    }
+    dispose() {
+        this.removeListeners();
+        this.setProperties({
+            el: undefined,
+            attrs: {},
+            classes: [],
+            css: {},
+            listeners: []
+        });
+    }
+    removeListeners() {
+        removeEventListeners(this.el, this.listeners);
+        return this;
+    }
+    removeClass() {
+        removeClasses(this.el, this.classes);
+        return this;
+    }
+    removeCss() {
+        removeStyles(this.el, this.css);
+        return this;
+    }
+    removeAttrs() {
+        removeAttrs(this.el, this.attrs);
+        return this;
+    }
+    applyListeners() {
+        addEventListeners(this.el, this.listeners);
+        return this;
+    }
+    applyClass() {
+        addClasses(this.el, this.classes);
+        return this;
+    }
+    applyCss() {
+        addStyles(this.el, this.css);
+        return this;
+    }
+    applyAttrs() {
+        addAttrs(this.el, this.attrs);
+        return this;
+    }
+}
+ElementManager.create = (args) => new ElementManager(args);
+//# sourceMappingURL=element-manager.js.map

package/dist/esm/html/element-styler.d.ts

@@ -0,0 +1,3 @@
+export declare function addStyles(el?: HTMLElement, css?: Partial<CSSStyleDeclaration>): void;
+export declare function removeStyles(el?: HTMLElement, css?: Partial<CSSStyleDeclaration>): void;
+//# sourceMappingURL=element-styler.d.ts.map

package/dist/esm/html/element-styler.js

@@ -0,0 +1,15 @@
+export function addStyles(el, css) {
+    if (el && css) {
+        Object.keys(css).forEach(k => {
+            el.style[k] = css[k];
+        });
+    }
+}
+export function removeStyles(el, css) {
+    if (el && css) {
+        Object.keys(css).forEach(k => {
+            el.style[k] = undefined;
+        });
+    }
+}
+//# sourceMappingURL=element-styler.js.map

package/dist/esm/html/index.d.ts

@@ -0,0 +1,6 @@
+export * from './element-attributer';
+export * from './element-classer';
+export * from './element-listening';
+export * from './element-styler';
+export * from './element-manager';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/html/index.js

@@ -0,0 +1,6 @@
+export * from './element-attributer';
+export * from './element-classer';
+export * from './element-listening';
+export * from './element-styler';
+export * from './element-manager';
+//# sourceMappingURL=index.js.map

package/dist/esm/index.d.ts

@@ -0,0 +1,15 @@
+export * from './interfaces/disposable';
+export * as Htmler from './html';
+export * from './utils/array';
+export * from './utils/date';
+export * from './utils/file';
+export * from './utils/guid';
+export * from './utils/is-of';
+export * from './utils/mime-types';
+export * from './utils/name-of';
+export * from './utils/object';
+export * from './utils/slugify';
+export * from './utils/strings';
+export * from './utils/url';
+export * from './services/event-listener-service';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/index.js

@@ -0,0 +1,15 @@
+export * from './interfaces/disposable';
+export * as Htmler from './html';
+export * from './utils/array';
+export * from './utils/date';
+export * from './utils/file';
+export * from './utils/guid';
+export * from './utils/is-of';
+export * from './utils/mime-types';
+export * from './utils/name-of';
+export * from './utils/object';
+export * from './utils/slugify';
+export * from './utils/strings';
+export * from './utils/url';
+export * from './services/event-listener-service';
+//# sourceMappingURL=index.js.map

package/dist/esm/interfaces/disposable.d.ts

@@ -0,0 +1,4 @@
+export interface IDisposable {
+    dispose(): void;
+}
+//# sourceMappingURL=disposable.d.ts.map

package/dist/esm/interfaces/disposable.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=disposable.js.map

package/dist/esm/services/event-listener-service.d.ts

@@ -0,0 +1,23 @@
+import { IDisposable } from "../interfaces/disposable";
+export type TEventType = (keyof DocumentEventMap) | string;
+export declare class DomListenerService {
+    private listeners;
+    register(element: Document | HTMLElement, event: TEventType, callback: (event: Event) => void, capture?: boolean): DomListenerItem;
+    getListeners(): DomListenerItem[];
+    private remove;
+}
+export declare class DomListenerItem implements IDisposable {
+    readonly element: Document | HTMLElement | Window;
+    readonly event: TEventType;
+    private readonly callback;
+    readonly capture: boolean;
+    private removeCallback;
+    private isActive;
+    constructor(element: Document | HTMLElement | Window, event: TEventType, callback: (event: Event) => void, capture: boolean, removeCallback: (listener: DomListenerItem) => void);
+    activate(): this;
+    deactivate(): this;
+    dispose(): void;
+    private delayedAttach;
+    private attach;
+}
+//# sourceMappingURL=event-listener-service.d.ts.map

package/dist/esm/services/event-listener-service.js

@@ -0,0 +1,54 @@
+export class DomListenerService {
+    constructor() {
+        this.listeners = [];
+    }
+    register(element, event, callback, capture = false) {
+        const listener = new DomListenerItem(element, event, callback, capture, this.remove.bind(this));
+        this.listeners.push(listener);
+        return listener;
+    }
+    getListeners() {
+        return this.listeners;
+    }
+    remove(listener) {
+        const index = this.listeners.indexOf(listener);
+        if (index !== -1) {
+            this.listeners.splice(index, 1);
+        }
+    }
+}
+export class DomListenerItem {
+    constructor(element, event, callback, capture, removeCallback) {
+        this.element = element;
+        this.event = event;
+        this.callback = callback;
+        this.capture = capture;
+        this.removeCallback = removeCallback;
+        this.isActive = false;
+    }
+    activate() {
+        if (!this.isActive) {
+            this.delayedAttach();
+        }
+        return this;
+    }
+    deactivate() {
+        if (this.isActive) {
+            this.element.removeEventListener(this.event, this.callback, this.capture);
+            this.isActive = false;
+        }
+        return this;
+    }
+    dispose() {
+        this.deactivate();
+        this.removeCallback(this); // Notify the service to remove this from its tracking list
+    }
+    delayedAttach() {
+        setTimeout(() => { this.attach(); }, 0);
+    }
+    attach() {
+        this.element.addEventListener(this.event, this.callback, this.capture);
+        this.isActive = true;
+    }
+}
+//# sourceMappingURL=event-listener-service.js.map

package/dist/esm/utils/array.d.ts

@@ -0,0 +1,2 @@
+export declare function groupBy<T>(arr: T[], fn: (item: T) => any): Record<string, T[]>;
+//# sourceMappingURL=array.d.ts.map

package/dist/esm/utils/array.js

@@ -0,0 +1,9 @@
+export function groupBy(arr, fn) {
+    return arr.reduce((prev, curr) => {
+        const groupKey = fn(curr);
+        prev[groupKey] = prev[groupKey] || [];
+        prev[groupKey].push(curr);
+        return prev;
+    }, {});
+}
+//# sourceMappingURL=array.js.map

package/dist/esm/utils/date.d.ts

@@ -0,0 +1,3 @@
+export type DateParseValues = 'today' | string | number | Date;
+export declare function dateParse(value?: DateParseValues): Date;
+//# sourceMappingURL=date.d.ts.map

package/dist/esm/utils/date.js

@@ -0,0 +1,33 @@
+export function dateParse(value) {
+    if (value == undefined) {
+        return undefined;
+    }
+    if (value instanceof Date) {
+        return value;
+    }
+    if (typeof value == 'string') {
+        if (value.toLowerCase() == 'today') {
+            return new Date();
+        }
+        let v = new Date(String(value));
+        if (isValidDate(v)) {
+            return v;
+        }
+    }
+    let number = Number.parseInt(String(value));
+    if (Number.isInteger(number)) {
+        const d = new Date();
+        d.setDate(d.getDate() + number);
+        return d;
+    }
+    return undefined;
+}
+function isValidDate(date) {
+    try {
+        return Number.isInteger(date.getTime());
+    }
+    catch (e) {
+        return false;
+    }
+}
+//# sourceMappingURL=date.js.map

package/dist/esm/utils/file.d.ts

@@ -0,0 +1,16 @@
+export declare class FileinputCall {
+    private readonly doc;
+    private el;
+    constructor(doc?: Document);
+    call(opts?: IFileInputOptions): Promise<FileList>;
+    private init;
+    destroy(): void;
+}
+export interface IFileInputOptions {
+    multiple?: boolean;
+    accept?: string;
+    capture?: string;
+    webkitdirectory?: boolean;
+}
+export declare function saveAs(blob: File | Blob, filename: string, globalWindow?: Window & typeof globalThis): void;
+//# sourceMappingURL=file.d.ts.map

package/dist/esm/utils/file.js

@@ -0,0 +1,56 @@
+export class FileinputCall {
+    constructor(doc = document) {
+        this.doc = doc;
+        this.el = null;
+    }
+    call(opts) {
+        this.init(opts);
+        return new Promise((resolve) => {
+            this.el.onchange = () => {
+                const files = this.el.files;
+                this.destroy(); // Clean up after selection
+                resolve(files);
+            };
+            this.el.click();
+        });
+    }
+    init(opts) {
+        this.destroy();
+        this.el = this.doc.createElement('input');
+        this.el.type = 'file';
+        // Hide the input element
+        this.el.style.display = 'none';
+        // Append to the document to ensure the file picker works in all browsers
+        this.doc.body.appendChild(this.el);
+        // Allowed options for the file input element
+        const allowedOptions = [
+            'multiple',
+            'accept',
+            'capture',
+            'webkitdirectory',
+        ];
+        if (opts) {
+            allowedOptions.forEach((key) => {
+                if (opts[key] !== undefined) {
+                    this.el[key] = opts[key];
+                }
+            });
+        }
+    }
+    destroy() {
+        if (this.el && this.el.parentElement) {
+            this.el.parentElement.removeChild(this.el);
+            this.el = null;
+        }
+    }
+}
+export function saveAs(blob, filename, globalWindow = window) {
+    const a = globalWindow.document.createElementNS('http://www.w3.org/1999/xhtml', 'a');
+    a.download = filename;
+    a.rel = 'noopener';
+    a.href = globalWindow.URL.createObjectURL(blob);
+    const timeout = 40 * 1000;
+    globalWindow.setTimeout(() => URL.revokeObjectURL(a.href), timeout);
+    globalWindow.setTimeout(() => a.click(), 0);
+}
+//# sourceMappingURL=file.js.map

package/dist/esm/utils/guid.d.ts

@@ -0,0 +1,2 @@
+export declare function uuidv4(): string;
+//# sourceMappingURL=guid.d.ts.map

package/dist/esm/utils/guid.js

@@ -0,0 +1,7 @@
+export function uuidv4() {
+    return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, c => {
+        const parsed = Number.parseInt(c);
+        return (parsed ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> parsed / 4).toString(16);
+    });
+}
+//# sourceMappingURL=guid.js.map

package/dist/esm/utils/is-of.d.ts

@@ -0,0 +1,10 @@
+type InstanceType = 'string' | 'number' | 'boolean' | 'bigint' | 'function' | 'symbol' | 'undefined' | Object | any;
+export declare function isPrimitive(arg: any): boolean;
+export declare function typeOf(obj: any): any;
+export declare function instanceOf(obj: any, type: InstanceType): any;
+export declare function isString(obj: any): obj is string;
+export declare function isNumber(obj: any): obj is number;
+export declare function isBool(obj: any): obj is boolean;
+export declare function isDate(obj: any): obj is Date;
+export {};
+//# sourceMappingURL=is-of.d.ts.map

package/dist/esm/utils/is-of.js

@@ -0,0 +1,29 @@
+export function isPrimitive(arg) {
+    const type = typeof arg;
+    return arg == null || (type != "object" && type != "function");
+}
+export function typeOf(obj) { return Object.getPrototypeOf(obj).constructor; }
+export function instanceOf(obj, type) {
+    if (isPrimitive(obj)) {
+        return typeof obj === type;
+    }
+    const objType = typeOf(obj);
+    return (
+    // Allow native instanceof in case of Symbol.hasInstance
+    obj instanceof type ||
+        // Handle case where is of type type
+        typeof obj === type ||
+        // Handle general case
+        type.isPrototypeOf(objType) ||
+        // Handle special case where type.prototype acts as a
+        // prototype of the object but its type isn't in the
+        // prototype chain of the obj's type
+        // OPTIONALLY remove this case if you don't want
+        // primitives to be considered instances of Object
+        type.prototype.isPrototypeOf(objType.prototype));
+}
+export function isString(obj) { return typeof obj === 'string'; }
+export function isNumber(obj) { return typeof obj === 'number'; }
+export function isBool(obj) { return typeof obj === 'boolean'; }
+export function isDate(obj) { return obj instanceof Date; }
+//# sourceMappingURL=is-of.js.map

package/dist/esm/utils/mime-types.d.ts

@@ -0,0 +1,23 @@
+declare class MimeType {
+    readonly type: string;
+    readonly exts: string[];
+    constructor(type: string, exts: string[]);
+}
+declare class MimeGroup {
+    readonly name: string;
+    readonly types: MimeType[];
+    constructor(name: string, types: MimeType[]);
+    findExtension(type: string): string;
+    findExtensions(type: string): string[];
+    findType(extension: string): string;
+}
+export declare const imageMimeTypes: MimeType[];
+declare class MimeFinder {
+    readonly image: MimeGroup;
+    findExtension(type: string): MimeGroup;
+    findExtensions(type: string): MimeGroup;
+    findType(type: string): MimeGroup;
+}
+export declare const mimes: MimeFinder;
+export {};
+//# sourceMappingURL=mime-types.d.ts.map

package/dist/esm/utils/mime-types.js

@@ -0,0 +1,54 @@
+class MimeType {
+    constructor(type, exts) {
+        this.type = type;
+        this.exts = exts;
+    }
+}
+class MimeGroup {
+    constructor(name, types) {
+        this.name = name;
+        this.types = types;
+    }
+    findExtension(type) {
+        return this.types.find(e => e.type == type)?.exts?.find(e => e);
+    }
+    findExtensions(type) {
+        return this.types.find(e => e.type == type)?.exts;
+    }
+    findType(extension) {
+        return this.types.find(t => t.exts.some(e => e == extension))?.type;
+    }
+}
+export const imageMimeTypes = [
+    new MimeType('image/gif', ['gif']),
+    new MimeType('image/jpeg', ['jpeg', 'jpg']),
+    new MimeType('image/png', ['png']),
+    new MimeType('image/apng', ['apng']),
+    new MimeType('image/tiff', ['tif', 'tiff']),
+    new MimeType('image/vnd.wap.wbmp', ['wbmp']),
+    new MimeType('image/x-icon', ['ico']),
+    new MimeType('image/x-jng', ['jng']),
+    new MimeType('image/x-ms-bmp', ['bmp']),
+    new MimeType('image/svg+xml', ['svg']),
+    new MimeType('image/webp', ['webp']),
+    new MimeType('image/avif', ['avif'])
+];
+class MimeFinder {
+    constructor() {
+        this.image = new MimeGroup('image', imageMimeTypes);
+    }
+    findExtension(type) {
+        return [this.image]
+            .find(x => x.findExtension(type));
+    }
+    findExtensions(type) {
+        return [this.image]
+            .find(x => x.findExtensions(type));
+    }
+    findType(type) {
+        return [this.image]
+            .find(x => x.findType(type));
+    }
+}
+export const mimes = new MimeFinder();
+//# sourceMappingURL=mime-types.js.map

package/dist/esm/utils/name-of.d.ts

@@ -0,0 +1,2 @@
+export declare function nameof<T>(selector: (s: T) => any, deep?: boolean): string;
+//# sourceMappingURL=name-of.d.ts.map

package/dist/esm/utils/name-of.js

@@ -0,0 +1,10 @@
+export function nameof(selector, deep = true) {
+    const s = '' + selector;
+    const m = s.match(/return\s+([A-Z0-9$_.]+)/i)
+        || s.match(/.*?(?:=>|function.*?{(?!\s*return))\s*([A-Z0-9$_.]+)/i);
+    const name = m && m[1] || "";
+    const splitted = name.split('.');
+    splitted.shift();
+    return deep ? splitted.join('.') : splitted.pop() ?? '';
+}
+//# sourceMappingURL=name-of.js.map

package/dist/esm/utils/object.d.ts

@@ -0,0 +1,2 @@
+export declare function trimStrings(obj: Object): void;
+//# sourceMappingURL=object.d.ts.map

package/dist/esm/utils/object.js

@@ -0,0 +1,14 @@
+export function trimStrings(obj) {
+    Object.keys(obj).forEach(key => {
+        if (!obj[key]) {
+            return;
+        }
+        if (typeof obj[key] === 'string') {
+            obj[key] = obj[key].trim();
+        }
+        else if (typeof obj[key] === 'object') {
+            trimStrings(obj[key]);
+        }
+    });
+}
+//# sourceMappingURL=object.js.map

package/dist/esm/utils/slugify.d.ts

@@ -0,0 +1,2 @@
+export declare function slugify(string: any): any;
+//# sourceMappingURL=slugify.d.ts.map

package/dist/esm/utils/slugify.js

@@ -0,0 +1,14 @@
+export function slugify(string) {
+    const a = 'àáäâãåăæçèéëêǵḧìíïîḿńǹñòóöôœøṕŕßśșțùúüûǘẃẍÿź·/_,:;';
+    const b = 'aaaaaaaaceeeeghiiiimnnnooooooprssstuuuuuwxyz------';
+    const p = new RegExp(a.split('').join('|'), 'g');
+    return string.toString().toLowerCase()
+        .replace(/\s+/g, '-') // Replace spaces with -
+        .replace(p, c => b.charAt(a.indexOf(c))) // Replace special characters
+        .replace(/&/g, '-and-') // Replace & with 'and'
+        .replace(/[^\w\-]+/g, '') // Remove all non-word characters
+        .replace(/\-\-+/g, '-') // Replace multiple - with single -
+        .replace(/^-+/, '') // Trim - from start of text
+        .replace(/-+$/, ''); // Trim - from end of text
+}
+//# sourceMappingURL=slugify.js.map

package/dist/esm/utils/strings.d.ts

@@ -0,0 +1,3 @@
+export declare const kebabize: (str: any) => any;
+export declare function trimWhiteSpace(s: string, allOccurences?: boolean): string;
+//# sourceMappingURL=strings.d.ts.map

package/dist/esm/utils/strings.js

@@ -0,0 +1,5 @@
+export const kebabize = (str) => str.replace(/[A-Z]+(?![a-z])|[A-Z]/g, ($, ofs) => (ofs ? "-" : "") + $.toLowerCase());
+export function trimWhiteSpace(s, allOccurences = true) {
+    return s.replace(new RegExp('\\s', allOccurences ? 'g' : undefined), "");
+}
+//# sourceMappingURL=strings.js.map

package/dist/esm/utils/url.d.ts

@@ -0,0 +1,2 @@
+export declare function urlCombine(...parts: string[]): string;
+//# sourceMappingURL=url.d.ts.map

package/dist/esm/utils/url.js

@@ -0,0 +1,4 @@
+export function urlCombine(...parts) {
+    return parts.join("/").replace(/([^:]\/)\/+/g, "$1");
+}
+//# sourceMappingURL=url.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ev-core/core",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "Core library for ev-core",
   "types": "dist/esm/index.d.ts",
   "module": "dist/esm/index.mjs",
@@ -22,6 +22,6 @@
     "clean": "rimraf dist && mkdir dist",
     "build": "pnpm run build:cjs && pnpm run build:esm",
     "build:cjs": "tsc -p tsconfig.cjs.json",
-    "build:esm": "tsc -p tsconfig.esm.json && ts2mjs dist/esm --remove-source"
+    "build:esm": "tsc -p tsconfig.esm.json && ts2mjs dist/esm"
   }
 }