@appartmint/mint 5.0.3 → 5.0.4

package/dist/{js/imports → imports}/util/object.d.ts

@@ -1,11 +1,11 @@
 /**
  * Object functions for the util library
  */
-export declare abstract class MintObject {
+export declare const MintObject: {
     /**
      * Returns true if the provided objects have the same entries
      */
-    static isSimilar(obj1: any, obj2: any): boolean;
+    isSimilar(obj1: Record<string, unknown>, obj2: Record<string, unknown>): boolean;
     /**
      * Returns true if the first object has at least the same
      * entries as the second object
@@ -13,69 +13,68 @@ export declare abstract class MintObject {
      * @param subset - the object whose entries are required
      * @returns - true if the first object is a superset of the second
      */
-    static isSuperset(superset: any, subset: any): boolean;
+    isSuperset(superset: unknown, subset: unknown): boolean;
     /**
      * Removes object entries by key
      * @see mintObject.removeKeys
      * @param object - the object to remove entries from
      * @param keys - the keys to remove
      */
-    static remove(object: any, keys: string[]): Object;
+    remove(object: Record<string, unknown>, keys: string[]): Record<string, unknown>;
     /**
      * Removes object entries by key
      * @param object - the object to remove entries from
      * @param keys - the keys to remove
      */
-    static removeKeys(object: any, keys: string[]): any;
+    removeKeys(object: Record<string, unknown>, keys: string[]): Record<string, unknown>;
     /**
      * Removes object entries by value
      */
-    static removeValues(object: any, values: any[]): any;
+    removeValues(object: Record<string, unknown>, values: unknown[]): Record<string, unknown>;
     /**
      * Sorts an object's entries alphabetically by key
      */
-    static sort(object: any, compareFn?: (a: string, b: string) => number): any;
+    sort(object: Record<string, unknown>, compareFn?: (a: string, b: string) => number): Record<string, unknown>;
     /**
      * Sorts an object's entries alphabetically by key
      */
-    static sortKeys(object: any, compareFn?: (a: string, b: string) => number): any;
+    sortKeys(object: Record<string, unknown>, compareFn?: (a: string, b: string) => number): Record<string, unknown>;
     /**
      * Sorts an object's entries alphabetically by value
      */
-    static sortValues(object: any, compareFn: (a: any, b: any) => number): any;
+    sortValues(object: Record<string, unknown>, compareFn: (a: unknown, b: unknown) => number): Record<string, unknown>;
     /**
      * @see mintObject.filterKeys
      */
-    static filter(object: any, keys: string[]): Object;
+    filter(object: Record<string, unknown>, keys: string[]): Record<string, unknown>;
     /**
      * Filters an object by its keys
      * @param object - the object to filter
      * @param keys - the keys to keep
      * @returns - the filtered object
      */
-    static filterKeys(object: any, keys: string[]): Object;
+    filterKeys(object: Record<string, unknown>, keys: string[]): Record<string, unknown>;
     /**
      * Filters an object by its values
      * @param object - the object to filter
      * @param values - the values to keep
      * @returns - the filtered object
      */
-    static filterValues(object: any, values: any[]): Object;
+    filterValues(object: Record<string, unknown>, values: unknown[]): Record<string, unknown>;
     /**
      * Update two sets of objects
      * @param original - the original object
      * @param update - the object to update the original with
      * @returns - the original objects with updated data from the update
      */
-    static updateArray(original: any[], update?: any[], key?: string): any;
+    updateArray(original: Record<string, unknown>[], update?: Record<string, unknown>[], key?: string): void;
     /**
      * Get an object's key by value
      */
-    static getKeyByValue(object: any, value: any): string | undefined;
+    getKeyByValue(object: Record<string, unknown>, value: unknown): string | undefined;
     /**
      * Create a deep copy of an object
      */
-    static deepClone<T>(object: T): T;
-}
+    deepClone<T>(object: T): T;
+};
 export default MintObject;
-//# sourceMappingURL=object.d.ts.map

package/dist/imports/util/object.esm.js

