renovate-log-parser 0.1.0

package/web/.output/server/node_modules/hookable/dist/index.mjs

@@ -0,0 +1,257 @@
+function flatHooks(configHooks, hooks = {}, parentName) {
+	for (const key in configHooks) {
+		const subHook = configHooks[key];
+		const name = parentName ? `${parentName}:${key}` : key;
+		if (typeof subHook === "object" && subHook !== null) flatHooks(subHook, hooks, name);
+		else if (typeof subHook === "function") hooks[name] = subHook;
+	}
+	return hooks;
+}
+function mergeHooks(...hooks) {
+	const finalHooks = {};
+	for (const hook of hooks) {
+		const flatenHook = flatHooks(hook);
+		for (const key in flatenHook) if (finalHooks[key]) finalHooks[key].push(flatenHook[key]);
+		else finalHooks[key] = [flatenHook[key]];
+	}
+	for (const key in finalHooks) if (finalHooks[key].length > 1) {
+		const array = finalHooks[key];
+		finalHooks[key] = (...arguments_) => serial(array, (function_) => function_(...arguments_));
+	} else finalHooks[key] = finalHooks[key][0];
+	return finalHooks;
+}
+function serial(tasks, function_) {
+	return tasks.reduce((promise, task) => promise.then(() => function_(task)), Promise.resolve());
+}
+const createTask = /* @__PURE__ */ (() => {
+	if (console.createTask) return console.createTask;
+	const defaultTask = { run: (fn) => fn() };
+	return () => defaultTask;
+})();
+function callHooks(hooks, args, startIndex, task) {
+	for (let i = startIndex; i < hooks.length; i += 1) try {
+		const result = task ? task.run(() => hooks[i](...args)) : hooks[i](...args);
+		if (result && typeof result.then === "function") return Promise.resolve(result).then(() => callHooks(hooks, args, i + 1, task));
+	} catch (error) {
+		return Promise.reject(error);
+	}
+}
+function serialTaskCaller(hooks, args, name) {
+	if (hooks.length > 0) return callHooks(hooks, args, 0, createTask(name));
+}
+function parallelTaskCaller(hooks, args, name) {
+	if (hooks.length > 0) {
+		const task = createTask(name);
+		return Promise.all(hooks.map((hook) => task.run(() => hook(...args))));
+	}
+}
+function serialCaller(hooks, arguments_) {
+	return hooks.reduce((promise, hookFunction) => promise.then(() => hookFunction(...arguments_ || [])), Promise.resolve());
+}
+function parallelCaller(hooks, args) {
+	return Promise.all(hooks.map((hook) => hook(...args || [])));
+}
+function callEachWith(callbacks, arg0) {
+	for (const callback of [...callbacks]) callback(arg0);
+}
+var Hookable = class {
+	_hooks;
+	_before;
+	_after;
+	_deprecatedHooks;
+	_deprecatedMessages;
+	constructor() {
+		this._hooks = {};
+		this._before = void 0;
+		this._after = void 0;
+		this._deprecatedMessages = void 0;
+		this._deprecatedHooks = {};
+		this.hook = this.hook.bind(this);
+		this.callHook = this.callHook.bind(this);
+		this.callHookWith = this.callHookWith.bind(this);
+	}
+	hook(name, function_, options = {}) {
+		if (!name || typeof function_ !== "function") return () => {};
+		const originalName = name;
+		let dep;
+		while (this._deprecatedHooks[name]) {
+			dep = this._deprecatedHooks[name];
+			name = dep.to;
+		}
+		if (dep && !options.allowDeprecated) {
+			let message = dep.message;
+			if (!message) message = `${originalName} hook has been deprecated` + (dep.to ? `, please use ${dep.to}` : "");
+			if (!this._deprecatedMessages) this._deprecatedMessages = /* @__PURE__ */ new Set();
+			if (!this._deprecatedMessages.has(message)) {
+				console.warn(message);
+				this._deprecatedMessages.add(message);
+			}
+		}
+		if (!function_.name) try {
+			Object.defineProperty(function_, "name", {
+				get: () => "_" + name.replace(/\W+/g, "_") + "_hook_cb",
+				configurable: true
+			});
+		} catch {}
+		this._hooks[name] = this._hooks[name] || [];
+		this._hooks[name].push(function_);
+		return () => {
+			if (function_) {
+				this.removeHook(name, function_);
+				function_ = void 0;
+			}
+		};
+	}
+	hookOnce(name, function_) {
+		let _unreg;
+		let _function = (...arguments_) => {
+			if (typeof _unreg === "function") _unreg();
+			_unreg = void 0;
+			_function = void 0;
+			return function_(...arguments_);
+		};
+		_unreg = this.hook(name, _function);
+		return _unreg;
+	}
+	removeHook(name, function_) {
+		const hooks = this._hooks[name];
+		if (hooks) {
+			const index = hooks.indexOf(function_);
+			if (index !== -1) hooks.splice(index, 1);
+			if (hooks.length === 0) this._hooks[name] = void 0;
+		}
+	}
+	clearHook(name) {
+		this._hooks[name] = void 0;
+	}
+	deprecateHook(name, deprecated) {
+		this._deprecatedHooks[name] = typeof deprecated === "string" ? { to: deprecated } : deprecated;
+		const _hooks = this._hooks[name] || [];
+		this._hooks[name] = void 0;
+		for (const hook of _hooks) this.hook(name, hook);
+	}
+	deprecateHooks(deprecatedHooks) {
+		for (const name in deprecatedHooks) this.deprecateHook(name, deprecatedHooks[name]);
+	}
+	addHooks(configHooks) {
+		const hooks = flatHooks(configHooks);
+		const removeFns = Object.keys(hooks).map((key) => this.hook(key, hooks[key]));
+		return () => {
+			for (const unreg of removeFns) unreg();
+			removeFns.length = 0;
+		};
+	}
+	removeHooks(configHooks) {
+		const hooks = flatHooks(configHooks);
+		for (const key in hooks) this.removeHook(key, hooks[key]);
+	}
+	removeAllHooks() {
+		this._hooks = {};
+	}
+	callHook(name, ...args) {
+		return this.callHookWith(serialTaskCaller, name, args);
+	}
+	callHookParallel(name, ...args) {
+		return this.callHookWith(parallelTaskCaller, name, args);
+	}
+	callHookWith(caller, name, args) {
+		const event = this._before || this._after ? {
+			name,
+			args,
+			context: {}
+		} : void 0;
+		if (this._before) callEachWith(this._before, event);
+		const result = caller(this._hooks[name] ? [...this._hooks[name]] : [], args, name);
+		if (result instanceof Promise) return result.finally(() => {
+			if (this._after && event) callEachWith(this._after, event);
+		});
+		if (this._after && event) callEachWith(this._after, event);
+		return result;
+	}
+	beforeEach(function_) {
+		this._before = this._before || [];
+		this._before.push(function_);
+		return () => {
+			if (this._before !== void 0) {
+				const index = this._before.indexOf(function_);
+				if (index !== -1) this._before.splice(index, 1);
+			}
+		};
+	}
+	afterEach(function_) {
+		this._after = this._after || [];
+		this._after.push(function_);
+		return () => {
+			if (this._after !== void 0) {
+				const index = this._after.indexOf(function_);
+				if (index !== -1) this._after.splice(index, 1);
+			}
+		};
+	}
+};
+function createHooks() {
+	return new Hookable();
+}
+var HookableCore = class {
+	_hooks;
+	constructor() {
+		this._hooks = {};
+	}
+	hook(name, fn) {
+		if (!name || typeof fn !== "function") return () => {};
+		this._hooks[name] = this._hooks[name] || [];
+		this._hooks[name].push(fn);
+		return () => {
+			if (fn) {
+				this.removeHook(name, fn);
+				fn = void 0;
+			}
+		};
+	}
+	removeHook(name, function_) {
+		const hooks = this._hooks[name];
+		if (hooks) {
+			const index = hooks.indexOf(function_);
+			if (index !== -1) hooks.splice(index, 1);
+			if (hooks.length === 0) this._hooks[name] = void 0;
+		}
+	}
+	callHook(name, ...args) {
+		const hooks = this._hooks[name];
+		if (!hooks || hooks.length === 0) return;
+		return callHooks(hooks, args, 0);
+	}
+};
+const isBrowser = typeof window !== "undefined";
+function createDebugger(hooks, _options = {}) {
+	const options = {
+		inspect: isBrowser,
+		group: isBrowser,
+		filter: () => true,
+		..._options
+	};
+	const _filter = options.filter;
+	const filter = typeof _filter === "string" ? (name) => name.startsWith(_filter) : _filter;
+	const _tag = options.tag ? `[${options.tag}] ` : "";
+	const logPrefix = (event) => _tag + event.name + "".padEnd(event._id, "\0");
+	const _idCtr = {};
+	const unsubscribeBefore = hooks.beforeEach((event) => {
+		if (filter !== void 0 && !filter(event.name)) return;
+		_idCtr[event.name] = _idCtr[event.name] || 0;
+		event._id = _idCtr[event.name]++;
+		console.time(logPrefix(event));
+	});
+	const unsubscribeAfter = hooks.afterEach((event) => {
+		if (filter !== void 0 && !filter(event.name)) return;
+		if (options.group) console.groupCollapsed(event.name);
+		if (options.inspect) console.timeLog(logPrefix(event), event.args);
+		else console.timeEnd(logPrefix(event));
+		if (options.group) console.groupEnd();
+		_idCtr[event.name]--;
+	});
+	return { close: () => {
+		unsubscribeBefore();
+		unsubscribeAfter();
+	} };
+}
+export { Hookable, HookableCore, createDebugger, createHooks, flatHooks, mergeHooks, parallelCaller, serial, serialCaller };

