Added download with progress

# Conflicts:
#	package.json

package.json

@@ -1,46 +1,46 @@
-{
-	"name": "@ztimson/utils",
-	"version": "0.30.6",
-	"description": "Utility library",
-	"author": "Zak Timson",
-	"license": "MIT",
-	"private": false,
-	"repository": {
-		"type": "git",
-		"url": "https://git.zakscode.com/ztimson/js-utilities"
-	},
-	"main": "./dist/index.cjs",
-	"module": "./dist/index.mjs",
-	"types": "./dist/index.d.ts",
-	"exports": {
-		".": {
-			"types": "./dist/index.d.ts",
-			"import": "./dist/index.mjs",
-			"require": "./dist/index.cjs"
-		}
-	},
-	"scripts": {
-		"build": "npx tsc && npx vite build",
-		"docs": "typedoc --cleanOutputDir false --out ./docs --entryPoints src/**/*.ts --readme none",
-		"test": "npx jest",
-		"test:coverage": "npx jest --coverage",
-		"watch": "npx vite build --watch"
-	},
-	"dependencies": {
-		"var-persist": "^1.0.1"
-	},
-	"devDependencies": {
-		"@types/jest": "^30.0.0",
-		"fake-indexeddb": "^6.2.5",
-		"jest": "^30.2.0",
-		"jest-junit": "^16.0.0",
-		"ts-jest": "^29.4.5",
-		"typedoc": "^0.28.15",
-		"typescript": "^5.9.3",
-		"vite": "^7.2.4",
-		"vite-plugin-dts": "^4.5.4"
-	},
-	"files": [
-		"dist"
-	]
-}
+{
+	"name": "@ztimson/utils",
+	"version": "0.30.9",
+	"description": "Utility library",
+	"author": "Zak Timson",
+	"license": "MIT",
+	"private": false,
+	"repository": {
+		"type": "git",
+		"url": "https://git.zakscode.com/ztimson/js-utilities"
+	},
+	"main": "./dist/index.cjs",
+	"module": "./dist/index.mjs",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.mjs",
+			"require": "./dist/index.cjs"
+		}
+	},
+	"scripts": {
+		"build": "npx tsc && npx vite build",
+		"docs": "typedoc --cleanOutputDir false --out ./docs --entryPoints src/**/*.ts --readme none",
+		"test": "npx jest",
+		"test:coverage": "npx jest --coverage",
+		"watch": "npx vite build --watch"
+	},
+	"dependencies": {
+		"var-persist": "^1.0.1"
+	},
+	"devDependencies": {
+		"@types/jest": "^30.0.0",
+		"fake-indexeddb": "^6.2.5",
+		"jest": "^30.2.0",
+		"jest-junit": "^16.0.0",
+		"ts-jest": "^29.4.5",
+		"typedoc": "^0.28.15",
+		"typescript": "^5.9.3",
+		"vite": "^7.2.4",
+		"vite-plugin-dts": "^4.5.4"
+	},
+	"files": [
+		"dist"
+	]
+}

src/files.ts

