@rolldown/pluginutils - npm Package Compare versions

Comparing version 1.0.0 to 1.0.1

dist/filter-B_mD-HGz.mjs

+//#region src/utils.ts
+const postfixRE = /[?#].*$/;
+function cleanUrl(url) {
+	return url.replace(postfixRE, "");
+}
+function extractQueryWithoutFragment(url) {
+	const questionMarkIndex = url.indexOf("?");
+	if (questionMarkIndex === -1) return "";
+	const fragmentIndex = url.indexOf("#", questionMarkIndex);
+	if (fragmentIndex === -1) return url.substring(questionMarkIndex);
+	else return url.substring(questionMarkIndex, fragmentIndex);
+}
+//#endregion
+//#region src/filter/composable-filters.ts
+var And = class {
+	kind;
+	args;
+	constructor(...args) {
+		if (args.length === 0) throw new Error("`And` expects at least one operand");
+		this.args = args;
+		this.kind = "and";
+	}
+};
+var Or = class {
+	kind;
+	args;
+	constructor(...args) {
+		if (args.length === 0) throw new Error("`Or` expects at least one operand");
+		this.args = args;
+		this.kind = "or";
+	}
+};
+var Not = class {
+	kind;
+	expr;
+	constructor(expr) {
+		this.expr = expr;
+		this.kind = "not";
+	}
+};
+var Id = class {
+	kind;
+	pattern;
+	params;
+	constructor(pattern, params) {
+		this.pattern = pattern;
+		this.kind = "id";
+		this.params = params ?? { cleanUrl: false };
+	}
+};
+var ImporterId = class {
+	kind;
+	pattern;
+	params;
+	constructor(pattern, params) {
+		this.pattern = pattern;
+		this.kind = "importerId";
+		this.params = params ?? { cleanUrl: false };
+	}
+};
+var ModuleType = class {
+	kind;
+	pattern;
+	constructor(pattern) {
+		this.pattern = pattern;
+		this.kind = "moduleType";
+	}
+};
+var Code = class {
+	kind;
+	pattern;
+	constructor(expr) {
+		this.pattern = expr;
+		this.kind = "code";
+	}
+};
+var Query = class {
+	kind;
+	key;
+	pattern;
+	constructor(key, pattern) {
+		this.pattern = pattern;
+		this.key = key;
+		this.kind = "query";
+	}
+};
+var Include = class {
+	kind;
+	expr;
+	constructor(expr) {
+		this.expr = expr;
+		this.kind = "include";
+	}
+};
+var Exclude = class {
+	kind;
+	expr;
+	constructor(expr) {
+		this.expr = expr;
+		this.kind = "exclude";
+	}
+};
+function and(...args) {
+	return new And(...args);
+}
+function or(...args) {
+	return new Or(...args);
+}
+function not(expr) {
+	return new Not(expr);
+}
+function id(pattern, params) {
+	return new Id(pattern, params);
+}
+function importerId(pattern, params) {
+	return new ImporterId(pattern, params);
+}
+function moduleType(pattern) {
+	return new ModuleType(pattern);
+}
+function code(pattern) {
+	return new Code(pattern);
+}
+function query(key, pattern) {
+	return new Query(key, pattern);
+}
+function include(expr) {
+	return new Include(expr);
+}
+function exclude(expr) {
+	return new Exclude(expr);
+}
+/**
+* convert a queryObject to FilterExpression like
+* ```js
+*   and(query(k1, v1), query(k2, v2))
+* ```
+* @param queryFilterObject The query filter object needs to be matched.
+* @returns a `And` FilterExpression
+*/
+function queries(queryFilter) {
+	return and(...Object.entries(queryFilter).map(([key, value]) => {
+		return new Query(key, value);
+	}));
+}
+function interpreter(exprs, code, id, moduleType, importerId) {
+	let arr = [];
+	if (Array.isArray(exprs)) arr = exprs;
+	else arr = [exprs];
+	return interpreterImpl(arr, code, id, moduleType, importerId);
+}
+function interpreterImpl(expr, code, id, moduleType, importerId, ctx = {}) {
+	let hasInclude = false;
+	for (const e of expr) switch (e.kind) {
+		case "include":
+			hasInclude = true;
+			if (exprInterpreter(e.expr, code, id, moduleType, importerId, ctx)) return true;
+			break;
+		case "exclude":
+			if (exprInterpreter(e.expr, code, id, moduleType, importerId, ctx)) return false;
+			break;
+	}
+	return !hasInclude;
+}
+function exprInterpreter(expr, code, id, moduleType, importerId, ctx = {}) {
+	switch (expr.kind) {
+		case "and": return expr.args.every((e) => exprInterpreter(e, code, id, moduleType, importerId, ctx));
+		case "or": return expr.args.some((e) => exprInterpreter(e, code, id, moduleType, importerId, ctx));
+		case "not": return !exprInterpreter(expr.expr, code, id, moduleType, importerId, ctx);
+		case "id": {
+			if (id === void 0) throw new Error("`id` is required for `id` expression");
+			let idToMatch = id;
+			if (expr.params.cleanUrl) idToMatch = cleanUrl(idToMatch);
+			return typeof expr.pattern === "string" ? idToMatch === expr.pattern : expr.pattern.test(idToMatch);
+		}
+		case "importerId": {
+			if (importerId === void 0) return false;
+			let importerIdToMatch = importerId;
+			if (expr.params.cleanUrl) importerIdToMatch = cleanUrl(importerIdToMatch);
+			return typeof expr.pattern === "string" ? importerIdToMatch === expr.pattern : expr.pattern.test(importerIdToMatch);
+		}
+		case "moduleType":
+			if (moduleType === void 0) throw new Error("`moduleType` is required for `moduleType` expression");
+			return moduleType === expr.pattern;
+		case "code":
+			if (code === void 0) throw new Error("`code` is required for `code` expression");
+			return typeof expr.pattern === "string" ? code.includes(expr.pattern) : expr.pattern.test(code);
+		case "query": {
+			if (id === void 0) throw new Error("`id` is required for `Query` expression");
+			if (!ctx.urlSearchParamsCache) {
+				let queryString = extractQueryWithoutFragment(id);
+				ctx.urlSearchParamsCache = new URLSearchParams(queryString);
+			}
+			let urlParams = ctx.urlSearchParamsCache;
+			if (typeof expr.pattern === "boolean") if (expr.pattern) return urlParams.has(expr.key);
+			else return !urlParams.has(expr.key);
+			else if (typeof expr.pattern === "string") return urlParams.get(expr.key) === expr.pattern;
+			else return expr.pattern.test(urlParams.get(expr.key) ?? "");
+		}
+		default: throw new Error(`Expression ${JSON.stringify(expr)} is not expected.`);
+	}
+}
+//#endregion
+//#region src/filter/filter-vite-plugins.ts
+/**
+* Filters out Vite plugins that have `apply: 'serve'` set.
+*
+* Since Rolldown operates in build mode, plugins marked with `apply: 'serve'`
+* are intended only for Vite's dev server and should be excluded from the build process.
+*
+* @param plugins - Array of plugins (can include nested arrays)
+* @returns Filtered array with serve-only plugins removed
+*
+* @example
+* ```ts
+* import { defineConfig } from 'rolldown';
+* import { filterVitePlugins } from '@rolldown/pluginutils';
+* import viteReact from '@vitejs/plugin-react';
+*
+* export default defineConfig({
+*   plugins: filterVitePlugins([
+*     viteReact(),
+*     {
+*       name: 'dev-only',
+*       apply: 'serve', // This will be filtered out
+*       // ...
+*     }
+*   ])
+* });
+* ```
+*/
+function filterVitePlugins(plugins) {
+	if (!plugins) return [];
+	const pluginArray = Array.isArray(plugins) ? plugins : [plugins];
+	const result = [];
+	for (const plugin of pluginArray) {
+		if (!plugin) continue;
+		if (Array.isArray(plugin)) {
+			result.push(...filterVitePlugins(plugin));
+			continue;
+		}
+		const pluginWithApply = plugin;
+		if ("apply" in pluginWithApply) {
+			const applyValue = pluginWithApply.apply;
+			if (typeof applyValue === "function") try {
+				if (applyValue({}, {
+					command: "build",
+					mode: "production"
+				})) result.push(plugin);
+			} catch {
+				result.push(plugin);
+			}
+			else if (applyValue === "serve") continue;
+			else result.push(plugin);
+		} else result.push(plugin);
+	}
+	return result;
+}
+//#endregion
+//#region src/filter/simple-filters.ts
+/**
+* Constructs a RegExp that matches the exact string specified.
+*
+* This is useful for plugin hook filters.
+*
+* @param str the string to match.
+* @param flags flags for the RegExp.
+*
+* @example
+* ```ts
+* import { exactRegex } from '@rolldown/pluginutils';
+* const plugin = {
+*   name: 'plugin',
+*   resolveId: {
+*     filter: { id: exactRegex('foo') },
+*     handler(id) {} // will only be called for `foo`
+*   }
+* }
+* ```
+*/
+function exactRegex(str, flags) {
+	return new RegExp(`^${escapeRegex(str)}$`, flags);
+}
+/**
+* Constructs a RegExp that matches a value that has the specified prefix.
+*
+* This is useful for plugin hook filters.
+*
+* @param str the string to match.
+* @param flags flags for the RegExp.
+*
+* @example
+* ```ts
+* import { prefixRegex } from '@rolldown/pluginutils';
+* const plugin = {
+*   name: 'plugin',
+*   resolveId: {
+*     filter: { id: prefixRegex('foo') },
+*     handler(id) {} // will only be called for IDs starting with `foo`
+*   }
+* }
+* ```
+*/
+function prefixRegex(str, flags) {
+	return new RegExp(`^${escapeRegex(str)}`, flags);
+}
+const escapeRegexRE = /[-/\\^$*+?.()|[\]{}]/g;
+function escapeRegex(str) {
+	return str.replace(escapeRegexRE, "\\$&");
+}
+function makeIdFiltersToMatchWithQuery(input) {
+	if (!Array.isArray(input)) return makeIdFilterToMatchWithQuery(input);
+	return input.map((i) => makeIdFilterToMatchWithQuery(i));
+}
+function makeIdFilterToMatchWithQuery(input) {
+	if (typeof input === "string") return `${input}{?*,}`;
+	return makeRegexIdFilterToMatchWithQuery(input);
+}
+function makeRegexIdFilterToMatchWithQuery(input) {
+	return new RegExp(input.source.replace(/(?<!\\)\$/g, "(?:\\?.*)?$"), input.flags);
+}
+//#endregion
+export { queries as _, and as a, exprInterpreter as c, include as d, interpreter as f, or as g, not as h, filterVitePlugins as i, id as l, moduleType as m, makeIdFiltersToMatchWithQuery as n, code as o, interpreterImpl as p, prefixRegex as r, exclude as s, exactRegex as t, importerId as u, query as v };

dist/filter/index.d.mts

+//#region src/filter/composable-filters.d.ts
+type StringOrRegExp = string | RegExp;
+type PluginModuleType = 'js' | 'jsx' | 'ts' | 'tsx' | 'json' | 'text' | 'base64' | 'dataurl' | 'binary' | 'empty' | (string & {});
+type FilterExpressionKind = FilterExpression['kind'];
+type FilterExpression = And | Or | Not | Id | ImporterId | ModuleType | Code | Query;
+type TopLevelFilterExpression = Include | Exclude;
+declare class And {
+  kind: 'and';
+  args: FilterExpression[];
+  constructor(...args: FilterExpression[]);
+}
+declare class Or {
+  kind: 'or';
+  args: FilterExpression[];
+  constructor(...args: FilterExpression[]);
+}
+declare class Not {
+  kind: 'not';
+  expr: FilterExpression;
+  constructor(expr: FilterExpression);
+}
+interface QueryFilterObject {
+  [key: string]: StringOrRegExp | boolean;
+}
+interface IdParams {
+  cleanUrl?: boolean;
+}
+declare class Id {
+  kind: 'id';
+  pattern: StringOrRegExp;
+  params: IdParams;
+  constructor(pattern: StringOrRegExp, params?: IdParams);
+}
+declare class ImporterId {
+  kind: 'importerId';
+  pattern: StringOrRegExp;
+  params: IdParams;
+  constructor(pattern: StringOrRegExp, params?: IdParams);
+}
+declare class ModuleType {
+  kind: 'moduleType';
+  pattern: PluginModuleType;
+  constructor(pattern: PluginModuleType);
+}
+declare class Code {
+  kind: 'code';
+  pattern: StringOrRegExp;
+  constructor(expr: StringOrRegExp);
+}
+declare class Query {
+  kind: 'query';
+  key: string;
+  pattern: StringOrRegExp | boolean;
+  constructor(key: string, pattern: StringOrRegExp | boolean);
+}
+declare class Include {
+  kind: 'include';
+  expr: FilterExpression;
+  constructor(expr: FilterExpression);
+}
+declare class Exclude {
+  kind: 'exclude';
+  expr: FilterExpression;
+  constructor(expr: FilterExpression);
+}
+declare function and(...args: FilterExpression[]): And;
+declare function or(...args: FilterExpression[]): Or;
+declare function not(expr: FilterExpression): Not;
+declare function id(pattern: StringOrRegExp, params?: IdParams): Id;
+declare function importerId(pattern: StringOrRegExp, params?: IdParams): ImporterId;
+declare function moduleType(pattern: PluginModuleType): ModuleType;
+declare function code(pattern: StringOrRegExp): Code;
+declare function query(key: string, pattern: StringOrRegExp | boolean): Query;
+declare function include(expr: FilterExpression): Include;
+declare function exclude(expr: FilterExpression): Exclude;
+/**
+ * convert a queryObject to FilterExpression like
+ * ```js
+ *   and(query(k1, v1), query(k2, v2))
+ * ```
+ * @param queryFilterObject The query filter object needs to be matched.
+ * @returns a `And` FilterExpression
+ */
+declare function queries(queryFilter: QueryFilterObject): And;
+declare function interpreter(exprs: TopLevelFilterExpression | TopLevelFilterExpression[], code?: string, id?: string, moduleType?: PluginModuleType, importerId?: string): boolean;
+interface InterpreterCtx {
+  urlSearchParamsCache?: URLSearchParams;
+}
+declare function interpreterImpl(expr: TopLevelFilterExpression[], code?: string, id?: string, moduleType?: PluginModuleType, importerId?: string, ctx?: InterpreterCtx): boolean;
+declare function exprInterpreter(expr: FilterExpression, code?: string, id?: string, moduleType?: PluginModuleType, importerId?: string, ctx?: InterpreterCtx): boolean;
+//#endregion
+//#region src/filter/filter-vite-plugins.d.ts
+/**
+ * Filters out Vite plugins that have `apply: 'serve'` set.
+ *
+ * Since Rolldown operates in build mode, plugins marked with `apply: 'serve'`
+ * are intended only for Vite's dev server and should be excluded from the build process.
+ *
+ * @param plugins - Array of plugins (can include nested arrays)
+ * @returns Filtered array with serve-only plugins removed
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from 'rolldown';
+ * import { filterVitePlugins } from '@rolldown/pluginutils';
+ * import viteReact from '@vitejs/plugin-react';
+ *
+ * export default defineConfig({
+ *   plugins: filterVitePlugins([
+ *     viteReact(),
+ *     {
+ *       name: 'dev-only',
+ *       apply: 'serve', // This will be filtered out
+ *       // ...
+ *     }
+ *   ])
+ * });
+ * ```
+ */
+declare function filterVitePlugins<T = any>(plugins: T | T[] | null | undefined | false): T[];
+//#endregion
+//#region src/filter/simple-filters.d.ts
+/**
+ * Constructs a RegExp that matches the exact string specified.
+ *
+ * This is useful for plugin hook filters.
+ *
+ * @param str the string to match.
+ * @param flags flags for the RegExp.
+ *
+ * @example
+ * ```ts
+ * import { exactRegex } from '@rolldown/pluginutils';
+ * const plugin = {
+ *   name: 'plugin',
+ *   resolveId: {
+ *     filter: { id: exactRegex('foo') },
+ *     handler(id) {} // will only be called for `foo`
+ *   }
+ * }
+ * ```
+ */
+declare function exactRegex(str: string, flags?: string): RegExp;
+/**
+ * Constructs a RegExp that matches a value that has the specified prefix.
+ *
+ * This is useful for plugin hook filters.
+ *
+ * @param str the string to match.
+ * @param flags flags for the RegExp.
+ *
+ * @example
+ * ```ts
+ * import { prefixRegex } from '@rolldown/pluginutils';
+ * const plugin = {
+ *   name: 'plugin',
+ *   resolveId: {
+ *     filter: { id: prefixRegex('foo') },
+ *     handler(id) {} // will only be called for IDs starting with `foo`
+ *   }
+ * }
+ * ```
+ */
+declare function prefixRegex(str: string, flags?: string): RegExp;
+type WidenString<T> = T extends string ? string : T;
+/**
+ * Converts a id filter to match with an id with a query.
+ *
+ * @param input the id filters to convert.
+ *
+ * @example
+ * ```ts
+ * import { makeIdFiltersToMatchWithQuery } from '@rolldown/pluginutils';
+ * const plugin = {
+ *   name: 'plugin',
+ *   transform: {
+ *     filter: { id: makeIdFiltersToMatchWithQuery(['**' + '/*.js', /\.ts$/]) },
+ *     // The handler will be called for IDs like:
+ *     // - foo.js
+ *     // - foo.js?foo
+ *     // - foo.txt?foo.js
+ *     // - foo.ts
+ *     // - foo.ts?foo
+ *     // - foo.txt?foo.ts
+ *     handler(code, id) {}
+ *   }
+ * }
+ * ```
+ */
+declare function makeIdFiltersToMatchWithQuery<T extends string | RegExp>(input: T): WidenString<T>;
+declare function makeIdFiltersToMatchWithQuery<T extends string | RegExp>(input: readonly T[]): WidenString<T>[];
+declare function makeIdFiltersToMatchWithQuery(input: string | RegExp | readonly (string | RegExp)[]): string | RegExp | (string | RegExp)[];
+//#endregion
+export { FilterExpression, FilterExpressionKind, QueryFilterObject, TopLevelFilterExpression, and, code, exactRegex, exclude, exprInterpreter, filterVitePlugins, id, importerId, include, interpreter, interpreterImpl, makeIdFiltersToMatchWithQuery, moduleType, not, or, prefixRegex, queries, query };

dist/filter/index.mjs

+import { _ as queries, a as and, c as exprInterpreter, d as include, f as interpreter, g as or, h as not, i as filterVitePlugins, l as id, m as moduleType, n as makeIdFiltersToMatchWithQuery, o as code, p as interpreterImpl, r as prefixRegex, s as exclude, t as exactRegex, u as importerId, v as query } from "../filter-B_mD-HGz.mjs";
+export { and, code, exactRegex, exclude, exprInterpreter, filterVitePlugins, id, importerId, include, interpreter, interpreterImpl, makeIdFiltersToMatchWithQuery, moduleType, not, or, prefixRegex, queries, query };

dist/index.d.mts

+import { FilterExpression, FilterExpressionKind, QueryFilterObject, TopLevelFilterExpression, and, code, exactRegex, exclude, exprInterpreter, filterVitePlugins, id, importerId, include, interpreter, interpreterImpl, makeIdFiltersToMatchWithQuery, moduleType, not, or, prefixRegex, queries, query } from "./filter/index.mjs";
+export { FilterExpression, FilterExpressionKind, QueryFilterObject, TopLevelFilterExpression, and, code, exactRegex, exclude, exprInterpreter, filterVitePlugins, id, importerId, include, interpreter, interpreterImpl, makeIdFiltersToMatchWithQuery, moduleType, not, or, prefixRegex, queries, query };

dist/index.mjs

+import { _ as queries, a as and, c as exprInterpreter, d as include, f as interpreter, g as or, h as not, i as filterVitePlugins, l as id, m as moduleType, n as makeIdFiltersToMatchWithQuery, o as code, p as interpreterImpl, r as prefixRegex, s as exclude, t as exactRegex, u as importerId, v as query } from "./filter-B_mD-HGz.mjs";
+export { and, code, exactRegex, exclude, exprInterpreter, filterVitePlugins, id, importerId, include, interpreter, interpreterImpl, makeIdFiltersToMatchWithQuery, moduleType, not, or, prefixRegex, queries, query };

LICENSE

 MIT License
 
-Copyright (c) 2024-present VoidZero Inc. & Contributors
+Copyright (c) 2026-present, rolldown/plugins repository contributors
 
@@ -22,5 +22,1 @@ Permission is hereby granted, free of charge, to any person obtaining a copy
 SOFTWARE.
-
-end of terms and conditions
-
-The licenses of externally maintained libraries from which parts of the Software is derived are listed [here](https://github.com/rolldown/rolldown/blob/main/THIRD-PARTY-LICENSE).

package.json

 {
   "name": "@rolldown/pluginutils",
-  "version": "1.0.0",
-  "homepage": "https://rolldown.rs/",
+  "version": "1.0.1",
+  "description": "Plugin utilities for Rolldown",
+  "keywords": [
+    "filter",
+    "plugin",
+    "rolldown"
+  ],
+  "homepage": "https://github.com/rolldown/plugins/tree/main/packages/pluginutils#readme",
+  "bugs": {
+    "url": "https://github.com/rolldown/plugins/issues"
+  },
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/rolldown/rolldown.git",
+    "url": "git+https://github.com/rolldown/plugins.git",
     "directory": "packages/pluginutils"
@@ -15,24 +24,18 @@ },
   "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./dist/index.js",
-    "./filter": "./dist/filter/index.js",
+    ".": "./dist/index.mjs",
+    "./filter": "./dist/filter/index.mjs",
     "./package.json": "./package.json"
   },
-  "publishConfig": {
-    "access": "public"
-  },
   "devDependencies": {
-    "@types/picomatch": "^4.0.0",
-    "picomatch": "^4.0.2",
-    "typescript": "^6.0.0",
-    "vitest": "^4.0.15"
+    "@types/picomatch": "^4.0.3",
+    "picomatch": "^4.0.4",
+    "typescript": "^5.9.3"
   },
   "scripts": {
-    "build": "tsc",
-    "test": "vitest --typecheck",
-    "publint": "publint ."
+    "dev": "tsdown --watch",
+    "build": "tsdown",
+    "test": "vitest --project pluginutils",
+    "test:types": "vitest --project pluginutils --typecheck.only"
   }
 }

