@credo-ts/askar-to-drizzle-storage-migration 0.6.0-alpha-20251010154241 → 0.6.0-alpha-20251010164336

package/build/node_modules/.pnpm/async-mutex@0.5.0/node_modules/async-mutex/index.js

@@ -0,0 +1,303 @@
+
+//#region ../../node_modules/.pnpm/async-mutex@0.5.0/node_modules/async-mutex/index.mjs
+const E_TIMEOUT = /* @__PURE__ */ new Error("timeout while waiting for mutex to become available");
+const E_CANCELED = /* @__PURE__ */ new Error("request for lock canceled");
+var __awaiter$2 = function(thisArg, _arguments, P, generator) {
+	function adopt(value) {
+		return value instanceof P ? value : new P(function(resolve) {
+			resolve(value);
+		});
+	}
+	return new (P || (P = Promise))(function(resolve, reject) {
+		function fulfilled(value) {
+			try {
+				step(generator.next(value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function rejected(value) {
+			try {
+				step(generator["throw"](value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function step(result) {
+			result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+		}
+		step((generator = generator.apply(thisArg, _arguments || [])).next());
+	});
+};
+var Semaphore = class {
+	constructor(_value, _cancelError = E_CANCELED) {
+		this._value = _value;
+		this._cancelError = _cancelError;
+		this._queue = [];
+		this._weightedWaiters = [];
+	}
+	acquire(weight = 1, priority = 0) {
+		if (weight <= 0) throw new Error(`invalid weight ${weight}: must be positive`);
+		return new Promise((resolve, reject) => {
+			const task = {
+				resolve,
+				reject,
+				weight,
+				priority
+			};
+			const i = findIndexFromEnd(this._queue, (other) => priority <= other.priority);
+			if (i === -1 && weight <= this._value) this._dispatchItem(task);
+			else this._queue.splice(i + 1, 0, task);
+		});
+	}
+	runExclusive(callback_1) {
+		return __awaiter$2(this, arguments, void 0, function* (callback, weight = 1, priority = 0) {
+			const [value, release] = yield this.acquire(weight, priority);
+			try {
+				return yield callback(value);
+			} finally {
+				release();
+			}
+		});
+	}
+	waitForUnlock(weight = 1, priority = 0) {
+		if (weight <= 0) throw new Error(`invalid weight ${weight}: must be positive`);
+		if (this._couldLockImmediately(weight, priority)) return Promise.resolve();
+		else return new Promise((resolve) => {
+			if (!this._weightedWaiters[weight - 1]) this._weightedWaiters[weight - 1] = [];
+			insertSorted(this._weightedWaiters[weight - 1], {
+				resolve,
+				priority
+			});
+		});
+	}
+	isLocked() {
+		return this._value <= 0;
+	}
+	getValue() {
+		return this._value;
+	}
+	setValue(value) {
+		this._value = value;
+		this._dispatchQueue();
+	}
+	release(weight = 1) {
+		if (weight <= 0) throw new Error(`invalid weight ${weight}: must be positive`);
+		this._value += weight;
+		this._dispatchQueue();
+	}
+	cancel() {
+		this._queue.forEach((entry) => entry.reject(this._cancelError));
+		this._queue = [];
+	}
+	_dispatchQueue() {
+		this._drainUnlockWaiters();
+		while (this._queue.length > 0 && this._queue[0].weight <= this._value) {
+			this._dispatchItem(this._queue.shift());
+			this._drainUnlockWaiters();
+		}
+	}
+	_dispatchItem(item) {
+		const previousValue = this._value;
+		this._value -= item.weight;
+		item.resolve([previousValue, this._newReleaser(item.weight)]);
+	}
+	_newReleaser(weight) {
+		let called = false;
+		return () => {
+			if (called) return;
+			called = true;
+			this.release(weight);
+		};
+	}
+	_drainUnlockWaiters() {
+		if (this._queue.length === 0) for (let weight = this._value; weight > 0; weight--) {
+			const waiters = this._weightedWaiters[weight - 1];
+			if (!waiters) continue;
+			waiters.forEach((waiter) => waiter.resolve());
+			this._weightedWaiters[weight - 1] = [];
+		}
+		else {
+			const queuedPriority = this._queue[0].priority;
+			for (let weight = this._value; weight > 0; weight--) {
+				const waiters = this._weightedWaiters[weight - 1];
+				if (!waiters) continue;
+				const i = waiters.findIndex((waiter) => waiter.priority <= queuedPriority);
+				(i === -1 ? waiters : waiters.splice(0, i)).forEach(((waiter) => waiter.resolve()));
+			}
+		}
+	}
+	_couldLockImmediately(weight, priority) {
+		return (this._queue.length === 0 || this._queue[0].priority < priority) && weight <= this._value;
+	}
+};
+function insertSorted(a, v) {
+	const i = findIndexFromEnd(a, (other) => v.priority <= other.priority);
+	a.splice(i + 1, 0, v);
+}
+function findIndexFromEnd(a, predicate) {
+	for (let i = a.length - 1; i >= 0; i--) if (predicate(a[i])) return i;
+	return -1;
+}
+var __awaiter$1 = function(thisArg, _arguments, P, generator) {
+	function adopt(value) {
+		return value instanceof P ? value : new P(function(resolve) {
+			resolve(value);
+		});
+	}
+	return new (P || (P = Promise))(function(resolve, reject) {
+		function fulfilled(value) {
+			try {
+				step(generator.next(value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function rejected(value) {
+			try {
+				step(generator["throw"](value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function step(result) {
+			result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+		}
+		step((generator = generator.apply(thisArg, _arguments || [])).next());
+	});
+};
+var Mutex = class {
+	constructor(cancelError) {
+		this._semaphore = new Semaphore(1, cancelError);
+	}
+	acquire() {
+		return __awaiter$1(this, arguments, void 0, function* (priority = 0) {
+			const [, releaser] = yield this._semaphore.acquire(1, priority);
+			return releaser;
+		});
+	}
+	runExclusive(callback, priority = 0) {
+		return this._semaphore.runExclusive(() => callback(), 1, priority);
+	}
+	isLocked() {
+		return this._semaphore.isLocked();
+	}
+	waitForUnlock(priority = 0) {
+		return this._semaphore.waitForUnlock(1, priority);
+	}
+	release() {
+		if (this._semaphore.isLocked()) this._semaphore.release();
+	}
+	cancel() {
+		return this._semaphore.cancel();
+	}
+};
+var __awaiter = function(thisArg, _arguments, P, generator) {
+	function adopt(value) {
+		return value instanceof P ? value : new P(function(resolve) {
+			resolve(value);
+		});
+	}
+	return new (P || (P = Promise))(function(resolve, reject) {
+		function fulfilled(value) {
+			try {
+				step(generator.next(value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function rejected(value) {
+			try {
+				step(generator["throw"](value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function step(result) {
+			result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+		}
+		step((generator = generator.apply(thisArg, _arguments || [])).next());
+	});
+};
+function withTimeout(sync, timeout, timeoutError = E_TIMEOUT) {
+	return {
+		acquire: (weightOrPriority, priority) => {
+			let weight;
+			if (isSemaphore(sync)) weight = weightOrPriority;
+			else {
+				weight = void 0;
+				priority = weightOrPriority;
+			}
+			if (weight !== void 0 && weight <= 0) throw new Error(`invalid weight ${weight}: must be positive`);
+			return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+				let isTimeout = false;
+				const handle = setTimeout(() => {
+					isTimeout = true;
+					reject(timeoutError);
+				}, timeout);
+				try {
+					const ticket = yield isSemaphore(sync) ? sync.acquire(weight, priority) : sync.acquire(priority);
+					if (isTimeout) (Array.isArray(ticket) ? ticket[1] : ticket)();
+					else {
+						clearTimeout(handle);
+						resolve(ticket);
+					}
+				} catch (e) {
+					if (!isTimeout) {
+						clearTimeout(handle);
+						reject(e);
+					}
+				}
+			}));
+		},
+		runExclusive(callback, weight, priority) {
+			return __awaiter(this, void 0, void 0, function* () {
+				let release = () => void 0;
+				try {
+					const ticket = yield this.acquire(weight, priority);
+					if (Array.isArray(ticket)) {
+						release = ticket[1];
+						return yield callback(ticket[0]);
+					} else {
+						release = ticket;
+						return yield callback();
+					}
+				} finally {
+					release();
+				}
+			});
+		},
+		release(weight) {
+			sync.release(weight);
+		},
+		cancel() {
+			return sync.cancel();
+		},
+		waitForUnlock: (weightOrPriority, priority) => {
+			let weight;
+			if (isSemaphore(sync)) weight = weightOrPriority;
+			else {
+				weight = void 0;
+				priority = weightOrPriority;
+			}
+			if (weight !== void 0 && weight <= 0) throw new Error(`invalid weight ${weight}: must be positive`);
+			return new Promise((resolve, reject) => {
+				const handle = setTimeout(() => reject(timeoutError), timeout);
+				(isSemaphore(sync) ? sync.waitForUnlock(weight, priority) : sync.waitForUnlock(priority)).then(() => {
+					clearTimeout(handle);
+					resolve();
+				});
+			});
+		},
+		isLocked: () => sync.isLocked(),
+		getValue: () => sync.getValue(),
+		setValue: (value) => sync.setValue(value)
+	};
+}
+function isSemaphore(sync) {
+	return sync.getValue !== void 0;
+}
+
+//#endregion
+exports.Mutex = Mutex;
+exports.withTimeout = withTimeout;

package/build/node_modules/.pnpm/async-mutex@0.5.0/node_modules/async-mutex/index.mjs

@@ -0,0 +1,302 @@
+//#region ../../node_modules/.pnpm/async-mutex@0.5.0/node_modules/async-mutex/index.mjs
+const E_TIMEOUT = /* @__PURE__ */ new Error("timeout while waiting for mutex to become available");
+const E_CANCELED = /* @__PURE__ */ new Error("request for lock canceled");
+var __awaiter$2 = function(thisArg, _arguments, P, generator) {
+	function adopt(value) {
+		return value instanceof P ? value : new P(function(resolve) {
+			resolve(value);
+		});
+	}
+	return new (P || (P = Promise))(function(resolve, reject) {
+		function fulfilled(value) {
+			try {
+				step(generator.next(value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function rejected(value) {
+			try {
+				step(generator["throw"](value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function step(result) {
+			result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+		}
+		step((generator = generator.apply(thisArg, _arguments || [])).next());
+	});
+};
+var Semaphore = class {
+	constructor(_value, _cancelError = E_CANCELED) {
+		this._value = _value;
+		this._cancelError = _cancelError;
+		this._queue = [];
+		this._weightedWaiters = [];
+	}
+	acquire(weight = 1, priority = 0) {
+		if (weight <= 0) throw new Error(`invalid weight ${weight}: must be positive`);
+		return new Promise((resolve, reject) => {
+			const task = {
+				resolve,
+				reject,
+				weight,
+				priority
+			};
+			const i = findIndexFromEnd(this._queue, (other) => priority <= other.priority);
+			if (i === -1 && weight <= this._value) this._dispatchItem(task);
+			else this._queue.splice(i + 1, 0, task);
+		});
+	}
+	runExclusive(callback_1) {
+		return __awaiter$2(this, arguments, void 0, function* (callback, weight = 1, priority = 0) {
+			const [value, release] = yield this.acquire(weight, priority);
+			try {
+				return yield callback(value);
+			} finally {
+				release();
+			}
+		});
+	}
+	waitForUnlock(weight = 1, priority = 0) {
+		if (weight <= 0) throw new Error(`invalid weight ${weight}: must be positive`);
+		if (this._couldLockImmediately(weight, priority)) return Promise.resolve();
+		else return new Promise((resolve) => {
+			if (!this._weightedWaiters[weight - 1]) this._weightedWaiters[weight - 1] = [];
+			insertSorted(this._weightedWaiters[weight - 1], {
+				resolve,
+				priority
+			});
+		});
+	}
+	isLocked() {
+		return this._value <= 0;
+	}
+	getValue() {
+		return this._value;
+	}
+	setValue(value) {
+		this._value = value;
+		this._dispatchQueue();
+	}
+	release(weight = 1) {
+		if (weight <= 0) throw new Error(`invalid weight ${weight}: must be positive`);
+		this._value += weight;
+		this._dispatchQueue();
+	}
+	cancel() {
+		this._queue.forEach((entry) => entry.reject(this._cancelError));
+		this._queue = [];
+	}
+	_dispatchQueue() {
+		this._drainUnlockWaiters();
+		while (this._queue.length > 0 && this._queue[0].weight <= this._value) {
+			this._dispatchItem(this._queue.shift());
+			this._drainUnlockWaiters();
+		}
+	}
+	_dispatchItem(item) {
+		const previousValue = this._value;
+		this._value -= item.weight;
+		item.resolve([previousValue, this._newReleaser(item.weight)]);
+	}
+	_newReleaser(weight) {
+		let called = false;
+		return () => {
+			if (called) return;
+			called = true;
+			this.release(weight);
+		};
+	}
+	_drainUnlockWaiters() {
+		if (this._queue.length === 0) for (let weight = this._value; weight > 0; weight--) {
+			const waiters = this._weightedWaiters[weight - 1];
+			if (!waiters) continue;
+			waiters.forEach((waiter) => waiter.resolve());
+			this._weightedWaiters[weight - 1] = [];
+		}
+		else {
+			const queuedPriority = this._queue[0].priority;
+			for (let weight = this._value; weight > 0; weight--) {
+				const waiters = this._weightedWaiters[weight - 1];
+				if (!waiters) continue;
+				const i = waiters.findIndex((waiter) => waiter.priority <= queuedPriority);
+				(i === -1 ? waiters : waiters.splice(0, i)).forEach(((waiter) => waiter.resolve()));
+			}
+		}
+	}
+	_couldLockImmediately(weight, priority) {
+		return (this._queue.length === 0 || this._queue[0].priority < priority) && weight <= this._value;
+	}
+};
+function insertSorted(a, v) {
+	const i = findIndexFromEnd(a, (other) => v.priority <= other.priority);
+	a.splice(i + 1, 0, v);
+}
+function findIndexFromEnd(a, predicate) {
+	for (let i = a.length - 1; i >= 0; i--) if (predicate(a[i])) return i;
+	return -1;
+}
+var __awaiter$1 = function(thisArg, _arguments, P, generator) {
+	function adopt(value) {
+		return value instanceof P ? value : new P(function(resolve) {
+			resolve(value);
+		});
+	}
+	return new (P || (P = Promise))(function(resolve, reject) {
+		function fulfilled(value) {
+			try {
+				step(generator.next(value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function rejected(value) {
+			try {
+				step(generator["throw"](value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function step(result) {
+			result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+		}
+		step((generator = generator.apply(thisArg, _arguments || [])).next());
+	});
+};
+var Mutex = class {
+	constructor(cancelError) {
+		this._semaphore = new Semaphore(1, cancelError);
+	}
+	acquire() {
+		return __awaiter$1(this, arguments, void 0, function* (priority = 0) {
+			const [, releaser] = yield this._semaphore.acquire(1, priority);
+			return releaser;
+		});
+	}
+	runExclusive(callback, priority = 0) {
+		return this._semaphore.runExclusive(() => callback(), 1, priority);
+	}
+	isLocked() {
+		return this._semaphore.isLocked();
+	}
+	waitForUnlock(priority = 0) {
+		return this._semaphore.waitForUnlock(1, priority);
+	}
+	release() {
+		if (this._semaphore.isLocked()) this._semaphore.release();
+	}
+	cancel() {
+		return this._semaphore.cancel();
+	}
+};
+var __awaiter = function(thisArg, _arguments, P, generator) {
+	function adopt(value) {
+		return value instanceof P ? value : new P(function(resolve) {
+			resolve(value);
+		});
+	}
+	return new (P || (P = Promise))(function(resolve, reject) {
+		function fulfilled(value) {
+			try {
+				step(generator.next(value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function rejected(value) {
+			try {
+				step(generator["throw"](value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function step(result) {
+			result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+		}
+		step((generator = generator.apply(thisArg, _arguments || [])).next());
+	});
+};
+function withTimeout(sync, timeout, timeoutError = E_TIMEOUT) {
+	return {
+		acquire: (weightOrPriority, priority) => {
+			let weight;
+			if (isSemaphore(sync)) weight = weightOrPriority;
+			else {
+				weight = void 0;
+				priority = weightOrPriority;
+			}
+			if (weight !== void 0 && weight <= 0) throw new Error(`invalid weight ${weight}: must be positive`);
+			return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+				let isTimeout = false;
+				const handle = setTimeout(() => {
+					isTimeout = true;
+					reject(timeoutError);
+				}, timeout);
+				try {
+					const ticket = yield isSemaphore(sync) ? sync.acquire(weight, priority) : sync.acquire(priority);
+					if (isTimeout) (Array.isArray(ticket) ? ticket[1] : ticket)();
+					else {
+						clearTimeout(handle);
+						resolve(ticket);
+					}
+				} catch (e) {
+					if (!isTimeout) {
+						clearTimeout(handle);
+						reject(e);
+					}
+				}
+			}));
+		},
+		runExclusive(callback, weight, priority) {
+			return __awaiter(this, void 0, void 0, function* () {
+				let release = () => void 0;
+				try {
+					const ticket = yield this.acquire(weight, priority);
+					if (Array.isArray(ticket)) {
+						release = ticket[1];
+						return yield callback(ticket[0]);
+					} else {
+						release = ticket;
+						return yield callback();
+					}
+				} finally {
+					release();
+				}
+			});
+		},
+		release(weight) {
+			sync.release(weight);
+		},
+		cancel() {
+			return sync.cancel();
+		},
+		waitForUnlock: (weightOrPriority, priority) => {
+			let weight;
+			if (isSemaphore(sync)) weight = weightOrPriority;
+			else {
+				weight = void 0;
+				priority = weightOrPriority;
+			}
+			if (weight !== void 0 && weight <= 0) throw new Error(`invalid weight ${weight}: must be positive`);
+			return new Promise((resolve, reject) => {
+				const handle = setTimeout(() => reject(timeoutError), timeout);
+				(isSemaphore(sync) ? sync.waitForUnlock(weight, priority) : sync.waitForUnlock(priority)).then(() => {
+					clearTimeout(handle);
+					resolve();
+				});
+			});
+		},
+		isLocked: () => sync.isLocked(),
+		getValue: () => sync.getValue(),
+		setValue: (value) => sync.setValue(value)
+	};
+}
+function isSemaphore(sync) {
+	return sync.getValue !== void 0;
+}
+
+//#endregion
+export { Mutex, withTimeout };
+//# sourceMappingURL=index.mjs.map

package/build/node_modules/.pnpm/async-mutex@0.5.0/node_modules/async-mutex/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../../../../../../node_modules/.pnpm/async-mutex@0.5.0/node_modules/async-mutex/index.mjs"],"sourcesContent":["const E_TIMEOUT = new Error('timeout while waiting for mutex to become available');\nconst E_ALREADY_LOCKED = new Error('mutex already locked');\nconst E_CANCELED = new Error('request for lock canceled');\n\nvar __awaiter$2 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nclass Semaphore {\n    constructor(_value, _cancelError = E_CANCELED) {\n        this._value = _value;\n        this._cancelError = _cancelError;\n        this._queue = [];\n        this._weightedWaiters = [];\n    }\n    acquire(weight = 1, priority = 0) {\n        if (weight <= 0)\n            throw new Error(`invalid weight ${weight}: must be positive`);\n        return new Promise((resolve, reject) => {\n            const task = { resolve, reject, weight, priority };\n            const i = findIndexFromEnd(this._queue, (other) => priority <= other.priority);\n            if (i === -1 && weight <= this._value) {\n                // Needs immediate dispatch, skip the queue\n                this._dispatchItem(task);\n            }\n            else {\n                this._queue.splice(i + 1, 0, task);\n            }\n        });\n    }\n    runExclusive(callback_1) {\n        return __awaiter$2(this, arguments, void 0, function* (callback, weight = 1, priority = 0) {\n            const [value, release] = yield this.acquire(weight, priority);\n            try {\n                return yield callback(value);\n            }\n            finally {\n                release();\n            }\n        });\n    }\n    waitForUnlock(weight = 1, priority = 0) {\n        if (weight <= 0)\n            throw new Error(`invalid weight ${weight}: must be positive`);\n        if (this._couldLockImmediately(weight, priority)) {\n            return Promise.resolve();\n        }\n        else {\n            return new Promise((resolve) => {\n                if (!this._weightedWaiters[weight - 1])\n                    this._weightedWaiters[weight - 1] = [];\n                insertSorted(this._weightedWaiters[weight - 1], { resolve, priority });\n            });\n        }\n    }\n    isLocked() {\n        return this._value <= 0;\n    }\n    getValue() {\n        return this._value;\n    }\n    setValue(value) {\n        this._value = value;\n        this._dispatchQueue();\n    }\n    release(weight = 1) {\n        if (weight <= 0)\n            throw new Error(`invalid weight ${weight}: must be positive`);\n        this._value += weight;\n        this._dispatchQueue();\n    }\n    cancel() {\n        this._queue.forEach((entry) => entry.reject(this._cancelError));\n        this._queue = [];\n    }\n    _dispatchQueue() {\n        this._drainUnlockWaiters();\n        while (this._queue.length > 0 && this._queue[0].weight <= this._value) {\n            this._dispatchItem(this._queue.shift());\n            this._drainUnlockWaiters();\n        }\n    }\n    _dispatchItem(item) {\n        const previousValue = this._value;\n        this._value -= item.weight;\n        item.resolve([previousValue, this._newReleaser(item.weight)]);\n    }\n    _newReleaser(weight) {\n        let called = false;\n        return () => {\n            if (called)\n                return;\n            called = true;\n            this.release(weight);\n        };\n    }\n    _drainUnlockWaiters() {\n        if (this._queue.length === 0) {\n            for (let weight = this._value; weight > 0; weight--) {\n                const waiters = this._weightedWaiters[weight - 1];\n                if (!waiters)\n                    continue;\n                waiters.forEach((waiter) => waiter.resolve());\n                this._weightedWaiters[weight - 1] = [];\n            }\n        }\n        else {\n            const queuedPriority = this._queue[0].priority;\n            for (let weight = this._value; weight > 0; weight--) {\n                const waiters = this._weightedWaiters[weight - 1];\n                if (!waiters)\n                    continue;\n                const i = waiters.findIndex((waiter) => waiter.priority <= queuedPriority);\n                (i === -1 ? waiters : waiters.splice(0, i))\n                    .forEach((waiter => waiter.resolve()));\n            }\n        }\n    }\n    _couldLockImmediately(weight, priority) {\n        return (this._queue.length === 0 || this._queue[0].priority < priority) &&\n            weight <= this._value;\n    }\n}\nfunction insertSorted(a, v) {\n    const i = findIndexFromEnd(a, (other) => v.priority <= other.priority);\n    a.splice(i + 1, 0, v);\n}\nfunction findIndexFromEnd(a, predicate) {\n    for (let i = a.length - 1; i >= 0; i--) {\n        if (predicate(a[i])) {\n            return i;\n        }\n    }\n    return -1;\n}\n\nvar __awaiter$1 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nclass Mutex {\n    constructor(cancelError) {\n        this._semaphore = new Semaphore(1, cancelError);\n    }\n    acquire() {\n        return __awaiter$1(this, arguments, void 0, function* (priority = 0) {\n            const [, releaser] = yield this._semaphore.acquire(1, priority);\n            return releaser;\n        });\n    }\n    runExclusive(callback, priority = 0) {\n        return this._semaphore.runExclusive(() => callback(), 1, priority);\n    }\n    isLocked() {\n        return this._semaphore.isLocked();\n    }\n    waitForUnlock(priority = 0) {\n        return this._semaphore.waitForUnlock(1, priority);\n    }\n    release() {\n        if (this._semaphore.isLocked())\n            this._semaphore.release();\n    }\n    cancel() {\n        return this._semaphore.cancel();\n    }\n}\n\nvar __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nfunction withTimeout(sync, timeout, timeoutError = E_TIMEOUT) {\n    return {\n        acquire: (weightOrPriority, priority) => {\n            let weight;\n            if (isSemaphore(sync)) {\n                weight = weightOrPriority;\n            }\n            else {\n                weight = undefined;\n                priority = weightOrPriority;\n            }\n            if (weight !== undefined && weight <= 0) {\n                throw new Error(`invalid weight ${weight}: must be positive`);\n            }\n            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {\n                let isTimeout = false;\n                const handle = setTimeout(() => {\n                    isTimeout = true;\n                    reject(timeoutError);\n                }, timeout);\n                try {\n                    const ticket = yield (isSemaphore(sync)\n                        ? sync.acquire(weight, priority)\n                        : sync.acquire(priority));\n                    if (isTimeout) {\n                        const release = Array.isArray(ticket) ? ticket[1] : ticket;\n                        release();\n                    }\n                    else {\n                        clearTimeout(handle);\n                        resolve(ticket);\n                    }\n                }\n                catch (e) {\n                    if (!isTimeout) {\n                        clearTimeout(handle);\n                        reject(e);\n                    }\n                }\n            }));\n        },\n        runExclusive(callback, weight, priority) {\n            return __awaiter(this, void 0, void 0, function* () {\n                let release = () => undefined;\n                try {\n                    const ticket = yield this.acquire(weight, priority);\n                    if (Array.isArray(ticket)) {\n                        release = ticket[1];\n                        return yield callback(ticket[0]);\n                    }\n                    else {\n                        release = ticket;\n                        return yield callback();\n                    }\n                }\n                finally {\n                    release();\n                }\n            });\n        },\n        release(weight) {\n            sync.release(weight);\n        },\n        cancel() {\n            return sync.cancel();\n        },\n        waitForUnlock: (weightOrPriority, priority) => {\n            let weight;\n            if (isSemaphore(sync)) {\n                weight = weightOrPriority;\n            }\n            else {\n                weight = undefined;\n                priority = weightOrPriority;\n            }\n            if (weight !== undefined && weight <= 0) {\n                throw new Error(`invalid weight ${weight}: must be positive`);\n            }\n            return new Promise((resolve, reject) => {\n                const handle = setTimeout(() => reject(timeoutError), timeout);\n                (isSemaphore(sync)\n                    ? sync.waitForUnlock(weight, priority)\n                    : sync.waitForUnlock(priority)).then(() => {\n                    clearTimeout(handle);\n                    resolve();\n                });\n            });\n        },\n        isLocked: () => sync.isLocked(),\n        getValue: () => sync.getValue(),\n        setValue: (value) => sync.setValue(value),\n    };\n}\nfunction isSemaphore(sync) {\n    return sync.getValue !== undefined;\n}\n\n// eslint-disable-next-lisne @typescript-eslint/explicit-module-boundary-types\nfunction tryAcquire(sync, alreadyAcquiredError = E_ALREADY_LOCKED) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    return withTimeout(sync, 0, alreadyAcquiredError);\n}\n\nexport { E_ALREADY_LOCKED, E_CANCELED, E_TIMEOUT, Mutex, Semaphore, tryAcquire, withTimeout };\n"],"x_google_ignoreList":[0],"mappings":"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"}