@kubb/agent 5.0.0-beta.3 → 5.0.0-beta.31

package/.output/server/node_modules/@rolldown/pluginutils/dist/filter/composable-filters.js

@@ -1,256 +0,0 @@
-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.`);
-        }
-    }
-}

package/.output/server/node_modules/@rolldown/pluginutils/dist/filter/filter-vite-plugins.js

@@ -1,75 +0,0 @@
-/**
- * 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;
-}

package/.output/server/node_modules/@rolldown/pluginutils/dist/filter/index.js

@@ -1,3 +0,0 @@
-export * from "./composable-filters.js";
-export * from "./filter-vite-plugins.js";
-export * from "./simple-filters.js";

package/.output/server/node_modules/@rolldown/pluginutils/dist/filter/simple-filters.js

@@ -1,70 +0,0 @@
-/**
- * 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);
-}

package/.output/server/node_modules/@rolldown/pluginutils/dist/index.js

@@ -1 +0,0 @@
-export * from "./filter/index.js";

package/.output/server/node_modules/@rolldown/pluginutils/dist/utils.js

@@ -1,17 +0,0 @@
-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);
-    }
-}

package/.output/server/node_modules/@rolldown/pluginutils/package.json

@@ -1,37 +0,0 @@
-{
-  "name": "@rolldown/pluginutils",
-  "version": "1.0.0-rc.17",
-  "homepage": "https://rolldown.rs/",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/rolldown/rolldown.git",
-    "directory": "packages/pluginutils"
-  },
-  "files": [
-    "dist"
-  ],
-  "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": "./dist/index.js",
-    "./filter": "./dist/filter/index.js",
-    "./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"
-  },
-  "scripts": {
-    "build": "tsc",
-    "test": "vitest --typecheck",
-    "publint": "publint ."
-  }
-}

package/.output/server/node_modules/rolldown/dist/index.mjs

@@ -1,50 +0,0 @@
-import { n as __toESM, t as require_binding } from "./shared/binding-BeU_1iEk.mjs";
-import { n as onExit, t as watch } from "./shared/watch-Bd8v9ewv.mjs";
-import { a as RolldownMagicString, b as RUNTIME_MODULE_ID, x as VERSION } from "./shared/bindingify-input-options-DbbBhzky.mjs";
-import { t as rolldown } from "./shared/rolldown-D3JZ9rMt.mjs";
-import { t as defineConfig } from "./shared/define-config-DJOr6Iwt.mjs";
-import { isMainThread } from "node:worker_threads";
-//#region src/setup.ts
-var import_binding = /* @__PURE__ */ __toESM(require_binding(), 1);
-if (isMainThread) {
-	const subscriberGuard = (0, import_binding.initTraceSubscriber)();
-	onExit(() => {
-		subscriberGuard?.close();
-	});
-}
-//#endregion
-//#region src/api/build.ts
-/**
-* The API similar to esbuild's `build` function.
-*
-* @example
-* ```js
-* import { build } from 'rolldown';
-*
-* const result = await build({
-*   input: 'src/main.js',
-*   output: {
-*     file: 'bundle.js',
-*   },
-* });
-* console.log(result);
-* ```
-*
-* @experimental
-* @category Programmatic APIs
-*/
-async function build(options) {
-	if (Array.isArray(options)) return Promise.all(options.map((opts) => build(opts)));
-	else {
-		const { output, write = true, ...inputOptions } = options;
-		const build = await rolldown(inputOptions);
-		try {
-			if (write) return await build.write(output);
-			else return await build.generate(output);
-		} finally {
-			await build.close();
-		}
-	}
-}
-//#endregion
-export { RUNTIME_MODULE_ID, RolldownMagicString, VERSION, build, defineConfig, rolldown, watch };

package/.output/server/node_modules/rolldown/dist/parse-ast-index.mjs

@@ -1,60 +0,0 @@
-import { l as locate, n as error, s as logParseError, t as augmentCodeLocation, u as getCodeFrame } from "./shared/logs-D80CXhvg.mjs";
-import { n as parseSync, t as parse } from "./shared/parse-B_ZnWxLZ.mjs";
-//#region src/parse-ast-index.ts
-function wrap(result, filename, sourceText) {
-	if (result.errors.length > 0) return normalizeParseError(filename, sourceText, result.errors);
-	return result.program;
-}
-function normalizeParseError(filename, sourceText, errors) {
-	let message = `Parse failed with ${errors.length} error${errors.length < 2 ? "" : "s"}:\n`;
-	const pos = errors[0]?.labels?.[0]?.start;
-	for (let i = 0; i < errors.length; i++) {
-		if (i >= 5) {
-			message += "\n...";
-			break;
-		}
-		const e = errors[i];
-		message += e.message + "\n" + e.labels.map((label) => {
-			const location = locate(sourceText, label.start, { offsetLine: 1 });
-			if (!location) return;
-			return getCodeFrame(sourceText, location.line, location.column);
-		}).filter(Boolean).join("\n");
-	}
-	const log = logParseError(message, filename, pos);
-	if (pos !== void 0 && filename) augmentCodeLocation(log, pos, sourceText, filename);
-	return error(log);
-}
-const defaultParserOptions = {
-	lang: "js",
-	preserveParens: false
-};
-/**
-* Parse code synchronously and return the AST.
-*
-* This function is similar to Rollup's `parseAst` function.
-* Prefer using {@linkcode parseSync} instead of this function as it has more information in the return value.
-*
-* @category Utilities
-*/
-function parseAst(sourceText, options, filename) {
-	return wrap(parseSync(filename ?? "file.js", sourceText, {
-		...defaultParserOptions,
-		...options
-	}), filename, sourceText);
-}
-/**
-* Parse code asynchronously and return the AST.
-*
-* This function is similar to Rollup's `parseAstAsync` function.
-* Prefer using {@linkcode parseAsync} instead of this function as it has more information in the return value.
-*
-* @category Utilities
-*/
-async function parseAstAsync(sourceText, options, filename) {
-	return wrap(await parse(filename ?? "file.js", sourceText, {
-		...defaultParserOptions,
-		...options
-	}), filename, sourceText);
-}
-//#endregion
-export { parseAst, parseAstAsync };