@@ -0,0 +1,115 @@
+//#region src/ts/imports/util/object.ts
+var e = {
+	isSimilar(e, t) {
+		let n = Object.keys(e);
+		if (n.length !== Object.keys(t).length) return !1;
+		let r = !0;
+		return n.forEach((n) => {
+			e[n] !== t[n] && (r = !1);
+		}), r;
+	},
+	isSuperset(t, n) {
+		let r = !0;
+		if (t === n) return r;
+		try {
+			if (Object.keys(n).length === 0) return !r;
+		} catch {
+			return !r;
+		}
+		let i = n, a = t ?? {};
+		return Object.keys(i).forEach((t) => {
+			r &&= e.isSuperset(a[t], i[t]);
+		}), r;
+	},
+	remove(t, n) {
+		return e.removeKeys(t, n);
+	},
+	removeKeys(e, t) {
+		return Object.keys(e).reduce((n, r) => (t.includes(r) || (n[r] = e[r]), n), {});
+	},
+	removeValues(e, t) {
+		return Object.keys(e).reduce((n, r) => (t.includes(e[r]) || (n[r] = e[r]), n), {});
+	},
+	sort(t, n) {
+		return e.sortKeys(t, n);
+	},
+	sortKeys(e, t) {
+		return Object.keys(e).sort(t).reduce((t, n) => (t[n] = e[n], t), {});
+	},
+	sortValues(e, t) {
+		return Object.keys(e).sort((n, r) => t(e[n], e[r])).reduce((t, n) => (t[n] = e[n], t), {});
+	},
+	filter(t, n) {
+		return e.filterKeys(t, n);
+	},
+	filterKeys(e, t) {
+		return t.reduce((t, n) => (t[n] = e[n], t), {});
+	},
+	filterValues(e, t) {
+		return Object.keys(e).reduce((n, r) => (t.includes(e[r]) && (n[r] = e[r]), n), {});
+	},
+	updateArray(e, t, n = "id") {
+		let r = (e) => typeof e == "string" || typeof e == "number" ? String(e) : "";
+		if (!t?.length) return;
+		let i = t.reduce((e, t) => ({
+			...e,
+			[r(t[n])]: t
+		}), {});
+		e.filter((e) => !(r(e[n]) in i)).forEach((t) => {
+			let n = e.indexOf(t);
+			n !== -1 && e.splice(n, 1);
+		}), e.forEach((e) => {
+			let t = r(e[n]);
+			t in i && Object.assign(e, i[t]);
+		}), t.filter((t) => !e.some((e) => e[n] === t[n])).forEach((t) => e.push(t));
+	},
+	getKeyByValue(e, t) {
+		return Object.keys(e).find((n) => e[n] === t);
+	},
+	deepClone(e) {
+		if (typeof e != "object" || !e) return e;
+		let t = /* @__PURE__ */ new WeakMap(), n = [[e, Array.isArray(e) ? [] : {}]];
+		for (; n.length;) {
+			let e = n.pop();
+			if (!e) break;
+			let [r, i, a] = e;
+			if (a !== void 0) {
+				let e = r[a];
+				if (typeof e == "function") {
+					i[a] = e.bind(i);
+					continue;
+				}
+				if (typeof e != "object" || !e) {
+					i[a] = e;
+					continue;
+				}
+				if (t.has(e)) {
+					i[a] = t.get(e);
+					continue;
+				}
+				i[a] = Array.isArray(e) ? [] : {}, t.set(e, i[a]), n.push([e, i[a]]);
+			} else {
+				if (t.set(r, i), Array.isArray(r)) {
+					r.forEach((e, t) => {
+						n.push([
+							r,
+							i,
+							t
+						]);
+					});
+					continue;
+				}
+				Object.keys(r).forEach((e) => {
+					n.push([
+						r,
+						i,
+						e
+					]);
+				});
+			}
+		}
+		return t.get(e);
+	}
+};
+//#endregion
+export { e as MintObject, e as default };

package/dist/imports/util/scroll.cjs.js