README.md

@@ -1,9 +0,11 @@
-# @rolldown/pluginutils
+# @rolldown/pluginutils [![npm](https://img.shields.io/npm/v/@rolldown/pluginutils.svg)](https://npmx.dev/package/@rolldown/pluginutils)
 
-A utility library for building flexible, composable filter expressions that can be used in plugin hook filters of Rolldown/Vite/Rollup/Unplugin plugins.
+Plugin utilities for [Rolldown](https://rolldown.rs).
 
-## Installation
+Includes regex helpers for plugin hook filters, composable filter expressions, and a helper for filtering out Vite-serve-only plugins.
 
-```sh
-pnpm add @rolldown/pluginutils
+## Install
+
+```bash
+pnpm add -D @rolldown/pluginutils
 ```
@@ -13,72 +15,132 @@
 
-### Simple Filters
+```ts
+import { exactRegex, prefixRegex, makeIdFiltersToMatchWithQuery } from '@rolldown/pluginutils'
+```
 
+All filter helpers are also exposed via the `/filter` subpath:
+
 ```ts
-import { exactRegex, makeIdFiltersToMatchWithQuery, prefixRegex } from '@rolldown/pluginutils';
+import { and, or, id, include } from '@rolldown/pluginutils/filter'
+```
 
-// Match exactly 'foo.js'
-const filter = exactRegex('foo.js');
+## Regex helpers
 
-// Match any id starting with 'lib/'
-const prefix = prefixRegex('lib/');
+### `exactRegex`
 
-// Match ids with query params (e.g. 'foo.js?bar')
-const idFilters = makeIdFiltersToMatchWithQuery(['**/*.js', /\.ts$/]);
+- **Type:** `(str: string, flags?: string) => RegExp`
 
-// Usage in a plugin to define a hook filter
-const myPlugin = {
+Constructs a `RegExp` that matches the exact string specified. Useful as a plugin hook filter.
+
+```ts
+import { exactRegex } from '@rolldown/pluginutils'
+
+const plugin = {
+  name: 'plugin',
   resolveId: {
-    filter: {
-      id: [exactRegex('MY_ID_TO_CHECK'), /some-other-regex/],
-    },
-    handler(id) {
-      // Your code here
-    },
+    filter: { id: exactRegex('foo') },
+    handler(id) {}, // only called for `foo`
   },
-};
+}
 ```
 
-### Composable Filters
+### `prefixRegex`
 
-> [!WARNING]
-> Composable filters are not yet supported in Vite or unplugin. They can be used in Rolldown plugins only.
+- **Type:** `(str: string, flags?: string) => RegExp`
 
+Constructs a `RegExp` that matches values starting with the specified prefix.
+
 ```ts
