@clayroach/effect-unplugin 4.0.0-effect4-transformer.1

package/README.md

@@ -0,0 +1,384 @@
+# @clayroach/effect-unplugin
+
+Build-time AST transformer for Effect source location tracing and automatic span instrumentation.
+
+## Features
+
+- **Source Tracing**: Transforms `yield*` expressions inside `Effect.gen()` to inject stack frame information
+- **Span Instrumentation**: Auto-wraps Effect combinators with `Effect.withSpan()` for distributed tracing
+- **OpenTelemetry Semantic Conventions**: Adds `code.filepath`, `code.lineno`, `code.column`, `code.function` attributes
+- **Configurable Span Names**: Three formats - function-based, location-based, or full
+- **Granular Control**: Depth-based or override-based filtering strategies
+
+## Installation
+
+```bash
+pnpm add -D @clayroach/effect-unplugin
+```
+
+## Quick Start
+
+### Vite
+
+```typescript
+// vite.config.ts
+import { defineConfig } from 'vite'
+import effectPlugin from '@clayroach/effect-unplugin/vite'
+
+export default defineConfig({
+  plugins: [
+    effectPlugin({
+      sourceTrace: true,
+      spans: { enabled: true }
+    })
+  ]
+})
+```
+
+### ESBuild
+
+```typescript
+import effectPlugin from '@clayroach/effect-unplugin/esbuild'
+import { build } from 'esbuild'
+
+build({
+  plugins: [effectPlugin({ sourceTrace: true, spans: { enabled: true } })],
+  // ... other options
+})
+```
+
+### Webpack / Rollup
+
+```typescript
+import effectPlugin from '@clayroach/effect-unplugin/webpack'
+// or
+import effectPlugin from '@clayroach/effect-unplugin/rollup'
+```
+
+## Configuration
+
+### Basic Options
+
+```typescript
+effectPlugin({
+  // Enable source tracing for yield* expressions (default: true)
+  sourceTrace: true,
+
+  // Extract function names from yield* arguments (default: true)
+  extractFunctionName: true,
+
+  // File patterns to include (default: .js, .ts, .jsx, .tsx)
+  include: /\.[jt]sx?$/,
+
+  // File patterns to exclude (default: node_modules)
+  exclude: /node_modules/,
+
+  // Span instrumentation options
+  spans: {
+    enabled: true,
+    include: ["gen", "fork", "all", "forEach"],
+    nameFormat: "function"  // "function" | "location" | "full"
+  }
+})
+```
+
+### Span Name Formats
+
+Control how span names appear in traces:
+
+**`"function"` (default)**: Use function/variable names
+```
+effect.gen (fetchUser)
+effect.all
+effect.forEach (processItems)
+```
+
+**`"location"`: Use file locations
+```
+effect.gen (index.ts:23)
+effect.all (index.ts:49)
+effect.forEach (index.ts:59)
+```
+
+**`"full"`: Include both
+```
+effect.gen (fetchUser @ index.ts:23)
+effect.all (index.ts:49)
+effect.forEach (processItems @ index.ts:59)
+```
+
+All formats include full source location in span attributes (`code.filepath`, `code.lineno`, etc.)
+
+## Instrumentation Strategies
+
+Reduce overhead with fine-grained control over which Effect calls get instrumented.
+
+### Depth Strategy
+
+Limit instrumentation by nesting depth:
+
+```typescript
+spans: {
+  enabled: true,
+  strategy: {
+    type: "depth",
+    maxDepth: 2  // 0 = top-level only, 1 = one level deep, etc.
+  }
+}
+```
+
+**Per-combinator depth limits:**
+```typescript
+spans: {
+  enabled: true,
+  strategy: {
+    type: "depth",
+    perCombinator: {
+      fork: 0,        // Only top-level forks
+      gen: 1,         // Gen + one level deep
+      all: Infinity   // No limit on Effect.all
+    }
+  }
+}
+```
+
+### Override Strategy
+
+Filter by file patterns and function names:
+
+```typescript
+spans: {
+  enabled: true,
+  strategy: {
+    type: "overrides",
+    rules: {
+      // Only instrument forks in worker files
+      fork: {
+        files: "src/workers/**"
+      },
+      // Skip gen in tests and private functions
+      gen: {
+        excludeFiles: "**/*.test.ts",
+        excludeFunctions: "^_.*"
+      },
+      // Only instrument forEach in API handlers
+      forEach: {
+        files: ["src/api/**", "src/handlers/**"],
+        functions: "^handle.*"
+      }
+    }
+  }
+}
+```
+
+**Filter Options:**
+- `files`: Glob patterns to include (single string or array)
+- `excludeFiles`: Glob patterns to exclude
+- `functions`: Regex patterns for function names to include
+- `excludeFunctions`: Regex patterns for function names to exclude
+
+## Examples
+
+### Example 1: Reduce Fork Overhead
+
+Only instrument top-level forks to avoid noisy background task traces:
+
+```typescript
+spans: {
+  enabled: true,
+  strategy: {
+    type: "depth",
+    perCombinator: {
+      fork: 0,
+      forkDaemon: 0,
+      forkScoped: 0
+    }
+  }
+}
+```
+
+### Example 2: Production-Only Instrumentation
+
+Skip instrumentation in tests and development utilities:
+
+```typescript
+spans: {
+  enabled: true,
+  strategy: {
+    type: "overrides",
+    rules: {
+      gen: {
+        excludeFiles: [
+          "**/*.test.ts",
+          "**/__tests__/**",
+          "src/dev/**"
+        ]
+      }
+    }
+  }
+}
+```
+
+### Example 3: Selective High-Value Traces
+
+Only instrument critical paths:
+
+```typescript
+spans: {
+  enabled: true,
+  strategy: {
+    type: "overrides",
+    rules: {
+      gen: {
+        files: [
+          "src/api/**",
+          "src/workers/**",
+          "src/processors/**"
+        ]
+      },
+      fork: {
+        files: "src/workers/**",
+        functions: "^(background|worker).*"
+      }
+    }
+  }
+}
+```
+
+## How It Works
+
+### Source Tracing
+
+Transforms:
+```typescript
+const fetchUser = (id: string) =>
+  Effect.gen(function* () {
+    yield* Console.log(`Fetching ${id}`)
+    return { id, name: `User ${id}` }
+  })
+```
+
+Into:
+```typescript
+const _sf0 = { name: "log", stack: () => "index.ts:3:4", parent: undefined }
+
+const fetchUser = (id: string) =>
+  Effect.gen(function* () {
+    yield* Effect.updateService(
+      Console.log(`Fetching ${id}`),
+      References.CurrentStackFrame,
+      (parent) => ({ ..._sf0, parent })
+    )
+    return { id, name: `User ${id}` }
+  })
+```
+
+### Span Instrumentation
+
+Transforms:
+```typescript
+const program = Effect.gen(function* () {
+  const users = yield* Effect.all([
+    fetchUser('alice'),
+    fetchUser('bob')
+  ])
+})
+```
+
+Into:
+```typescript
+const program = Effect.withSpan(
+  Effect.gen(function* () {
+    const users = yield* Effect.withSpan(
+      Effect.all([fetchUser('alice'), fetchUser('bob')]),
+      "effect.all",
+      {
+        attributes: {
+          "code.filepath": "src/index.ts",
+          "code.lineno": 5,
+          "code.column": 23,
+          "code.function": "effect.all"
+        }
+      }
+    )
+  }),
+  "effect.gen (program)",
+  {
+    attributes: {
+      "code.filepath": "src/index.ts",
+      "code.lineno": 3,
+      "code.column": 16,
+      "code.function": "program"
+    }
+  }
+)
+```
+
+## Supported Combinators
+
+- `gen` - Effect.gen()
+- `fork` - Effect.fork()
+- `forkDaemon` - Effect.forkDaemon()
+- `forkScoped` - Effect.forkScoped()
+- `all` - Effect.all()
+- `forEach` - Effect.forEach()
+- `filter` - Effect.filter()
+- `reduce` - Effect.reduce()
+- `iterate` - Effect.iterate()
+- `loop` - Effect.loop()
+
+## API Reference
+
+### SourceTraceOptions
+
+```typescript
+interface SourceTraceOptions {
+  include?: string | RegExp | Array<string | RegExp>
+  exclude?: string | RegExp | Array<string | RegExp>
+  sourceTrace?: boolean
+  extractFunctionName?: boolean
+  spans?: SpanInstrumentationOptions
+}
+```
+
+### SpanInstrumentationOptions
+
+```typescript
+interface SpanInstrumentationOptions {
+  enabled?: boolean
+  include?: Array<InstrumentableEffect>
+  exclude?: Array<InstrumentableEffect>
+  nameFormat?: "function" | "location" | "full"
+  strategy?: DepthInstrumentationStrategy | OverrideInstrumentationStrategy
+}
+```
+
+### DepthInstrumentationStrategy
+
+```typescript
+interface DepthInstrumentationStrategy {
+  type: "depth"
+  maxDepth?: number
+  perCombinator?: Partial<Record<InstrumentableEffect, number>>
+}
+```
+
+### OverrideInstrumentationStrategy
+
+```typescript
+interface OverrideInstrumentationStrategy {
+  type: "overrides"
+  rules: Partial<Record<InstrumentableEffect, CombinatorFilter>>
+}
+
+interface CombinatorFilter {
+  files?: string | Array<string>
+  excludeFiles?: string | Array<string>
+  functions?: string | Array<string>      // Regex patterns
+  excludeFunctions?: string | Array<string>  // Regex patterns
+}
+```
+
+## License
+
+MIT