@@ -0,0 +1 @@
+Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:`Module`}});const e=require("./event.cjs.js");var t={toTop(){window.scrollTo(0,0)},toBottom(){window.scrollTo(0,document.body.scrollHeight)},showElements(){requestAnimationFrame(()=>{let e=document.querySelectorAll(`.mint-fall-in:not(.mint-show)`),t=[];for(let n of e)n.getBoundingClientRect().top<0?n.classList.add(`mint-show`):n.getBoundingClientRect().top<window.innerHeight*3/4&&t.push(n);for(let e=0;e<t.length;e++)setTimeout(()=>{t[e].classList.add(`mint-show`)},e*100)})},showElementsOnScroll(){window.addEventListener(`scroll`,e.MintEvent.throttleEvent(()=>{t.showElements()},200))}};exports.MintScroll=t,exports.default=t;

package/dist/{js/imports → imports}/util/scroll.d.ts

@@ -1,23 +1,22 @@
 /**
  * Scroll functions
  */
-export declare abstract class MintScroll {
+export declare const MintScroll: {
     /**
      * Scroll to the top of the page
      */
-    static toTop(): void;
+    toTop(): void;
     /**
      * Scroll to the bottom of the page
      */
-    static toBottom(): void;
+    toBottom(): void;
     /**
      * Show visible elements
      */
-    static showElements(): void;
+    showElements(): void;
     /**
      * Show visible elements on scroll
      */
-    static showElementsOnScroll(): void;
-}
+    showElementsOnScroll(): void;
+};
 export default MintScroll;
-//# sourceMappingURL=scroll.d.ts.map

package/dist/imports/util/scroll.esm.js

@@ -0,0 +1,26 @@
+import { MintEvent as e } from "./event.esm.js";
+//#region src/ts/imports/util/scroll.ts
+var t = {
+	toTop() {
+		window.scrollTo(0, 0);
+	},
+	toBottom() {
+		window.scrollTo(0, document.body.scrollHeight);
+	},
+	showElements() {
+		requestAnimationFrame(() => {
+			let e = document.querySelectorAll(".mint-fall-in:not(.mint-show)"), t = [];
+			for (let n of e) n.getBoundingClientRect().top < 0 ? n.classList.add("mint-show") : n.getBoundingClientRect().top < window.innerHeight * 3 / 4 && t.push(n);
+			for (let e = 0; e < t.length; e++) setTimeout(() => {
+				t[e].classList.add("mint-show");
+			}, e * 100);
+		});
+	},
+	showElementsOnScroll() {
+		window.addEventListener("scroll", e.throttleEvent(() => {
+			t.showElements();
+		}, 200));
+	}
+};
+//#endregion
+export { t as MintScroll, t as default };

package/dist/imports/util/selectors.cjs.js

@@ -0,0 +1,8 @@
+Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:`Module`}});var e=`mint`,t=`${e}-`,n=`[disabled]`,r=`[aria-controls]`,i=`[aria-expanded]`,a=`[href]`,o=`[routerLink]`,s=`[id]`,c=`[tabindex^="-"]`;function l(e){return`:not(${e})`}var u=`[tabindex]${l(c)}`,d=`input${l(n)}${l(c)},
+							select${l(n)}${l(c)},
+							textarea${l(n)}${l(c)},
+							button${l(n)}${l(c)},
+							object${l(n)}${l(c)},
+							a${a}, a${o},
+							area${a},
+							${u}`.replace(/\s/g,``),f=`button${r}`,p={lib:e,pre:t,disabled:n,hasControls:r,hasExpanded:i,hasLink:a,hasRouterLink:o,hasId:s,notTabbable:c,tabbable:u,focusable:d,subMenuButtons:f,subMenu:`${f} + ul${s}`,prefix(e){return e=e.toLowerCase(),e.startsWith(t)?e:`${t}${e}`},cssPrefix(e){return`--${p.prefix(e.replace(/^-+/,``))}`},cssVar(e){return`var(${p.cssPrefix(e)})`},neg:l,class(e){return`.${p.prefix(e)}`},id(e){return`#${p.prefix(e)}`},controls(e){return e?`[aria-controls="${p.prefix(e)}"]`:r},expanded(e){return typeof e==`boolean`?`[aria-expanded="${String(e)}"]`:i},getFocusables(e){let t;return t=e?Array.from(e.querySelectorAll(d)):Array.from(document.querySelectorAll(d)),t.filter(e=>p.isFocusable(e))},isFocusable(e){let t=e;do{if(window.getComputedStyle(t).getPropertyValue(`display`).toLowerCase()===`none`)return!1;t=t.parentElement}while(t);return!0}};exports.MintSelectors=p,exports.default=p;