-import { and, id, include, moduleType, query } from '@rolldown/pluginutils';
+import { prefixRegex } from '@rolldown/pluginutils'
 
-// Build a filter expression
-const filterExpr = and(id(/\.ts$/), moduleType('ts'), query('foo', true));
+const plugin = {
+  name: 'plugin',
+  resolveId: {
+    filter: { id: prefixRegex('foo') },
+    handler(id) {}, // called for IDs starting with `foo`
+  },
+}
+```
 
-// Usage in a plugin to define a hook filter
-const myPlugin = {
+### `makeIdFiltersToMatchWithQuery`
+
+- **Type:** `(input: string | RegExp | (string | RegExp)[]) => string | RegExp | (string | RegExp)[]`
+
+Converts an id filter so that it also matches ids that include a query string.
+
+```ts
+import { makeIdFiltersToMatchWithQuery } from '@rolldown/pluginutils'
+
+const plugin = {
+  name: 'plugin',
   transform: {
-    filter: [include(filterExpr)],
-    handler(code, id, options) {
-      // Your code here
-    },
+    filter: { id: makeIdFiltersToMatchWithQuery(['**/*.js', /\.ts$/]) },
+    // Matches:
+    //   foo.js, foo.js?foo, foo.txt?foo.js,
+    //   foo.ts, foo.ts?foo, foo.txt?foo.ts
+    handler(code, id) {},
   },
-};
+}
 ```
 
-## API Reference
+## Composable filters
 
-### Simple Filters
+[Composable filter expressions](https://rolldown.rs/apis/plugin-api/hook-filters#composable-filters) for use cases where a simple `id`/`include`/`exclude` is not enough. For example, when a plugin needs to combine `id`, `moduleType`, `code`, and `query` conditions.
 
-- `exactRegex(str: string, flags?: string): RegExp` — Matches the exact string.
-- `prefixRegex(str: string, flags?: string): RegExp` — Matches values with the given prefix.
-- `makeIdFiltersToMatchWithQuery(input: string | RegExp | (string | RegExp)[]): string | RegExp | (string | RegExp)[]` — Adapts filters to match ids with query params.
+```ts
+import { and, code, id, include, interpreter, moduleType, or } from '@rolldown/pluginutils'
 