package/web/.output/server/node_modules/hookable/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "hookable",
+  "version": "6.1.1",
+  "description": "Awaitable hook system",
+  "keywords": [
+    "hook",
+    "hookable",
+    "plugin",
+    "tapable",
+    "tappable"
+  ],
+  "license": "MIT",
+  "repository": "unjs/hookable",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": "./dist/index.mjs"
+  },
+  "scripts": {
+    "bench": "node --expose-gc --allow-natives-syntax test/bench.ts",
+    "build": "obuild src/index.ts",
+    "dev": "vitest",
+    "lint": "oxlint . && oxfmt --check src test",
+    "lint:fix": "oxlint . --fix && oxfmt src test",
+    "prepublish": "pnpm build",
+    "release": "pnpm test && pnpm build && changelogen --release --publish --push",
+    "test": "pnpm lint && vitest run --coverage",
+    "test:types": "tsgo --noEmit"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "@typescript/native-preview": "^7.0.0-dev.20260414.1",
+    "@vitest/coverage-v8": "^4.1.4",
+    "changelogen": "^0.6.2",
+    "esbuild": "^0.28.0",
+    "eslint-config-unjs": "^0.6.2",
+    "expect-type": "^1.3.0",
+    "hookable-prev": "npm:hookable@^6.1.0",
+    "mitata": "^1.0.34",
+    "obuild": "^0.4.33",
+    "oxfmt": "^0.45.0",
+    "oxlint": "^1.60.0",
+    "typescript": "^6.0.2",
+    "vite": "^8.0.8",
+    "vitest": "^4.1.4"
+  },
+  "packageManager": "pnpm@10.33.0"
+}