@@ -82,11 +82,11 @@ export function timestampFilename(name?: string, date: Date | number | string =
 }
 
 /**
- * Upload file to URL with progress callback using PromiseProgress
+ * Upload file to URL with progress (size/total/speed/eta/...) via PromiseProgress
  * Works in both browser (with progress) and Node.js (fallback without progress)
  *
  * @param {{url: string, files: File[], headers?: {[p: string]: string}, withCredentials?: boolean}} options
- * @return {PromiseProgress<T>} Promise of request with `onProgress` callback
+ * @return {PromiseProgress<T>} Promise of request with `onProgress` callback & meta getters
  */
 export function uploadWithProgress<T>(options: {
 	url: string;
@@ -102,7 +102,7 @@ export function uploadWithProgress<T>(options: {
 			options.files.forEach(f => formData.append('files', f));
 
 			xhr.withCredentials = !!options.withCredentials;
-			xhr.upload.addEventListener('progress', (event) => event.lengthComputable ? prog(event.loaded / event.total) : null);
+			xhr.upload.addEventListener('progress', (event) => event.lengthComputable ? prog(event.loaded, event.total) : null);
 			xhr.addEventListener('loadend', () => res(<T>JSONAttemptParse(xhr.responseText)));
 			xhr.addEventListener('error', () => rej(JSONAttemptParse(xhr.responseText)));
 			xhr.addEventListener('timeout', () => rej({error: 'Request timed out'}));
@@ -131,3 +131,39 @@ export function uploadWithProgress<T>(options: {
 		}
 	});
 }
+
+/**
+ * Download file from URL with progress (size/total/speed/eta/...) via PromiseProgress
+ * Streams the response body for progress when supported, falls back to a plain blob otherwise
+ *
+ * @param {{url: string, name?: string, headers?: {[p: string]: string}}} options name - if set, triggers a file save via `downloadFile`
+ * @return {PromiseProgress<Blob>} Promise of downloaded blob with `onProgress` callback & meta getters
+ */
+export function downloadWithProgress(options: {url: string; name?: string; headers?: {[key: string]: string}}): PromiseProgress<Blob> {
+	return new PromiseProgress<Blob>(async (res, rej, prog) => {
+		try {
+			const response = await fetch(options.url, {headers: options.headers || {}});
+			if(!response.ok) return rej(JSONAttemptParse(await response.text()));
+			const total = Number(response.headers.get('content-length')) || 0;
+			if(!response.body?.getReader) {
+				const blob = await response.blob();
+				options.name && downloadFile(blob, options.name);
+				return res(blob);
+			}
+			const reader = response.body.getReader();
+			const chunks: Uint8Array[] = [];
+			let size = 0;
+			while(true) {
+				const {done, value} = await reader.read();
+				if(done) break;
+				chunks.push(value);
+				prog(size += value.length, total);
+			}
+			const blob = new Blob(chunks as BlobPart[]);
+			options.name && downloadFile(blob, options.name);
+			res(blob);
+		} catch (error) {
+			rej(error);
+		}
+	});
+}

src/objects.ts

@@ -1,309 +1,311 @@
-import {JSONSanitize} from './json.ts';
-
-export type Delta = { [key: string]: any | Delta | null };
-
-/**
- * Applies deltas to `target`.
- * @param base starting point
- * @param deltas List of deltas to apply
- * @returns Mutated target
- */
-export function applyDeltas(base: any, ...deltas: any[]): any {
-	function applyDelta(base: any, delta: any): any {
-		if(delta === null) return null;
-		if(typeof base !== 'object' || base === null) return delta === undefined ? base : delta;
-		const result = Array.isArray(base) ? [...base] : { ...base };
-		for(const key in delta) {
-			const val = delta[key];
-			if(val === undefined) delete result[key];
-			else if(typeof val === 'object' && val !== null && !Array.isArray(val)) result[key] = applyDelta(result[key], val);
-			else result[key] = val;
-		}
-		return result;
-	}
-
-	for(const d of deltas.flat()) base = applyDelta(base, d?.delta ?? d);
-	return base;
-}
-
-/**
- * Creates a nested delta that reverts `target` back to `old`.
- * @param old - Original object
- * @param updated - Modified object
- * @returns New changes
- */
-export function calcDelta(old: any, updated: any): any {
-	if(updated == null) return null; // full delete
-	const delta: any = {};
-	const isObj = (v: any) => v && typeof v === 'object' && !Array.isArray(v);
-	for (const key of new Set([...(old ? Object.keys(old) : []), ...(updated ? Object.keys(updated) : [])])) {
-		const oldVal = old?.[key];
-		const newVal = updated?.[key];
-		if(isObj(oldVal) && isObj(newVal)) {
-			const nested = calcDelta(oldVal, newVal);
-			if(nested !== null && Object.keys(nested).length > 0) delta[key] = nested;
-		} else if(JSON.stringify(oldVal) !== JSON.stringify(newVal)) {
-			delta[key] = newVal;
-		}
-	}
-	return Object.keys(delta).length === 0 ? {} : delta;
-}
-
-/**
- * Removes any null values from an object in-place
- *
- * @example
- * ```ts
- * let test = {a: 0, b: false, c: null, d: 'abc'}
- * console.log(clean(test)); // Output: {a: 0, b: false, d: 'abc'}
- * ```
- *
- * @param {T} obj Object reference that will be cleaned
- * @param undefinedOnly Ignore null values
- * @returns {Partial<T>} Cleaned object
- */
-export function clean<T>(obj: T, undefinedOnly = false): Partial<T> {
-	if(obj == null) throw new Error("Cannot clean a NULL value");
-	if(Array.isArray(obj)) {
-		obj = <any>obj.filter(o => undefinedOnly ? o !== undefined : o != null);
-	} else {
-		Object.entries(obj).forEach(([key, value]) => {
-			if((undefinedOnly && value === undefined) || (!undefinedOnly && value == null)) delete (<any>obj)[key];
-		});
-	}
-	return <any>obj;
-}
-
-/**
- * Create a deep copy of an object (vs. a shallow copy of references)
- *
- * Should be replaced by `structuredClone` once released.
- * @param {T} value Object to copy
- * @returns {T} Type
- */
-export function deepCopy<T>(value: T): T {
-	if(value == null) return value;
-	const t = typeof value;
-	if(t === 'string' || t === 'number' || t === 'boolean' || t === 'function') return value;
-	try {return structuredClone(value); }
-	catch { return JSON.parse(JSONSanitize(value)); }
-}
-
-/**
- * Merge any number of objects into the target
- *
- * @param target Destination of all properties
- * @param sources Objects that will copied into target
- * @return {any} The des
- */
-export function deepMerge<T>(target: any, ...sources: any[]): T {
-	sources.forEach(s => {
-		for(const key in s) {
-			if(s[key] && typeof s[key] == 'object' && !Array.isArray(s[key])) {
-				if(!target[key]) target[key] = {};
-				deepMerge(target[key], s[key]);
-			} else {
-				target[key] = s[key];
-			}
-		}
-	});
-	return target;
-}
-
-/**
- * Get/set a property of an object using dot notation
- *
- * @example
- * ```ts
- * // Get a value
- * const name = dotNotation<string>(person, 'firstName');
- * const familyCarMake = dotNotation(family, 'cars[0].make');
- * // Set a value
- * dotNotation(family, 'cars[0].make', 'toyota');
- * ```
- *
- * @type T Return type
- * @param {Object} obj source object to search
- * @param {string} prop property name (Dot notation & indexing allowed)
- * @param {any} set  Set object property to value, omit to fetch value instead
- * @return {T} property value
- */
-export function dotNotation<T>(obj: any, prop: string, set: T): T;
-export function dotNotation<T>(obj: any, prop: string): T | undefined;
-export function dotNotation<T>(obj: any, prop: string, set?: T): T | undefined {
-	if(obj == null || !prop) return undefined;
-	// Split property string by '.' or [index]
-	return <T>prop.split(/[.[\]]/g).filter(prop => prop.length).reduce((obj, prop,  i, arr) => {
-		if(prop[0] == '"' || prop[0] == "'") prop = prop.slice(1, -1); // Take quotes out
-		if(!obj?.hasOwnProperty(prop)) {
-			if(set == undefined) return undefined;
-			obj[prop] = {};
-		}
-		if(set !== undefined && i == arr.length - 1)
-			return obj[prop] = set;
-		return obj[prop];
-	}, obj);
-}
-
-/**
- * Convert object into URL encoded query string
- *
- * @example
- * ```js
- * const query = encodeQuery({page: 1, size: 20});
- * console.log(query); // Output: "page=1&size=20"
- * ```
- *
- * @param {any} data - data to convert
- * @returns {string} - Encoded form data
- */
-export function encodeQuery(data: any): string {
-	return Object.entries(data).map(([key, value]) =>
-		encodeURIComponent(key) + '=' + encodeURIComponent(<any>value)
-	).join('&');
-}
-
-/**
- * Recursively flatten a nested object, while maintaining key structure
- *
- * @example
- * ```ts
- * const car = {honda: {model: "Civic"}};
- * console.log(flattenObj(car)); //Output {honda.model: "Civic"}
- * ```
- *
- * @param obj - Object to flatten
- * @param parent - Recursively check if key is a parent key or not
- * @param result - Result
- * @returns {object} - Flattened object
- */
-export function flattenObj(obj: any, parent?: any, result: any = {}) {
-	if(typeof obj === "object" && !Array.isArray(obj)) {
-		for(const key of Object.keys(obj)) {
-			const propName = parent ? `${parent}.${key}` : key;
-			if(typeof obj[key] === 'object' && obj[key] != null && !Array.isArray(obj[key])) {
-				flattenObj(obj[key], propName, result);
-			} else {
-				result[propName] = obj[key];
-			}
-		}
-		return result;
-	}
-}
-
-/**
- * Convert object to FormData
- *
- * @param target - Object to convert
- * @return {FormData} - Form object
- */
-export function formData(target: any): FormData {
-	const data = new FormData();
-	Object.entries(target).forEach(([key, value]) => data.append(key, <any>value));
-	return data;
-}
-
-/**
- * Check that an object has the following values
- *
- * @example
- * ```ts
- * const test = {a: 2, b: 2};
- * includes(test, {a: 1}); // true
- * includes(test, {b: 1, c: 3}); // false
- * ```
- *
- * @param target Object to search
- * @param values Criteria to check against
- * @param allowMissing Only check the keys that are available on the target
- * @returns {boolean} Does target include all the values
- */
-export function includes(target: any, values: any, allowMissing = false): boolean {
-	if(target == undefined) return allowMissing;
-	if(Array.isArray(values)) return values.findIndex((e: any, i: number) => !includes(target[i], values[i], allowMissing)) == -1;
-	const type = typeof values;
-	if(type != typeof target) return false;
-	if(type == 'object') {
-		return Object.keys(values).find(key => !includes(target[key], values[key], allowMissing)) == null;
-	}
-	if(type == 'function') return target.toString() == values.toString();
-	return target == values;
-}
-
-/**
- * Deep check if two items are equal.
- * Handles primitives, objects, arrays, functions, Date, RegExp, and circular references.
- *
- * @param {any} a - first item to compare
- * @param {any} b - second item to compare
- * @param {WeakMap<object, object>} [seen] - Internal parameter to track circular references
- * @returns {boolean} True if they match
- */
-export function isEqual(a: any, b: any, seen = new WeakMap<object, object>()): boolean {
-	// Simple cases
-	if(a === b) return true;
-	if(a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
-	if(a instanceof RegExp && b instanceof RegExp) return a.source === b.source && a.flags === b.flags;
-
-	// Null checks
-	if(typeof a !== 'object' || a === null || typeof b !== 'object' || b === null) {
-		if(Number.isNaN(a) && Number.isNaN(b)) return true;
-		if(typeof a === 'function' && typeof b === 'function') return a.toString() === b.toString()
-		return false;
-	}
-
-	// Circular references
-	if(seen.has(a)) return seen.get(a) === b;
-	seen.set(a, b);
-	const isArrayA = Array.isArray(a);
-	const isArrayB = Array.isArray(b);
-
-	// Array checks
-	if(isArrayA && isArrayB) {
-		if(a.length !== b.length) return false;
-		for(let i = 0; i < a.length; i++) {
-			if(!isEqual(a[i], b[i], seen)) return false;
-		}
-		return true;
-	}
-	if(isArrayA !== isArrayB) return false;
-
-	// Key & value deep comparison
-	const keysA = Object.keys(a);
-	const keysB = Object.keys(b);
-	if(keysA.length !== keysB.length) return false;
-	for(const key of keysA) {
-		if(!Object.prototype.hasOwnProperty.call(b, key) || !isEqual(a[key], b[key], seen)) return false;
-	}
-	return true;
-}
-
-/**
- * Experimental: Combine multiple object prototypes into one
- *
- * @param target Object that will have prototypes added
- * @param {any[]} constructors Additionally prototypes that should be merged into target
- */
-export function mixin(target: any, constructors: any[]) {
-	constructors.forEach(c => {
-		Object.getOwnPropertyNames(c.prototype).forEach((name) => {
-			Object.defineProperty(
-				target.prototype,
-				name,
-				Object.getOwnPropertyDescriptor(c.prototype, name) ||
-				Object.create(null)
-			);
-		});
-	});
-}
-
-/**
- * Run a map function on each property
- * @param obj Object that will be iterated
- * @param {(key: string, value: any) => any} fn Transformer function - receives key & value
- * @returns {{}}
- */
-export function objectMap<T>(obj: any, fn: (key: string, value: any) => any): T {
-	return <any>Object.entries(obj).map(([key, value]: [string, any]) => [key, fn(key, value)])
-		.reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {});
-}
+import {JSONSanitize} from './json.ts';
+
+export type Delta = { [key: string]: any | Delta | null };
+
+/**
+ * Applies deltas to `target`.
+ * @param base starting point
+ * @param deltas List of deltas to apply
+ * @returns Mutated target
+ */
+export function applyDeltas(base: any, ...deltas: any[]): any {
+	function applyDelta(base: any, delta: any): any {
+		if(delta === null) return null;
+		if(typeof base !== 'object' || base === null) return delta === undefined ? base : delta;
+		const result = Array.isArray(base) ? [...base] : { ...base };
+		for(const key in delta) {
+			const val = delta[key];
+			if(val === undefined) delete result[key];
+			else if(typeof val === 'object' && val !== null && !Array.isArray(val)) result[key] = applyDelta(result[key], val);
+			else result[key] = val;
+		}
+		return result;
+	}
+
+	for(const d of deltas.flat()) base = applyDelta(base, d?.delta ?? d);
+	return base;
+}
+
+/**
+ * Creates a nested delta that reverts `target` back to `old`.
+ * @param old - Original object
+ * @param updated - Modified object
+ * @returns New changes
+ */
+export function calcDelta(old: any, updated: any): any {
+	if(updated == null) return null; // full delete
+	const delta: any = {};
+	const isObj = (v: any) => v && typeof v === 'object' && !Array.isArray(v);
+	for (const key of new Set([...(old ? Object.keys(old) : []), ...(updated ? Object.keys(updated) : [])])) {
+		const oldVal = old?.[key];
+		const newVal = updated?.[key];
+		if(isObj(oldVal) && isObj(newVal)) {
+			const nested = calcDelta(oldVal, newVal);
+			if(nested !== null && Object.keys(nested).length > 0) delta[key] = nested;
+		} else if(JSON.stringify(oldVal) !== JSON.stringify(newVal)) {
+			delta[key] = newVal;
+		}
+	}
+	return Object.keys(delta).length === 0 ? {} : delta;
+}
+
+/**
+ * Removes any null values from an object in-place
+ *
+ * @example
+ * ```ts
+ * let test = {a: 0, b: false, c: null, d: 'abc'}
+ * console.log(clean(test)); // Output: {a: 0, b: false, d: 'abc'}
+ * ```
+ *
+ * @param {T} obj Object reference that will be cleaned
+ * @param undefinedOnly Ignore null values
+ * @returns {Partial<T>} Cleaned object
+ */
+export function clean<T>(obj: T, undefinedOnly = false): Partial<T> {
+	if(obj == null) throw new Error("Cannot clean a NULL value");
+	if(Array.isArray(obj)) {
+		obj = <any>obj.filter(o => undefinedOnly ? o !== undefined : o != null);
+	} else {
+		Object.entries(obj).forEach(([key, value]) => {
+			if((undefinedOnly && value === undefined) || (!undefinedOnly && value == null)) delete (<any>obj)[key];
+		});
+	}
+	return <any>obj;
+}
+
+/**
+ * Create a deep copy of an object (vs. a shallow copy of references)
+ *
+ * Should be replaced by `structuredClone` once released.
+ * @param {T} value Object to copy
+ * @returns {T} Type
+ */
+export function deepCopy<T>(value: T): T {
+	if(value == null) return value;
+	const t = typeof value;
+	if(t === 'string' || t === 'number' || t === 'boolean' || t === 'function') return value;
+	try {return structuredClone(value); }
+	catch { return JSON.parse(JSONSanitize(value)); }
+}
+
+/**
+ * Merge any number of objects into the target
+ *
+ * @param target Destination of all properties
+ * @param sources Objects that will copied into target
+ * @return {any} The des
+ */
+export function deepMerge<T>(target: any, ...sources: any[]): T {
+	const BLOCKED = new Set(['__proto__', 'constructor', 'prototype']);
+	sources.forEach(s => {
+		for(const key in s) {
+			if(BLOCKED.has(key) || !Object.prototype.hasOwnProperty.call(s, key)) continue;
+			if(s[key] && typeof s[key] == 'object' && !Array.isArray(s[key])) {
+				if(!target[key]) target[key] = {};
+				deepMerge(target[key], s[key]);
+			} else {
+				target[key] = s[key];
+			}
+		}
+	});
+	return target;
+}
+
+/**
+ * Get/set a property of an object using dot notation
+ *
+ * @example
+ * ```ts
+ * // Get a value
+ * const name = dotNotation<string>(person, 'firstName');
+ * const familyCarMake = dotNotation(family, 'cars[0].make');
+ * // Set a value
+ * dotNotation(family, 'cars[0].make', 'toyota');
+ * ```
+ *
+ * @type T Return type
+ * @param {Object} obj source object to search
+ * @param {string} prop property name (Dot notation & indexing allowed)
+ * @param {any} set  Set object property to value, omit to fetch value instead
+ * @return {T} property value
+ */
+export function dotNotation<T>(obj: any, prop: string, set: T): T;
+export function dotNotation<T>(obj: any, prop: string): T | undefined;
+export function dotNotation<T>(obj: any, prop: string, set?: T): T | undefined {
+	if(obj == null || !prop) return undefined;
+	// Split property string by '.' or [index]
+	return <T>prop.split(/[.[\]]/g).filter(prop => prop.length).reduce((obj, prop,  i, arr) => {
+		if(prop[0] == '"' || prop[0] == "'") prop = prop.slice(1, -1); // Take quotes out
+		if(!obj?.hasOwnProperty(prop)) {
+			if(set == undefined) return undefined;
+			obj[prop] = {};
+		}
+		if(set !== undefined && i == arr.length - 1)
+			return obj[prop] = set;
+		return obj[prop];
+	}, obj);
+}
+
+/**
+ * Convert object into URL encoded query string
+ *
+ * @example
+ * ```js
+ * const query = encodeQuery({page: 1, size: 20});
+ * console.log(query); // Output: "page=1&size=20"
+ * ```
+ *
+ * @param {any} data - data to convert
+ * @returns {string} - Encoded form data
+ */
+export function encodeQuery(data: any): string {
+	return Object.entries(data).map(([key, value]) =>
+		encodeURIComponent(key) + '=' + encodeURIComponent(<any>value)
+	).join('&');
+}
+
+/**
+ * Recursively flatten a nested object, while maintaining key structure
+ *
+ * @example
+ * ```ts
+ * const car = {honda: {model: "Civic"}};
+ * console.log(flattenObj(car)); //Output {honda.model: "Civic"}
+ * ```
+ *
+ * @param obj - Object to flatten
+ * @param parent - Recursively check if key is a parent key or not
+ * @param result - Result
+ * @returns {object} - Flattened object
+ */
+export function flattenObj(obj: any, parent?: any, result: any = {}) {
+	if(typeof obj === "object" && !Array.isArray(obj)) {
+		for(const key of Object.keys(obj)) {
+			const propName = parent ? `${parent}.${key}` : key;
+			if(typeof obj[key] === 'object' && obj[key] != null && !Array.isArray(obj[key])) {
+				flattenObj(obj[key], propName, result);
+			} else {
+				result[propName] = obj[key];
+			}
+		}
+		return result;
+	}
+}
+
+/**
+ * Convert object to FormData
+ *
+ * @param target - Object to convert
+ * @return {FormData} - Form object
+ */
+export function formData(target: any): FormData {
+	const data = new FormData();
+	Object.entries(target).forEach(([key, value]) => data.append(key, <any>value));
+	return data;
+}
+
+/**
+ * Check that an object has the following values
+ *
+ * @example
+ * ```ts
+ * const test = {a: 2, b: 2};
+ * includes(test, {a: 1}); // true
+ * includes(test, {b: 1, c: 3}); // false
+ * ```
+ *
+ * @param target Object to search
+ * @param values Criteria to check against
+ * @param allowMissing Only check the keys that are available on the target
+ * @returns {boolean} Does target include all the values
+ */
+export function includes(target: any, values: any, allowMissing = false): boolean {
+	if(target == undefined) return allowMissing;
+	if(Array.isArray(values)) return values.findIndex((e: any, i: number) => !includes(target[i], values[i], allowMissing)) == -1;
+	const type = typeof values;
+	if(type != typeof target) return false;
+	if(type == 'object') {
+		return Object.keys(values).find(key => !includes(target[key], values[key], allowMissing)) == null;
+	}
+	if(type == 'function') return target.toString() == values.toString();
+	return target == values;
+}
+
+/**
+ * Deep check if two items are equal.
+ * Handles primitives, objects, arrays, functions, Date, RegExp, and circular references.
+ *
+ * @param {any} a - first item to compare
+ * @param {any} b - second item to compare
+ * @param {WeakMap<object, object>} [seen] - Internal parameter to track circular references
+ * @returns {boolean} True if they match
+ */
+export function isEqual(a: any, b: any, seen = new WeakMap<object, object>()): boolean {
+	// Simple cases
+	if(a === b) return true;
+	if(a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+	if(a instanceof RegExp && b instanceof RegExp) return a.source === b.source && a.flags === b.flags;
+
+	// Null checks
+	if(typeof a !== 'object' || a === null || typeof b !== 'object' || b === null) {
+		if(Number.isNaN(a) && Number.isNaN(b)) return true;
+		if(typeof a === 'function' && typeof b === 'function') return a.toString() === b.toString()
+		return false;
+	}
+
+	// Circular references
+	if(seen.has(a)) return seen.get(a) === b;
+	seen.set(a, b);
+	const isArrayA = Array.isArray(a);
+	const isArrayB = Array.isArray(b);
+
+	// Array checks
+	if(isArrayA && isArrayB) {
+		if(a.length !== b.length) return false;
+		for(let i = 0; i < a.length; i++) {
+			if(!isEqual(a[i], b[i], seen)) return false;
+		}
+		return true;
+	}
+	if(isArrayA !== isArrayB) return false;
+
+	// Key & value deep comparison
+	const keysA = Object.keys(a);
+	const keysB = Object.keys(b);
+	if(keysA.length !== keysB.length) return false;
+	for(const key of keysA) {
+		if(!Object.prototype.hasOwnProperty.call(b, key) || !isEqual(a[key], b[key], seen)) return false;
+	}
+	return true;
+}
+
+/**
+ * Experimental: Combine multiple object prototypes into one
+ *
+ * @param target Object that will have prototypes added
+ * @param {any[]} constructors Additionally prototypes that should be merged into target
+ */
+export function mixin(target: any, constructors: any[]) {
+	constructors.forEach(c => {
+		Object.getOwnPropertyNames(c.prototype).forEach((name) => {
+			Object.defineProperty(
+				target.prototype,
+				name,
+				Object.getOwnPropertyDescriptor(c.prototype, name) ||
+				Object.create(null)
+			);
+		});
+	});
+}
+
+/**
+ * Run a map function on each property
+ * @param obj Object that will be iterated
+ * @param {(key: string, value: any) => any} fn Transformer function - receives key & value
+ * @returns {{}}
+ */
+export function objectMap<T>(obj: any, fn: (key: string, value: any) => any): T {
+	return <any>Object.entries(obj).map(([key, value]: [string, any]) => [key, fn(key, value)])
+		.reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {});
+}

src/promise-progress.ts

@@ -1,65 +1,83 @@
-export type ProgressCallback = (progress: number) => any;
+export interface ProgressMeta {
+	start: number;
+	end: number | null;
+	elapsed: number; // seconds
+	speed: number;   // bytes/sec
+	progress: number; // 0-1
+	size: number;    // bytes transferred
+	total: number;   // total bytes
+	eta: number | null; // seconds remaining
+}
+
+export type ProgressCallback = (meta: ProgressMeta) => any;
 
 /**
- * A promise that fires the `onProgress` callback on incremental progress
+ * A promise that tracks transfer progress (size/total/speed/eta/elapsed) via `onProgress` callback & direct getters
  *
  * @example
  * ```js
- * const promise = new Promise((resolve, reject, progress) => {
- *   const max = 10;
- * 	 for(let i = 0; i < max; i++) progress(i / max);
+ * const promise = new PromiseProgress((resolve, reject, progress) => {
+ *   const total = 100;
+ * 	 for(let i = 0; i <= total; i++) progress(i, total);
  * 	 resolve(1);
  * });
  *
- * console.log(promise.progress);
+ * console.log(promise.progress, promise.speed, promise.eta);
  *
- * promise.onProgress(console.log)
+ * promise.onProgress(m => console.log(m.progress, m.eta))
  *        .then(console.log)
  *        .catch(console.error)
  *        .finally(...);
- *
  * ```
  */
 export class PromiseProgress<T> extends Promise<T> {
 	private listeners: ProgressCallback[] = [];
+	private _meta: ProgressMeta = {start: Date.now(), end: null, elapsed: 0, speed: 0, progress: 0, size: 0, total: 0, eta: null};
 
-	private _progress = 0;
-	get progress() { return this._progress; }
-	set progress(p: number) {
-		if(p == this._progress) return;
-		this._progress = p;
-		this.listeners.forEach(l => l(p));
+	get meta() { return this._meta; }
+	get start() { return this._meta.start; }
+	get end() { return this._meta.end; }
+	get elapsed() { return this._meta.elapsed; }
+	get speed() { return this._meta.speed; }
+	get progress() { return this._meta.progress; }
+	get size() { return this._meta.size; }
+	get total() { return this._meta.total; }
+	get eta() { return this._meta.eta; }
+
+	private update(size: number, total: number) {
+		const elapsed = (Date.now() - this._meta.start) / 1000;
+		const speed = elapsed ? size / elapsed : 0;
+		const progress = total ? size / total : this._meta.progress;
+		this._meta = {...this._meta, size, total, progress, elapsed, speed, eta: speed && total ? (total - size) / speed : null};
+		(this.listeners ||= []).forEach(l => l(this._meta));
 	}
 
-	constructor(executor: (resolve: (value: T) => any, reject: (reason: any) => void, progress: (progress: number) => any) => void) {
+	constructor(executor: (resolve: (value: T) => any, reject: (reason: any) => void, progress: (size: number, total?: number) => any) => void) {
 		super((resolve, reject) => executor(
-			(value: T) => resolve(value),
-			(reason: any) => reject(reason),
-			(progress: number) => this.progress = progress,
+			(value: T) => { this._meta = {...this._meta, end: Date.now()}; resolve(value); },
+			(reason: any) => { this._meta = {...this._meta, end: Date.now()}; reject(reason); },
+			(size: number, total?: number) => this.update(size, total ?? this._meta.total),
 		));
 	}
 
 	static from<T>(promise: Promise<T>): PromiseProgress<T> {
 		if(promise instanceof PromiseProgress) return promise;
-		return new PromiseProgress<T>((res, rej) => promise
-			.then((...args) => res(...args))
-			.catch((...args) => rej(...args)));
+		return new PromiseProgress<T>((res, rej) => promise.then(res).catch(rej));
 	}
 
 	private from(promise: Promise<T>): PromiseProgress<T> {
 		const newPromise = PromiseProgress.from(promise);
-		this.onProgress(p => newPromise.progress = p);
+		this.onProgress(m => newPromise.update(m.size, m.total));
 		return newPromise;
 	}
 
 	onProgress(callback: ProgressCallback) {
-		this.listeners.push(callback);
+		(this.listeners ||= []).push(callback);
 		return this;
 	}
 
 	then(res?: (v: T) => any, rej?: (err: any) => any): PromiseProgress<any> {
-		const resp = super.then(res, rej);
-		return this.from(resp);
+		return this.from(super.then(res, rej));
 	}
 
 	catch(rej?: (err: any) => any): PromiseProgress<any> {

src/xml.ts

@@ -1,12 +1,12 @@
 /**
- * Parses an XML string into a structured JavaScript object.
+ * Parses an XML string into a plain JavaScript object.
+ * Each tag becomes a key. Attributes and child tags are merged as
+ * sibling properties on that tag's object. Duplicate tag/attribute
+ * names are collapsed into arrays. Text-only tags resolve to their
+ * (optionally numeric) value; if a tag has both text and attributes/
+ * children, the text is kept under a `_text` key.
  * @param {string} xml - The XML string to parse
- * @returns {Object} An object with `tag`, `attributes`, and `children` properties
- */
-/**
- * Parses an XML string into a structured JavaScript object (fast-xml-parser format).
- * @param {string} xml - The XML string to parse
- * @returns {Object} An object with tag names as keys and text content or nested objects as values
+ * @returns {Object} The parsed object tree
  */
 export function fromXml(xml: string) {
 	xml = xml.trim();
@@ -33,11 +33,11 @@ export function fromXml(xml: string) {
 
 		if(xml[pos] === '/' && xml[pos + 1] === '>') {
 			pos += 2; // skip />
-			return { [tagName]: '' };
+			return { [tagName]: Object.keys(attributes).length ? attributes : '' };
 		}
 
 		pos++; // skip >
-		const children: any[] = [];
+		const children: any[] = Object.entries(attributes).map(([k, v]) => ({ [k]: v }));
 		let textContent = '';
 
 		while(pos < xml.length) {
@@ -49,7 +49,6 @@ export function fromXml(xml: string) {
 				pos++; // skip >
 				break;
 			}
-			const startPos = pos;
 			const child = parseNode();
 			if(typeof child === 'string') {
 				textContent += child;
@@ -64,17 +63,18 @@ export function fromXml(xml: string) {
 			return { [tagName]: value };
 		}
 
-		// If only text with no children
+		// If nothing at all
 		if(children.length === 0) {
 			return { [tagName]: '' };
 		}
 
-		// Merge children into object
+		// Merge attributes/children into object
 		const result: any = {};
+		if(textContent) result._text = isNumeric(textContent) ? Number(textContent) : textContent;
 		for(const child of children) {
 			for(const [key, value] of Object.entries(child)) {
 				if(result[key]) {
-					// Convert to array if duplicate tags
+					// Convert to array if duplicate tags/attrs
 					if(!Array.isArray(result[key])) {
 						result[key] = [result[key]];
 					}

tests/xml.spec.ts

@@ -14,10 +14,10 @@ describe('XML Parser', () => {
 			expect(result).toEqual({ item: '' });
 		});
 
-		it('should parse tag with attributes (ignored in fast-xml-parser format)', () => {
+		it('should parse tag with attributes as merged properties', () => {
 			const xml = '<user id="1" name="someone" />';
 			const result = fromXml(xml);
-			expect(result).toEqual({ user: '' });
+			expect(result).toEqual({ user: { id: '1', name: 'someone' } });
 		});
 
 		it('should parse tag with text content', () => {
@@ -94,6 +94,8 @@ describe('XML Parser', () => {
 			expect(result).toEqual({
 				root: {
 					user: {
+						id: '1',
+						name: 'someone',
 						email: 'someone@example.com',
 						active: ''
 					}
@@ -190,7 +192,7 @@ describe('XML Parser', () => {
 	});
 
 	describe('round-trip', () => {
-		it('should parse toXml output back to fast-xml-parser format', () => {
+		it('should parse toXml output back with attributes merged as properties', () => {
 			const obj = {
 				tag: 'root',
 				attributes: { id: '1' },
@@ -202,6 +204,7 @@ describe('XML Parser', () => {
 			const parsed = fromXml(xml);
 			expect(parsed).toEqual({
 				root: {
+					id: '1',
 					child: 'text'
 				}
 			});