-### Composable Filters
+const expr = include(and(or(id(/\.tsx?$/), id(/\.jsx?$/)), moduleType('tsx'), code(/import React/)))
 
-- `and(...exprs)` / `or(...exprs)` / `not(expr)` — Logical composition of filter expressions.
-- `id(pattern, params?)` — Filter by id. A `string` pattern is matched by exact equality (not glob); a `RegExp` is tested against the id.
-- `importerId(pattern, params?)` — Filter by importer id. A `string` pattern is matched by exact equality; a `RegExp` is tested against the importer id. Only usable with the `resolveId` hook.
-- `moduleType(type)` — Filter by module type (e.g. 'js', 'tsx', or 'json').
-- `code(pattern)` — Filter by code content.
-- `query(key, pattern)` — Filter by query parameter.
-- `include(expr)` / `exclude(expr)` — Top-level include/exclude wrappers.
-- `queries(obj)` — Compose multiple query filters.
+interpreter(expr, sourceCode, sourceId, 'tsx') // boolean
+```
 
-### Utilities
+### Builders
 
-- `filterVitePlugins(plugins)` — Filters out Vite plugins with `apply: 'serve'`.
+| Builder                        | Description                                                                                                                                              |
+| ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `and(...exprs)`                | All operands must match.                                                                                                                                 |
+| `or(...exprs)`                 | At least one operand must match.                                                                                                                         |
+| `not(expr)`                    | Negates the operand.                                                                                                                                     |
+| `id(pattern, params?)`         | Match the module id. `pattern` is `string` or `RegExp`. `params.cleanUrl` strips the query/hash before matching.                                         |
+| `importerId(pattern, params?)` | Match the importer's id. Same shape as `id`.                                                                                                             |
+| `moduleType(type)`             | Match Rolldown's module type (`'js'`, `'jsx'`, `'ts'`, `'tsx'`, `'json'`, `'text'`, `'base64'`, `'dataurl'`, `'binary'`, `'empty'`, or a custom string). |
+| `code(pattern)`                | Match the module source. `string` matches with `includes`; `RegExp` with `test`.                                                                         |
+| `query(key, pattern)`          | Match a single query parameter. `pattern` is `boolean` (key presence/truthiness), `string` (exact value), or `RegExp` (value pattern).                   |
+| `queries(obj)`                 | Shorthand for `and(...)` over multiple `query` entries.                                                                                                  |
+| `include(expr)`                | Top-level wrapper marking `expr` as an inclusion rule.                                                                                                   |
+| `exclude(expr)`                | Top-level wrapper marking `expr` as an exclusion rule.                                                                                                   |
+
+### `interpreter`
+
+- **Type:** `(exprs, code?, id?, moduleType?, importerId?) => boolean`
+
+Evaluates one or more top-level expressions against the given inputs. Returns `true` when at least one `include` matches and no `exclude` matches; when no `include` is present, defaults to `true` unless an `exclude` matches.
+
+The argument required by each expression must be provided. For example, evaluating an `id(...)` expression without passing `id` will throw.
+
+## `filterVitePlugins`
+
+- **Type:** `<T>(plugins: T | T[] | null | undefined | false) => T[]`
+
+Removes Vite plugins that target the dev server (`apply: 'serve'`) from a (possibly nested) plugin array. Plugins whose `apply` is a function are invoked with a `command: 'build'` context to decide. Useful when reusing a Vite plugin array inside a Rolldown config.
+
+```ts
+import { defineConfig } from 'rolldown'
+import { filterVitePlugins } from '@rolldown/pluginutils'
+import viteReact from '@vitejs/plugin-react'
+
+export default defineConfig({
+  plugins: filterVitePlugins([
+    viteReact(),
+    {
+      name: 'dev-only',
+      apply: 'serve', // filtered out
+      // ...
+    },
+  ]),
+})
+```
+
+## License
+
+MIT

dist/filter/composable-filters.d.ts

-type StringOrRegExp = string | RegExp;
-type PluginModuleType = 'js' | 'jsx' | 'ts' | 'tsx' | 'json' | 'text' | 'base64' | 'dataurl' | 'binary' | 'empty' | (string & {});
-export type FilterExpressionKind = FilterExpression['kind'];
-export type FilterExpression = And | Or | Not | Id | ImporterId | ModuleType | Code | Query;
-export type TopLevelFilterExpression = Include | Exclude;
-declare class And {
-    kind: 'and';
-    args: FilterExpression[];
-    constructor(...args: FilterExpression[]);
-}
-declare class Or {
-    kind: 'or';
-    args: FilterExpression[];
-    constructor(...args: FilterExpression[]);
-}
-declare class Not {
-    kind: 'not';
-    expr: FilterExpression;
-    constructor(expr: FilterExpression);
-}
-export interface QueryFilterObject {
-    [key: string]: StringOrRegExp | boolean;
-}
-interface IdParams {
-    cleanUrl?: boolean;
-}
-declare class Id {
-    kind: 'id';
-    pattern: StringOrRegExp;
-    params: IdParams;
-    constructor(pattern: StringOrRegExp, params?: IdParams);
-}
-declare class ImporterId {
-    kind: 'importerId';
-    pattern: StringOrRegExp;
-    params: IdParams;
-    constructor(pattern: StringOrRegExp, params?: IdParams);
-}
-declare class ModuleType {
-    kind: 'moduleType';
-    pattern: PluginModuleType;
-    constructor(pattern: PluginModuleType);
-}
-declare class Code {
-    kind: 'code';
-    pattern: StringOrRegExp;
-    constructor(expr: StringOrRegExp);
-}
-declare class Query {
-    kind: 'query';
-    key: string;
-    pattern: StringOrRegExp | boolean;
-    constructor(key: string, pattern: StringOrRegExp | boolean);
-}
-declare class Include {
-    kind: 'include';
-    expr: FilterExpression;
-    constructor(expr: FilterExpression);
-}
-declare class Exclude {
-    kind: 'exclude';
-    expr: FilterExpression;
-    constructor(expr: FilterExpression);
-}
-export declare function and(...args: FilterExpression[]): And;
-export declare function or(...args: FilterExpression[]): Or;
-export declare function not(expr: FilterExpression): Not;
-export declare function id(pattern: StringOrRegExp, params?: IdParams): Id;
-export declare function importerId(pattern: StringOrRegExp, params?: IdParams): ImporterId;
-export declare function moduleType(pattern: PluginModuleType): ModuleType;
-export declare function code(pattern: StringOrRegExp): Code;
-export declare function query(key: string, pattern: StringOrRegExp | boolean): Query;
-export declare function include(expr: FilterExpression): Include;
-export declare function exclude(expr: FilterExpression): Exclude;
-/**
- * convert a queryObject to FilterExpression like
- * ```js
- *   and(query(k1, v1), query(k2, v2))
- * ```
- * @param queryFilterObject The query filter object needs to be matched.
- * @returns a `And` FilterExpression
- */
-export declare function queries(queryFilter: QueryFilterObject): And;
-export declare function interpreter(exprs: TopLevelFilterExpression | TopLevelFilterExpression[], code?: string, id?: string, moduleType?: PluginModuleType, importerId?: string): boolean;
-interface InterpreterCtx {
-    urlSearchParamsCache?: URLSearchParams;
-}
-export declare function interpreterImpl(expr: TopLevelFilterExpression[], code?: string, id?: string, moduleType?: PluginModuleType, importerId?: string, ctx?: InterpreterCtx): boolean;
-export declare function exprInterpreter(expr: FilterExpression, code?: string, id?: string, moduleType?: PluginModuleType, importerId?: string, ctx?: InterpreterCtx): boolean;
-export {};

dist/filter/composable-filters.js

-import { cleanUrl, extractQueryWithoutFragment } from "../utils.js";
-class And {
-    kind;
-    args;
-    constructor(...args) {
-        if (args.length === 0) {
-            throw new Error('`And` expects at least one operand');
-        }
-        this.args = args;
-        this.kind = 'and';
-    }
-}
-class Or {
-    kind;
-    args;
-    constructor(...args) {
-        if (args.length === 0) {
-            throw new Error('`Or` expects at least one operand');
-        }
-        this.args = args;
-        this.kind = 'or';
-    }
-}
-class Not {
-    kind;
-    expr;
-    constructor(expr) {
-        this.expr = expr;
-        this.kind = 'not';
-    }
-}
-class Id {
-    kind;
-    pattern;
-    params;
-    constructor(pattern, params) {
-        this.pattern = pattern;
-        this.kind = 'id';
-        this.params = params ?? {
-            cleanUrl: false,
-        };
-    }
-}
-class ImporterId {
-    kind;
-    pattern;
-    params;
-    constructor(pattern, params) {
-        this.pattern = pattern;
-        this.kind = 'importerId';
-        this.params = params ?? {
-            cleanUrl: false,
-        };
-    }
-}
-class ModuleType {
-    kind;
-    pattern;
-    constructor(pattern) {
-        this.pattern = pattern;
-        this.kind = 'moduleType';
-    }
-}
-class Code {
-    kind;
-    pattern;
-    constructor(expr) {
-        this.pattern = expr;
-        this.kind = 'code';
-    }
-}
-class Query {
-    kind;
-    key;
-    pattern;
-    constructor(key, pattern) {
-        this.pattern = pattern;
-        this.key = key;
-        this.kind = 'query';
-    }
-}
-class Include {
-    kind;
-    expr;
-    constructor(expr) {
-        this.expr = expr;
-        this.kind = 'include';
-    }
-}
-class Exclude {
-    kind;
-    expr;
-    constructor(expr) {
-        this.expr = expr;
-        this.kind = 'exclude';
-    }
-}
-export function and(...args) {
-    return new And(...args);
-}
-export function or(...args) {
-    return new Or(...args);
-}
-export function not(expr) {
-    return new Not(expr);
-}
-export function id(pattern, params) {
-    return new Id(pattern, params);
-}
-export function importerId(pattern, params) {
-    return new ImporterId(pattern, params);
-}
-export function moduleType(pattern) {
-    return new ModuleType(pattern);
-}
-export function code(pattern) {
-    return new Code(pattern);
-}
-/*
- * There are three kinds of conditions are supported:
- * 1. `boolean`: if the value is `true`, the key must exist and be truthy. if the value is `false`, the key must not exist or be falsy.
- * 2. `string`: the key must exist and be equal to the value.
- * 3. `RegExp`: the key must exist and match the value.
- */
-export function query(key, pattern) {
-    return new Query(key, pattern);
-}
-export function include(expr) {
-    return new Include(expr);
-}
-export function exclude(expr) {
-    return new Exclude(expr);
-}
-/**
- * convert a queryObject to FilterExpression like
- * ```js
- *   and(query(k1, v1), query(k2, v2))
- * ```
- * @param queryFilterObject The query filter object needs to be matched.
- * @returns a `And` FilterExpression
- */
-export function queries(queryFilter) {
-    let arr = Object.entries(queryFilter).map(([key, value]) => {
-        return new Query(key, value);
-    });
-    return and(...arr);
-}
-export function interpreter(exprs, code, id, moduleType, importerId) {
-    let arr = [];
-    if (Array.isArray(exprs)) {
-        arr = exprs;
-    }
-    else {
-        arr = [exprs];
-    }
-    return interpreterImpl(arr, code, id, moduleType, importerId);
-}
-export function interpreterImpl(expr, code, id, moduleType, importerId, ctx = {}) {
-    let hasInclude = false;
-    for (const e of expr) {
-        switch (e.kind) {
-            case 'include': {
-                hasInclude = true;
-                if (exprInterpreter(e.expr, code, id, moduleType, importerId, ctx)) {
-                    return true;
-                }
-                break;
-            }
-            case 'exclude': {
-                if (exprInterpreter(e.expr, code, id, moduleType, importerId, ctx)) {
-                    return false;
-                }
-                break;
-            }
-        }
-    }
-    return !hasInclude;
-}
-export function exprInterpreter(expr, code, id, moduleType, importerId, ctx = {}) {
-    switch (expr.kind) {
-        case 'and': {
-            return expr.args.every((e) => exprInterpreter(e, code, id, moduleType, importerId, ctx));
-        }
-        case 'or': {
-            return expr.args.some((e) => exprInterpreter(e, code, id, moduleType, importerId, ctx));
-        }
-        case 'not': {
-            return !exprInterpreter(expr.expr, code, id, moduleType, importerId, ctx);
-        }
-        case 'id': {
-            if (id === undefined) {
-                throw new Error('`id` is required for `id` expression');
-            }
-            let idToMatch = id;
-            if (expr.params.cleanUrl) {
-                idToMatch = cleanUrl(idToMatch);
-            }
-            return typeof expr.pattern === 'string'
-                ? idToMatch === expr.pattern
-                : expr.pattern.test(idToMatch);
-        }
-        case 'importerId': {
-            if (importerId === undefined) {
-                return false; // Entry files have no importer, so no match
-            }
-            let importerIdToMatch = importerId;
-            if (expr.params.cleanUrl) {
-                importerIdToMatch = cleanUrl(importerIdToMatch);
-            }
-            return typeof expr.pattern === 'string'
-                ? importerIdToMatch === expr.pattern
-                : expr.pattern.test(importerIdToMatch);
-        }
-        case 'moduleType': {
-            if (moduleType === undefined) {
-                throw new Error('`moduleType` is required for `moduleType` expression');
-            }
-            return moduleType === expr.pattern;
-        }
-        case 'code': {
-            if (code === undefined) {
-                throw new Error('`code` is required for `code` expression');
-            }
-            return typeof expr.pattern === 'string'
-                ? code.includes(expr.pattern)
-                : expr.pattern.test(code);
-        }
-        case 'query': {
-            if (id === undefined) {
-                throw new Error('`id` is required for `Query` expression');
-            }
-            if (!ctx.urlSearchParamsCache) {
-                let queryString = extractQueryWithoutFragment(id);
-                ctx.urlSearchParamsCache = new URLSearchParams(queryString);
-            }
-            let urlParams = ctx.urlSearchParamsCache;
-            if (typeof expr.pattern === 'boolean') {
-                if (expr.pattern) {
-                    return urlParams.has(expr.key);
-                }
-                else {
-                    return !urlParams.has(expr.key);
-                }
-            }
-            else if (typeof expr.pattern === 'string') {
-                return urlParams.get(expr.key) === expr.pattern;
-            }
-            else {
-                return expr.pattern.test(urlParams.get(expr.key) ?? '');
-            }
-        }
-        default: {
-            throw new Error(`Expression ${JSON.stringify(expr)} is not expected.`);
-        }
-    }
-}

dist/filter/filter-vite-plugins.d.ts

-/**
- * Filters out Vite plugins that have `apply: 'serve'` set.
- *
- * Since Rolldown operates in build mode, plugins marked with `apply: 'serve'`
- * are intended only for Vite's dev server and should be excluded from the build process.
- *
- * @param plugins - Array of plugins (can include nested arrays)
- * @returns Filtered array with serve-only plugins removed
- *
- * @example
- * ```ts
- * import { defineConfig } from 'rolldown';
- * import { filterVitePlugins } from '@rolldown/pluginutils';
- * import viteReact from '@vitejs/plugin-react';
- *
- * export default defineConfig({
- *   plugins: filterVitePlugins([
- *     viteReact(),
- *     {
- *       name: 'dev-only',
- *       apply: 'serve', // This will be filtered out
- *       // ...
- *     }
- *   ])
- * });
- * ```
- */
-export declare function filterVitePlugins<T = any>(plugins: T | T[] | null | undefined | false): T[];

dist/filter/filter-vite-plugins.js

-/**
- * Filters out Vite plugins that have `apply: 'serve'` set.
- *
- * Since Rolldown operates in build mode, plugins marked with `apply: 'serve'`
- * are intended only for Vite's dev server and should be excluded from the build process.
- *
- * @param plugins - Array of plugins (can include nested arrays)
- * @returns Filtered array with serve-only plugins removed
- *
- * @example
- * ```ts
- * import { defineConfig } from 'rolldown';
- * import { filterVitePlugins } from '@rolldown/pluginutils';
- * import viteReact from '@vitejs/plugin-react';
- *
- * export default defineConfig({
- *   plugins: filterVitePlugins([
- *     viteReact(),
- *     {
- *       name: 'dev-only',
- *       apply: 'serve', // This will be filtered out
- *       // ...
- *     }
- *   ])
- * });
- * ```
- */
-export function filterVitePlugins(plugins) {
-    if (!plugins) {
-        return [];
-    }
-    const pluginArray = Array.isArray(plugins) ? plugins : [plugins];
-    const result = [];
-    for (const plugin of pluginArray) {
-        // Skip falsy values
-        if (!plugin) {
-            continue;
-        }
-        // Handle nested arrays recursively
-        if (Array.isArray(plugin)) {
-            result.push(...filterVitePlugins(plugin));
-            continue;
-        }
-        // Check if plugin has apply property
-        const pluginWithApply = plugin;
-        if ('apply' in pluginWithApply) {
-            const applyValue = pluginWithApply.apply;
-            // If apply is a function, call it with build mode
-            if (typeof applyValue === 'function') {
-                try {
-                    const shouldApply = applyValue({}, // config object
-                    { command: 'build', mode: 'production' });
-                    if (shouldApply) {
-                        result.push(plugin);
-                    }
-                }
-                catch {
-                    // If function throws, include the plugin to be safe
-                    result.push(plugin);
-                }
-            } // If apply is 'serve', skip this plugin
-            else if (applyValue === 'serve') {
-                continue;
-            } // If apply is 'build' or anything else, include it
-            else {
-                result.push(plugin);
-            }
-        }
-        else {
-            // No apply property, include the plugin
-            result.push(plugin);
-        }
-    }
-    return result;
-}

dist/filter/index.d.ts

-export * from './composable-filters.ts';
-export * from './filter-vite-plugins.ts';
-export * from './simple-filters.ts';

dist/filter/index.js

-export * from "./composable-filters.js";
-export * from "./filter-vite-plugins.js";
-export * from "./simple-filters.js";

dist/filter/simple-filters.d.ts

-/**
- * Constructs a RegExp that matches the exact string specified.
- *
- * This is useful for plugin hook filters.
- *
- * @param str the string to match.
- * @param flags flags for the RegExp.
- *
- * @example
- * ```ts
- * import { exactRegex } from '@rolldown/pluginutils';
- * const plugin = {
- *   name: 'plugin',
- *   resolveId: {
- *     filter: { id: exactRegex('foo') },
- *     handler(id) {} // will only be called for `foo`
- *   }
- * }
- * ```
- */
-export declare function exactRegex(str: string, flags?: string): RegExp;
-/**
- * Constructs a RegExp that matches a value that has the specified prefix.
- *
- * This is useful for plugin hook filters.
- *
- * @param str the string to match.
- * @param flags flags for the RegExp.
- *
- * @example
- * ```ts
- * import { prefixRegex } from '@rolldown/pluginutils';
- * const plugin = {
- *   name: 'plugin',
- *   resolveId: {
- *     filter: { id: prefixRegex('foo') },
- *     handler(id) {} // will only be called for IDs starting with `foo`
- *   }
- * }
- * ```
- */
-export declare function prefixRegex(str: string, flags?: string): RegExp;
-type WidenString<T> = T extends string ? string : T;
-/**
- * Converts a id filter to match with an id with a query.
- *
- * @param input the id filters to convert.
- *
- * @example
- * ```ts
- * import { makeIdFiltersToMatchWithQuery } from '@rolldown/pluginutils';
- * const plugin = {
- *   name: 'plugin',
- *   transform: {
- *     filter: { id: makeIdFiltersToMatchWithQuery(['**' + '/*.js', /\.ts$/]) },
- *     // The handler will be called for IDs like:
- *     // - foo.js
- *     // - foo.js?foo
- *     // - foo.txt?foo.js
- *     // - foo.ts
- *     // - foo.ts?foo
- *     // - foo.txt?foo.ts
- *     handler(code, id) {}
- *   }
- * }
- * ```
- */
-export declare function makeIdFiltersToMatchWithQuery<T extends string | RegExp>(input: T): WidenString<T>;
-export declare function makeIdFiltersToMatchWithQuery<T extends string | RegExp>(input: readonly T[]): WidenString<T>[];
-export declare function makeIdFiltersToMatchWithQuery(input: string | RegExp | readonly (string | RegExp)[]): string | RegExp | (string | RegExp)[];
-export {};

dist/filter/simple-filters.js

-/**
- * Constructs a RegExp that matches the exact string specified.
- *
- * This is useful for plugin hook filters.
- *
- * @param str the string to match.
- * @param flags flags for the RegExp.
- *
- * @example
- * ```ts
- * import { exactRegex } from '@rolldown/pluginutils';
- * const plugin = {
- *   name: 'plugin',
- *   resolveId: {
- *     filter: { id: exactRegex('foo') },
- *     handler(id) {} // will only be called for `foo`
- *   }
- * }
- * ```
- */
-export function exactRegex(str, flags) {
-    return new RegExp(`^${escapeRegex(str)}$`, flags);
-}
-/**
- * Constructs a RegExp that matches a value that has the specified prefix.
- *
- * This is useful for plugin hook filters.
- *
- * @param str the string to match.
- * @param flags flags for the RegExp.
- *
- * @example
- * ```ts
- * import { prefixRegex } from '@rolldown/pluginutils';
- * const plugin = {
- *   name: 'plugin',
- *   resolveId: {
- *     filter: { id: prefixRegex('foo') },
- *     handler(id) {} // will only be called for IDs starting with `foo`
- *   }
- * }
- * ```
- */
-export function prefixRegex(str, flags) {
-    return new RegExp(`^${escapeRegex(str)}`, flags);
-}
-const escapeRegexRE = /[-/\\^$*+?.()|[\]{}]/g;
-function escapeRegex(str) {
-    return str.replace(escapeRegexRE, '\\$&');
-}
-export function makeIdFiltersToMatchWithQuery(input) {
-    if (!Array.isArray(input)) {
-        return makeIdFilterToMatchWithQuery(
-        // Array.isArray cannot narrow the type
-        // https://github.com/microsoft/TypeScript/issues/17002
-        input);
-    }
-    return input.map((i) => makeIdFilterToMatchWithQuery(i));
-}
-function makeIdFilterToMatchWithQuery(input) {
-    if (typeof input === 'string') {
-        return `${input}{?*,}`;
-    }
-    return makeRegexIdFilterToMatchWithQuery(input);
-}
-function makeRegexIdFilterToMatchWithQuery(input) {
-    return new RegExp(
-    // replace `$` with `(?:\?.*)?$` (ignore `\$`)
-    input.source.replace(/(?<!\\)\$/g, '(?:\\?.*)?$'), input.flags);
-}

dist/index.d.ts

-export * from './filter/index.ts';

dist/index.js

-export * from "./filter/index.js";

dist/utils.d.ts

-export declare function cleanUrl(url: string): string;
-export declare function extractQueryWithoutFragment(url: string): string;

dist/utils.js

-const postfixRE = /[?#].*$/;
-export function cleanUrl(url) {
-    return url.replace(postfixRE, '');
-}
-export function extractQueryWithoutFragment(url) {
-    const questionMarkIndex = url.indexOf('?');
-    if (questionMarkIndex === -1) {
-        return '';
-    }
-    const fragmentIndex = url.indexOf('#', questionMarkIndex); // Search for # after ?
-    if (fragmentIndex === -1) {
-        return url.substring(questionMarkIndex);
-    }
-    else {
-        return url.substring(questionMarkIndex, fragmentIndex);
-    }
-}

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Long strings

Supply chain risk

Contains long string literals, which may be a sign of obfuscated or packed code.

Found 1 instance in 1 package

Fixed alerts

No bug tracker

Maintenance

Package does not have a linked bug tracker in package.json.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

25693

8.99%

Dev dependency count

3

-25%

Number of low maintenance alerts

1

-50%

Number of lines in readme file

146

73.81%

Worsened metrics

Number of package files

8

-46.67%

Lines of code

329

-46.68%

Number of low supply chain risk alerts

1

Infinity%

Number of medium supply chain risk alerts

1

Infinity%

No dependency changes