package/dist/{js/imports → imports}/util/selectors.d.ts

@@ -1,114 +1,72 @@
-/**
- * CSS-selector helpers
- * @public
- */
-export declare abstract class MintSelectors {
-    /**
-     * The library name that will be added as a prefix
-     */
-    static lib: string;
-    /**
-     * The prefix built from the library name
-     */
-    static pre: string;
-    /**
-     * CSS-selector for disabled elements
-     */
-    static disabled: string;
-    /**
-     * CSS-selector for elements with an aria-controls attribute
-     */
-    static hasControls: string;
-    /**
-     * CSS-selector for elements with an aria-expanded attribute
-     */
-    static hasExpanded: string;
-    /**
-     * CSS-selector for elements with an href attribute
-     */
-    static hasLink: string;
-    /**
-     * CSS-selector for elements with a routerLink attribute
-     */
-    static hasRouterLink: string;
-    /**
-     * CSS-selector for elements with an id attribute
-     */
-    static hasId: string;
-    /**
-     * CSS-selector for elements that aren't tabbable (i.e. tabindex is negative)
-     */
-    static notTabbable: string;
-    /**
-     * CSS-selector for elements that are tabbable (i.e. tabindex isn't negative)
-     */
-    static tabbable: string;
-    /**
-     * CSS-selector for elements that can receive focus
-     */
-    static focusable: string;
-    /**
-     * CSS-selector for submenu buttons
-     */
-    static subMenuButtons: string;
-    /**
-     * CSS-selector for submenus
-     */
-    static subMenu: string;
+declare function neg(base: string): string;
+export declare const MintSelectors: {
+    lib: string;
+    pre: string;
+    disabled: string;
+    hasControls: string;
+    hasExpanded: string;
+    hasLink: string;
+    hasRouterLink: string;
+    hasId: string;
+    notTabbable: string;
+    tabbable: string;
+    focusable: string;
+    subMenuButtons: string;
+    subMenu: string;
     /**
      * Adds the library prefix to the beginning of the provided string
      * @param base - the string to be prefixed
      * @returns - the provided string prefixed with the library name
      */
-    static prefix(base: string): string;
+    prefix(base: string): string;
     /**
      * Adds two dashes to the beginning of the provided string
      * @param base - the string to be prefixed
      * @returns - the provided string prefixed with two dashes
      */
-    static cssPrefix(base: string): string;
+    cssPrefix(base: string): string;
     /**
      * Turns the provided string into a CSS variable call
      * @param base - the name of the CSS variable to call
      * @returns - the CSS variable call for the provided string
      */
-    static cssVar(base: string): string;
+    cssVar(base: string): string;
     /**
      * Negates the provided CSS selector
      * @param base - the CSS selector to negate
      * @returns - the negated CSS selector
      */
-    static neg(base: string): string;
+    neg: typeof neg;
     /**
      * Generates a class CSS selector
      * @param base - the name of the class to generate
      * @returns - the generated CSS selector
      */
-    static class(base: string): string;
+    class(base: string): string;
     /**
      * Generates an id CSS selector
      * @param base - the name of the id to generate
      * @returns - the generated CSS selector
      */
-    static id(base: string): string;
+    id(base: string): string;
     /**
      * Generates an aria-controls CSS selector
      * @param id - the id of the controlled element
      * @returns - the generated CSS selector
      */
-    static controls(id?: string | null): string;
+    controls(id?: string | null): string;
     /**
      * Generates an aria-expanded CSS selector
      * @param bool - whether the element is expanded or not
      * @returns - the generated CSS selector
      */
-    static expanded(bool?: boolean | null): string;
+    expanded(bool?: boolean | null): string;
     /**
      * Returns a NodeList of HTMLElements within the given element that are focusable
      * @param el - the element whose focusable children will be returned
      * @returns - the elements within the given element that are focusable
      */
-    static getFocusables(el?: HTMLElement | null): HTMLElement[];
+    getFocusables(el?: HTMLElement | null): HTMLElement[];
     /**
      * Returns true if an element is focusable and false if not,
      * based on styles (i.e. a parent has display: none;)
@@ -116,7 +74,6 @@ export declare abstract class MintSelectors {
      * @param el - the element
      * @returns - true if the element is focusable; false if not
      */
-    static isFocusable(el: HTMLElement): boolean;
-}
+    isFocusable(el: HTMLElement): boolean;
+};
 export default MintSelectors;
