@noodleseed/one 0.5.0 → 0.6.0

package/node_modules/@rolldown/binding-linux-x64-gnu/README.md

@@ -1,3 +0,0 @@
-# `@rolldown/binding-linux-x64-gnu`
-
-This is the **x86_64-unknown-linux-gnu** binary for `@rolldown/binding`

package/node_modules/@rolldown/binding-linux-x64-gnu/package.json

@@ -1,40 +0,0 @@
-{
-  "name": "@rolldown/binding-linux-x64-gnu",
-  "version": "1.1.3",
-  "cpu": [
-    "x64"
-  ],
-  "main": "rolldown-binding.linux-x64-gnu.node",
-  "files": [
-    "rolldown-binding.linux-x64-gnu.node"
-  ],
-  "description": "Fast JavaScript/TypeScript bundler in Rust with Rollup-compatible API.",
-  "keywords": [
-    "bundler",
-    "esbuild",
-    "parcel",
-    "rolldown",
-    "rollup",
-    "webpack"
-  ],
-  "homepage": "https://rolldown.rs/",
-  "license": "MIT",
-  "engines": {
-    "node": "^20.19.0 || >=22.12.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/rolldown/rolldown.git",
-    "directory": "packages/rolldown"
-  },
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org/",
-    "access": "public"
-  },
-  "os": [
-    "linux"
-  ],
-  "libc": [
-    "glibc"
-  ]
-}

package/node_modules/@rolldown/pluginutils/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026-present, rolldown/plugins repository contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/node_modules/@rolldown/pluginutils/README.md

@@ -1,145 +0,0 @@
-# @rolldown/pluginutils [![npm](https://img.shields.io/npm/v/@rolldown/pluginutils.svg)](https://npmx.dev/package/@rolldown/pluginutils)
-
-Plugin utilities for [Rolldown](https://rolldown.rs).
-
-Includes regex helpers for plugin hook filters, composable filter expressions, and a helper for filtering out Vite-serve-only plugins.
-
-## Install
-
-```bash
-pnpm add -D @rolldown/pluginutils
-```
-
-## Usage
-
-```ts
-import { exactRegex, prefixRegex, makeIdFiltersToMatchWithQuery } from '@rolldown/pluginutils'
-```
-
-All filter helpers are also exposed via the `/filter` subpath:
-
-```ts
-import { and, or, id, include } from '@rolldown/pluginutils/filter'
-```
-
-## Regex helpers
-
-### `exactRegex`
-
-- **Type:** `(str: string, flags?: string) => RegExp`
-
-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('foo') },
-    handler(id) {}, // only called for `foo`
-  },
-}
-```
-
-### `prefixRegex`
-
-- **Type:** `(str: string, flags?: string) => RegExp`
-
-Constructs a `RegExp` that matches values starting with the specified prefix.
-
-```ts
-import { prefixRegex } from '@rolldown/pluginutils'
-
-const plugin = {
-  name: 'plugin',
-  resolveId: {
-    filter: { id: prefixRegex('foo') },
-    handler(id) {}, // called for IDs starting with `foo`
-  },
-}
-```
-
-### `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: { 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) {},
-  },
-}
-```
-
-## Composable 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.
-
-```ts
-import { and, code, id, include, interpreter, moduleType, or } from '@rolldown/pluginutils'
-
-const expr = include(and(or(id(/\.tsx?$/), id(/\.jsx?$/)), moduleType('tsx'), code(/import React/)))
-
-interpreter(expr, sourceCode, sourceId, 'tsx') // boolean
-```
-
-### Builders
-
-| 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

package/node_modules/@rolldown/pluginutils/dist/filter/index.d.mts

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

package/node_modules/@rolldown/pluginutils/dist/filter/index.mjs

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