package/dist/annotateEffects.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @since 0.0.1
+ * @category models
+ */
+export interface AnnotateResult {
+    readonly code: string;
+    readonly map?: unknown;
+    readonly transformed: boolean;
+}
+/**
+ * Transforms source code to add pure annotations to Effect calls.
+ *
+ * @since 0.0.1
+ * @category transform
+ */
+export declare function annotateEffects(code: string, id: string): AnnotateResult;
+//# sourceMappingURL=annotateEffects.d.ts.map

package/dist/annotateEffects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotateEffects.d.ts","sourceRoot":"","sources":["../src/annotateEffects.ts"],"names":[],"mappings":"AA2EA;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,GAAG,CAAC,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAA;CAC9B;AA0ED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,cAAc,CA8CxE"}

package/dist/annotateEffects.js

@@ -0,0 +1,125 @@
+/**
+ * Effect tree-shaking annotations transformer.
+ *
+ * Adds `\/* @__PURE__ *\/` comments to Effect calls for bundler tree-shaking.
+ *
+ * @since 0.0.1
+ */
+import { parse } from "@babel/parser";
+import * as _traverse from "@babel/traverse";
+import * as _generate from "@babel/generator";
+import * as t from "@babel/types";
+// Handle CommonJS/ESM interop for babel packages
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const traverseModule = _traverse;
+const traverse = typeof traverseModule === "function" ? traverseModule : typeof traverseModule.default === "function" ? traverseModule.default : traverseModule.default?.default ?? traverseModule;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const generateModule = _generate;
+const generate = typeof generateModule === "function" ? generateModule : typeof generateModule.default === "function" ? generateModule.default : generateModule.default?.default ?? generateModule;
+/**
+ * Effect module names that should have pure annotations.
+ */
+const EFFECT_MODULES = /*#__PURE__*/new Set(["Effect", "Option", "Either", "Data", "Schema", "Array", "Chunk", "HashMap", "HashSet", "List", "Queue", "Stream", "Layer", "Scope", "Ref", "SynchronizedRef", "SubscriptionRef", "Duration", "Schedule", "Cause", "Exit", "Match", "Boolean", "Number", "String", "Struct", "Tuple", "Function", "Predicate", "Order", "Equivalence", "Context", "Brand", "Types"]);
+/**
+ * Checks if a call expression already has a pure annotation.
+ */
+function hasPureAnnotation(node) {
+  const comments = node.leadingComments;
+  if (!comments) return false;
+  return comments.some(comment => comment.type === "CommentBlock" && (comment.value.includes("@__PURE__") || comment.value.includes("#__PURE__")));
+}
+/**
+ * Checks if a call is to an Effect module method.
+ */
+function isEffectModuleCall(node) {
+  const callee = node.callee;
+  // Effect.succeed(...) or Option.some(...)
+  if (t.isMemberExpression(callee) && t.isIdentifier(callee.object) && EFFECT_MODULES.has(callee.object.name)) {
+    return true;
+  }
+  return false;
+}
+/**
+ * Checks if a CallExpression is in a context where pure annotation is useful.
+ * Only annotate calls in variable declarations or export declarations.
+ */
+function isInAnnotatableContext(path) {
+  let parent = path.parentPath;
+  while (parent !== null) {
+    const node = parent.node;
+    // Variable declaration: const x = Effect.succeed(...)
+    if (t.isVariableDeclarator(node)) {
+      return true;
+    }
+    // Export: export const x = Effect.succeed(...)
+    if (t.isExportDefaultDeclaration(node) || t.isExportNamedDeclaration(node)) {
+      return true;
+    }
+    // Return statement: return Effect.succeed(...)
+    if (t.isReturnStatement(node)) {
+      return true;
+    }
+    // Arrow function body: () => Effect.succeed(...)
+    if (t.isArrowFunctionExpression(node)) {
+      return true;
+    }
+    // Stop at block statements
+    if (t.isBlockStatement(node) || t.isProgram(node)) {
+      break;
+    }
+    parent = parent.parentPath;
+  }
+  return false;
+}
+/**
+ * Transforms source code to add pure annotations to Effect calls.
+ *
+ * @since 0.0.1
+ * @category transform
+ */
+export function annotateEffects(code, id) {
+  let ast;
+  try {
+    ast = parse(code, {
+      sourceType: "module",
+      plugins: ["typescript", "jsx"],
+      sourceFilename: id
+    });
+  } catch {
+    return {
+      code,
+      transformed: false
+    };
+  }
+  let hasTransformed = false;
+  traverse(ast, {
+    CallExpression(path) {
+      // Skip if already has pure annotation
+      if (hasPureAnnotation(path.node)) return;
+      // Only annotate Effect module calls
+      if (!isEffectModuleCall(path.node)) return;
+      // Only annotate in useful contexts
+      if (!isInAnnotatableContext(path)) return;
+      // Add @__PURE__ annotation
+      t.addComment(path.node, "leading", "#__PURE__", false);
+      hasTransformed = true;
+    }
+  });
+  if (!hasTransformed) {
+    return {
+      code,
+      transformed: false
+    };
+  }
+  const result = generate(ast, {
+    sourceMaps: true,
+    sourceFileName: id,
+    comments: true
+  }, code);
+  return {
+    code: result.code,
+    map: result.map,
+    transformed: true
+  };
+}
+//# sourceMappingURL=annotateEffects.js.map