-//# sourceMappingURL=selectors.d.ts.map

package/dist/imports/util/selectors.esm.js

@@ -0,0 +1,63 @@
+//#region src/ts/imports/util/selectors.ts
+var e = "mint", t = `${e}-`, n = "[disabled]", r = "[aria-controls]", i = "[aria-expanded]", a = "[href]", o = "[routerLink]", s = "[id]", c = "[tabindex^=\"-\"]";
+function l(e) {
+	return `:not(${e})`;
+}
+var u = `[tabindex]${l(c)}`, d = `input${l(n)}${l(c)},
+							select${l(n)}${l(c)},
+							textarea${l(n)}${l(c)},
+							button${l(n)}${l(c)},
+							object${l(n)}${l(c)},
+							a${a}, a${o},
+							area${a},
+							${u}`.replace(/\s/g, ""), f = `button${r}`, p = {
+	lib: e,
+	pre: t,
+	disabled: n,
+	hasControls: r,
+	hasExpanded: i,
+	hasLink: a,
+	hasRouterLink: o,
+	hasId: s,
+	notTabbable: c,
+	tabbable: u,
+	focusable: d,
+	subMenuButtons: f,
+	subMenu: `${f} + ul${s}`,
+	prefix(e) {
+		return e = e.toLowerCase(), e.startsWith(t) ? e : `${t}${e}`;
+	},
+	cssPrefix(e) {
+		return `--${p.prefix(e.replace(/^-+/, ""))}`;
+	},
+	cssVar(e) {
+		return `var(${p.cssPrefix(e)})`;
+	},
+	neg: l,
+	class(e) {
+		return `.${p.prefix(e)}`;
+	},
+	id(e) {
+		return `#${p.prefix(e)}`;
+	},
+	controls(e) {
+		return e ? `[aria-controls="${p.prefix(e)}"]` : r;
+	},
+	expanded(e) {
+		return typeof e == "boolean" ? `[aria-expanded="${String(e)}"]` : i;
+	},
+	getFocusables(e) {
+		let t;
+		return t = e ? Array.from(e.querySelectorAll(d)) : Array.from(document.querySelectorAll(d)), t.filter((e) => p.isFocusable(e));
+	},
+	isFocusable(e) {
+		let t = e;
+		do {
+			if (window.getComputedStyle(t).getPropertyValue("display").toLowerCase() === "none") return !1;
+			t = t.parentElement;
+		} while (t);
+		return !0;
+	}
+};
+//#endregion
+export { p as MintSelectors, p as default };

package/dist/imports/util/settings.cjs.js

