Improved markdown parser

.gitignore

@@ -10,6 +10,7 @@ uploads
 public/momentum*js
 junit.xml
 /docs/
+main.mjs
 
 # Logs
 *.log

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ztimson/utils",
-	"version": "0.29.4",
+	"version": "0.30.4",
 	"description": "Utility library",
 	"author": "Zak Timson",
 	"license": "MIT",

src/cache.ts

@@ -31,6 +31,8 @@ export class Cache<K extends string | number | symbol, T> {
 	/** Await initial loading */
 	loading = new Promise<void>(r => this._loading = r);
 
+	get size() { return this.store.keys().toArray().length }
+
 	/**
 	 * Create new cache
 	 * @param {keyof T} key Default property to use as primary key

src/files.ts

@@ -83,6 +83,7 @@ export function timestampFilename(name?: string, date: Date | number | string =
 
 /**
  * Upload file to URL with progress callback using 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
@@ -93,10 +94,12 @@ export function uploadWithProgress<T>(options: {
 	headers?: {[key: string]: string};
 	withCredentials?: boolean;
 }): PromiseProgress<T> {
+	// Browser environment - use XMLHttpRequest for progress
+	if (typeof XMLHttpRequest !== 'undefined') {
 		return new PromiseProgress<T>((res, rej, prog) => {
 			const xhr = new XMLHttpRequest();
 			const formData = new FormData();
-		options.files.forEach(f => formData.append('file', f));
+			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);
@@ -109,3 +112,22 @@ export function uploadWithProgress<T>(options: {
 			xhr.send(formData);
 		});
 	}
+
+	// Node.js environment - fallback to fetch without progress
+	return new PromiseProgress<T>(async (res, rej) => {
+		try {
+			const formData = new FormData();
+			options.files.forEach(f => formData.append('files', f));
+			const response = await fetch(options.url, {method: 'POST', headers: options.headers || {}, body: formData});
+			if(!response.ok) {
+				const error = await response.text();
+				rej(JSONAttemptParse(error));
+			} else {
+				const result = await response.text();
+				res(<T>JSONAttemptParse(result));
+			}
+		} catch (error) {
+			rej(error);
+		}
+	});
+}

src/html.ts

@@ -0,0 +1,65 @@
+/**
+ * Decode HTML escaped characters
+ * @param html HTML to clean up
+ * @returns {any}
+ */
+export function decodeHtml(html: string) {
+	return html
+		.replace(/ /g, '\u00A0')
+		.replace(/"/g, '"')
+		.replace(/'/g, "'")
+		.replace(/&lt;/g, '<')
+		.replace(/&gt;/g, '>')
+		.replace(/&cent;/g, '¢')
+		.replace(/&pound;/g, '£')
+		.replace(/&yen;/g, '¥')
+		.replace(/&euro;/g, '€')
+		.replace(/&copy;/g, '©')
+		.replace(/&reg;/g, '®')
+		.replace(/&trade;/g, '™')
+		.replace(/&times;/g, '×')
+		.replace(/&divide;/g, '÷')
+		.replace(/&#(\d+);/g, (match, dec) => String.fromCharCode(dec))
+		.replace(/&#x([0-9a-fA-F]+);/g, (match, hex) => String.fromCharCode(parseInt(hex, 16)))
+		.replace(/&amp;/g, '&'); // Always last!
+}
+
+/**
+ * Parse markdown headers
+ *
+ * **NOTE: frontmatter parsing only works 2 layers deep**
+ *
+ * @param {string} content
+ * @returns {{meta: any, content: string} | {meta: {}, content: string}}
+ */
+export function parseMarkdown(content: string) {
+	const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+	if (!match) return {meta: {}, content};
+
+	const meta: any = {};
+	let currentParent: string | null = null;
+
+	for (const rawLine of match[1].split('\n')) {
+		if (!rawLine.trim()) continue;
+		const indented = /^\s+/.test(rawLine);
+		const line = rawLine.trim();
+		const colonIdx = line.indexOf(':');
+		if (colonIdx === -1) continue;
+
+		const key = line.slice(0, colonIdx).trim();
+		const value = line.slice(colonIdx + 1).trim();
+
+		let parsed: any = value;
+		try { parsed = JSON.parse(value); } catch {}
+
+		if (!indented) {
+			currentParent = value === '' ? key : null;
+			if (value === '') meta[key] = {};
+			else meta[key] = parsed;
+		} else if (currentParent) {
+			meta[currentParent][key] = parsed;
+		}
+	}
+
+	return {meta, content: match[2].trim()};
+}

src/index.ts

@@ -7,9 +7,10 @@ export * from './cache';
 export * from './color';
 export * from './csv';
 export * from './database';
-export * from './files';
 export * from './emitter';
 export * from './errors';
+export * from './files';
+export * from './html';
 export * from './http';
 export * from './json';
 export * from './jwt';

src/path-events.ts

@@ -76,8 +76,18 @@ export class PathEvent {
 	/** Whether this path contains glob patterns */
 	hasGlob!: boolean;
 
-	/** Internal cache for PathEvent instances to avoid redundant parsing */
-	private static pathEventCache: Map<string, PathEvent> = new Map();
+	/** Internal cache for parsed path data (plain objects, not instances) */
+	private static pathEventCache: Map<string, {
+		module: string;
+		fullPath: string;
+		dir: string;
+		path: string;
+		name: string;
+		methods: Method[];
+		hasGlob: boolean;
+	}> = new Map();
+	/** Max size for path cache before LRU eviction */
+	private static readonly MAX_PATH_CACHE_SIZE = 1000;
 	/** Cache for compiled permissions (path + required permissions → result) */
 	private static permissionCache: Map<string, PathEvent> = new Map();
 	/** Max size for permission cache before LRU eviction */
@@ -111,8 +121,20 @@ export class PathEvent {
 			return;
 		}
 
+		// Check cache and reconstruct from plain object
 		if(PathEvent.pathEventCache.has(e)) {
-			Object.assign(this, PathEvent.pathEventCache.get(e)!);
+			const cached = PathEvent.pathEventCache.get(e)!;
+			// Move to end (LRU - most recently used)
+			PathEvent.pathEventCache.delete(e);
+			PathEvent.pathEventCache.set(e, cached);
+
+			this.module = cached.module;
+			this.fullPath = cached.fullPath;
+			this.dir = cached.dir;
+			this.path = cached.path;
+			this.name = cached.name;
+			this.methods = new ASet(cached.methods);
+			this.hasGlob = cached.hasGlob;
 			return;
 		}
 
@@ -128,19 +150,49 @@ export class PathEvent {
 			this.name = '';
 			this.methods = new ASet<Method>(p === '*' ? ['*'] : <any>method.split(''));
 			this.hasGlob = true;
-			PathEvent.pathEventCache.set(e, this);
+
+			// LRU eviction
+			if(PathEvent.pathEventCache.size >= PathEvent.MAX_PATH_CACHE_SIZE) {
+				const firstKey = PathEvent.pathEventCache.keys().next().value;
+				if(firstKey) PathEvent.pathEventCache.delete(firstKey);
+			}
+
+			PathEvent.pathEventCache.set(e, {
+				module: this.module,
+				fullPath: this.fullPath,
+				dir: this.dir,
+				path: this.path,
+				name: this.name,
+				methods: [...this.methods],
+				hasGlob: this.hasGlob
+			});
 			return;
 		}
 
 		let temp = p.split('/').filter(p => !!p);
 		this.module = temp.splice(0, 1)[0] || '';
 		this.path = temp.join('/');
-		this.dir = temp.length > 2 ? temp.slice(0, -1).join('/') : '';
+		this.dir = temp.length > 1 ? temp.slice(0, -1).join('/') : '';
 		this.fullPath = `${this.module}${this.module && this.path ? '/' : ''}${this.path}`;
 		this.name = temp.pop() || '';
 		this.hasGlob = this.fullPath.includes('*');
 		this.methods = new ASet(<any>method.split(''));
-		PathEvent.pathEventCache.set(e, this);
+
+		// LRU eviction
+		if(PathEvent.pathEventCache.size >= PathEvent.MAX_PATH_CACHE_SIZE) {
+			const firstKey = PathEvent.pathEventCache.keys().next().value;
+			if(firstKey) PathEvent.pathEventCache.delete(firstKey);
+		}
+
+		PathEvent.pathEventCache.set(e, {
+			module: this.module,
+			fullPath: this.fullPath,
+			dir: this.dir,
+			path: this.path,
+			name: this.name,
+			methods: [...this.methods],
+			hasGlob: this.hasGlob
+		});
 	}
 
 	/**

src/search.ts

@@ -1,44 +1,122 @@
 import {JSONAttemptParse, JSONSerialize} from './json.ts';
 import {dotNotation} from './objects.ts';
 
-/**
- * Filters an array of objects based on a search term and optional regex checking.
- *
- * @param {Array} rows Array of objects to filter
- * @param {string} search The logic string or regext to filter on
- * @param {boolean} [regex=false] Treat search expression as regex
- * @param {Function} [transform=(r) => r] - Transform rows before filtering
- * @return {Array} The filtered array of objects that matched search
- */
-export function search(rows: any[], search: string, regex?: boolean, transform: Function = (r: any) => r) {
-	if(!rows) return [];
-	return rows.filter(r => {
-		// Empty search
-		if(!search) return true;
-		const value = transform(r);
-		// Regex search
-		if(regex) {
-			return !!Object.values(value).filter((v: any) => {
-				try { return RegExp(search, 'gm').test(v.toString()); }
-				catch { return false; }
-			}).length
-		} else {
-			return logicTest(value, search);
-		}
-	});
+const VALID_FLAGS = new Set([...'dgimsuvy']);
+
+function toRegex(pattern: string, defaultFlags = 'gm'): RegExp | null {
+	const lit = /^\/(.+)\/([a-zA-Z]*)$/.exec(pattern);
+	try { return lit ? new RegExp(lit[1], lit[2]) : new RegExp(pattern, defaultFlags); }
+	catch { return null; }
 }
 
 /**
- * Test an object against a logic condition. By default values are checked
- * @param {string} condition
- * @param {object} target
- * @return {boolean}
+ * Filters an array of objects based on a query string.
+ *
+ * Supports plain text, regex, boolean/logical operators, and dataset helpers.
+ *
+ * **Examples**
+ * ```js
+ * search(rows: T[], 'alice'): T[] // Case-Insensitive
+ * search(rows: T[], 'Alice'): T[] // Case-Sensitive
+ *
+ * search(rows: T[], 'name = Alice'): T[] // loose equality
+ * search(rows: T[], 'name != Alice'): T[] // loose inequality
+ * search(rows: T[], 'role += admin'): T[] // Contains
+ * search(rows: T[], 'status -= archived'): T[] // Not Contain
+ * search(rows: T[], 'age > 18'): T[] // Greater Than
+ * search(rows: T[], 'age >= 18'): T[] // Greater Than or Equal
+ * search(rows: T[], 'age < 18'): T[] // Less Than
+ * search(rows: T[], 'age <= 18'): T[] // Less Than or Equal
+ *
+ * search(rows: T[], '/^alice/gi'): T[] // Global Regex
+ * search(rows: T[], 'name =~ ^Al'): T[] // Regex Match (shorthand)
+ * search(rows: T[], 'name =~ /^al/i'): T[] // Regex Match (with flags)
+ * search(rows: T[], 'email !~ /@test\.com$/i'): T[] // Regex Not Match
+ *
+ * search(rows: T[], 'unique(email)'): T[] // Unique property values
+ * search(rows: T[], 'duplicate(email)'): T[] // Duplicate property values
+ * search(rows: T[], 'distinct(type)'): T[] // Distinct property values
+ *
+ * search(rows: T[], 'active && role != admin'): T[] // ANDs
+ * search(rows: T[], 'email != null || distinct(email)'): T[] // ORs
+ * ```
+ *
+ * @param rows - Array of objects to filter
+ * @param query - Query string; see supported syntax above
+ * @param transform - Optional transform applied to each row before matching
+ * @returns The filtered array of rows
+ */
+export function search(rows: any[], query: string, transform: (r: any) => any = r => r): any[] {
+	if (!rows || !query?.trim()) return rows ?? [];
+
+	const q = query.trim();
+
+	// Global regex: /pattern/flags — strict, whole string, at least one valid flag
+	const globalRegex = /^\/(.+)\/([a-zA-Z]+)$/.exec(q);
+	if (globalRegex && [...globalRegex[2]].every(f => VALID_FLAGS.has(f))) {
+		const re = toRegex(q);
+		return rows.filter(r => re && Object.values(transform(r)).some((v: any) => {
+			try { return re.test(v?.toString() ?? ''); } catch { return false; }
+		}));
+	}
+
+	// Split top-level && into predicates and dataset helpers
+	const parts = q.split('&&').map(p => p.trim());
+	const helpers = parts.filter(p => /^(unique|duplicate|distinct)\(\w+\)$/.test(p));
+	const predicate = parts.filter(p => !helpers.includes(p)).join(' && ');
+
+	let filtered = predicate
+		? rows.filter(r => logicTest(transform(r), predicate))
+		: [...rows];
+
+	for (const h of helpers) {
+		const [, fn, field] = /^(\w+)\((\w+)\)$/.exec(h)!;
+		if (fn === 'distinct') continue; // run last
+		const freq = new Map<any, number>();
+		filtered.forEach(r => { const v = dotNotation(transform(r), field); freq.set(v, (freq.get(v) ?? 0) + 1); });
+		filtered = filtered.filter(r => fn === 'unique' ? freq.get(dotNotation(transform(r), field)) === 1 : (freq.get(dotNotation(transform(r), field)) ?? 0) > 1);
+	}
+
+	for (const h of helpers.filter(h => h.startsWith('distinct'))) {
+		const field = /\((\w+)\)/.exec(h)![1];
+		const seen = new Set();
+		filtered = filtered.filter(r => { const v = dotNotation(transform(r), field); return seen.has(v) ? false : !!seen.add(v); });
+	}
+
+	return filtered;
+}
+
+/**
+ * Tests object against a logic string.
+ *
+ * **Property operators**
+ * ```
+ * 'alice'                    // case-insensitive
+ * 'Alice'                    // case-sensitive
+ * 'name = Alice'             // loose equality (==)
+ * 'name == Alice'            // loose equality
+ * 'name != Alice'            // loose inequality
+ * 'role += admin'            // field contains value
+ * 'status -= archived'       // field does not contain value
+ * 'age > 21'                 // greater than
+ * 'age >= 21'                // greater than or equal
+ * 'age < 21'                 // less than
+ * 'age <= 21'                // less than or equal
+ * 'name =~ ^Al'              // regex match (shorthand)
+ * 'name =~ /^al/i'           // regex match (with flags)
+ * 'email !~ /@test\.com$/i'  // regex not match
+ * 'status = active && role != admin'    // ANDs
+ * 'status = active || status = pending' // ORs
+ * ```
+ *
+ * @param target - The object to test
+ * @param condition - The condition string; see supported syntax above
+ * @returns Whether the object satisfies the condition
  */
 export function logicTest(target: object, condition: string): boolean {
 	const evalBoolean = (a: any, op: string, b: any): boolean => {
 		switch (op) {
-			case '=':
-			case '==': return a == b;
+			case '=': case '==': return a == b;
 			case '!=': return a != b;
 			case '+=': return a?.toString().includes(b);
 			case '-=': return !a?.toString().includes(b);
@@ -46,26 +124,23 @@ export function logicTest(target: object, condition: string): boolean {
 			case '>=': return a >= b;
 			case '<': return a < b;
 			case '<=': return a <= b;
+			case '~=': try { return !!toRegex(b)?.test(a?.toString() ?? ''); } catch { return false; }
+			case '!~': try { return !toRegex(b)?.test(a?.toString() ?? ''); } catch { return false; }
 			default: return false;
 		}
-	}
+	};
 
-	const or = condition.split('||').map(p => p.trim()).filter(p => !!p);
-	return -1 != or.findIndex(p => {
-		// Make sure all ANDs pass
-		const and = p.split('&&').map(p => p.trim()).filter(p => !!p);
-		return and.filter(p => {
-			// Boolean operator
-			const prop = /(\S+)\s*(==?|!=|\+=|-=|>=|>|<=|<)\s*(\S+)/g.exec(p);
-			if(prop) {
-				const key = Object.keys(target).find(k => k.toLowerCase() == prop[1].toLowerCase());
-				return evalBoolean(dotNotation<any>(target, key || prop[1]),  prop[2], JSONAttemptParse(prop[3]));
-			}
-			// Case-sensitive
+	const resolve = (key: string) => dotNotation<any>(target, Object.keys(target).find(k => k.toLowerCase() === key.toLowerCase()) ?? key);
+
+	const evalExpr = (expr: string): boolean => {
+		const e = expr.trim();
+		const prop = /^(\S+)\s*(==?|!=|~=|!~|\+=|-=|>=|>|<=|<)\s*(.+)$/.exec(e);
+		if (prop) return evalBoolean(resolve(prop[1]), prop[2], JSONAttemptParse(prop[3].trim()));
 		const v = Object.values(target).map(JSONSerialize).join('');
-			if(/[A-Z]/g.test(condition)) return v.includes(p);
-			// Case-insensitive
-			return v.toLowerCase().includes(p);
-		}).length == and.length;
-	});
+		return /[A-Z]/.test(e) ? v.includes(e) : v.toLowerCase().includes(e.toLowerCase());
+	};
+
+	return condition.split('||').map(p => p.trim()).filter(Boolean).some(group =>
+		group.split('&&').map(p => p.trim()).filter(Boolean).every(evalExpr)
+	);
 }

src/string.ts

@@ -27,32 +27,6 @@ export function camelCase(str?: string): string {
 	return pascal.charAt(0).toLowerCase() + pascal.slice(1);
 }
 
-/**
- * Decode HTML escaped characters
- * @param html HTML to clean up
- * @returns {any}
- */
-export function decodeHtml(html: string) {
-	return html
-		.replace(/ /g, '\u00A0')
-		.replace(/"/g, '"')
-		.replace(/'/g, "'")
-		.replace(/&lt;/g, '<')
-		.replace(/&gt;/g, '>')
-		.replace(/&cent;/g, '¢')
-		.replace(/&pound;/g, '£')
-		.replace(/&yen;/g, '¥')
-		.replace(/&euro;/g, '€')
-		.replace(/&copy;/g, '©')
-		.replace(/&reg;/g, '®')
-		.replace(/&trade;/g, '™')
-		.replace(/&times;/g, '×')
-		.replace(/&divide;/g, '÷')
-		.replace(/&#(\d+);/g, (match, dec) => String.fromCharCode(dec))
-		.replace(/&#x([0-9a-fA-F]+);/g, (match, hex) => String.fromCharCode(parseInt(hex, 16)))
-		.replace(/&amp;/g, '&'); // Always last!
-}
-
 /**
  * Convert number of bytes into a human-readable size
  *
@@ -125,7 +99,6 @@ export function kebabCase(str?: string): string {
 	return wordSegments(str).map(w => w.toLowerCase()).join("-");
 }
 
-
 /**
  * Add padding to string
  *
@@ -256,18 +229,14 @@ export function strSplice(str: string, start: number, deleteCount: number, inser
 	return before + insert + after;
 }
 
-function titleCase(str: string) {
-	// Normalize separators: replace underscores and hyphens with spaces
-	let normalizedStr = str.replace(/(_|-)/g, ' ');
-	// Handle CamelCase/PascalCase boundaries: insert a space before capital letters
-	normalizedStr = normalizedStr.replace(/([a-z])([A-Z])/g, '$1 $2');
-	// Lowercase the whole string, split by any whitespace, and capitalize each word
-	let words = normalizedStr.toLowerCase().split(/\s+/).filter(Boolean);
-	const titledWords = words.map(word => {
-		if (word.length === 0) return '';
-		return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
-	});
-	return titledWords.join(' ');
+/**
+ * Converts text to Title Case
+ */
+export function titleCase(str?: string): string {
+	if(!str) return '';
+	return wordSegments(str)
+		.map(w => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+		.join(' ');
 }
 
 /**
@@ -280,19 +249,16 @@ function titleCase(str: string) {
  * @return {RegExpExecArray[]} Found matches.
  */
 export function matchAll(value: string, regex: RegExp | string): RegExpExecArray[] {
-	if(typeof regex === 'string') {
-		regex = new RegExp(regex, 'g');
-	}
-
-	// https://stackoverflow.com/a/60290199
-	if(!regex.global) {
-		throw new TypeError('Regular expression must be global.');
-	}
+	if(typeof regex === 'string') regex = new RegExp(regex, 'g');
+	if(!regex.global) throw new TypeError('Regular expression must be global.');
 
 	let ret: RegExpExecArray[] = [];
 	let match: RegExpExecArray | null;
 	while((match = regex.exec(value)) !== null) {
 		ret.push(match);
+		if(match[0].length === 0) {
+			regex.lastIndex++;
+		}
 	}
 
 	return ret;

tests/search.spec.ts

@@ -17,56 +17,131 @@ describe('Search Utilities', () => {
 			expect(search(rows, '')).toEqual(rows);
 		});
 
-		it('filters based on a simple property string', () => {
-			expect(search(rows, 'Alice')).toEqual([rows[0]]);
-		});
-
-		it('filters using regex when regex=true', () => {
-			expect(search(rows, '^B', true)).toEqual([rows[1]]);
-		});
-
-		it('applies the transform function before filtering', () => {
-			const transform = (r: any) => ({...r, name: r.name.toLowerCase()});
-			expect(search(rows, 'alice', false, transform)).toEqual([rows[0]]);
-		});
-
-		it('uses logicTest for non-regex search', () => {
-			expect(search(rows, 'age == 30')).toEqual([rows[0], rows[2]]);
-			expect(search(rows, 'id = 2')).toEqual([rows[1]]);
-		});
-
-		it('returns all if search is falsy and regex enabled', () => {
-			expect(search(rows, '', true)).toEqual(rows);
-		});
-
-		it('handles regex search with special characters', () => {
-			expect(search(rows, '^[AC]', true)).toEqual([rows[0], rows[2]]);
-		});
-
-		it('ignores case when regex is applied', () => {
-			expect(search(rows, 'ALICE', true)).toEqual([]);
-		});
-
-		it('performs partial matches for properties when regex=false', () => {
-			expect(search(rows, 'Da')).toEqual([rows[3]]);
-		});
-
 		it('handles empty array input gracefully', () => {
 			expect(search([], 'test')).toEqual([]);
 		});
 
-		it('handles numeric values with comparison logic in strings', () => {
-			expect(search(rows, 'age < 31')).toEqual([rows[0], rows[1], rows[2]]);
+		it('applies transform before filtering', () => {
+			const transform = (r: any) => ({...r, name: r.name.toLowerCase()});
+			expect(search(rows, 'alice', transform)).toEqual([rows[0]]);
 		});
 
-		// New test cases for `+` and `-` operators
-		it('filters rows using the + operator', () => {
+		describe('plain text', () => {
+			it('matches case-insensitively when lowercase', () => {
+				expect(search(rows, 'alice')).toEqual([rows[0]]);
+			});
+
+			it('matches case-sensitively when uppercase present', () => {
+				expect(search(rows, 'Alice')).toEqual([rows[0]]);
+				expect(search(rows, 'ALICE')).toEqual([]);
+			});
+
+			it('performs partial matches', () => {
+				expect(search(rows, 'Da')).toEqual([rows[3]]);
+			});
+		});
+
+		describe('global regex', () => {
+			it('matches with valid /pattern/flags syntax', () => {
+				expect(search(rows, '/^B/g')).toEqual([rows[1]]);
+			});
+
+			it('matches multiple rows', () => {
+				expect(search(rows, '/^[AC]/g')).toEqual([rows[0], rows[2]]);
+			});
+
+			it('respects flags', () => {
+				expect(search(rows, '/alice/i')).toEqual([rows[0]]);
+				expect(search(rows, '/alice/g')).toEqual([]);
+			});
+
+			it('does not treat /pattern/ without flags as regex', () => {
+				expect(search(rows, '/Alice/')).toEqual([]);
+			});
+
+			it('does not treat paths as regex', () => {
+				const pathRows = [{url: 'users/alice'}];
+				expect(search(pathRows, 'users/alice')).toEqual(pathRows);
+			});
+		});
+
+		describe('property operators', () => {
+			it('filters with equality', () => {
+				expect(search(rows, 'age == 30')).toEqual([rows[0], rows[2]]);
+				expect(search(rows, 'id = 2')).toEqual([rows[1]]);
+			});
+
+			it('filters with inequality', () => {
+				expect(search(rows, 'name != Alice')).toEqual([rows[1], rows[2], rows[3]]);
+			});
+
+			it('filters with contains', () => {
 				expect(search(rows, 'name += Al')).toEqual([rows[0]]);
 			});
 
-		it('filters rows using the - operator', () => {
+			it('filters with not-contains', () => {
 				expect(search(rows, 'name -= Al')).toEqual([rows[1], rows[2], rows[3]]);
 			});
+
+			it('filters with numeric comparisons', () => {
+				expect(search(rows, 'age < 31')).toEqual([rows[0], rows[1], rows[2]]);
+				expect(search(rows, 'age > 30')).toEqual([rows[3]]);
+				expect(search(rows, 'age >= 30')).toEqual([rows[0], rows[2], rows[3]]);
+			});
+		});
+
+		describe('property regex', () => {
+			it('matches with ~= shorthand', () => {
+				expect(search(rows, 'name ~= ^Al')).toEqual([rows[0]]);
+			});
+
+			it('matches with ~= /pattern/flags', () => {
+				expect(search(rows, 'name ~= /^al/i')).toEqual([rows[0]]);
+			});
+
+			it('excludes with !~', () => {
+				expect(search(rows, 'name !~ ^[AB]')).toEqual([rows[2], rows[3]]);
+			});
+		});
+
+		describe('logical operators', () => {
+			it('supports &&', () => {
+				expect(search(rows, 'age == 30 && name != Alice')).toEqual([rows[2]]);
+			});
+
+			it('supports ||', () => {
+				expect(search(rows, 'name = Alice || name = Bob')).toEqual([rows[0], rows[1]]);
+			});
+		});
+
+		describe('dataset helpers', () => {
+			const dupeRows = [
+				{id: 1, email: 'a@a.com', type: 'admin'},
+				{id: 2, email: 'b@b.com', type: 'user'},
+				{id: 3, email: 'a@a.com', type: 'user'},
+				{id: 4, email: 'c@c.com', type: 'admin'},
+			];
+
+			it('unique() returns rows where field appears once', () => {
+				expect(search(dupeRows, 'unique(email)')).toEqual([dupeRows[1], dupeRows[3]]);
+			});
+
+			it('duplicate() returns rows where field appears more than once', () => {
+				expect(search(dupeRows, 'duplicate(email)')).toEqual([dupeRows[0], dupeRows[2]]);
+			});
+
+			it('distinct() returns one row per field value', () => {
+				expect(search(dupeRows, 'distinct(type)')).toEqual([dupeRows[0], dupeRows[1]]);
+			});
+
+			it('composes helpers with predicates', () => {
+				expect(search(dupeRows, 'type = user && duplicate(email)')).toEqual([]);
+			});
+
+			it('applies distinct last', () => {
+				expect(search(dupeRows, 'duplicate(email) && distinct(type)')).toEqual([dupeRows[0], dupeRows[2]]);
+			});
+		});
 	});
 
 	describe('logicTest', () => {
@@ -83,60 +158,63 @@ describe('Search Utilities', () => {
 			expect(logicTest(obj, 'x < 5')).toBe(false);
 		});
 
-		it('supports case insensitive property search', () => {
-			expect(logicTest(obj, 'alpha')).toBeTruthy();
-			expect(logicTest(obj, 'ALPHA')).toBeFalsy();
+		it('handles contains and not-contains', () => {
+			expect(logicTest(obj, 'name += Alpha')).toBe(true);
+			expect(logicTest(obj, 'name += Alp')).toBe(true);
+			expect(logicTest(obj, 'name += Bet')).toBe(false);
+			expect(logicTest(obj, 'name -= Alpha')).toBe(false);
+			expect(logicTest(obj, 'name -= Bet')).toBe(true);
+			expect(logicTest(obj, 'name += lph')).toBe(true);
+			expect(logicTest(obj, 'name -= lph')).toBe(false);
 		});
 
-		it('handles logical AND/OR expressions', () => {
+		it('handles property regex ~=', () => {
+			expect(logicTest(obj, 'name ~= ^Alp')).toBe(true);
+			expect(logicTest(obj, 'name ~= /^alp/i')).toBe(true);
+			expect(logicTest(obj, 'name ~= ^Bet')).toBe(false);
+		});
+
+		it('handles property regex !~', () => {
+			expect(logicTest(obj, 'name !~ ^Bet')).toBe(true);
+			expect(logicTest(obj, 'name !~ ^Alp')).toBe(false);
+		});
+
+		it('handles invalid regex gracefully', () => {
+			expect(logicTest(obj, 'name ~= [invalid')).toBe(false);
+		});
+
+		it('supports plain text case-insensitive search', () => {
+			expect(logicTest(obj, 'alpha')).toBe(true);
+		});
+
+		it('supports plain text case-sensitive search', () => {
+			expect(logicTest(obj, 'Alpha')).toBe(true);
+			expect(logicTest(obj, 'ALPHA')).toBe(false);
+		});
+
+		it('handles logical AND/OR', () => {
 			expect(logicTest(obj, 'x == 10 && y == 5')).toBe(true);
 			expect(logicTest(obj, 'x == 10 || y == 100')).toBe(true);
 			expect(logicTest(obj, 'x == 1 && y == 5')).toBe(false);
 		});
 
+		it('handles numeric ranges', () => {
+			expect(logicTest(obj, 'x > 5 && x < 15')).toBe(true);
+			expect(logicTest(obj, 'x > 15')).toBe(false);
+		});
+
+		it('matches keys case-insensitively', () => {
+			const mixedCaseObj = {TestKey: 123};
+			expect(logicTest(mixedCaseObj, 'TestKey == 123')).toBe(true);
+			expect(logicTest(mixedCaseObj, 'testkey == 123')).toBe(true);
+		});
+
 		it('returns false for unsupported operators', () => {
 			expect(logicTest(obj, 'x === 10')).toBe(false);
 		});
 
-		it('handles invalid condition strings gracefully', () => {
-			expect(logicTest(obj, 'invalid condition')).toBe(false);
-		});
-
-		it('supports numeric operations with ranges', () => {
-			expect(logicTest(obj, 'x > 5 && x < 15')).toBe(true);
-			expect(logicTest(obj, 'x > 15')).toBe(false);
-		});
-
-		it('handles mixed case keys gracefully', () => {
-			const mixedCaseObj = {TestKey: 123};
-			expect(logicTest(mixedCaseObj, 'TestKey == 123')).toBe(true);
-			expect(logicTest(mixedCaseObj, 'testkey == 123')).toBe(true);
-		});
-
-		it('returns false if condition operators are missing', () => {
+		it('returns false for missing operators', () => {
 			expect(logicTest(obj, 'x 10')).toBe(false);
 		});
-
-		// New test cases for `+` and `-` operators
-		it('handles the + operator for inclusion', () => {
-			expect(logicTest(obj, 'name += Alpha')).toBe(true);
-			expect(logicTest(obj, 'name += Alp')).toBe(true);
-			expect(logicTest(obj, 'name += Bet')).toBe(false);
-		});
-
-		it('handles the - operator for exclusion', () => {
-			expect(logicTest(obj, 'name -= Alpha')).toBe(false);
-			expect(logicTest(obj, 'name -= Alp')).toBe(false);
-			expect(logicTest(obj, 'name -= Bet')).toBe(true);
-		});
-
-		it('includes partial matches correctly with +', () => {
-			expect(logicTest(obj, 'name += lph')).toBe(true);
-		});
-
-		it('excludes partial matches correctly with -', () => {
-			expect(logicTest(obj, 'name -= lph')).toBe(false);
-			expect(logicTest(obj, 'name -= xyz')).toBe(true);
-		});
 	});
 });