package/dist/annotateEffects.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotateEffects.js","names":["parse","_traverse","_generate","t","traverseModule","traverse","default","generateModule","generate","EFFECT_MODULES","Set","hasPureAnnotation","node","comments","leadingComments","some","comment","type","value","includes","isEffectModuleCall","callee","isMemberExpression","isIdentifier","object","has","name","isInAnnotatableContext","path","parent","parentPath","isVariableDeclarator","isExportDefaultDeclaration","isExportNamedDeclaration","isReturnStatement","isArrowFunctionExpression","isBlockStatement","isProgram","annotateEffects","code","id","ast","sourceType","plugins","sourceFilename","transformed","hasTransformed","CallExpression","addComment","result","sourceMaps","sourceFileName","map"],"sources":["../src/annotateEffects.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/esbuild.d.ts

@@ -0,0 +1,3 @@
+declare const _default: (options?: import("./types.ts").SourceTraceOptions | undefined) => import("unplugin").EsbuildPlugin;
+export default _default;
+//# sourceMappingURL=esbuild.d.ts.map

package/dist/esbuild.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"esbuild.d.ts","sourceRoot":"","sources":["../src/esbuild.ts"],"names":[],"mappings":";AAiBA,wBAA+B"}

package/dist/esbuild.js

@@ -0,0 +1,18 @@
+/**
+ * esbuild plugin for Effect source location tracing.
+ *
+ * @example
+ * ```ts
+ * import esbuild from "esbuild"
+ * import effectSourceTrace from "@effect/unplugin/esbuild"
+ *
+ * esbuild.build({
+ *   plugins: [effectSourceTrace()]
+ * })
+ * ```
+ *
+ * @since 0.0.1
+ */
+import unplugin from "./index.js";
+export default unplugin.esbuild;
+//# sourceMappingURL=esbuild.js.map