@@ -0,0 +1 @@
+Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:`Module`}});var e={delayBase:0,delayStep:100,delay:{instant:0,fast:100,medFast:200,default:300,medSlow:400,slow:500},break:{z:0,xs:480,sm:768,md:1024,lg:1200,xl:1440},set(t){let n=!1;typeof t.delayBase==`number`&&(e.delayBase=t.delayBase,n=!0),typeof t.delayStep==`number`&&(e.delayStep=t.delayStep,n=!0),n&&e.setDelay(),t.delay&&Object.keys(t.delay).length&&Object.values(t.delay).every(e=>typeof e==`number`)&&(e.delay={...e.delay,...t.delay}),t.break&&Object.keys(t.break).length&&Object.values(t.break).every(e=>typeof e==`number`)&&(e.break={...e.break,...t.break})},setDelay(){e.delay={instant:e.delayBase+e.delayStep*0,fast:e.delayBase+e.delayStep*1,medFast:e.delayBase+e.delayStep*2,default:e.delayBase+e.delayStep*3,medSlow:e.delayBase+e.delayStep*4,slow:e.delayBase+e.delayStep*5}}};exports.MintSettings=e,exports.default=e;

package/dist/imports/util/settings.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Settings management
+ * @public
+ */
+export interface MintSettingsUpdate {
+    delayBase?: number;
+    delayStep?: number;
+    delay?: Record<string, number>;
+    break?: Record<string, number>;
+}
+export declare const MintSettings: {
+    /**
+     * Value added to all delay variables
+     */
+    delayBase: number;
+    /**
+     * Value multiplied by delay variable index
+     */
+    delayStep: number;
+    /**
+     * Delay variables
+     */
+    delay: Record<string, number>;
+    /**
+     * Breakpoint variables
+     */
+    break: Record<string, number>;
+    /**
+     * Update the provided settings variables
+     * @param settings - Object of settings variables to update
+     */
+    set(settings: MintSettingsUpdate): void;
+    /**
+     * Updates the delay variables based on `delayBase` and `delayStep`
+     */
+    setDelay(): void;
+};
+export default MintSettings;

package/dist/imports/util/settings.esm.js

@@ -0,0 +1,43 @@
+//#region src/ts/imports/util/settings.ts
+var e = {
+	delayBase: 0,
+	delayStep: 100,
+	delay: {
+		instant: 0,
+		fast: 100,
+		medFast: 200,
+		default: 300,
+		medSlow: 400,
+		slow: 500
+	},
+	break: {
+		z: 0,
+		xs: 480,
+		sm: 768,
+		md: 1024,
+		lg: 1200,
+		xl: 1440
+	},
+	set(t) {
+		let n = !1;
+		typeof t.delayBase == "number" && (e.delayBase = t.delayBase, n = !0), typeof t.delayStep == "number" && (e.delayStep = t.delayStep, n = !0), n && e.setDelay(), t.delay && Object.keys(t.delay).length && Object.values(t.delay).every((e) => typeof e == "number") && (e.delay = {
+			...e.delay,
+			...t.delay
+		}), t.break && Object.keys(t.break).length && Object.values(t.break).every((e) => typeof e == "number") && (e.break = {
+			...e.break,
+			...t.break
+		});
+	},
+	setDelay() {
+		e.delay = {
+			instant: e.delayBase + e.delayStep * 0,
+			fast: e.delayBase + e.delayStep * 1,
+			medFast: e.delayBase + e.delayStep * 2,
+			default: e.delayBase + e.delayStep * 3,
+			medSlow: e.delayBase + e.delayStep * 4,
+			slow: e.delayBase + e.delayStep * 5
+		};
+	}
+};
+//#endregion
+export { e as MintSettings, e as default };

package/dist/imports/util/text.cjs.js

