@yongdall/common 0.1.0

package/index.mjs

@@ -0,0 +1,1158 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+//#region packages/common/Search/util.mjs
+/**
+* @template T
+* @template TReturn
+* @template TNext
+* @param {Generator<T, TReturn, TNext>} generator 
+* @param {(value: T) => TNext} run 
+* @param {TNext} def 
+*/
+function runGenerator(generator, run, def) {
+	/** @type {TNext} */
+	let value = def;
+	for (;;) {
+		const result = generator.next(value);
+		if (result.done) return result.value;
+		value = run(result.value);
+	}
+}
+/**
+* @template T
+* @template TReturn
+* @template TNext
+* @param {Generator<T, TReturn, TNext>} generator 
+* @param {(value: T) => PromiseLike<TNext> | TNext} run 
+* @param {TNext} def 
+*/
+async function asyncRunGenerator(generator, run, def) {
+	/** @type {TNext} */
+	let value = def;
+	for (;;) {
+		const result = generator.next(value);
+		if (result.done) return result.value;
+		value = await run(result.value);
+	}
+}
+
+//#endregion
+//#region packages/common/Search/exec.mjs
+/** @import { Children, Field, Match, Or } from './types.mjs' */
+/**
+* 
+* @param {Record<string, any>[]} data 
+* @param {Field[]} fields 
+* @returns {any[]}
+*/
+function select(data, fields) {
+	let list = data;
+	for (let item of fields) {
+		const [field, ...sub] = typeof item === "string" ? [item] : item;
+		if (!list.length) continue;
+		/** @type {any[]} */
+		const subList = [];
+		it: for (const item of list) {
+			if (!item || typeof item !== "object") continue;
+			if (!Object.hasOwn(item, field)) continue;
+			let value = item[field];
+			for (const index of sub) {
+				if (!Array.isArray(value)) continue it;
+				value = value[index];
+			}
+			subList.push(value);
+		}
+		list = subList.flat(Infinity).filter((v) => v && typeof v === "object");
+	}
+	return list;
+}
+/**
+* 
+* @param {Record<string, any>[]} list 
+* @param {string} field 
+* @returns {any[]}
+*/
+function selectValue(list, field) {
+	/** @type {any[]} */
+	const subList = [];
+	for (const item of list) {
+		if (!item || typeof item !== "object") continue;
+		if (!Object.hasOwn(item, field)) continue;
+		subList.push(item[field]);
+	}
+	return subList;
+}
+/**
+* @typedef {object} ExecParam
+* @property {string[]} fields
+* @property {string} operator
+* @property {string?} [sign]
+* @property {any} value
+* @property {any[]} values
+*/
+/**
+* 
+* @param {Record<string, any>[]} data 
+* @param {string[]} parentFields 
+* @param {Match} match 
+* @returns {Generator<ExecParam, boolean?, boolean?>}
+*/
+function* execMatch(data, parentFields, match) {
+	const fields = [...match[0]];
+	const currentFields = [...parentFields, ...fields.map((v) => typeof v === "string" ? v : v[0])];
+	const last = fields.pop();
+	if (!last) return null;
+	const lastField = typeof last === "string" ? last : last[0];
+	const records = select(data, fields);
+	if (!records.length) return false;
+	const [, value, operator, sign] = match;
+	if (operator === null) {
+		const values = selectValue(records, lastField);
+		return sign ? values.find((v) => v === null) : values.find((v) => v !== null);
+	}
+	if (typeof value !== "object" || !value || Array.isArray(value)) {
+		const values = selectValue(records, lastField);
+		if (!values.length) return false;
+		return yield {
+			fields: currentFields,
+			operator,
+			sign,
+			value,
+			values
+		};
+	}
+	if (value.filter || value.table || value.placeholder) return null;
+	const field = value.field;
+	if (!field) return null;
+	/** @type {boolean?} */
+	let defResult = false;
+	for (const item of records) {
+		if (!item || typeof item !== "object") continue;
+		if (!Object.hasOwn(item, field)) continue;
+		if (!Object.hasOwn(item, lastField)) continue;
+		defResult = null;
+		const result = yield {
+			fields: currentFields,
+			operator,
+			sign,
+			value: item[field],
+			values: [item[lastField]]
+		};
+		if (result === null) continue;
+		return result;
+	}
+	return defResult;
+}
+/**
+* 
+* @param {Record<string, any>[]} data 
+* @param {string[]} parentFields 
+* @param {Match | Children | Or} match 
+* @returns {Generator<ExecParam, boolean?, boolean?>}
+*/
+function* execItem(data, parentFields, match) {
+	if (!Array.isArray(match)) {
+		const { and, or } = match;
+		return yield* execOr(data, parentFields, and, or);
+	}
+	if (match.length !== 2) return yield* execMatch(data, parentFields, match);
+	/** @type {boolean?} */
+	let defResult = null;
+	const values = select(data, match[0]);
+	if (!values.length) return false;
+	const fields = [...parentFields, ...match[0].map((v) => typeof v === "string" ? v : v[0])];
+	for (const item of match[1]) {
+		const result = yield* execItem(values, fields, item);
+		if (result === null) continue;
+		if (!result) return false;
+		defResult = true;
+	}
+	return defResult;
+}
+/**
+* 
+* @param {Record<string, any>[]} list 
+* @param {string[]} parentFields 
+* @param {(Match | Children)[]} [and] 
+* @param {(Match | Children | Or)[]} [or] 
+* @returns {Generator<ExecParam, boolean?, boolean?>}
+*/
+function* execOr(list, parentFields, and, or) {
+	/** @type {boolean?} */
+	let defResult = null;
+	if (Array.isArray(and)) for (const item of and) {
+		const result = yield* execItem(list, parentFields, item);
+		if (result === null) continue;
+		if (!result) return false;
+		defResult = true;
+	}
+	if (Array.isArray(or)) for (const item of or) {
+		const result = yield* execItem(list, parentFields, item);
+		if (result === null) continue;
+		if (result) return true;
+		defResult = true;
+	}
+	return defResult;
+}
+/**
+* 
+* @param {Record<string, any>} data 
+* @param {(value: ExecParam) => boolean?} exec 
+* @param {(Match | Children)[]} [and] 
+* @param {(Match | Children | Or)[]} [or] 
+*/
+function exec(data, exec, and, or) {
+	return runGenerator(execOr([data].flat(), [], and, or), exec, null);
+}
+/**
+* 
+* @param {Record<string, any>} data 
+* @param {(value: ExecParam) => PromiseLike<boolean?> | boolean?} exec 
+* @param {(Match | Children)[]} [and] 
+* @param {(Match | Children | Or)[]} [or] 
+*/
+async function asyncExec(data, exec, and, or) {
+	return asyncRunGenerator(execOr([data].flat(), [], and, or), exec, null);
+}
+
+//#endregion
+//#region packages/common/Search/fill.mjs
+/** @import { Value } from './types.mjs' */
+/** @import { Children, Field, FieldValue, Match, Or } from './types.mjs' */
+/**
+* 
+* @template {Match | Children | Or} T 
+* @param {T[]} match 
+* @returns {Generator<Value | (() => Value), T[]?, Value | (() => string | null) | null>}
+*/
+function* fillList(match) {
+	/** @type {T[]} */
+	let list = [];
+	let has = false;
+	for (const child of match) {
+		const val = yield* fillMatch(child);
+		list.push(val || child);
+		if (val) has = true;
+	}
+	return has ? list : null;
+}
+/**
+* 
+* @template {Match | Children | Or} T 
+* @param {T} match 
+* @returns {Generator<Value | (() => Value), T?, Value | (() => string | null) | null>}
+*/
+function* fillMatch(match) {
+	if (!Array.isArray(match)) {
+		const and = match.and && (yield* fillMatches(match.and));
+		const or = match.or && (yield* fillMatches(match.or));
+		if (!and && !or) return null;
+		return {
+			and: and || match.and,
+			or: or || match.or
+		};
+	}
+	if (match.length === 2) {
+		if (!(yield* fillMatches(match[1]))) return null;
+		return [match[0], match[1]];
+	}
+	const value = yield match[1];
+	if (value === null) return null;
+	return [
+		match[0],
+		value,
+		match[2],
+		match[3]
+	];
+}
+/**
+* 
+* @template {Match | Children | Or} T 
+* @param {T[]} match 
+* @returns {Generator<Value | (() => Value), T[]?, Value | (() => string | null) | null>}
+*/
+function* fillMatches(match) {
+	/** @type {T[]} */
+	const list = [];
+	let has = false;
+	for (const child of match) {
+		const val = yield* fillMatch(child);
+		list.push(val || child);
+		if (val) has = true;
+	}
+	return has ? list : null;
+}
+/**
+* 
+* @template {Match | Children | Or} T 
+* @param {T[] | null | undefined} match 
+* @param {(placeholder: string) => string | (() => string | null) | null} getPlaceholder 
+* @returns {T[]}
+*/
+function fill(match, getPlaceholder) {
+	if (!match) return [];
+	/**
+	* 
+	* @template {Value | (() => Value)} T 
+	* @param {T} match 
+	* @returns {Value | (() => string | null) | null}
+	*/
+	function fillValue(match) {
+		if (!match || typeof match !== "object") return null;
+		if (Array.isArray(match)) return null;
+		const placeholder = match.placeholder;
+		if (!placeholder || typeof placeholder !== "string") return null;
+		return getPlaceholder(placeholder);
+	}
+	return runGenerator(fillList(match), fillValue, null) || match;
+}
+
+//#endregion
+//#region packages/common/Search/parse.mjs
+/** @import { RecursiveArray } from '../types/types.mjs' */
+/** @import { Children, Field, Match, Or, Param, Value } from './types.mjs' */
+/**
+* @typedef {object} Parse.Field
+* @property {string} field
+* @property {string?} [group]
+* @property {number[]} sub
+*/
+/**
+* @typedef {object} Parse.Match
+* @property {null} [children]
+* @property {Parse.Field[]} fields
+* @property {string?} operator
+* @property {string} [sign]
+* @property {Value} value
+*/
+/**
+* @typedef {object} Parse.Children
+* @property {Parse.Field[]} fields
+* @property {(Parse.Match | Parse.Children)[]} children
+*/
+/**
+* 
+* @param {Parse.Field[]} fields 
+* @returns {Field[]}
+*/
+function compressFields(fields) {
+	return fields.map(({ field, sub }) => sub.length ? [field, ...sub] : field);
+}
+/**
+* 
+* @param {Parse.Match | Parse.Children} v 
+* @returns {Match | Children}
+*/
+function compressAndItem(v) {
+	if (v.children) return [compressFields(v.fields), v.children.map(compressAndItem)];
+	const { fields, operator, value, sign } = v;
+	return [
+		compressFields(fields),
+		value,
+		operator,
+		sign
+	];
+}
+const fieldParserRegex = /^([-_\d\p{L}]+)((?:\[-?\d+\])*)$/u;
+/**
+* 
+* @param {string} l 
+*/
+function parseFields(l) {
+	/** @type {Parse.Field[]} */
+	const fields = [];
+	for (const v of l.split(".")) {
+		if (!v || v[0] === "?") return null;
+		const index = v.indexOf("?");
+		const r = fieldParserRegex.exec(index > 0 ? v.slice(0, index) : v);
+		if (!r) return null;
+		const sub = r[2]?.split(/\[|\]/).filter(Boolean).map((v) => parseInt(v) || 0) || [];
+		const group = index > 0 ? v.slice(index) : void 0;
+		fields.push({
+			field: r[1],
+			group,
+			sub
+		});
+	}
+	return fields;
+}
+/** @param {string} v  */
+const decodeValue = (v) => decodeURIComponent(v.replaceAll("+", " "));
+/**
+* 
+* @param {string} s 
+* @returns {string | RecursiveArray<string>?}
+*/
+function parseArrayValue(s) {
+	/** @type {(string | RecursiveArray<string>)[]} */
+	const root = [];
+	/** @type {(string | RecursiveArray<string>)[][]} */
+	const stack = [];
+	let current = root;
+	/** @type {string[]} */
+	let strings = [];
+	let end = false;
+	let must = true;
+	function add() {
+		current.push(decodeValue(strings.join()));
+		strings = [];
+	}
+	for (const c of s) {
+		if (c === ",") {
+			if (end) end = false;
+			else add();
+			must = true;
+			continue;
+		}
+		if (c === ")") {
+			if (must || strings.length) {
+				add();
+				must = false;
+			}
+			const last = stack.pop();
+			if (!last) return null;
+			last.push(current);
+			current = last;
+			end = true;
+			continue;
+		}
+		if (end) return null;
+		must = false;
+		if (c !== "(") {
+			strings.push(c);
+			continue;
+		}
+		if (strings.length) return null;
+		stack.push(current);
+		current = [];
+	}
+	if (must || strings.length) add();
+	if (stack.length) return null;
+	return root.length === 1 ? root[0] : root;
+}
+const valueQRegex = /^([-_\d\p{L}]+)@([-_\d\p{L}]+)/u;
+/**
+* 
+* @param {string?} v 
+* @returns {Value | true}
+*/
+function parseValue(v) {
+	if (v === null) return true;
+	if (v[0] === "?") return { placeholder: decodeValue(v.slice(1)) };
+	if (v[0] === ":") return { field: decodeValue(v.slice(1)) };
+	if (v[0] === "@") return null;
+	if (valueQRegex.test(v)) return null;
+	if (v.includes("(") || v.includes(")")) {
+		const list = parseArrayValue(v);
+		if (list) return list;
+	}
+	if (v.includes(",")) return v.split(",").map((v) => decodeValue(v.replaceAll("+", " ")));
+	return decodeValue(v);
+}
+/**
+* 
+* @param {(Parse.Match | Parse.Children)[]} list 
+* @returns {Iterable<Match | Children>}
+*/
+function* toAnd(list) {
+	/** @type {[(Parse.Match | Parse.Children), Parse.Field[], Parse.Field[]][]} */
+	const values = list.map((v) => {
+		const fields = v.fields;
+		const index = fields.findLastIndex((v) => v.group);
+		if (index < 0 || index >= fields.length - 1) return [
+			v,
+			[],
+			[]
+		];
+		const field = fields[index];
+		if (!field) return [
+			v,
+			[],
+			[]
+		];
+		return [
+			{
+				...v,
+				fields: fields.slice(index + 1)
+			},
+			fields.slice(0, index + 1),
+			[...fields.slice(0, index), {
+				...field,
+				group: void 0
+			}]
+		];
+	});
+	const map = Object.groupBy(values, (v) => JSON.stringify(v[1]));
+	yield* map["[]"]?.map((v) => compressAndItem(v[0])) || [];
+	delete map["[]"];
+	/** @type {Parse.Children[]} */
+	const result = Object.values(map).filter(Boolean).map((list = []) => {
+		if (!list?.length) return {
+			fields: [],
+			children: []
+		};
+		return {
+			fields: list[0][2] || [],
+			children: list.map((v) => v[0])
+		};
+	}).filter((v) => v.fields.length);
+	if (!result.length) return;
+	yield* toAnd(result);
+}
+/**
+* 
+* @param {(Parse.Match & {groups: string[]})[]} list 
+* @returns {Or}
+*/
+function toOr(list) {
+	const map = Map.groupBy(list, (v) => v.groups.shift() ?? null);
+	const and = map.get(null) || [];
+	const baseOr = map.get("") || [];
+	map.delete(null);
+	map.delete("");
+	return {
+		or: [...baseOr.map((v) => compressAndItem(v)), ...[...map.values()].map((v) => toOr(v))],
+		and: [...toAnd(and)]
+	};
+}
+/**
+* 
+* @param {string} search 
+* @returns {Param}
+*/
+function parse(search, split = "&") {
+	/** @type {string[]} */
+	const values = [];
+	/** @type {string[]} */
+	const select = [];
+	/** @type {[field: string, desc?: boolean][]} */
+	const sorts = [];
+	let limit = 0;
+	let offset = 0;
+	let page = 0;
+	/** @type {Record<string, string>} */
+	const placeholders = {};
+	/** @type {(Parse.Match & {groups: string[]})[]} */
+	const allMatches = [];
+	for (const s of search.split(split)) {
+		if (s[0] === "=") {
+			values.push(s.slice(1));
+			continue;
+		}
+		const index = s.indexOf("=");
+		const key = index < 0 ? s : s.slice(0, index);
+		const val = index < 0 ? null : s.slice(index + 1);
+		if (index <= 0) continue;
+		if (`.!@^*<>{}[]()+|;,"'\`\\/`.includes(key[0])) continue;
+		if (key[0] === "?") {
+			placeholders[decodeValue(key.slice(1))] = decodeValue(val || "");
+			continue;
+		}
+		if (key[0] === ":") {
+			const name = key.slice(1);
+			if (!val) continue;
+			if (name === "sort") sorts.push(...val.split(",").filter(Boolean).map((v) => {
+				const desc = v[0] === "-";
+				return [decodeValue(desc ? v.slice(1) : v), desc];
+			}).filter(Boolean));
+			else if (name === "select") select.push(...val.split(",").map(decodeValue).filter(Boolean));
+			else if (name === "limit") {
+				if (val && /^\d+$/.test(val)) limit = parseInt(val);
+			} else if (name === "offset") {
+				if (val && /^\d+$/.test(val)) offset = parseInt(val);
+			} else if (name === "page") {
+				if (val && /^\d+$/.test(val)) page = parseInt(val);
+			}
+			continue;
+		}
+		const sg = key.split("~");
+		let field = sg.pop() || "";
+		let sign = "";
+		if ("!".includes(field[field.length - 1])) {
+			sign = "!";
+			field = field.slice(0, -1);
+		}
+		const l = field.split(":", 3);
+		if (l.length > 2) continue;
+		const fields = parseFields(l[0]);
+		if (!fields) continue;
+		const value = parseValue(val);
+		if (value === null) continue;
+		const operator = decodeValue(l[1] || "");
+		const groupIndex = sg.indexOf("");
+		const groups = groupIndex < 0 ? sg : sg.slice(0, groupIndex + 1);
+		allMatches.push({
+			groups,
+			fields,
+			operator: !operator && value === true ? null : operator,
+			sign,
+			value: value === true ? null : value
+		});
+	}
+	const { and, or } = toOr(allMatches);
+	/** @type {Param} */
+	const result = {};
+	if (values?.length) result.values = values;
+	if (limit && limit > 0) result.limit = limit;
+	if (page && page > 0) result.page = page;
+	if (offset && offset > 0) result.offset = offset;
+	if (select?.length) result.select = select;
+	if (sorts?.length) result.sort = sorts;
+	const where = and;
+	if (where?.length) result.where = where;
+	const orWhere = or;
+	if (orWhere?.length) result.orWhere = orWhere;
+	if (Array.isArray(placeholders) && placeholders.length) result.placeholders = placeholders;
+	return result;
+}
+
+//#endregion
+//#region packages/common/Search/merge.mjs
+/** @import { Param } from './types.mjs' */
+/**
+* 
+* @param {Partial<Param>} a 
+* @param {Partial<Param>} b 
+* @returns {Param}
+*/
+function merge(a, b) {
+	const limit = b.limit || a.limit || 10;
+	const page = b.page ?? a.page;
+	const offset = b.offset ?? (b.limit && (b.page || b.page === 0) ? (Math.floor(Math.max(b.page || 0, 1)) - 1) * b.limit : null) ?? a.offset ?? (a.limit && (a.page || a.page === 0) ? (Math.floor(Math.max(a.page || 0, 1)) - 1) * a.limit : null) ?? (Math.floor(Math.max(page || 0, 1)) - 1) * limit;
+	const values = [...a.values || [], ...b.values || []];
+	const sort = [...a.sort || [], ...b.sort || []];
+	const select = [...a.select || [], ...b.select || []];
+	const where = [...a.where || [], ...b.where || []];
+	const orWhere = [...a.orWhere || [], ...b.orWhere || []];
+	const or = [...a.or || [], ...b.or || []];
+	/** @type {Param} */
+	const result = {};
+	if (values?.length) result.values = values;
+	if (limit && limit > 0) result.limit = limit;
+	if (page && page > 0) result.page = page;
+	if (offset && offset > 0) result.offset = offset;
+	if (select?.length) result.select = select;
+	if (sort?.length) result.sort = sort;
+	if (where?.length) result.where = where;
+	if (orWhere?.length) result.orWhere = orWhere;
+	if (or?.length) result.or = or;
+	return result;
+}
+
+//#endregion
+//#region packages/common/Search/stringify.mjs
+/** @import { RecursiveArray } from '../types/types.mjs' */
+/** @import { Children, Field, FieldValue, Match, Or, Param } from './types.mjs' */
+/** @param {string} v  */
+const encodeValue = (v) => encodeURIComponent(v).replaceAll("%20", "+");
+/**
+* 
+* @param {string | RecursiveArray<string> | FieldValue} value 
+*/
+function stringifyValue(value) {
+	if (Array.isArray(value)) {
+		/**
+		* 
+		* @param {string | RecursiveArray<string>} v 
+		* @returns {string}
+		*/
+		function s(v) {
+			if (Array.isArray(v)) return `(${v.map(s).join(",")})`;
+			return encodeValue(v);
+		}
+		const val = value.map(s).join(",");
+		if (value.length > 1) return val;
+		return `(${val})`;
+	}
+	if (typeof value !== "object") return encodeValue(value);
+	const { field, placeholder } = value;
+	if (placeholder) return `?${encodeValue(placeholder)}`;
+	if (field) return `:${encodeValue(field)}`;
+	return "";
+}
+/**
+* 
+* @param {Field[]} fields 
+*/
+function stringifyFields(fields) {
+	return fields.map((item) => {
+		const [field, ...sub] = typeof item === "string" ? [item] : item;
+		return `${encodeValue(field)}${sub.map(() => `[k]`).join("")}`;
+	}).join(".");
+}
+/**
+* 
+* @param {Match} define 
+*/
+function stringifyDefine([fields, value, operator, sign]) {
+	const key = operator ? `${stringifyFields(fields)}:${encodeValue(operator)}${sign || ""}` : `${stringifyFields(fields)}${sign || ""}`;
+	if (operator === null) return key;
+	if (value === null) return "";
+	if (typeof value === "function") return "";
+	return `${key}=${stringifyValue(value)}`;
+}
+/**
+* 
+* @param {(Match | Children)[]} list 
+* @returns {string[]}
+*/
+function stringifyAnd(list) {
+	let index = 0;
+	return list.flatMap((v) => {
+		if (v.length !== 2) return stringifyDefine(v);
+		const list = stringifyAnd(v[1]);
+		if (!list.length) return [];
+		let key = stringifyFields(v[0]);
+		if (list.length > 1) key += `?${(index++).toString(36)}`;
+		return list.map((v) => `${key}.${v}`);
+	}).filter(Boolean);
+}
+/**
+* 
+* @param {(Match | Children | Or)[]} list 
+* @returns {string[]}
+*/
+function stringifyOr(list) {
+	let index = 0;
+	return list.map((v) => {
+		if (Array.isArray(v)) return stringifyAnd([v]);
+		return [...stringifyAnd(v.and || []), ...stringifyOr(v.or || [])];
+	}).flatMap((list) => {
+		if (!list) return [];
+		const key = list.length === 1 ? `~` : `${(index++).toString(36)}~`;
+		return list.map((v) => `${key}${v}`);
+	});
+}
+/**
+* 
+* @param {Partial<Param>} query 
+* @param {boolean} [usePage] 
+*/
+function stringify({ values, where, orWhere, sort, select, limit, offset, page, placeholders }, usePage) {
+	/** @type {string[]} */
+	let queries = [];
+	for (const v of values || []) {
+		if (!v) continue;
+		queries.push(`=${encodeValue(v)}`);
+	}
+	if (limit && limit > 0) queries.push(`:limit=${limit}`);
+	if (usePage) {
+		if (page && page > 0) queries.push(`:page=${page}`);
+	} else if (offset && offset > 0) queries.push(`:offset=${offset}`);
+	if (select) {
+		const val = select.filter(Boolean).map(encodeValue).join(",");
+		if (val) queries.push(`.select=${val}`);
+	}
+	if (sort) {
+		const val = sort.filter(Boolean).map((v) => {
+			if (Array.isArray(v)) {
+				const [field, desc] = v;
+				if (field) return `${desc ? "-" : ""}${encodeValue(field)}`;
+			} else if (v) return encodeValue(v);
+			return "";
+		}).filter(Boolean).join(",");
+		if (val) queries.push(`.sort=${val}`);
+	}
+	if (placeholders && typeof placeholders === "object" && !Array.isArray(placeholders)) for (const [k, v] of Object.entries(placeholders)) queries.push(`?${encodeValue(k)}=${encodeValue(v)}`);
+	for (const v of stringifyAnd(where || [])) queries.push(v);
+	for (const v of stringifyOr(orWhere || [])) queries.push(v);
+	return queries.join("&");
+}
+
+//#endregion
+//#region packages/common/Search/index.mjs
+var Search_exports = /* @__PURE__ */ __exportAll({
+	asyncExec: () => asyncExec,
+	asyncRunGenerator: () => asyncRunGenerator,
+	exec: () => exec,
+	fill: () => fill,
+	fillMatches: () => fillMatches,
+	merge: () => merge,
+	parse: () => parse,
+	runGenerator: () => runGenerator,
+	stringify: () => stringify
+});
+
+//#endregion
+//#region packages/common/Hook.mjs
+/**
+* @template T
+* @typedef {T | readonly T[]} Hook.MaybeArray
+*/
+/**
+* @template T
+* @typedef {T extends readonly any[] ? Readonly<T>
+*   : T extends Record<string, any> ? Hook.MaybeArray<Hook.Define<T> | T>
+*   : T extends object ? Hook.MaybeArray<Hook.Define<T> | T>
+*   : Hook.MaybeArray<T>
+* } Hook.Item
+*/
+/**
+* @template T
+* @typedef {T extends Record<string, any> ? { [k in keyof T]?: Hook.Item<T[k]> } : T} Hook.Define
+*/
+/** @type {*} */
+const noopFilter = () => true;
+/**
+* 
+* @param {Record<string, any>} plugin 
+* @param {string[]} name 
+* @returns {*[]}
+*/
+function findHook(plugin, name) {
+	let list = [plugin].flat();
+	for (const k of name.filter(Boolean)) {
+		const values = [];
+		for (const it of list) {
+			if (!it || typeof it !== "object") continue;
+			if (!Object.hasOwn(it, k)) continue;
+			values.push(it[k]);
+		}
+		if (!values.length) return [];
+		list = values.flat();
+	}
+	return list;
+}
+/**
+* 
+* @template T
+* @param {any} plugin 
+* @param {string[]} names 
+* @returns {T | void}
+*/
+function first(plugin, names) {
+	if (!names.length) return plugin;
+	if (!plugin || typeof plugin !== "object") return;
+	const [name, ...keys] = names;
+	for (const v of [plugin].flat()) {
+		const val = first(v[name], keys);
+		if (val !== void 0) return val;
+	}
+}
+/**
+* 
+* @template T
+* @param {Record<string, any>} hooks 
+* @param {string[]} name 
+* @returns {IterableIterator<T>}
+*/
+function* values(hooks, name) {
+	for (const it of Object.values(hooks)) for (const value of findHook(it, name)) yield value;
+}
+/**
+* @template T
+*/
+var Hook = class Hook {
+	/**
+	* @template {object} T
+	* @param {Record<string, Hook.Define<T>> | (() => Record<string, Hook.Define<T>>)} [options]
+	* @return {Hook<T>}
+	*/
+	static build(options) {
+		const hook = new Hook();
+		return Hook.update(hook, options);
+	}
+	/**
+	* 
+	* @template T
+	* @param {Hook<T>} hook
+	* @param {Record<string, Hook.Define<T>> | (() => Record<string, Hook.Define<T>>)} [options]
+	*/
+	static update(hook, options) {
+		let updated = false;
+		if (typeof options === "function") {
+			Object.defineProperty(hook.#config, "hooks", {
+				configurable: true,
+				get() {
+					const r = options();
+					return typeof r === "object" && r || {};
+				}
+			});
+			updated = true;
+		} else if (options && typeof options === "object") {
+			Object.defineProperty(hook.#config, "hooks", {
+				configurable: true,
+				value: options
+			});
+			updated = true;
+		}
+		if (updated) Hook.reset(hook);
+		return hook;
+	}
+	/**
+	* 
+	* @template T
+	* @param {Hook<T>} hook
+	*/
+	static reset(hook) {
+		const hooks = hook.#hooks;
+		const resetFn = hook.#config.resetFn;
+		resetFn.sort(([, a], [, b]) => a - b);
+		const before = resetFn.filter(([, p]) => p <= 0);
+		const after = resetFn.filter(([, p]) => p > 0);
+		for (const [fn] of before) fn();
+		for (const fn of values(hooks, ["reset"])) {
+			if (typeof fn !== "function") continue;
+			fn();
+		}
+		for (const [fn] of after) fn();
+	}
+	/** @type {{hooks: any; resetFn: [fn: () => void, hysteresis: number][]}} */
+	#config = {
+		hooks: Object.create(null),
+		resetFn: []
+	};
+	/** @type {string[]} */
+	#keys = [];
+	#stringTag = "Hook";
+	[Symbol.iterator]() {
+		return this.entries();
+	}
+	[Symbol.toStringTag]() {
+		return this.#stringTag;
+	}
+	/** @param {string} hint */
+	[Symbol.toPrimitive](hint) {
+		if (hint === "number") return NaN;
+		return `[${this[Symbol.toStringTag]()}]`;
+	}
+	get #hooks() {
+		return this.#config.hooks;
+	}
+	/**
+	* @template {T extends readonly any[] ? never : T extends object ? string & keyof T : never} K
+	* @param {K} key 
+	* @returns {Hook<Exclude<T extends readonly any[] ? never : T extends object ? T[K] :never, void | undefined>>}
+	*/
+	get(key) {
+		const keys = [...this.#keys, key];
+		const hook = new Hook();
+		hook.#config = this.#config;
+		hook.#keys = keys;
+		hook.#stringTag = `Hook(${keys.join(".")})`;
+		return hook;
+	}
+	/**
+	* @param  {T extends (...args: infer A) => any ? A : []} args 
+	* @returns 
+	*/
+	call(...args) {
+		for (const fn of this.values()) {
+			if (typeof fn !== "function") continue;
+			fn(...args);
+		}
+	}
+	/**
+	* 
+	* @param {string} plugin 
+	* @returns {T | void}
+	*/
+	first(plugin) {
+		const hooks = this.#hooks;
+		if (!Object.hasOwn(hooks, plugin)) return;
+		return first(hooks[plugin], this.#keys.filter(Boolean));
+	}
+	/**
+	* 
+	* @param {string} plugin 
+	* @returns {IterableIterator<T extends readonly (infer V)[] ? V : T>}
+	*/
+	*plugin(plugin) {
+		const hooks = this.#hooks;
+		if (!Object.hasOwn(hooks, plugin)) return;
+		yield* findHook(hooks[plugin], this.#keys.filter(Boolean));
+	}
+	/**
+	* 
+	* @returns {IterableIterator<T extends readonly (infer V)[] ? V : T>}
+	*/
+	values() {
+		return values(this.#hooks, this.#keys);
+	}
+	/**
+	* 
+	* @returns {IterableIterator<[string, T extends readonly (infer V)[] ? V : T]>}
+	*/
+	*entries() {
+		const hooks = this.#hooks;
+		const name = this.#keys;
+		for (const [plugin, it] of Object.entries(hooks)) for (const value of findHook(it, name)) yield [plugin, value];
+	}
+	/**
+	* 
+	* @template [TX=(T extends Record<string, infer TT>? TT extends readonly (infer V)[] ? V : TT : never)]
+	* @param {(v: *)=>v is TX} filter 
+	* @returns {IterableIterator<[plugin: string, key: string, value: TX]>}
+	*/
+	*entriesObject(filter = noopFilter) {
+		for (const [plugin, hooksMap] of this.entries()) {
+			if (!hooksMap || typeof hooksMap !== "object") continue;
+			for (const [k, v] of Object.entries(hooksMap)) {
+				if (!filter(v)) continue;
+				yield [
+					plugin,
+					k,
+					v
+				];
+			}
+		}
+	}
+	/**
+	* @template [TT=(T extends Record<string, infer TT> ? TT : never)]
+	* @param {(v: *)=>v is TT} [filter] 
+	* @returns {Record<string, TT>}
+	*/
+	named(filter = noopFilter) {
+		/** @type {Record<string, TT>} */
+		const result = Object.create(null);
+		for (const hooksMap of this.values()) {
+			if (!hooksMap || typeof hooksMap !== "object") continue;
+			for (const [k, v] of Object.entries(hooksMap)) {
+				if (!filter(v)) continue;
+				result[k] = v;
+			}
+		}
+		return result;
+	}
+	/**
+	* 
+	* @param {() => void} fn 
+	* @param {number} [hysteresis] 
+	* @returns 
+	*/
+	listen(fn, hysteresis) {
+		if (typeof fn !== "function") return () => {};
+		const resetFn = this.#config.resetFn;
+		/** @type {[() => void, number]} */
+		const it = [fn, Number.isFinite(hysteresis) && hysteresis || 0];
+		resetFn.push(it);
+		resetFn.sort(([, a], [, b]) => b - a);
+		return () => {
+			const index = resetFn.findIndex((v) => v === it);
+			if (index >= 0) resetFn.splice(index, 1);
+		};
+	}
+};
+
+//#endregion
+//#region packages/common/model.mjs
+const regex = /\{([^}{}]+)\}/g;
+/**
+* 
+* @param {string?} [pattern] 
+*/
+function getPatternFields(pattern) {
+	if (!pattern || typeof pattern !== "string") return [];
+	/** @type {string[]} */
+	const fields = [];
+	for (let result = regex.exec(pattern); result; result = regex.exec(pattern)) fields.push(result[1]);
+	return fields;
+}
+/**
+* 
+* @param {string?} [pattern] 
+* @param {Record<string, any>?} [document] 
+* @returns 
+*/
+function runPattern(pattern, document) {
+	if (!pattern || typeof pattern !== "string") return "";
+	const doc = typeof document === "object" && document || {};
+	return pattern.replace(regex, (_, v) => {
+		if (Object.hasOwn(doc, v)) return doc[v] ?? "";
+		return `{${v}}`;
+	});
+}
+
+//#endregion
+//#region packages/common/yieldPermissionConstraintFields.mjs
+/** @import { Permission } from '@yongdall/types' */
+/**
+*
+* @param {Permission} permission
+* @returns {Iterable<string>}
+*/
+function* yieldPermissionConstraintFields({ constraints, organizationField }) {
+	if (organizationField) yield organizationField;
+	if (!constraints) return;
+	for (const [field, constraint] of Object.entries(constraints)) {
+		if (!constraint) continue;
+		const { value, values, user } = constraint;
+		if (value !== void 0) yield field;
+		else if (Array.isArray(values) && values.length) yield field;
+		else if (values instanceof Set && values.size) yield field;
+		else if (user) yield field;
+	}
+}
+
+//#endregion
+//#region packages/common/index.mjs
+const pluginIdRegex = /^(?:(?<scope>@[a-zA-Z\d_.-]+)\/)?(?<name>[a-zA-Z\d_.-]+)$/;
+const findPluginIdRegex = /^(?<pluginId>(?:(?<scope>@[a-zA-Z\d_.-]+)\/)?(?<name>[a-zA-Z\d_.-]+))(?:\/(?<path>[^#]*))?(?:#(?<hash>.*))?$/;
+/**
+* @typedef {object} Plugin
+* @property {string} [version]
+* @property {Record<string, string>} [assets]
+* @property {string} [hooks]
+* @property {string[]} [styles]
+*/
+/**
+* @typedef {object} BootConfiguration
+* @property {string} [route] 路由管理器
+* @property {string} [theme] 界面主题
+* @property {string} [authenticator] 登陆器
+* @property {boolean} [authRequired] 是否强制登陆
+* @property {string} [skin]
+* @property {boolean} [single] 
+* @property {string} [application] 
+* @property {string} [domain] 
+* @property {string | number} [port] 
+* @property {string} [path] 
+* @property {Record<string, string>} [pages]
+* @property {Record<string, string>} [configurationPages]
+* 
+* 
+* @property {string} [logo] 
+* @property {string} [title] 
+* @property {string} [company] 
+* @property {string} [type] 
+* @property {string} [help] 帮助链接
+* @property {any[]} [userMenus]
+*/
+/**
+* @typedef {object} Importmap
+* @property {Record<string, string>} imports
+* @property {Record<string, Record<string, string>>} scopes
+*/
+/**
+* @typedef {object} Indicator
+* @property {string} color
+* @property {string} label
+* @property {unknown} [filters]
+*/
+/**
+*
+* @param {*} v
+* @returns {v is (...p: any[]) => any}
+*/
+function isFunction(v) {
+	return typeof v === "function";
+}
+
+//#endregion
+export { Hook, Search_exports as Search, findPluginIdRegex, getPatternFields, isFunction, pluginIdRegex, runPattern, yieldPermissionConstraintFields };
+//# sourceMappingURL=index.mjs.map