@aiao/rxdb-plugin-history 0.0.0-stage → 0.0.26

package/dist/index.js

@@ -0,0 +1,1480 @@
+import { ENTITY_LOCAL_CREATE_EVENT as e, MergeBranchBeginEvent as t, MergeBranchCommitEvent as n, MergeBranchFailedEvent as r, REPOSITORY_SYNC_COMPLETE_EVENT as i, RxDBBranch as a, RxDBChange as o, RxDBError as s, RxDBPluginBase as c, RxDBSync as l, SwitchBranchBeginEvent as u, SwitchBranchCommitEvent as d, SwitchBranchRollbackEvent as f, TRANSACTION_BEGIN as p, TRANSACTION_COMMIT as m, TRANSACTION_ROLLBACK as h, buildPushableRepositoryRules as ee, getCurrentBranch as te, getEntityMetadata as g, getLocalSystemRepositories as ne, getRemoteSystemRepositories as re, getRxDBChangeKey as _, getRxDBEntityIdentityKey as v, isAdapterShutdownError as y, resolve_current_branch as ie } from "@aiao/rxdb";
+import { BehaviorSubject as b, EMPTY as ae, Observable as x, ReplaySubject as oe, Subject as se, catchError as ce, combineLatest as S, filter as C, firstValueFrom as w, map as T, shareReplay as E, switchMap as D, takeUntil as O } from "rxjs";
+import { isNil as k } from "@aiao/utils";
+//#region src/create-branch.ts
+var le = async (e, t, n) => {
+	let { branchRepository: r, adapter: i } = await e.getLocalRepositories();
+	if ((await r.find({
+		where: {
+			combinator: "and",
+			rules: [{
+				field: "id",
+				operator: "=",
+				value: t
+			}]
+		},
+		limit: 1
+	})).length) throw new s(`Branch id (${t}) already exists`);
+	if (e.rxdb.config.sync?.remote?.adapter) {
+		let { adapter: n } = await e.getRemoteRepositories();
+		if (n.branchExists && await n.branchExists(t)) throw new s(`Branch id (${t}) already exists on remote`);
+	}
+	let c = await i.transaction(async (r) => {
+		let i = r.getRepository(a), s = r.getRepository(o);
+		if ((await i.find({
+			where: {
+				combinator: "and",
+				rules: [{
+					field: "id",
+					operator: "=",
+					value: t
+				}]
+			},
+			limit: 1
+		})).length) return `Branch id (${t}) already exists`;
+		let c, l;
+		if (n) {
+			let e = (await s.find({
+				where: {
+					combinator: "and",
+					rules: [{
+						field: "id",
+						operator: "=",
+						value: n
+					}]
+				},
+				limit: 1
+			}))[0];
+			if (!e) return `Change ID (${n}) not found`;
+			l = e, c = (await i.find({
+				where: {
+					combinator: "and",
+					rules: [{
+						field: "id",
+						operator: "=",
+						value: e.branchId
+					}]
+				},
+				limit: 1
+			}))[0];
+		} else c = await ie(i, e.rxdb), l = await ue(s, c.id);
+		if (!c) return "Source branch not found";
+		let u = e.rxdb.entityManager.instantiate(a);
+		return u.id = t, u.activated = !1, u.local = !0, u.remote = !1, u.fromChangeId = l?.id ?? null, u.parentId = c.id, await i.create(u), u;
+	});
+	if (typeof c == "string") throw new s(c);
+	return c;
+}, ue = async (e, t) => (await e.find({
+	where: {
+		combinator: "and",
+		rules: [t ? {
+			field: "branchId",
+			operator: "=",
+			value: t
+		} : {
+			field: "branch.activated",
+			operator: "=",
+			value: !0
+		}, {
+			field: "revertChangeId",
+			operator: "=",
+			value: null
+		}]
+	},
+	orderBy: [{
+		field: "id",
+		sort: "desc"
+	}],
+	limit: 1
+}))[0], A = (e) => {
+	if (!e || typeof e != "object") return !1;
+	let t = "name" in e ? String(e.name) : "";
+	return ("errno" in e ? Number(e.errno) : void 0) === 44 || t === "AbortError" || y(e);
+};
+//#endregion
+//#region src/history-item-builder.ts
+function j(e) {
+	if (e.length === 1) {
+		let t = e[0];
+		return `${t.type === "INSERT" ? "创建" : t.type === "UPDATE" ? "更新" : "删除"} ${t.entity}`;
+	}
+	let t = {};
+	for (let n of e) {
+		let e = n.type.toLowerCase();
+		t[e] = (t[e] ?? 0) + 1;
+	}
+	let n = [];
+	return t.insert && n.push(`创建${t.insert}条`), t.update && n.push(`更新${t.update}条`), t.delete && n.push(`删除${t.delete}条`), `事务: ${n.join(", ")}`;
+}
+function M(e) {
+	let t = e[0], n = e.length, r = t.transactionId ?? null, i = t.createdAt, a = t.namespace, o = t.entity, s = r ? "TRANSACTION" : t.type, c = [
+		s,
+		v(t.entityId),
+		i.getTime()
+	].join(":"), l = e.some((e) => k(e.revertChangeId) === !1), u = e.some((e) => k(e.redoInvalidatedAt) === !1);
+	return {
+		transactionId: r,
+		changeId: e.reduce((e, t) => t.id > e ? t.id : e, e[0].id),
+		fingerprint: c,
+		changes: e,
+		type: s,
+		count: n,
+		createdAt: i,
+		description: j(e),
+		namespace: a,
+		entity: o,
+		reverted: l,
+		redoInvalidated: u
+	};
+}
+function N(e) {
+	let t = [], n = [], r;
+	return e.forEach((e) => {
+		e.transactionId && e.transactionId === r ? n.push(e) : (r = e.transactionId, n.length &&= (t.push(M([...n])), 0), e.transactionId ? n.push(e) : t.push(M([e])));
+	}), n.length && t.push(M([...n])), t;
+}
+//#endregion
+//#region src/history-filters.ts
+var P = (e) => `${e.namespace}:${e.entity}`;
+function F(e, t) {
+	let n = new Map(t);
+	for (let t of e) {
+		if (t.lastPushedChangeId === null) continue;
+		let e = P(t), r = n.get(e);
+		r !== void 0 && r >= t.lastPushedChangeId || n.set(e, t.lastPushedChangeId);
+	}
+	return n;
+}
+function I(e, t) {
+	return t.type === "database" ? e : e.map((e) => {
+		let n = e.changes.filter((e) => t.type === "repository" ? e.namespace === t.namespace && e.entity === t.entity : e.namespace === t.namespace && e.entity === t.entity && e.entityId === t.entityId);
+		return n.length === 0 ? null : {
+			...e,
+			changes: n,
+			count: n.length,
+			description: j(n)
+		};
+	}).filter((e) => e !== null);
+}
+function L(e, t, n = 0, r = null) {
+	return e.filter((e) => !e.reverted && e.changes.every((e) => {
+		let i = e.remoteId == null, a = t.get(P(e)), o = a == null || e.id > a, s = e.id > n, c = r === null || e.createdAt.getTime() > r.getTime();
+		return i && o && s && c;
+	}));
+}
+function de(e) {
+	return e.type === "database" ? "database" : e.type === "repository" ? `${e.namespace}:${e.entity}` : `${e.namespace}:${e.entity}:${v(e.entityId)}`;
+}
+//#endregion
+//#region src/history-scope-api.ts
+function fe(e) {
+	if (!e) return { type: "database" };
+	if (Object.getPrototypeOf(e) === Object.prototype && "type" in e) return e;
+	let t = g(e), n = "id" in e ? e.id : void 0, r = typeof n == "string" || typeof n == "number" || typeof n == "bigint" ? n : void 0;
+	return r === void 0 ? {
+		type: "repository",
+		namespace: t.namespace,
+		entity: t.name
+	} : {
+		type: "entity",
+		namespace: t.namespace,
+		entity: t.name,
+		entityId: r
+	};
+}
+function pe(e, t) {
+	let n = fe(t), r = de(n), i = e.history_cache.get(r);
+	if (i) return i;
+	let a = () => {
+		let t = (e.history_ref_counts.get(r) || 0) - 1;
+		t <= 0 ? (e.history_cache.delete(r), e.history_ref_counts.delete(r)) : e.history_ref_counts.set(r, t);
+	}, o = () => {
+		let t = (e.history_ref_counts.get(r) || 0) + 1;
+		e.history_ref_counts.set(r, t), e.history_cache.set(r, h);
+	}, s = (e) => new x((t) => {
+		o();
+		let n = e.subscribe(t);
+		return () => {
+			n.unsubscribe(), a();
+		};
+	}), c = e.histories$.pipe(T((e) => I(e, n)), E({
+		bufferSize: 1,
+		refCount: !0
+	})), l = s(c), u = s(e.undoHistories$.pipe(T((e) => I(e, n)), E({
+		bufferSize: 1,
+		refCount: !0
+	}))), d = s(e.redoHistories$.pipe(T((e) => I(e, n)), E({
+		bufferSize: 1,
+		refCount: !0
+	}))), f = s(c.pipe(T((e) => e.length), E({
+		bufferSize: 1,
+		refCount: !0
+	}))), p = s(u.pipe(T((e) => e.length), E({
+		bufferSize: 1,
+		refCount: !0
+	}))), m = s(d.pipe(T((e) => e.length), E({
+		bufferSize: 1,
+		refCount: !0
+	}))), h = {
+		type: n.type,
+		histories$: l,
+		undoHistories$: u,
+		redoHistories$: d,
+		count$: f,
+		undoCount$: p,
+		redoCount$: m,
+		undo: (t = 1) => e.runSerialized(async () => {
+			let r = e.undoSession$.value;
+			if (r.state === "cleared") return;
+			let { histories: i, lastPushedMap: a } = await e.fetchLatestHistories(r.boundary);
+			if (!e.isUndoSessionCurrent(r)) return;
+			let o = L(i, a, r.boundary.changeId, r.boundary.createdAfter), s = e.selectWholeTransactions(o, n, t);
+			s.length !== 0 && await e.applyUndoRedoHistories("undo", s, r);
+		}),
+		redo: (t = 1) => e.runSerialized(async () => {
+			let r = await w(e.redoHistories$), i = e.selectWholeTransactions(r, n, t);
+			i.length !== 0 && await e.applyUndoRedoHistories("redo", i);
+		})
+	};
+	return h;
+}
+//#endregion
+//#region src/history-undo-session.types.ts
+var R = {
+	changeId: 0,
+	createdAfter: null
+};
+//#endregion
+//#region src/pullable-count.ts
+function z(e, t) {
+	return e?.repositoryFilter !== void 0 && e.repositoryFilter.length > 0 ? !1 : !t.hasMore && t.failures.length === 0;
+}
+function B(e, t) {
+	return t.complete && !t.concurrent ? 0 : Math.max(0, e - t.pulled);
+}
+//#endregion
+//#region src/redo-stack.ts
+var me = 1e3, he = class {
+	#e = new b([]);
+	get items$() {
+		return this.#e.asObservable();
+	}
+	get value() {
+		return this.#e.value;
+	}
+	push(e) {
+		let t = [...e, ...this.#e.value], n = t.length > 1e3 ? t.slice(0, me) : t;
+		this.#e.next(n);
+	}
+	remove(e) {
+		let t = new Set(e.map((e) => e.fingerprint)), n = this.#e.value, r = n.filter((e) => t.has(e.fingerprint));
+		return r.length === 0 || this.#e.next(n.filter((e) => !t.has(e.fingerprint))), r;
+	}
+	clear() {
+		this.#e.next([]);
+	}
+};
+//#endregion
+//#region src/scope-selection.ts
+function V(e, t) {
+	return t.type === "database" ? !0 : e.namespace !== t.namespace || e.entity !== t.entity ? !1 : t.type === "repository" || e.entityId === t.entityId;
+}
+function ge(e, t) {
+	return e.changes.some((e) => V(e, t));
+}
+function _e(e, t) {
+	return e.changes.every((e) => V(e, t));
+}
+function ve(e, t, n) {
+	let r = e.filter((e) => ge(e, t)).slice(0, Math.max(0, n)), i = [], a = [];
+	for (let e of r) _e(e, t) ? a.push(e) : i.push(e);
+	return {
+		crossScope: i,
+		selected: a
+	};
+}
+var ye = (e) => e.type === "database" ? "database" : e.type === "repository" ? `${e.namespace}:${e.entity}` : `${e.namespace}:${e.entity}#${String(e.entityId)}`, be = (e, t) => {
+	let n = /* @__PURE__ */ new Set();
+	for (let r of e) for (let e of r.changes) V(e, t) || n.add(t.type === "entity" ? `${e.namespace}:${e.entity}#${String(e.entityId)}` : `${e.namespace}:${e.entity}`);
+	return [...n].join(", ");
+}, H = class e extends s {
+	scope;
+	histories;
+	constructor(t, n) {
+		super(`Scoped history operation would split a transaction: scope ${ye(t)} also changes ${be(n, t)}. Use the database scope to apply the whole transaction.`), this.scope = t, this.histories = n, this.name = "RxDBCrossScopeTransactionError", Object.setPrototypeOf(this, e.prototype);
+	}
+}, U = (e) => e.fromChangeId ?? 0, xe = (e) => {
+	let { branches: t, currentBranch: n, nextBranch: r } = e, i = e.currentChangeId ?? U(n), a = e.nextChangeId ?? U(r);
+	if (i === a) return [];
+	if (n.id === r.id) return [{
+		branch: n,
+		fromChangeId: i,
+		toChangeId: a
+	}];
+	let o = /* @__PURE__ */ new Map();
+	for (let e of t) o.set(e.id, e);
+	let c = (e) => {
+		let t = [e], n = /* @__PURE__ */ new Set([e.id]), r = e;
+		for (; r.parentId;) {
+			if (n.has(r.parentId)) throw new s(`Branch history is corrupt: cycle detected at branch '${r.id}' (parentId '${r.parentId}' already visited)`);
+			let e = o.get(r.parentId);
+			if (!e) throw new s(`Branch history is corrupt: branch '${r.id}' references missing parent '${r.parentId}'`);
+			n.add(e.id), t.push(e), r = e;
+		}
+		return t;
+	}, l = c(n), u = c(r), d = null, f = -1;
+	for (let e = 0; e < l.length; e++) if (u.findIndex((t) => t.id === l[e].id) !== -1) {
+		d = l[e], f = e;
+		break;
+	}
+	let p = [];
+	if (d) {
+		for (let e = 0; e < f; e++) {
+			let t = l[e], n = e === 0 ? i : U(l[e - 1]), r = U(t);
+			n !== r && p.push({
+				branch: t,
+				fromChangeId: n,
+				toChangeId: r
+			});
+		}
+		let e = u.findIndex((e) => e.id === d.id);
+		if (e === 0) {
+			let e = f === 0 ? i : U(l[f - 1]), t = a;
+			e !== t && p.push({
+				branch: d,
+				fromChangeId: e,
+				toChangeId: t
+			});
+		} else if (e > 0) {
+			let t = f === 0 ? i : U(l[f - 1]), n = U(u[e - 1]);
+			t !== n && p.push({
+				branch: d,
+				fromChangeId: t,
+				toChangeId: n
+			});
+		}
+		let t = u.slice(0, e).reverse();
+		for (let e = 0; e < t.length; e++) {
+			let n = t[e], r = U(n), i = e === t.length - 1 ? a : U(t[e + 1]);
+			r !== i && p.push({
+				branch: n,
+				fromChangeId: r,
+				toChangeId: i
+			});
+		}
+	} else {
+		for (let e = 0; e < l.length; e++) {
+			let t = l[e], n = e === 0 ? i : U(l[e - 1]), r = U(t);
+			n !== r && p.push({
+				branch: t,
+				fromChangeId: n,
+				toChangeId: r
+			});
+		}
+		let e = l[l.length - 1], t = U(e);
+		t !== 0 && p.push({
+			branch: e,
+			fromChangeId: t,
+			toChangeId: 0
+		});
+		let n = u[u.length - 1], r = u.length > 1 ? U(u[u.length - 2]) : a;
+		r !== 0 && p.push({
+			branch: n,
+			fromChangeId: 0,
+			toChangeId: r
+		});
+		let o = u.slice(0, u.length - 1).reverse();
+		for (let e = 0; e < o.length; e++) {
+			let t = o[e], n = U(t), r = e === o.length - 1 ? a : U(o[e + 1]);
+			n !== r && p.push({
+				branch: t,
+				fromChangeId: n,
+				toChangeId: r
+			});
+		}
+	}
+	return p;
+}, Se = async (e, t) => {
+	let { branchRepository: n, changeRepository: r } = await e.getLocalRepositories(), i = (await n.find({
+		where: {
+			combinator: "and",
+			rules: [{
+				field: "activated",
+				operator: "=",
+				value: !0
+			}]
+		},
+		limit: 1
+	}))[0];
+	if (!i) throw new s("Current branch not found");
+	let a = await n.find({ where: {
+		combinator: "and",
+		rules: []
+	} }), o = a.find((e) => e.id === t);
+	if (!o) throw new s(`Branch (${t}) not found`);
+	if (i.id === o.id) throw new s("Cannot switch to the same branch");
+	let c = await G(r, i.id), l = await G(r, o.id), u = xe({
+		branches: a,
+		currentBranch: i,
+		currentChangeId: c ? c.id : null,
+		nextBranch: o,
+		nextChangeId: l ? l.id : null
+	}), d = {
+		deletes: /* @__PURE__ */ new Map(),
+		updates: /* @__PURE__ */ new Map(),
+		inserts: /* @__PURE__ */ new Map()
+	};
+	for (let e = 0; e < u.length; e++) {
+		let { branch: t, fromChangeId: n, toChangeId: i } = u[e], a = n < i, o = n > i, s = Math.min(n, i), c = Math.max(n, i), l = { where: {
+			combinator: "and",
+			rules: [
+				{
+					field: "branchId",
+					operator: "=",
+					value: t.id
+				},
+				{
+					field: "id",
+					operator: ">",
+					value: s
+				},
+				{
+					field: "id",
+					operator: "<=",
+					value: c
+				},
+				{
+					field: "revertChangeId",
+					operator: "=",
+					value: null
+				}
+			]
+		} };
+		t.fromChangeId && s < t.fromChangeId && l.where.rules.push({
+			field: "id",
+			operator: ">",
+			value: t.fromChangeId
+		});
+		let f = await r.find(l);
+		o ? we(f, d) : a && Ce(f, d);
+	}
+	return d;
+}, Ce = (e, t) => W(e, !0, t), we = (e, t) => W(e, !1, t), W = (e, t, n = {
+	deletes: /* @__PURE__ */ new Map(),
+	updates: /* @__PURE__ */ new Map(),
+	inserts: /* @__PURE__ */ new Map()
+}) => {
+	if (t) {
+		let t = [...e].sort((e, t) => e.id - t.id);
+		for (let e of t) {
+			let t = _(e);
+			switch (e.type) {
+				case "INSERT":
+					n.inserts.set(t, {
+						patch: { ...e.patch },
+						inversePatch: null
+					});
+					break;
+				case "UPDATE":
+					{
+						let r = n.inserts.get(t) || n.updates.get(t);
+						r ? (r.patch && e.patch && Object.assign(r.patch, e.patch), r.inversePatch === null && e.inversePatch ? r.inversePatch = { ...e.inversePatch } : r.inversePatch && e.inversePatch && Object.assign(r.inversePatch, e.inversePatch)) : n.updates.set(t, {
+							patch: { ...e.patch },
+							inversePatch: { ...e.inversePatch }
+						});
+					}
+					break;
+				case "DELETE": n.deletes.set(t, {
+					patch: null,
+					inversePatch: { ...e.inversePatch }
+				}), n.inserts.delete(t), n.updates.delete(t);
+			}
+		}
+	} else {
+		let t = [...e].sort((e, t) => t.id - e.id);
+		for (let e of t) {
+			let t = _(e);
+			switch (e.type) {
+				case "INSERT":
+					n.deletes.set(t, {
+						patch: null,
+						inversePatch: { ...e.patch }
+					}), n.inserts.delete(t), n.updates.delete(t);
+					break;
+				case "UPDATE":
+					{
+						let r = n.inserts.get(t) || n.updates.get(t);
+						r ? (r.patch && e.inversePatch && Object.assign(r.patch, e.inversePatch), r.inversePatch && e.patch && Object.assign(r.inversePatch, e.patch)) : n.updates.set(t, {
+							patch: { ...e.inversePatch },
+							inversePatch: { ...e.patch }
+						});
+					}
+					break;
+				case "DELETE": n.inserts.set(t, {
+					patch: { ...e.inversePatch },
+					inversePatch: null
+				});
+			}
+		}
+	}
+	return n;
+}, G = async (e, t) => (await e.find({
+	where: {
+		combinator: "and",
+		rules: [{
+			field: "branchId",
+			operator: "=",
+			value: t
+		}, {
+			field: "revertChangeId",
+			operator: "=",
+			value: null
+		}]
+	},
+	orderBy: [{
+		field: "id",
+		sort: "desc"
+	}],
+	limit: 1
+}))[0], K = (e) => e.getRepository(l);
+async function Te(e, t) {
+	let { changeRepository: n, branchRepository: r } = await e.rxdb.versionManager.getLocalRepositories(), i = await r.find({ where: {
+		combinator: "and",
+		rules: [{
+			field: "activated",
+			operator: "=",
+			value: !0
+		}]
+	} });
+	if (i.length === 0) return {
+		histories: [],
+		lastPushedMap: /* @__PURE__ */ new Map()
+	};
+	let a = i[0], o = F(await K(await w(e.rxdb.localAdapter$)).find({ where: {
+		combinator: "and",
+		rules: [{
+			field: "branchId",
+			operator: "=",
+			value: a.id
+		}]
+	} }), e.rxdb.versionManager.pushInFlight.snapshot()), s = [{
+		field: "branchId",
+		operator: "=",
+		value: a.id
+	}, {
+		field: "createdAt",
+		operator: ">=",
+		value: e.getFirstConnectedAt()
+	}];
+	return t.changeId > 0 && s.push({
+		field: "id",
+		operator: ">",
+		value: t.changeId
+	}), {
+		histories: N(await n.find({
+			where: {
+				combinator: "and",
+				rules: s
+			},
+			orderBy: [{
+				field: "id",
+				sort: "desc"
+			}]
+		})),
+		lastPushedMap: o
+	};
+}
+async function Ee(e, t, n, r) {
+	e.isUndoRedoInProgress = !0;
+	try {
+		let i = n.flatMap((e) => e.changes).sort((e, n) => t === "undo" ? n.id - e.id : e.id - n.id), a = W(i, t === "redo"), o = e.getNextRevertStateUpdatedAt(i);
+		if (t === "undo") {
+			let { adapter: t } = await e.rxdb.versionManager.getLocalRepositories(), n = await t.getRxDBChangeSequence(), r = /* @__PURE__ */ new Date();
+			i.forEach((e, t) => {
+				let i = `rxdb:RxDBChange:${e.id}`, s = a.updates.get(i) || {
+					patch: {},
+					inversePatch: null
+				};
+				a.updates.set(i, {
+					patch: {
+						...s.patch,
+						revertChangeId: n + t + 1,
+						revertChangedAt: r,
+						updatedAt: o
+					},
+					inversePatch: s.inversePatch
+				});
+			}), a.updateRxDBChangeSequence = n + i.length, e.redoInvalidationFloor = n + i.length;
+		} else i.forEach((e) => {
+			let t = `rxdb:RxDBChange:${e.id}`, n = a.updates.get(t) || {
+				patch: {},
+				inversePatch: null
+			};
+			a.updates.set(t, {
+				patch: {
+					...n.patch,
+					revertChangeId: null,
+					updatedAt: o
+				},
+				inversePatch: n.inversePatch
+			});
+		});
+		let { adapter: s } = await e.rxdb.versionManager.getLocalRepositories();
+		if (t === "undo" && (r === void 0 || !e.isUndoSessionCurrent(r))) return;
+		await s.switchBranch({ actions: a }), e.pushableCountTrigger$.next(Date.now()), e.setRevertStateWatermarks(i, t === "undo", o), t === "undo" ? e.pushToRedoStack(n) : e.removeFromRedoStack(n);
+	} finally {
+		e.isUndoRedoInProgress = !1;
+	}
+}
+async function De(e) {
+	let t = ++e.pushableGeneration, n = (n) => {
+		t === e.pushableGeneration && e.pushableCount$.next(n);
+	};
+	try {
+		if (!await w(e.rxdb.connected$)) {
+			n(0);
+			return;
+		}
+		let t = K(await w(e.rxdb.localAdapter$)), r = e.rxdb.entityManager.getRepository(o), i = await w(e.rxdb.entityManager.getRepository(a).findOne({ where: {
+			combinator: "and",
+			rules: [{
+				field: "activated",
+				operator: "=",
+				value: !0
+			}]
+		} }));
+		if (!i) {
+			n(0);
+			return;
+		}
+		let s = await t.find({ where: {
+			combinator: "and",
+			rules: [{
+				field: "branchId",
+				operator: "=",
+				value: i.id
+			}]
+		} }), c = ee(e.rxdb.config.entities, e.rxdb.config.sync, s);
+		if (c.length === 0) {
+			n(0);
+			return;
+		}
+		n(await w(r.count({ where: {
+			combinator: "and",
+			rules: [
+				{
+					field: "branchId",
+					operator: "=",
+					value: i.id
+				},
+				{
+					field: "revertChangeId",
+					operator: "=",
+					value: null
+				},
+				{
+					field: "remoteId",
+					operator: "=",
+					value: null
+				},
+				{
+					combinator: "or",
+					rules: c
+				}
+			]
+		} })));
+	} catch (t) {
+		!e.destroyed && !y(t) && (console.error("[#updatePushableCount] error", t), e.errors$.next(t instanceof Error ? t : Error(String(t)))), n(0);
+	}
+}
+//#endregion
+//#region src/HistoryManager.ts
+var q = (e) => e.reduce((e, t) => t < e ? t : e, Infinity), J = class {
+	rxdb;
+	#e = [];
+	#t = !1;
+	#n;
+	#r;
+	#i = new oe(1);
+	#a = Promise.resolve();
+	#o = new b(0);
+	#s = 0;
+	#c = new b(0);
+	#l = 0;
+	#u = new b(0);
+	#d = /* @__PURE__ */ new Map();
+	#f = new b(0);
+	#p = 0;
+	#m;
+	#h = null;
+	#g = /* @__PURE__ */ new Date();
+	#_ = /* @__PURE__ */ new Map();
+	#v = null;
+	#y = 0;
+	#b = null;
+	#x = new b({
+		generation: 0,
+		state: "active",
+		boundary: R
+	});
+	isUndoRedoInProgress = !1;
+	isInvalidatingRedo = !1;
+	syncDepth = 0;
+	redoStack = new he();
+	history_cache = /* @__PURE__ */ new Map();
+	history_ref_counts = /* @__PURE__ */ new Map();
+	histories$;
+	undoHistories$;
+	redoHistories$;
+	undoCount$;
+	redoCount$;
+	errors$ = new se();
+	pushableCount$;
+	pullableCount$;
+	count$;
+	get undoSessionGeneration() {
+		return this.#x.value.generation;
+	}
+	constructor(e) {
+		this.rxdb = e, this.#n = this.#R(), this.#r = this.#z();
+		let t = e.entityManager.getRepository(a), n = e.entityManager.getRepository(o), r = t.findOne({ where: {
+			combinator: "and",
+			rules: [{
+				field: "activated",
+				operator: "=",
+				value: !0
+			}]
+		} });
+		this.#e.push(r.pipe(O(this.#i)).subscribe({
+			next: (e) => this.#E(e?.id ?? null),
+			error: (e) => this.#T("undo session 分支跟随的活跃分支流已中断", e)
+		})), this.#m = S({
+			connected: this.rxdb.connected$,
+			branch: r
+		}).pipe(C(({ connected: e, branch: t }) => e && !!t), D(({ branch: e }) => {
+			let t = this.#M();
+			return n.findAll({
+				where: {
+					combinator: "and",
+					rules: [{
+						field: "branchId",
+						operator: "=",
+						value: e.id
+					}, {
+						field: "createdAt",
+						operator: ">=",
+						value: t
+					}]
+				},
+				orderBy: [{
+					field: "id",
+					sort: "desc"
+				}]
+			});
+		}), O(this.#i));
+		let s = this.#m.pipe(T((e) => N(e)), E({
+			bufferSize: 1,
+			refCount: !0
+		}));
+		this.histories$ = S([s, this.#f]).pipe(T(([e]) => this.#O(e)), E({
+			bufferSize: 1,
+			refCount: !0
+		})), this.count$ = this.histories$.pipe(T((e) => e.length), E({
+			bufferSize: 1,
+			refCount: !0
+		})), this.undoHistories$ = S({
+			histories: this.histories$,
+			undoSession: this.#x,
+			trigger: this.#u
+		}).pipe(D(async ({ histories: e, undoSession: t }) => {
+			if (t.state === "cleared") return [];
+			try {
+				let n = await w(this.rxdb.entityManager.getRepository(a).findOne({ where: {
+					combinator: "and",
+					rules: [{
+						field: "activated",
+						operator: "=",
+						value: !0
+					}]
+				} }));
+				return n ? L(e, F(await K(await w(this.rxdb.localAdapter$)).find({ where: {
+					combinator: "and",
+					rules: [{
+						field: "branchId",
+						operator: "=",
+						value: n.id
+					}]
+				} }), this.rxdb.versionManager.pushInFlight.snapshot()), t.boundary.changeId, t.boundary.createdAfter) : [];
+			} catch (e) {
+				let t = e instanceof Error ? e : Error(String(e));
+				return this.errors$.next(t), [];
+			}
+		}), E({
+			bufferSize: 1,
+			refCount: !0
+		})), this.redoHistories$ = this.redoStack.items$, this.undoCount$ = this.undoHistories$.pipe(T((e) => e.length), E({
+			bufferSize: 1,
+			refCount: !0
+		})), this.redoCount$ = this.redoHistories$.pipe(T((e) => e.length), E({
+			bufferSize: 1,
+			refCount: !0
+		})), this.pushableCount$ = this.#c.asObservable(), this.pullableCount$ = this.#o.asObservable();
+		let c = S({
+			connected: this.rxdb.connected$,
+			branch: r
+		}).pipe(C(({ connected: e, branch: t }) => e && !!t), D(({ branch: e }) => {
+			let t = [
+				{
+					field: "branchId",
+					operator: "=",
+					value: e.id
+				},
+				{
+					field: "revertChangeId",
+					operator: "=",
+					value: null
+				},
+				{
+					field: "remoteId",
+					operator: "=",
+					value: null
+				}
+			];
+			return n.count({ where: {
+				combinator: "and",
+				rules: t
+			} }).pipe(ce((e) => (this.#T("pushableCount 的变更计数查询", e), ae)));
+		})).subscribe({
+			next: () => {
+				this.#L();
+			},
+			error: (e) => this.#T("pushableCount 重算的活跃分支流已中断", e)
+		});
+		this.#e.push(c), this.rxdb.addEventListener(i, this.#F), this.#L();
+	}
+	destroy() {
+		this.#t = !0, this.#i.next(), this.#i.complete();
+		for (let e of this.#e) e.unsubscribe();
+		this.#e.length = 0, this.rxdb.removeEventListener(i, this.#F), this.#d.clear(), this.errors$.complete();
+	}
+	incrementPullableCount(e) {
+		this.#s++;
+		let t = this.#o.value + e;
+		this.#o.next(t);
+	}
+	resetPullableCount() {
+		this.#s++, this.#o.next(0);
+	}
+	beginPullableSettlement() {
+		return this.#s;
+	}
+	reconcilePullableCount(e, t) {
+		let n = e === this.#s ? t : Math.max(this.#o.value, t);
+		this.#o.next(n);
+	}
+	settlePullableCount(e, t) {
+		this.#o.next(B(this.#o.value, {
+			complete: t.complete,
+			concurrent: e !== this.#s,
+			pulled: t.pulled
+		}));
+	}
+	pushToRedoStack(e) {
+		this.redoStack.push(e);
+	}
+	removeFromRedoStack(e) {
+		return this.redoStack.remove(e);
+	}
+	clearRedoStack() {
+		this.redoStack.clear();
+	}
+	setUndoBranch(e) {
+		this.#E(e);
+	}
+	clearUndoHistory() {
+		this.#w({
+			generation: this.#C(),
+			state: "cleared",
+			boundary: this.#x.value.boundary,
+			clearedAt: /* @__PURE__ */ new Date()
+		}), this.clearRedoStack();
+	}
+	clearAllUndoHistory() {
+		let e = /* @__PURE__ */ new Date(), t = (t) => ({
+			generation: this.#C(),
+			state: "cleared",
+			boundary: t.boundary,
+			clearedAt: e
+		});
+		for (let [e, n] of this.#_) this.#_.set(e, t(n));
+		this.#v = t(this.#v ?? {
+			generation: 0,
+			state: "active",
+			boundary: R
+		});
+		let n = this.#b === null ? void 0 : this.#_.get(this.#b);
+		this.#x.next(n ?? this.#v), this.clearRedoStack();
+	}
+	resetSyncCleared(e = [], t) {
+		let n = this.#x.value;
+		if (n.state === "active") return;
+		let r = e.filter((e) => Number.isSafeInteger(e) && e > 0);
+		if (t === void 0) {
+			if (r.length === 0) return;
+			let e = q(r);
+			this.#w({
+				generation: n.generation,
+				state: "active",
+				boundary: {
+					changeId: Math.max(n.boundary.changeId, e - 1),
+					createdAfter: n.boundary.createdAfter
+				}
+			});
+			return;
+		}
+		if (!(t.generation === null ? t.recordAt !== null && Number.isFinite(t.recordAt.getTime()) && t.recordAt.getTime() > n.clearedAt.getTime() : t.generation === n.generation)) return;
+		let i = r.length > 0 ? q(r) : null, a = i === null && (n.boundary.createdAfter === null || n.boundary.createdAfter.getTime() < n.clearedAt.getTime()) ? n.clearedAt : n.boundary.createdAfter;
+		this.#w({
+			generation: n.generation,
+			state: "active",
+			boundary: {
+				changeId: i === null ? n.boundary.changeId : Math.max(n.boundary.changeId, i - 1),
+				createdAfter: a
+			}
+		});
+	}
+	isExecutingUndoRedo() {
+		return this.isUndoRedoInProgress || this.isInvalidatingRedo || this.syncDepth > 0;
+	}
+	async syncing(e) {
+		this.syncDepth += 1;
+		try {
+			return await e();
+		} finally {
+			--this.syncDepth;
+		}
+	}
+	async invalidateRedoStack(e) {
+		return this.#j(async () => {
+			if (!(this.isUndoRedoInProgress || this.isInvalidatingRedo) && !(e?.length && e.every((e) => e <= this.#p))) {
+				this.isInvalidatingRedo = !0;
+				try {
+					let e = await w(this.redoHistories$);
+					if (e.length === 0) return;
+					let t = e.flatMap((e) => e.changes), n = /* @__PURE__ */ new Date(), r = W([], !1), { adapter: i } = await this.rxdb.versionManager.getLocalRepositories();
+					t.forEach((e) => {
+						let t = `rxdb:RxDBChange:${e.id}`;
+						r.updates.set(t, {
+							patch: { redoInvalidatedAt: n },
+							inversePatch: { redoInvalidatedAt: null }
+						});
+					}), await i.switchBranch({ actions: r }), this.clearRedoStack();
+				} catch (e) {
+					throw console.error("[HistoryManager] Failed to invalidate redo stack:", e), e;
+				} finally {
+					this.isInvalidatingRedo = !1;
+				}
+			}
+		});
+	}
+	history(e) {
+		return pe(this.#n, e);
+	}
+	#S(e, t, n) {
+		let { crossScope: r, selected: i } = ve(e, t, n);
+		if (r.length > 0) throw new H(t, r);
+		return i;
+	}
+	#C() {
+		return ++this.#y;
+	}
+	#w(e) {
+		this.#b !== null && this.#_.set(this.#b, e), this.#x.next(e);
+	}
+	#T(e, t) {
+		this.#t || y(t) || (console.error(`[HistoryManager] ${e}:`, t), this.errors$.next(t instanceof Error ? t : Error(String(t))));
+	}
+	#E(e) {
+		if (e === this.#b || (this.#b === null && e !== null && !this.#_.has(e) && this.#_.set(e, this.#x.value), this.#b = e, e === null)) return;
+		let t = this.#_.get(e) ?? this.#D();
+		this.#_.set(e, t), this.#x.next(t);
+	}
+	#D() {
+		let e = this.#C(), t = this.#v;
+		return t === null ? {
+			generation: e,
+			state: "active",
+			boundary: R
+		} : {
+			...t,
+			generation: e
+		};
+	}
+	#O(e) {
+		return e.map((e) => {
+			let t = !1;
+			for (let n of e.changes) {
+				let e = {
+					reverted: n.revertChangeId != null,
+					updatedAt: n.updatedAt.getTime()
+				}, r = this.#d.get(n.id), i = r && r.updatedAt >= e.updatedAt ? r : e;
+				r && e.updatedAt > r.updatedAt && this.#d.set(n.id, e), t ||= i.reverted;
+			}
+			return t === e.reverted ? e : {
+				...e,
+				reverted: t
+			};
+		});
+	}
+	#k(e) {
+		let t = Date.now();
+		for (let n of e) {
+			let e = this.#d.get(n.id)?.updatedAt ?? 0;
+			t = Math.max(t, n.updatedAt.getTime() + 1, e + 1);
+		}
+		return new Date(t);
+	}
+	#A(e, t, n) {
+		for (let r of e) this.#d.set(r.id, {
+			reverted: t,
+			updatedAt: n.getTime()
+		});
+		this.#f.next(this.#f.value + 1);
+	}
+	#j(e) {
+		let t = this.#a.then(e, e);
+		return this.#a = t.catch(() => void 0), t;
+	}
+	#M() {
+		return this.#h ||= this.rxdb.firstConnectedAt ?? this.#g, this.#h;
+	}
+	#N(e) {
+		return this.#x.value === e;
+	}
+	async #P(e) {
+		return Te(this.#r, e);
+	}
+	#F = () => {
+		this.#L(), this.#u.next(Date.now());
+	};
+	async #I(e, t, n) {
+		return Ee(this.#r, e, t, n);
+	}
+	async #L() {
+		return De(this.#r);
+	}
+	#R() {
+		let e = this;
+		return {
+			get history_cache() {
+				return e.history_cache;
+			},
+			get history_ref_counts() {
+				return e.history_ref_counts;
+			},
+			get histories$() {
+				return e.histories$;
+			},
+			get undoHistories$() {
+				return e.undoHistories$;
+			},
+			get redoHistories$() {
+				return e.redoHistories$;
+			},
+			get undoSession$() {
+				return e.#x;
+			},
+			runSerialized: (t) => e.#j(t),
+			fetchLatestHistories: (t) => e.#P(t),
+			isUndoSessionCurrent: (t) => e.#N(t),
+			selectWholeTransactions: (t, n, r) => e.#S(t, n, r),
+			applyUndoRedoHistories: (t, n, r) => e.#I(t, n, r)
+		};
+	}
+	#z() {
+		let e = this;
+		return {
+			get rxdb() {
+				return e.rxdb;
+			},
+			get destroyed() {
+				return e.#t;
+			},
+			get isUndoRedoInProgress() {
+				return e.isUndoRedoInProgress;
+			},
+			set isUndoRedoInProgress(t) {
+				e.isUndoRedoInProgress = t;
+			},
+			get redoInvalidationFloor() {
+				return e.#p;
+			},
+			set redoInvalidationFloor(t) {
+				e.#p = t;
+			},
+			get pushableGeneration() {
+				return e.#l;
+			},
+			set pushableGeneration(t) {
+				e.#l = t;
+			},
+			get pushableCount$() {
+				return e.#c;
+			},
+			get pushableCountTrigger$() {
+				return e.#u;
+			},
+			get errors$() {
+				return e.errors$;
+			},
+			getFirstConnectedAt: () => e.#M(),
+			isUndoSessionCurrent: (t) => e.#N(t),
+			getNextRevertStateUpdatedAt: (t) => e.#k(t),
+			setRevertStateWatermarks: (t, n, r) => e.#A(t, n, r),
+			pushToRedoStack: (t) => e.pushToRedoStack(t),
+			removeFromRedoStack: (t) => e.removeFromRedoStack(t)
+		};
+	}
+}, Y = async (e, t) => {
+	let { adapter: n } = await e.getLocalRepositories();
+	if (t === "main") throw new s("Cannot remove main branch");
+	let r = await n.transaction(async (e) => {
+		let n = e.getRepository(a), r = e.getRepository(o), i = (await n.find({
+			where: {
+				combinator: "and",
+				rules: [{
+					field: "id",
+					operator: "=",
+					value: t
+				}]
+			},
+			limit: 1
+		}))[0];
+		if (!i) return `Branch '${t}' not found`;
+		if (i.activated) return `Cannot remove active branch '${t}'. Switch to another branch first.`;
+		if ((await n.find({
+			where: {
+				combinator: "and",
+				rules: [{
+					field: "parentId",
+					operator: "=",
+					value: t
+				}, {
+					field: "id",
+					operator: "!=",
+					value: t
+				}]
+			},
+			limit: 1
+		}))?.length) return `Cannot remove branch '${t}' because it has child branches`;
+		let s = await r.find({ where: {
+			combinator: "and",
+			rules: [{
+				field: "branchId",
+				operator: "=",
+				value: t
+			}]
+		} });
+		await e.removeMany([...s, i]);
+	});
+	if (r) throw new s(r);
+}, Oe = async (e, t, n, r) => {
+	let i = r?.strategy ?? "squash", a = r?.deleteSource ?? !1, { branchRepository: o, changeRepository: c, adapter: l } = await e.getLocalRepositories();
+	if (t === n) throw new s(`Cannot merge branch '${t}' into itself`);
+	let u = (await o.find({
+		where: {
+			combinator: "and",
+			rules: [{
+				field: "id",
+				operator: "=",
+				value: t
+			}]
+		},
+		limit: 1
+	}))[0];
+	if (!u) throw new s(`Branch '${t}' not found`);
+	let d = await c.find({
+		where: {
+			combinator: "and",
+			rules: [
+				{
+					field: "branchId",
+					operator: "=",
+					value: t
+				},
+				{
+					field: "revertChangeId",
+					operator: "=",
+					value: null
+				},
+				...u.fromChangeId == null ? [] : [{
+					field: "id",
+					operator: ">",
+					value: u.fromChangeId
+				}]
+			]
+		},
+		orderBy: [{
+			field: "id",
+			sort: "asc"
+		}]
+	}), f = async () => {
+		if (!a) return { deleted: !1 };
+		try {
+			return await Y(e, t), { deleted: !0 };
+		} catch (e) {
+			return {
+				deleted: !1,
+				error: e instanceof Error ? e : Error(String(e))
+			};
+		}
+	}, p = (e, t) => ({
+		merged: e,
+		strategy: i,
+		sourceDeleted: t.deleted,
+		...t.error ? { sourceDeleteError: t.error } : {}
+	});
+	if (d.length === 0) return p(0, await f());
+	let m;
+	if (i === "normal") await l.transaction(async (e) => {
+		for (let t of d) {
+			let n = {
+				deletes: /* @__PURE__ */ new Map(),
+				updates: /* @__PURE__ */ new Map(),
+				inserts: /* @__PURE__ */ new Map()
+			}, r = _(t);
+			t.type === "INSERT" ? n.inserts.set(r, {
+				patch: t.patch,
+				inversePatch: null
+			}) : t.type === "UPDATE" ? n.updates.set(r, {
+				patch: t.patch,
+				inversePatch: t.inversePatch
+			}) : t.type === "DELETE" && n.deletes.set(r, {
+				patch: null,
+				inversePatch: t.inversePatch
+			}), await e.mergeChanges(n, void 0, !1);
+		}
+	}), m = d.length;
+	else {
+		let e = W(d, !0), t = new Set(d.filter((e) => e.type === "INSERT").map((e) => _(e)));
+		for (let n of t) e.deletes.has(n) && e.deletes.delete(n);
+		if (m = e.inserts.size + e.updates.size + e.deletes.size, m === 0) return p(0, await f());
+		await l.mergeChanges(e, void 0, !1);
+	}
+	return p(m, await f());
+}, X = class {
+	#e = /* @__PURE__ */ new Map();
+	#t = 0;
+	session() {
+		let e = ++this.#t, t = /* @__PURE__ */ new Map();
+		return this.#e.set(e, t), {
+			claim: (e, n) => {
+				let r = t.get(e);
+				r !== void 0 && r >= n || t.set(e, n);
+			},
+			release: () => {
+				this.#e.delete(e);
+			}
+		};
+	}
+	snapshot() {
+		let e = /* @__PURE__ */ new Map();
+		for (let t of this.#e.values()) for (let [n, r] of t) {
+			let t = e.get(n);
+			t !== void 0 && t >= r || e.set(n, r);
+		}
+		return e;
+	}
+};
+//#endregion
+//#region src/restore-entity.ts
+async function ke(e, t, n) {
+	let { changeRepository: r, adapter: i } = await e.getLocalRepositories(), a = await r.find({
+		where: {
+			combinator: "and",
+			rules: [{
+				field: "id",
+				operator: "=",
+				value: Number(n.changeId)
+			}]
+		},
+		limit: 1
+	});
+	if (a.length === 0) throw new s(`RxDBChange not found: ${n.changeId}`);
+	let o = a[0];
+	if (o.type !== "DELETE") throw new s(`Cannot restore from non-DELETE change (type=${o.type})`);
+	if (!o.inversePatch) throw new s(`RxDBChange ${n.changeId} has no inversePatch`);
+	let c = t.constructor, l = g(c), u = await e.getCurrentBranch();
+	if (o.namespace !== l.namespace || o.entity !== l.name) throw new s(`RxDBChange ${n.changeId} belongs to ${o.namespace}:${o.entity}, not ${l.namespace}:${l.name}`);
+	if (o.branchId != null && o.branchId !== u.id) throw new s(`RxDBChange ${n.changeId} belongs to branch '${o.branchId}', current branch is '${u.id}'`);
+	let d = W([o], !1);
+	await i.mergeChanges(d, void 0, !1);
+	let f = await i.getRepository(c).find({
+		where: {
+			combinator: "and",
+			rules: [{
+				field: "id",
+				operator: "=",
+				value: o.entityId
+			}]
+		},
+		limit: 1
+	});
+	if (!f[0]) throw new s(`Restore produced no row for ${l.namespace}:${l.name} id=${String(o.entityId)}`);
+	return f[0];
+}
+//#endregion
+//#region src/sync-history-bridge.ts
+var Z = (e, t) => ({
+	pushInFlight: t,
+	syncing: (t) => e().syncing(t),
+	clearUndoHistory: () => e().clearUndoHistory(),
+	beginPullableSettlement: () => e().beginPullableSettlement(),
+	settlePull: (t, n, r) => e().settlePullableCount(t, {
+		complete: z(n, r),
+		pulled: r.pulled
+	}),
+	settleAbortedPull: (t, n) => e().settlePullableCount(t, {
+		complete: !1,
+		pulled: n
+	}),
+	reconcilePullableCount: (t, n) => e().reconcilePullableCount(t, n),
+	incrementPullableCount: (t) => e().incrementPullableCount(t)
+}), Q = (e) => typeof e == "number" && Number.isSafeInteger(e) && e > 0 ? e : null, Ae = (e) => {
+	let t = Q(e.id);
+	return t === null ? typeof e.patch != "object" || e.patch === null || !("id" in e.patch) ? null : Q(e.patch.id) : t;
+}, je = (e) => {
+	let t = null;
+	for (let n of e) n.recordAt instanceof Date && Number.isFinite(n.recordAt.getTime()) && (t === null || n.recordAt.getTime() < t.getTime()) && (t = n.recordAt);
+	return t;
+}, Me = class {
+	rxdb;
+	#e = [];
+	#t = 0;
+	#n = null;
+	#r = !1;
+	#i = !1;
+	historyManager;
+	pushInFlight = new X();
+	syncBridge = Z(() => this.historyManager, this.pushInFlight);
+	get pushableCount$() {
+		return this.historyManager.pushableCount$;
+	}
+	get pullableCount$() {
+		return this.historyManager.pullableCount$;
+	}
+	constructor(e) {
+		this.rxdb = e, this.historyManager = new J(this.rxdb);
+	}
+	init() {
+		this.#i &&= (this.historyManager = new J(this.rxdb), !1);
+		let t = () => {
+			if (!this.#r) {
+				this.#r = !0;
+				let e = () => {
+					if (this.#t > 1) {
+						--this.#t;
+						return;
+					}
+					this.#t = 0, this.#n = null;
+				}, t = () => {
+					this.#t = 0, this.#n = null;
+				};
+				this.rxdb.addEventListener(m, e), this.rxdb.addEventListener(h, t), this.#e.push(() => this.rxdb.removeEventListener(m, e), () => this.rxdb.removeEventListener(h, t));
+			}
+			this.#t === 0 && (this.#n = this.historyManager.undoSessionGeneration), this.#t += 1;
+		};
+		this.rxdb.addEventListener(p, t), this.#e.push(() => this.rxdb.removeEventListener(p, t));
+		let n = (e) => {
+			let t = e.entities?.filter((e) => e.namespace === "rxdb" && e.entity === "RxDBChange") ?? [];
+			if (t.length > 0 && !this.historyManager.isExecutingUndoRedo()) {
+				let e = t.flatMap((e) => {
+					let t = Ae(e);
+					return t === null ? [] : [t];
+				});
+				this.#a(this.historyManager.invalidateRedoStack(e), "invalidateRedoStack");
+				let n = je(t);
+				this.#n !== null || n !== null ? this.historyManager.resetSyncCleared(e, {
+					generation: this.#n,
+					recordAt: n
+				}) : this.historyManager.resetSyncCleared(e);
+			}
+		};
+		this.rxdb.addEventListener(e, n), this.#e.push(() => this.rxdb.removeEventListener(e, n));
+	}
+	destroy() {
+		if (!this.#i) {
+			this.#i = !0, this.historyManager.destroy();
+			for (let e of this.#e) e();
+			this.#e.length = 0, this.#t = 0, this.#n = null, this.#r = !1;
+		}
+	}
+	resetSessionState() {
+		this.historyManager.clearAllUndoHistory(), this.historyManager.resetPullableCount();
+	}
+	async createBranch(e, t) {
+		return le(this, e, t);
+	}
+	async removeBranch(e) {
+		return Y(this, e);
+	}
+	async switchBranch(e) {
+		if ((await this.getCurrentBranch())?.id === e) return;
+		let t = !1;
+		try {
+			this.rxdb.dispatchEvent(new u(e));
+			let { adapter: n } = await this.getLocalRepositories(), r = await Se(this, e), i = await n.switchBranch({
+				branchId: e,
+				actions: r
+			});
+			return t = !0, this.historyManager.clearRedoStack(), this.historyManager.setUndoBranch(e), this.rxdb.dispatchEvent(new d(e)), i;
+		} catch (n) {
+			throw t || this.rxdb.dispatchEvent(new f(e)), n;
+		}
+	}
+	async mergeBranch(e, i) {
+		let a = await this.getCurrentBranch();
+		if (!a) throw new s("No active branch found");
+		let o = a.id;
+		try {
+			this.rxdb.dispatchEvent(new t(e, o));
+			let r = await Oe(this, e, o, i);
+			return r.merged > 0 && this.historyManager.clearUndoHistory(), this.rxdb.dispatchEvent(new n(e, o)), r;
+		} catch (t) {
+			throw this.rxdb.dispatchEvent(new r(e, o)), t;
+		}
+	}
+	history(e) {
+		return this.historyManager.history(e);
+	}
+	async restoreEntity(e, t) {
+		return ke(this, e, t);
+	}
+	async getLocalRepositories() {
+		return ne(this.rxdb);
+	}
+	async getRemoteRepositories() {
+		return re(this.rxdb);
+	}
+	async getCurrentBranch() {
+		return te(this.rxdb);
+	}
+	#a(e, t) {
+		e.catch((e) => {
+			A(e) || console.error(`[VersionManager] ${t} failed:`, e);
+		});
+	}
+}, $ = class extends c {
+	lifecycle = "scoped";
+	name = "history";
+	install(e) {
+		let t = new Me(this.rxdb);
+		e.acquire(() => (Object.defineProperty(this.rxdb, "versionManager", {
+			value: t,
+			configurable: !0,
+			enumerable: !0
+		}), () => void Reflect.deleteProperty(this.rxdb, "versionManager")), "history:slot"), e.acquire(() => () => t.destroy(), "history:versionManager"), t.init(), e.acquire(() => this.rxdb.syncState.bindPushableCount(t.pushableCount$), "history:pushableCount");
+	}
+}, Ne = (e) => new $(e);
+//#endregion
+export { X as PushInFlightRegistry, H as RxDBCrossScopeTransactionError, $ as RxDBPluginHistory, A as isIgnorableDetachedVersionEventError, Ne as rxDBPluginHistory };