@@ -0,0 +1,8 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});var e={truncate(e,t=100){return e.length>t?e.slice(0,t).trim()+`...`:e},slug(e){return e?.trim().toLowerCase().replace(/'/g,``).replace(/[^\w/-]+/g,`-`).replace(/-+/g,`-`).replace(/^-+|-+$/g,``).replace(/^\/+|\/+$/g,``)??``},unslug(t){return e.titleCase(t.replace(/[-/]+/g,` `))},phone(e){let t=e?.toString().trim()??``;if(t===`(`||t===``)return t;let n=t.replace(/\D/g,``),r=``;n.length>10&&(r+=`+${n.slice(0,n.length-10)} `,n=n.slice(n.length-10));let i=0;for(;i<n.length;i++){switch(i){case 0:r+=`(`;break;case 3:r+=`) `;break;case 6:r+=`-`;break}r+=n[i]}switch(t[t.length-1]){case`)`:i===3&&(r+=`) `);break;case`-`:i===6&&(r+=`-`);break}return r},plural(e){return e.endsWith(`ies`)||e.endsWith(`es`)||e.endsWith(`s`)&&!e.endsWith(`us`)&&!e.endsWith(`is`)&&!e.endsWith(`ss`)?e:e.endsWith(`y`)&&![`a`,`e`,`i`,`o`,`u`].includes(e.charAt(e.length-2))?e.slice(0,-1)+`ies`:e.endsWith(`s`)||e.endsWith(`sh`)||e.endsWith(`ch`)||e.endsWith(`x`)||e.endsWith(`z`)?e+`es`:e+`s`},titleCase(e){return e.toLowerCase().replace(/(?:^|\s)\S/g,e=>e.toUpperCase())},copyText(e){if(!e)return!1;let t=document.createElement(`textarea`);return t.value=e,t.style.cssText=`
+            position: fixed;
+            top: 0;
+            left: 0;
+            transform: translate(-100%, -100%);
+            opacity: 0;
+            z-index: -1;
+        `,document.body.appendChild(t),t.select(),t.setSelectionRange(0,99999),navigator.clipboard.writeText(t.value).then(()=>{document.body.removeChild(t)}).catch(()=>(document.body.removeChild(t),!1)),!0},isEmail(e){return/(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9])|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])/.exec(e)!==null},generateId(e=10){return Math.random().toString(36).substring(2,e+2)},isImage(e){return!!e?.match(/\.(jpe?g|png|webp|gif|svg)$/i)},isVideo(e){return!!e?.match(/\.(mp4|webm|ogg)$/i)}};exports.MintText=e;

package/dist/{js/imports → imports}/util/text.d.ts

@@ -1,61 +1,60 @@
 /**
  * Functions for analyzing and manipulating text.
  */
-export declare abstract class MintText {
+export declare const MintText: {
     /**
      * Shorten a string to the given length
      */
-    static truncate(text: string, length?: number): string;
+    truncate(text: string, length?: number): string;
     /**
      * Generate a slug from a string
      * @param text - The string to slugify
      * @returns The slugified string
      */
-    static slug(text?: string): string;
+    slug(text?: string): string;
     /**
      * Generate a title from a slug
      * @param slug - The slug to generate a title from
      * @returns The title
      */
-    static unslug(slug: string): string;
+    unslug(slug: string): string;
     /**
      * Format a phone number
      * @param phone - The phone number to format
      * @returns The formatted phone number
      */
-    static phone(phone?: string | number): string;
+    phone(phone?: string | number): string;
     /**
      * Pluralize the given word
      */
-    static plural(word: string): string;
+    plural(word: string): string;
     /**
      * Capitalize the first letter of the given word
      */
-    static titleCase(text: string): string;
+    titleCase(text: string): string;
     /**
      * Copies the provided text to the clipboard
      * @param text - the text to copy
      * @returns - true if the text was successfully copied to the clipboard; else false
      */
-    static copyText(text: string): boolean;
+    copyText(text: string): boolean;
     /**
      * Tests the validity of an email address
      * @see {@link https://stackoverflow.com/questions/201323/how-can-i-validate-an-email-address-using-a-regular-expression}
      * @param text - the string to test
      * @returns - true if the given string is an email address; false if not
      */
-    static isEmail(text: string): boolean;
+    isEmail(text: string): boolean;
     /**
      * Generate a random string [a-z0-9]
      */
-    static generateId(length?: number): string;
+    generateId(length?: number): string;
     /**
      * Check if the given string is an image url
      */
-    static isImage(src?: string): boolean;
+    isImage(src?: string): boolean;
     /**
      * Check if the given string is a video url
      */
-    static isVideo(src?: string): boolean;
-}
-//# sourceMappingURL=text.d.ts.map
+    isVideo(src?: string): boolean;
+};