return (colRef: Query) => {															// return a Query-function
		if (query.where)
			asArray<IWhere>(query.where)
				.forEach(qry => colRef = colRef.where(qry.fieldPath, qry.opStr as WhereFilterOp, qry.value));

		if (query.orderBy)
			asArray(query.orderBy)
				.forEach(order => colRef = colRef.orderBy(order.fieldPath, order.directionStr));

		if (isNumeric(query.limitTo))
			colRef = colRef.limit(query.limitTo as number);

		return colRef;
	}

export function dbg(fmt?: any, ...msg: any[]): void {
	let name = this && this.constructor && this.constructor.name || '';
	let sep = isString(fmt) && (fmt.includes(':') || msg.length === 0)
		? '.' : ': ';

	log(name + sep + fmt, ...msg);// prepend the current Module name to aid debugging
}

		.filter((row: IObject<any>) => {													// for each row, ...
			return asArray(filters)																	// 	apply each filter...
				.every(clause => {																		//	and return only rows that match every clause
					const key = row[clause.fieldPath as string];
					const field = isString(key) ? key.toLowerCase() : key;
					const value = isString(clause.value) ? clause.value.toLowerCase() : clause.value;

					switch (clause.opStr) {															// standard firestore query-operators, and '!='
						case '==':
							return isUndefined(field)
								? !value																			// if field not present, compare to 'falsy'
								: field == value;															// use '==' to allow for string/number match, instead of '==='
						case '>':
							return field > value;
						case '>=':
							return field >= value;
						case '<':
							return field < value;
						case '<=':
							return field <= value;
						case '!=':																				// non-standard operator
							return isUndefined(field) || field != value;
						default:
							return false;
					}
				})
		})

export const asAt = <T>(table: T[], cond: IWhere | IWhere[] = [], date?: string | number) => {
	const stamp = isNumber(date) ? date : fmtDate(date, DATE_FMT.yearMonthDayFmt).stamp;

	return filterTable(table, cond)													// return the rows where date is between _effect and IMeta
		.filter((row: IMeta) => stamp < (row[FIELD.expire] || Number.MAX_SAFE_INTEGER))
		.filter((row: IMeta) => (row[FIELD.effect] || Number.MIN_SAFE_INTEGER) <= stamp)
}

export const toHex = (num: number | number[] = [], len: number = 40) => {
	return asArray(num)
		.map(val => (val + 0x100).toString(16).slice(-2))
		.join('')
		.toLowerCase()
		.substring(0, len)
}

export const sprintf = (fmt: any, ...msg: any[]): string => {
	if (isString(fmt) && !fmt.includes('%')) {
		msg.unshift(fmt);           // put the format into the msg array
		fmt = msg     							// and build a new format string
			.map(arg => isObject(arg) ? '%j' : '%s')
			.join(', ')								// reassemble as a comma-separated string
	}
	return format(fmt, ...msg);		// NodeJS.format()
}

export const log = (fmt?: any, ...msg: any[]): void => {
	let out = 'log';
	if (isString(fmt)) {
		let match = fmt.match(/(\w*):/i) || [];
		if (['log', 'info', 'debug', 'warn', 'error'].includes(match[1]))
			out = match[1];
	}
	(console as any)[out](sprintf(fmt, ...msg));
}

			.map(arg => isObject(arg) ? '%j' : '%s')

export const cryptoHash = async (source: string | Object, len: number = 64) => {
	const buffer = asBuffer(asString(source));
	const hash = await crypto.subtle.digest('SHA-256', buffer);

	return toHex([...(new Uint8Array(hash))], len);
}