package/web/.output/server/node_modules/nostics/dist/index.mjs

@@ -0,0 +1,179 @@
+//#region src/formatters/plain.ts
+/**
+* Renders a diagnostic into a multi-line, unicode-decorated string suitable
+* for terminal output. The first line is `[<name>] <message>`; optional
+* details (`fix`, `sources`, `docs`) follow with `├▶`/`╰▶` connectors.
+*/
+function formatDiagnostic(diagnostic) {
+	const header = `[${diagnostic.name}] ${diagnostic.message}`;
+	const details = [];
+	if (diagnostic.fix) details.push(`fix: ${diagnostic.fix}`);
+	if (diagnostic.sources?.length) details.push(`sources: ${diagnostic.sources.join(", ")}`);
+	if (diagnostic.docs) details.push(`see: ${diagnostic.docs}`);
+	if (details.length === 0) return header;
+	return [header, ...details.map((detail, i) => {
+		return `${i < details.length - 1 ? "├▶" : "╰▶"} ${detail}`;
+	})].join("\n");
+}
+//#endregion
+//#region src/utils.ts
+/**
+* Transforms a value or a function that returns a value to a value.
+*
+* @param valFn either a value or a function that returns a value
+* @param args  arguments to pass to the function if `valFn` is a function
+*
+* @internal
+*/
+function toValueWithArgs(valFn, ...args) {
+	return typeof valFn === "function" ? valFn(...args) : valFn;
+}
+//#endregion
+//#region src/diagnostic.ts
+/**
+* Creates a console reporter that renders each diagnostic with `formatter` and
+* prints the result via `console[method]`. Both default sensibly (`'warn'` and
+* {@link formatDiagnostic}); `method` can also be overridden per call through
+* the reporter options.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function createConsoleReporter({ method: defaultMethod = "warn", formatter = formatDiagnostic } = {}) {
+	return (diagnostic, { method = defaultMethod } = {}) => {
+		console[method](formatter(diagnostic));
+	};
+}
+const captureStackTrace = Error.captureStackTrace;
+var Diagnostic = class Diagnostic extends Error {
+	name = "Diagnostic";
+	/**
+	* URL to extended documentation for this diagnostic code.
+	* Auto-generated from {@link DefineDiagnosticsOptions.docsBase}.
+	*/
+	docs;
+	/**
+	* Optional actionable instructions on how to resolve the problem.
+	*/
+	fix;
+	/**
+	* Locations in user code that contributed to this diagnostic, in
+	* `file:line:column` format. Relevant when the stack trace doesn't reflect
+	* the user's source (e.g. compilers, bundlers), otherwise redundant with the
+	* stack and should be omitted.
+	*/
+	sources;
+	/**
+	* Alias for {@link Error.message}: the reason this diagnostic was raised.
+	*/
+	get why() {
+		return this.message;
+	}
+	/**
+	* @param init        structured initializer; `why` is required
+	* @param captureFrom V8 stack-cutoff frame. Defaults to {@link Diagnostic}
+	* so the top of the trace is the `new Diagnostic(...)` call site.
+	* `defineDiagnostics` passes its action method to strip its own frames too.
+	* Ignored on engines without `Error.captureStackTrace`.
+	*/
+	constructor(init, captureFrom = Diagnostic) {
+		super(init.why, { cause: init.cause });
+		this.fix = init.fix;
+		this.docs = init.docs;
+		this.sources = init.sources;
+		captureStackTrace?.(this, captureFrom);
+	}
+	/**
+	* Converts the diagnostic into a serializable structured object.
+	*/
+	toJSON() {
+		return {
+			name: this.name,
+			why: this.why,
+			fix: this.fix,
+			docs: this.docs,
+			sources: this.sources,
+			cause: this.cause,
+			stack: this.stack
+		};
+	}
+};
+/**
+* Resolves the docs URL for a code from a `docsBase` (string template or
+* resolver function). Shared by {@link defineDiagnostics} and
+* {@link defineProdDiagnostics}. Per-code `docs` overrides are handled by the
+* caller; this only covers the `docsBase`-derived case.
+*
+* @internal
+*/
+function deriveDocs(docsBase, code) {
+	return typeof docsBase === "string" ? `${docsBase}/${code.toLowerCase()}` : docsBase?.(code);
+}
+/**
+* Creates a typed diagnostics object from a set of code definitions. Each
+* code becomes a callable {@link DiagnosticHandle}: invoke to report, or
+* `throw` the result to raise. No `new` required, no proxy.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function defineDiagnostics(options) {
+	const reporters = options.reporters ?? [];
+	const result = {};
+	const { docsBase } = options;
+	for (const code of Object.keys(options.codes)) {
+		const def = options.codes[code];
+		const docs = def.docs === false ? void 0 : def.docs || deriveDocs(docsBase, code);
+		const handle = (params = {}, reporterOptions = {}) => {
+			const diagnostic = new Diagnostic({
+				why: toValueWithArgs(def.why, params),
+				fix: toValueWithArgs(def.fix, params),
+				docs,
+				cause: params.cause,
+				sources: params.sources
+			}, handle);
+			diagnostic.name = code;
+			for (const reporter of reporters) reporter(diagnostic, reporterOptions);
+			return diagnostic;
+		};
+		result[code] = handle;
+	}
+	return result;
+}
+//#endregion
+//#region src/prod-diagnostics.ts
+/**
+* Production counterpart to {@link defineDiagnostics}. Returns a `Proxy` that
+* builds a minimal {@link Diagnostic} for any accessed code: the code becomes
+* both the `message` (`why`) and the instance `name`, and `docs` is derived
+* from `docsBase`. It carries no catalog text, so it stays tiny in a bundle.
+*
+* The strip plugin (`@nostics/unplugin`) can rewrite a `defineDiagnostics()`
+* call into a `process.env.NODE_ENV === 'production'` ternary that selects this
+* factory in production, dropping every `why`/`fix` string from the bundle.
+*
+* @example
+* ```ts
+* const diagnostics = defineProdDiagnostics({ docsBase: 'https://docs.example.com' })
+* throw diagnostics.NUXT_B2011() // Error: NUXT_B2011, docs derived from docsBase
+* ```
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function defineProdDiagnostics(options = {}) {
+	const { docsBase, reporters = [] } = options;
+	return new Proxy({}, { get(_target, code) {
+		if (typeof code !== "string") return void 0;
+		const handle = (params = {}, reporterOptions = {}) => {
+			const diagnostic = new Diagnostic({
+				why: code,
+				docs: deriveDocs(docsBase, code),
+				cause: params.cause,
+				sources: params.sources
+			}, handle);
+			diagnostic.name = code;
+			for (const reporter of reporters) reporter(diagnostic, reporterOptions);
+			return diagnostic;
+		};
+		return handle;
+	} });
+}
+//#endregion
+export { Diagnostic, createConsoleReporter, defineDiagnostics, defineProdDiagnostics, formatDiagnostic };
+
+//# sourceMappingURL=index.mjs.map

package/web/.output/server/node_modules/nostics/package.json

@@ -0,0 +1,124 @@
+{
+  "name": "nostics",
+  "type": "module",
+  "version": "1.1.4",
+  "description": "Structured diagnostic code library",
+  "author": "Anthony Fu <anthonyfu117@hotmail.com>",
+  "contributors": [
+    "Eduardo San Martin Morote <posva13@gmail.com>"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/vercel-labs/nostics#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vercel-labs/nostics.git"
+  },
+  "bugs": "https://github.com/vercel-labs/nostics/issues",
+  "keywords": [],
+  "sideEffects": false,
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./formatters/ansi": "./dist/formatters/ansi.mjs",
+    "./formatters/json": "./dist/formatters/json.mjs",
+    "./reporters/dev": "./dist/reporters/dev.mjs",
+    "./reporters/fetch": "./dist/reporters/fetch.mjs",
+    "./reporters/node": "./dist/reporters/node.mjs",
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist",
+    "skills"
+  ],
+  "devDependencies": {
+    "@antfu/eslint-config": "^9.0.0",
+    "@antfu/ni": "^30.1.0",
+    "@antfu/utils": "^9.3.0",
+    "@posva/prompts": "^2.4.4",
+    "@size-limit/esbuild-why": "^12.1.0",
+    "@size-limit/preset-small-lib": "^12.1.0",
+    "@types/node": "^25.9.3",
+    "@types/semver": "^7.7.1",
+    "@vitest/coverage-v8": "4.1.8",
+    "@vitest/ui": "4.1.8",
+    "conventional-changelog": "^7.2.0",
+    "conventional-changelog-angular": "^8.3.1",
+    "eslint": "^10.5.0",
+    "lint-staged": "^17.0.7",
+    "oxfmt": "^0.54.0",
+    "publint": "^0.3.21",
+    "semver": "^7.8.4",
+    "simple-git-hooks": "^2.13.1",
+    "size-limit": "^12.1.0",
+    "tsdown": "^0.22.2",
+    "tsnapi": "^0.3.3",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.16",
+    "vitest": "^4.1.8",
+    "nostics": "1.1.4"
+  },
+  "simple-git-hooks": {
+    "pre-commit": "pnpm i --frozen-lockfile --ignore-scripts --offline && npx lint-staged"
+  },
+  "lint-staged": {
+    "*": "eslint --fix"
+  },
+  "size-limit": [
+    {
+      "name": "defineDiagnostics from source",
+      "path": "src/index.ts",
+      "import": "{ defineDiagnostics }"
+    },
+    {
+      "name": "defineDiagnostics",
+      "path": "dist/index.mjs",
+      "import": "{ defineDiagnostics }"
+    },
+    {
+      "name": "defineProdDiagnostics",
+      "path": "dist/index.mjs",
+      "import": "{ defineProdDiagnostics }"
+    },
+    {
+      "name": "defineDiagnostics + createConsoleReporter",
+      "path": "dist/index.mjs",
+      "import": "{ defineDiagnostics, createConsoleReporter }"
+    },
+    {
+      "name": "defineProdDiagnostics + createConsoleReporter",
+      "path": "dist/index.mjs",
+      "import": "{ defineProdDiagnostics, createConsoleReporter }"
+    },
+    {
+      "name": "formatDiagnostic",
+      "path": "dist/index.mjs",
+      "import": "{ formatDiagnostic }"
+    },
+    {
+      "name": "full root",
+      "path": "dist/index.mjs",
+      "import": "*"
+    },
+    {
+      "name": "ansi formatter",
+      "path": "dist/formatters/ansi.mjs",
+      "import": "*"
+    }
+  ],
+  "scripts": {
+    "build": "tsdown && pnpm --filter \"./packages/*\" run build",
+    "dev": "vitest",
+    "docs": "pnpm -C docs run dev",
+    "docs:build": "pnpm -C docs run build",
+    "play": "pnpm -C playground run dev",
+    "lint": "eslint",
+    "release": "node scripts/release.ts",
+    "size": "size-limit",
+    "test": "pnpm run build && pnpm run \"/^test:/\"",
+    "test:unit": "vitest run --coverage",
+    "test:types": "pnpm run typecheck",
+    "test:lint": "pnpm run lint",
+    "test:demo": "pnpm -C demo-lib run build && pnpm -C demo-lib run test && pnpm -C playground run build",
+    "typecheck": "tsc && pnpm --filter \"./packages/*\" run typecheck"
+  }
+}

package/web/.output/server/node_modules/perfect-debounce/dist/index.mjs

@@ -0,0 +1,89 @@
+//#region src/index.ts
+const DEBOUNCE_DEFAULTS = { trailing: true };
+/**
+Debounce functions
+@param fn - Promise-returning/async function to debounce.
+@param wait - Milliseconds to wait before calling `fn`. Default value is 25ms
+@returns A function that delays calling `fn` until after `wait` milliseconds have elapsed since the last time it was called.
+@example
+```
+import { debounce } from 'perfect-debounce';
+const expensiveCall = async input => input;
+const debouncedFn = debounce(expensiveCall, 200);
+for (const number of [1, 2, 3]) {
+console.log(await debouncedFn(number));
+}
+//=> 1
+//=> 2
+//=> 3
+```
+*/
+function debounce(fn, wait = 25, options = {}) {
+	options = {
+		...DEBOUNCE_DEFAULTS,
+		...options
+	};
+	if (!Number.isFinite(wait)) throw new TypeError("Expected `wait` to be a finite number");
+	let leadingValue;
+	let timeout;
+	let resolveList = [];
+	let currentPromise;
+	let trailingArgs;
+	const applyFn = (_this, args) => {
+		currentPromise = _applyPromised(fn, _this, args);
+		currentPromise.finally(() => {
+			currentPromise = null;
+			if (options.trailing && trailingArgs && !timeout) {
+				const promise = applyFn(_this, trailingArgs);
+				trailingArgs = null;
+				return promise;
+			}
+		});
+		return currentPromise;
+	};
+	const debounced = function(...args) {
+		if (options.trailing) trailingArgs = args;
+		if (currentPromise) return currentPromise;
+		return new Promise((resolve) => {
+			const shouldCallNow = !timeout && options.leading;
+			clearTimeout(timeout);
+			timeout = setTimeout(() => {
+				timeout = null;
+				const promise = options.leading ? leadingValue : applyFn(this, args);
+				trailingArgs = null;
+				for (const _resolve of resolveList) _resolve(promise);
+				resolveList = [];
+			}, wait);
+			if (shouldCallNow) {
+				leadingValue = applyFn(this, args);
+				resolve(leadingValue);
+			} else resolveList.push(resolve);
+		});
+	};
+	const _clearTimeout = (timer) => {
+		if (timer) {
+			clearTimeout(timer);
+			timeout = null;
+		}
+	};
+	debounced.isPending = () => !!timeout;
+	debounced.cancel = () => {
+		_clearTimeout(timeout);
+		resolveList = [];
+		trailingArgs = null;
+	};
+	debounced.flush = () => {
+		_clearTimeout(timeout);
+		if (!trailingArgs || currentPromise) return;
+		const args = trailingArgs;
+		trailingArgs = null;
+		return applyFn(this, args);
+	};
+	return debounced;
+}
+async function _applyPromised(fn, _this, args) {
+	return await fn.apply(_this, args);
+}
+
+//#endregion
+export { debounce };