package/dist/esbuild.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"esbuild.js","names":["unplugin","esbuild"],"sources":["../src/esbuild.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;;;;AAeA,OAAOA,QAAQ,MAAM,YAAY;AAEjC,eAAeA,QAAQ,CAACC,OAAO","ignoreList":[]}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import type { SourceTraceOptions } from "./types.ts";
+export { type TransformResult } from "./sourceTrace.ts";
+export type { FilterPattern, InstrumentableEffect, SourceTraceOptions, SpanInstrumentationOptions } from "./types.ts";
+/**
+ * Creates the Effect source trace unplugin.
+ *
+ * @since 0.0.1
+ * @category unplugin
+ */
+export declare const unplugin: import("unplugin").UnpluginInstance<SourceTraceOptions | undefined, boolean>;
+export default unplugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAiCA,OAAO,KAAK,EAAiB,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAEnE,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAA;AACvD,YAAY,EAAE,aAAa,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAA;AAiCrH;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,8EAmBnB,CAAA;AAEF,eAAe,QAAQ,CAAA"}

package/dist/index.js

@@ -0,0 +1,86 @@
+/**
+ * Build-time AST transformer for Effect source location tracing and auto-instrumentation.
+ *
+ * Provides two features:
+ * 1. **Source Tracing**: Transforms `yield*` expressions inside `Effect.gen()` to
+ *    inject source location information via `CurrentStackFrame`.
+ * 2. **Span Instrumentation**: Wraps Effect combinators with `withSpan()` for
+ *    automatic distributed tracing with OpenTelemetry semantic conventions.
+ *
+ * @example
+ * ```ts
+ * // vite.config.ts
+ * import { defineConfig } from "vite"
+ * import effectSourceTrace from "@effect/unplugin/vite"
+ *
+ * export default defineConfig({
+ *   plugins: [effectSourceTrace({
+ *     // Enable source tracing (default: true)
+ *     sourceTrace: true,
+ *     // Enable span instrumentation
+ *     spans: {
+ *       enabled: true,
+ *       include: ["gen", "fork", "all", "forEach"],
+ *       nameFormat: "function" // "function" | "location" | "full"
+ *     }
+ *   })]
+ * })
+ * ```
+ *
+ * @since 0.0.1
+ */
+import { createUnplugin } from "unplugin";
+import { transform } from "./sourceTrace.js";
+export {} from "./sourceTrace.js";
+const defaultInclude = [/\.[jt]sx?$/];
+const defaultExclude = [/node_modules/];
+function toArray(value) {
+  if (value === undefined) return [];
+  if (Array.isArray(value)) return value;
+  return [value];
+}
+function createFilter(include, exclude) {
+  const includePatterns = toArray(include ?? defaultInclude);
+  const excludePatterns = toArray(exclude ?? defaultExclude);
+  return id => {
+    for (const pattern of excludePatterns) {
+      if (typeof pattern === "string" ? id.includes(pattern) : pattern.test(id)) {
+        return false;
+      }
+    }
+    for (const pattern of includePatterns) {
+      if (typeof pattern === "string" ? id.includes(pattern) : pattern.test(id)) {
+        return true;
+      }
+    }
+    return false;
+  };
+}
+/**
+ * Creates the Effect source trace unplugin.
+ *
+ * @since 0.0.1
+ * @category unplugin
+ */
+export const unplugin = /*#__PURE__*/createUnplugin((options = {}) => {
+  const filter = createFilter(options.include, options.exclude);
+  return {
+    name: "effect-source-trace",
+    enforce: "pre",
+    transformInclude(id) {
+      return filter(id);
+    },
+    transform(code, id) {
+      const result = transform(code, id, options);
+      if (!result.transformed) {
+        return null;
+      }
+      return {
+        code: result.code,
+        map: result.map
+      };
+    }
+  };
+});
+export default unplugin;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["createUnplugin","transform","defaultInclude","defaultExclude","toArray","value","undefined","Array","isArray","createFilter","include","exclude","includePatterns","excludePatterns","id","pattern","includes","test","unplugin","options","filter","name","enforce","transformInclude","code","result","transformed","map"],"sources":["../src/index.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,SAASA,cAAc,QAAyD,UAAU;AAC1F,SAASC,SAAS,QAAQ,kBAAkB;AAG5C,eAAqC,kBAAkB;AAGvD,MAAMC,cAAc,GAAmC,CAAC,YAAY,CAAC;AACrE,MAAMC,cAAc,GAAmC,CAAC,cAAc,CAAC;AAEvE,SAASC,OAAOA,CAACC,KAAgC;EAC/C,IAAIA,KAAK,KAAKC,SAAS,EAAE,OAAO,EAAE;EAClC,IAAIC,KAAK,CAACC,OAAO,CAACH,KAAK,CAAC,EAAE,OAAOA,KAAK;EACtC,OAAO,CAACA,KAAwB,CAAC;AACnC;AAEA,SAASI,YAAYA,CACnBC,OAAkC,EAClCC,OAAkC;EAElC,MAAMC,eAAe,GAAGR,OAAO,CAACM,OAAO,IAAIR,cAAc,CAAC;EAC1D,MAAMW,eAAe,GAAGT,OAAO,CAACO,OAAO,IAAIR,cAAc,CAAC;EAE1D,OAAQW,EAAU,IAAa;IAC7B,KAAK,MAAMC,OAAO,IAAIF,eAAe,EAAE;MACrC,IAAI,OAAOE,OAAO,KAAK,QAAQ,GAAGD,EAAE,CAACE,QAAQ,CAACD,OAAO,CAAC,GAAGA,OAAO,CAACE,IAAI,CAACH,EAAE,CAAC,EAAE;QACzE,OAAO,KAAK;MACd;IACF;IACA,KAAK,MAAMC,OAAO,IAAIH,eAAe,EAAE;MACrC,IAAI,OAAOG,OAAO,KAAK,QAAQ,GAAGD,EAAE,CAACE,QAAQ,CAACD,OAAO,CAAC,GAAGA,OAAO,CAACE,IAAI,CAACH,EAAE,CAAC,EAAE;QACzE,OAAO,IAAI;MACb;IACF;IACA,OAAO,KAAK;EACd,CAAC;AACH;AAEA;;;;;;AAMA,OAAO,MAAMI,QAAQ,gBAAGlB,cAAc,CAAiC,CAACmB,OAAO,GAAG,EAAE,KAAI;EACtF,MAAMC,MAAM,GAAGX,YAAY,CAACU,OAAO,CAACT,OAAO,EAAES,OAAO,CAACR,OAAO,CAAC;EAE7D,OAAO;IACLU,IAAI,EAAE,qBAAqB;IAC3BC,OAAO,EAAE,KAAK;IAEdC,gBAAgBA,CAACT,EAAE;MACjB,OAAOM,MAAM,CAACN,EAAE,CAAC;IACnB,CAAC;IAEDb,SAASA,CAACuB,IAAI,EAAEV,EAAE;MAChB,MAAMW,MAAM,GAAGxB,SAAS,CAACuB,IAAI,EAAEV,EAAE,EAAEK,OAAO,CAAC;MAC3C,IAAI,CAACM,MAAM,CAACC,WAAW,EAAE;QACvB,OAAO,IAAI;MACb;MACA,OAAO;QAAEF,IAAI,EAAEC,MAAM,CAACD,IAAI;QAAEG,GAAG,EAAEF,MAAM,CAACE;MAAG,CAA6B;IAC1E;GACD;AACH,CAAC,CAAC;AAEF,eAAeT,QAAQ","ignoreList":[]}

package/dist/rollup.d.ts

@@ -0,0 +1,3 @@
+declare const _default: (options?: import("./types.ts").SourceTraceOptions | undefined) => import("rollup").Plugin<any> | import("rollup").Plugin<any>[];
+export default _default;
+//# sourceMappingURL=rollup.d.ts.map

package/dist/rollup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rollup.d.ts","sourceRoot":"","sources":["../src/rollup.ts"],"names":[],"mappings":";AAiBA,wBAA8B"}