@vitejs/plugin-rsc 0.5.16 → 0.5.17

package/dist/browser.d.ts

@@ -1,4 +1,4 @@
-import { n as CallServerCallback } from "./index-DqoQPvhP.js";
-import { t as setRequireModule } from "./browser-BmyjVnfA.js";
+import { n as CallServerCallback } from "./index-now_lP2V.js";
+import { t as setRequireModule } from "./browser-s-WcB8A7.js";
 import { callServer, createFromFetch, createFromReadableStream, createServerReference, createTemporaryReferenceSet, encodeReply, findSourceMapURL, setServerCallback } from "./react/browser.js";
 export { CallServerCallback, callServer, createFromFetch, createFromReadableStream, createServerReference, createTemporaryReferenceSet, encodeReply, findSourceMapURL, setRequireModule, setServerCallback };

package/dist/{cjs-DH9Oa3zy.js → cjs-gAnoDF_x.js}

@@ -1,5 +1,5 @@
-import { t as createDebug } from "./dist-DZUJDIM2.js";
-import { n as parseIdQuery } from "./shared-Chot7h9j.js";
+import { t as createDebug } from "./dist-yW9-EeG1.js";
+import { n as parseIdQuery } from "./shared-CGK4coF3.js";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";

package/dist/core/browser.d.ts

@@ -1,2 +1,2 @@
-import { t as setRequireModule } from "../browser-BmyjVnfA.js";
+import { t as setRequireModule } from "../browser-s-WcB8A7.js";
 export { setRequireModule };

package/dist/core/browser.js

@@ -1,5 +1,5 @@
-import { n as memoize } from "../dist-DZUJDIM2.js";
-import { a as setInternalRequire, i as removeReferenceCacheTag } from "../shared-DEpnONZf.js";
+import { n as memoize } from "../dist-yW9-EeG1.js";
+import { a as setInternalRequire, i as removeReferenceCacheTag } from "../shared-rtJPs0Yj.js";
 
 //#region src/core/browser.ts
 let init = false;

package/dist/core/plugin.js

@@ -1,3 +1,3 @@
-import { t as vitePluginRscCore } from "../plugin-B1AJWrMi.js";
+import { t as vitePluginRscCore } from "../plugin-9NQn9bDA.js";
 
 export { vitePluginRscCore as default };

package/dist/core/rsc.d.ts

@@ -1,4 +1,4 @@
-import { r as ModuleMap, t as BundlerConfig } from "../index-DqoQPvhP.js";
+import { r as ModuleMap, t as BundlerConfig } from "../index-now_lP2V.js";
 
 //#region src/core/rsc.d.ts
 declare function setRequireModule(options: {

package/dist/core/rsc.js

@@ -1,3 +1,3 @@
-import { a as setRequireModule, i as loadServerAction, n as createServerDecodeClientManifest, r as createServerManifest, t as createClientManifest } from "../rsc-BCFg12vs.js";
+import { a as setRequireModule, i as loadServerAction, n as createServerDecodeClientManifest, r as createServerManifest, t as createClientManifest } from "../rsc-Bhp6O2qz.js";
 
 export { createClientManifest, createServerDecodeClientManifest, createServerManifest, loadServerAction, setRequireModule };

package/dist/core/ssr.d.ts

@@ -1,4 +1,4 @@
-import { i as ServerConsumerManifest } from "../index-DqoQPvhP.js";
+import { i as ServerConsumerManifest } from "../index-now_lP2V.js";
 
 //#region src/core/ssr.d.ts
 declare function setRequireModule(options: {

package/dist/core/ssr.js

@@ -1,5 +1,5 @@
-import { n as memoize } from "../dist-DZUJDIM2.js";
-import { a as setInternalRequire, i as removeReferenceCacheTag } from "../shared-DEpnONZf.js";
+import { n as memoize } from "../dist-yW9-EeG1.js";
+import { a as setInternalRequire, i as removeReferenceCacheTag } from "../shared-rtJPs0Yj.js";
 
 //#region src/core/ssr.ts
 let init = false;

package/dist/{dist-DZUJDIM2.js → dist-yW9-EeG1.js}

@@ -58,7 +58,7 @@ function createDebugPattern(namespace) {
 	const alts = [namespace];
 	for (let i = 1; i < parts.length; i++) alts.push(parts.slice(0, i).join(":") + ":*");
 	const pattern = alts.map((pattern2) => escapeRegExp(pattern2)).join("|");
-	return /* @__PURE__ */ new RegExp(`(^|,)(${pattern})($|,)`);
+	return new RegExp(`(^|,)(${pattern})($|,)`);
 }
 
 //#endregion

package/dist/index-CLmWsR1c.d.ts

@@ -0,0 +1,584 @@
+import MagicString from "magic-string";
+
+//#region ../../node_modules/.pnpm/@types+estree@1.0.8/node_modules/@types/estree/index.d.ts
+// This definition file follows a somewhat unusual format. ESTree allows
+// runtime type checks based on the `type` parameter. In order to explain this
+// to typescript we want to use discriminated union types:
+// https://github.com/Microsoft/TypeScript/pull/9163
+//
+// For ESTree this is a bit tricky because the high level interfaces like
+// Node or Function are pulling double duty. We want to pass common fields down
+// to the interfaces that extend them (like Identifier or
+// ArrowFunctionExpression), but you can't extend a type union or enforce
+// common fields on them. So we've split the high level interfaces into two
+// types, a base type which passes down inherited fields, and a type union of
+// all types which extend the base type. Only the type union is exported, and
+// the union is how other types refer to the collection of inheriting types.
+//
+// This makes the definitions file here somewhat more difficult to maintain,
+// but it has the notable advantage of making ESTree much easier to use as
+// an end user.
+interface BaseNodeWithoutComments {
+  // Every leaf interface that extends BaseNode must specify a type property.
+  // The type property should be a string literal. For example, Identifier
+  // has: `type: "Identifier"`
+  type: string;
+  loc?: SourceLocation | null | undefined;
+  range?: [number, number] | undefined;
+}
+interface BaseNode extends BaseNodeWithoutComments {
+  leadingComments?: Comment[] | undefined;
+  trailingComments?: Comment[] | undefined;
+}
+interface Comment extends BaseNodeWithoutComments {
+  type: "Line" | "Block";
+  value: string;
+}
+interface SourceLocation {
+  source?: string | null | undefined;
+  start: Position;
+  end: Position;
+}
+interface Position {
+  /** >= 1 */
+  line: number;
+  /** >= 0 */
+  column: number;
+}
+interface Program extends BaseNode {
+  type: "Program";
+  sourceType: "script" | "module";
+  body: Array<Directive | Statement | ModuleDeclaration>;
+  comments?: Comment[] | undefined;
+}
+interface Directive extends BaseNode {
+  type: "ExpressionStatement";
+  expression: Literal;
+  directive: string;
+}
+interface BaseFunction extends BaseNode {
+  params: Pattern[];
+  generator?: boolean | undefined;
+  async?: boolean | undefined; // The body is either BlockStatement or Expression because arrow functions
+  // can have a body that's either. FunctionDeclarations and
+  // FunctionExpressions have only BlockStatement bodies.
+  body: BlockStatement | Expression;
+}
+type Statement = ExpressionStatement | BlockStatement | StaticBlock | EmptyStatement | DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | WhileStatement | DoWhileStatement | ForStatement | ForInStatement | ForOfStatement | Declaration;
+interface BaseStatement extends BaseNode {}
+interface EmptyStatement extends BaseStatement {
+  type: "EmptyStatement";
+}
+interface BlockStatement extends BaseStatement {
+  type: "BlockStatement";
+  body: Statement[];
+  innerComments?: Comment[] | undefined;
+}
+interface StaticBlock extends Omit<BlockStatement, "type"> {
+  type: "StaticBlock";
+}
+interface ExpressionStatement extends BaseStatement {
+  type: "ExpressionStatement";
+  expression: Expression;
+}
+interface IfStatement extends BaseStatement {
+  type: "IfStatement";
+  test: Expression;
+  consequent: Statement;
+  alternate?: Statement | null | undefined;
+}
+interface LabeledStatement extends BaseStatement {
+  type: "LabeledStatement";
+  label: Identifier;
+  body: Statement;
+}
+interface BreakStatement extends BaseStatement {
+  type: "BreakStatement";
+  label?: Identifier | null | undefined;
+}
+interface ContinueStatement extends BaseStatement {
+  type: "ContinueStatement";
+  label?: Identifier | null | undefined;
+}
+interface WithStatement extends BaseStatement {
+  type: "WithStatement";
+  object: Expression;
+  body: Statement;
+}
+interface SwitchStatement extends BaseStatement {
+  type: "SwitchStatement";
+  discriminant: Expression;
+  cases: SwitchCase[];
+}
+interface ReturnStatement extends BaseStatement {
+  type: "ReturnStatement";
+  argument?: Expression | null | undefined;
+}
+interface ThrowStatement extends BaseStatement {
+  type: "ThrowStatement";
+  argument: Expression;
+}
+interface TryStatement extends BaseStatement {
+  type: "TryStatement";
+  block: BlockStatement;
+  handler?: CatchClause | null | undefined;
+  finalizer?: BlockStatement | null | undefined;
+}
+interface WhileStatement extends BaseStatement {
+  type: "WhileStatement";
+  test: Expression;
+  body: Statement;
+}
+interface DoWhileStatement extends BaseStatement {
+  type: "DoWhileStatement";
+  body: Statement;
+  test: Expression;
+}
+interface ForStatement extends BaseStatement {
+  type: "ForStatement";
+  init?: VariableDeclaration | Expression | null | undefined;
+  test?: Expression | null | undefined;
+  update?: Expression | null | undefined;
+  body: Statement;
+}
+interface BaseForXStatement extends BaseStatement {
+  left: VariableDeclaration | Pattern;
+  right: Expression;
+  body: Statement;
+}
+interface ForInStatement extends BaseForXStatement {
+  type: "ForInStatement";
+}
+interface DebuggerStatement extends BaseStatement {
+  type: "DebuggerStatement";
+}
+type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
+interface BaseDeclaration extends BaseStatement {}
+interface MaybeNamedFunctionDeclaration extends BaseFunction, BaseDeclaration {
+  type: "FunctionDeclaration";
+  /** It is null when a function declaration is a part of the `export default function` statement */
+  id: Identifier | null;
+  body: BlockStatement;
+}
+interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
+  id: Identifier;
+}
+interface VariableDeclaration extends BaseDeclaration {
+  type: "VariableDeclaration";
+  declarations: VariableDeclarator[];
+  kind: "var" | "let" | "const" | "using" | "await using";
+}
+interface VariableDeclarator extends BaseNode {
+  type: "VariableDeclarator";
+  id: Pattern;
+  init?: Expression | null | undefined;
+}
+interface ExpressionMap {
+  ArrayExpression: ArrayExpression;
+  ArrowFunctionExpression: ArrowFunctionExpression;
+  AssignmentExpression: AssignmentExpression;
+  AwaitExpression: AwaitExpression;
+  BinaryExpression: BinaryExpression;
+  CallExpression: CallExpression;
+  ChainExpression: ChainExpression;
+  ClassExpression: ClassExpression;
+  ConditionalExpression: ConditionalExpression;
+  FunctionExpression: FunctionExpression;
+  Identifier: Identifier;
+  ImportExpression: ImportExpression;
+  Literal: Literal;
+  LogicalExpression: LogicalExpression;
+  MemberExpression: MemberExpression;
+  MetaProperty: MetaProperty;
+  NewExpression: NewExpression;
+  ObjectExpression: ObjectExpression;
+  SequenceExpression: SequenceExpression;
+  TaggedTemplateExpression: TaggedTemplateExpression;
+  TemplateLiteral: TemplateLiteral;
+  ThisExpression: ThisExpression;
+  UnaryExpression: UnaryExpression;
+  UpdateExpression: UpdateExpression;
+  YieldExpression: YieldExpression;
+}
+type Expression = ExpressionMap[keyof ExpressionMap];
+interface BaseExpression extends BaseNode {}
+type ChainElement = SimpleCallExpression | MemberExpression;
+interface ChainExpression extends BaseExpression {
+  type: "ChainExpression";
+  expression: ChainElement;
+}
+interface ThisExpression extends BaseExpression {
+  type: "ThisExpression";
+}
+interface ArrayExpression extends BaseExpression {
+  type: "ArrayExpression";
+  elements: Array<Expression | SpreadElement | null>;
+}
+interface ObjectExpression extends BaseExpression {
+  type: "ObjectExpression";
+  properties: Array<Property | SpreadElement>;
+}
+interface PrivateIdentifier extends BaseNode {
+  type: "PrivateIdentifier";
+  name: string;
+}
+interface Property extends BaseNode {
+  type: "Property";
+  key: Expression | PrivateIdentifier;
+  value: Expression | Pattern; // Could be an AssignmentProperty
+  kind: "init" | "get" | "set";
+  method: boolean;
+  shorthand: boolean;
+  computed: boolean;
+}
+interface PropertyDefinition extends BaseNode {
+  type: "PropertyDefinition";
+  key: Expression | PrivateIdentifier;
+  value?: Expression | null | undefined;
+  computed: boolean;
+  static: boolean;
+}
+interface FunctionExpression extends BaseFunction, BaseExpression {
+  id?: Identifier | null | undefined;
+  type: "FunctionExpression";
+  body: BlockStatement;
+}
+interface SequenceExpression extends BaseExpression {
+  type: "SequenceExpression";
+  expressions: Expression[];
+}
+interface UnaryExpression extends BaseExpression {
+  type: "UnaryExpression";
+  operator: UnaryOperator;
+  prefix: true;
+  argument: Expression;
+}
+interface BinaryExpression extends BaseExpression {
+  type: "BinaryExpression";
+  operator: BinaryOperator;
+  left: Expression | PrivateIdentifier;
+  right: Expression;
+}
+interface AssignmentExpression extends BaseExpression {
+  type: "AssignmentExpression";
+  operator: AssignmentOperator;
+  left: Pattern | MemberExpression;
+  right: Expression;
+}
+interface UpdateExpression extends BaseExpression {
+  type: "UpdateExpression";
+  operator: UpdateOperator;
+  argument: Expression;
+  prefix: boolean;
+}
+interface LogicalExpression extends BaseExpression {
+  type: "LogicalExpression";
+  operator: LogicalOperator;
+  left: Expression;
+  right: Expression;
+}
+interface ConditionalExpression extends BaseExpression {
+  type: "ConditionalExpression";
+  test: Expression;
+  alternate: Expression;
+  consequent: Expression;
+}
+interface BaseCallExpression extends BaseExpression {
+  callee: Expression | Super;
+  arguments: Array<Expression | SpreadElement>;
+}
+type CallExpression = SimpleCallExpression | NewExpression;
+interface SimpleCallExpression extends BaseCallExpression {
+  type: "CallExpression";
+  optional: boolean;
+}
+interface NewExpression extends BaseCallExpression {
+  type: "NewExpression";
+}
+interface MemberExpression extends BaseExpression, BasePattern {
+  type: "MemberExpression";
+  object: Expression | Super;
+  property: Expression | PrivateIdentifier;
+  computed: boolean;
+  optional: boolean;
+}
+type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;
+interface BasePattern extends BaseNode {}
+interface SwitchCase extends BaseNode {
+  type: "SwitchCase";
+  test?: Expression | null | undefined;
+  consequent: Statement[];
+}
+interface CatchClause extends BaseNode {
+  type: "CatchClause";
+  param: Pattern | null;
+  body: BlockStatement;
+}
+interface Identifier extends BaseNode, BaseExpression, BasePattern {
+  type: "Identifier";
+  name: string;
+}
+type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
+interface SimpleLiteral extends BaseNode, BaseExpression {
+  type: "Literal";
+  value: string | boolean | number | null;
+  raw?: string | undefined;
+}
+interface RegExpLiteral extends BaseNode, BaseExpression {
+  type: "Literal";
+  value?: RegExp | null | undefined;
+  regex: {
+    pattern: string;
+    flags: string;
+  };
+  raw?: string | undefined;
+}
+interface BigIntLiteral extends BaseNode, BaseExpression {
+  type: "Literal";
+  value?: bigint | null | undefined;
+  bigint: string;
+  raw?: string | undefined;
+}
+type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
+type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "in" | "instanceof";
+type LogicalOperator = "||" | "&&" | "??";
+type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??=";
+type UpdateOperator = "++" | "--";
+interface ForOfStatement extends BaseForXStatement {
+  type: "ForOfStatement";
+  await: boolean;
+}
+interface Super extends BaseNode {
+  type: "Super";
+}
+interface SpreadElement extends BaseNode {
+  type: "SpreadElement";
+  argument: Expression;
+}
+interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
+  type: "ArrowFunctionExpression";
+  expression: boolean;
+  body: BlockStatement | Expression;
+}
+interface YieldExpression extends BaseExpression {
+  type: "YieldExpression";
+  argument?: Expression | null | undefined;
+  delegate: boolean;
+}
+interface TemplateLiteral extends BaseExpression {
+  type: "TemplateLiteral";
+  quasis: TemplateElement[];
+  expressions: Expression[];
+}
+interface TaggedTemplateExpression extends BaseExpression {
+  type: "TaggedTemplateExpression";
+  tag: Expression;
+  quasi: TemplateLiteral;
+}
+interface TemplateElement extends BaseNode {
+  type: "TemplateElement";
+  tail: boolean;
+  value: {
+    /** It is null when the template literal is tagged and the text has an invalid escape (e.g. - tag`\unicode and \u{55}`) */cooked?: string | null | undefined;
+    raw: string;
+  };
+}
+interface AssignmentProperty extends Property {
+  value: Pattern;
+  kind: "init";
+  method: boolean; // false
+}
+interface ObjectPattern extends BasePattern {
+  type: "ObjectPattern";
+  properties: Array<AssignmentProperty | RestElement>;
+}
+interface ArrayPattern extends BasePattern {
+  type: "ArrayPattern";
+  elements: Array<Pattern | null>;
+}
+interface RestElement extends BasePattern {
+  type: "RestElement";
+  argument: Pattern;
+}
+interface AssignmentPattern extends BasePattern {
+  type: "AssignmentPattern";
+  left: Pattern;
+  right: Expression;
+}
+interface BaseClass extends BaseNode {
+  superClass?: Expression | null | undefined;
+  body: ClassBody;
+}
+interface ClassBody extends BaseNode {
+  type: "ClassBody";
+  body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;
+}
+interface MethodDefinition extends BaseNode {
+  type: "MethodDefinition";
+  key: Expression | PrivateIdentifier;
+  value: FunctionExpression;
+  kind: "constructor" | "method" | "get" | "set";
+  computed: boolean;
+  static: boolean;
+}
+interface MaybeNamedClassDeclaration extends BaseClass, BaseDeclaration {
+  type: "ClassDeclaration";
+  /** It is null when a class declaration is a part of the `export default class` statement */
+  id: Identifier | null;
+}
+interface ClassDeclaration extends MaybeNamedClassDeclaration {
+  id: Identifier;
+}
+interface ClassExpression extends BaseClass, BaseExpression {
+  type: "ClassExpression";
+  id?: Identifier | null | undefined;
+}
+interface MetaProperty extends BaseExpression {
+  type: "MetaProperty";
+  meta: Identifier;
+  property: Identifier;
+}
+type ModuleDeclaration = ImportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration | ExportAllDeclaration;
+interface BaseModuleDeclaration extends BaseNode {}
+interface BaseModuleSpecifier extends BaseNode {
+  local: Identifier;
+}
+interface ImportDeclaration extends BaseModuleDeclaration {
+  type: "ImportDeclaration";
+  specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
+  attributes: ImportAttribute[];
+  source: Literal;
+}
+interface ImportSpecifier extends BaseModuleSpecifier {
+  type: "ImportSpecifier";
+  imported: Identifier | Literal;
+}
+interface ImportAttribute extends BaseNode {
+  type: "ImportAttribute";
+  key: Identifier | Literal;
+  value: Literal;
+}
+interface ImportExpression extends BaseExpression {
+  type: "ImportExpression";
+  source: Expression;
+  options?: Expression | null | undefined;
+}
+interface ImportDefaultSpecifier extends BaseModuleSpecifier {
+  type: "ImportDefaultSpecifier";
+}
+interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
+  type: "ImportNamespaceSpecifier";
+}
+interface ExportNamedDeclaration extends BaseModuleDeclaration {
+  type: "ExportNamedDeclaration";
+  declaration?: Declaration | null | undefined;
+  specifiers: ExportSpecifier[];
+  attributes: ImportAttribute[];
+  source?: Literal | null | undefined;
+}
+interface ExportSpecifier extends Omit<BaseModuleSpecifier, "local"> {
+  type: "ExportSpecifier";
+  local: Identifier | Literal;
+  exported: Identifier | Literal;
+}
+interface ExportDefaultDeclaration extends BaseModuleDeclaration {
+  type: "ExportDefaultDeclaration";
+  declaration: MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | Expression;
+}
+interface ExportAllDeclaration extends BaseModuleDeclaration {
+  type: "ExportAllDeclaration";
+  exported: Identifier | Literal | null;
+  attributes: ImportAttribute[];
+  source: Literal;
+}
+interface AwaitExpression extends BaseExpression {
+  type: "AwaitExpression";
+  argument: Expression;
+}
+//#endregion
+//#region src/transforms/hoist.d.ts
+declare function transformHoistInlineDirective(input: string, ast: Program, {
+  runtime,
+  rejectNonAsyncFunction,
+  ...options
+}: {
+  runtime: (value: string, name: string, meta: {
+    directiveMatch: RegExpMatchArray;
+  }) => string;
+  directive: string | RegExp;
+  rejectNonAsyncFunction?: boolean;
+  encode?: (value: string) => string;
+  decode?: (value: string) => string;
+  noExport?: boolean;
+}): {
+  output: MagicString;
+  names: string[];
+};
+declare function findDirectives(ast: Program, directive: string): Literal[];
+//#endregion
+//#region src/transforms/wrap-export.d.ts
+type ExportMeta = {
+  declName?: string;
+  isFunction?: boolean;
+  defaultExportIdentifierName?: string;
+};
+type TransformWrapExportFilter = (name: string, meta: ExportMeta) => boolean;
+type TransformWrapExportOptions = {
+  runtime: (value: string, name: string, meta: ExportMeta) => string;
+  ignoreExportAllDeclaration?: boolean;
+  rejectNonAsyncFunction?: boolean;
+  filter?: TransformWrapExportFilter;
+};
+declare function transformWrapExport(input: string, ast: Program, options: TransformWrapExportOptions): {
+  exportNames: string[];
+  output: MagicString;
+};
+//#endregion
+//#region src/transforms/proxy-export.d.ts
+type TransformProxyExportOptions = {
+  /** Required for source map and `keep` options */code?: string;
+  runtime: (name: string, meta?: {
+    value: string;
+  }) => string;
+  ignoreExportAllDeclaration?: boolean;
+  rejectNonAsyncFunction?: boolean;
+  /**
+  * escape hatch for Waku's `allowServer`
+  * @default false
+  */
+  keep?: boolean;
+};
+declare function transformDirectiveProxyExport(ast: Program, options: {
+  directive: string;
+} & TransformProxyExportOptions): {
+  exportNames: string[];
+  output: MagicString;
+} | undefined;
+declare function transformProxyExport(ast: Program, options: TransformProxyExportOptions): {
+  exportNames: string[];
+  output: MagicString;
+};
+//#endregion
+//#region src/transforms/utils.d.ts
+declare function hasDirective(body: Program["body"], directive: string): boolean;
+declare function getExportNames(ast: Program, options: {
+  ignoreExportAllDeclaration?: boolean;
+}): {
+  exportNames: string[];
+};
+//#endregion
+//#region src/transforms/server-action.d.ts
+declare function transformServerActionServer(input: string, ast: Program, options: {
+  runtime: (value: string, name: string) => string;
+  rejectNonAsyncFunction?: boolean;
+  encode?: (value: string) => string;
+  decode?: (value: string) => string;
+}): {
+  exportNames: string[];
+  output: MagicString;
+} | {
+  output: MagicString;
+  names: string[];
+};
+//#endregion
+export { transformDirectiveProxyExport as a, TransformWrapExportOptions as c, transformHoistInlineDirective as d, TransformProxyExportOptions as i, transformWrapExport as l, getExportNames as n, transformProxyExport as o, hasDirective as r, TransformWrapExportFilter as s, transformServerActionServer as t, findDirectives as u };

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-import { c as getPluginApi, r as PluginApi, s as RscPluginOptions, u as vitePluginRsc } from "./plugin-V6VFxi_0.js";
-import "./index-DJ0AhQ9B.js";
+import { c as getPluginApi, r as PluginApi, s as RscPluginOptions, u as vitePluginRsc } from "./plugin-K7i9F4Fd.js";
+import "./index-CLmWsR1c.js";
 export { type PluginApi, type RscPluginOptions, vitePluginRsc as default, getPluginApi };

package/dist/index.js

@@ -1,6 +1,6 @@
-import "./cjs-DH9Oa3zy.js";
-import { r as vitePluginRsc, t as getPluginApi } from "./plugin-DBWiu_Dx.js";
-import "./transforms-D4jDIHgD.js";
-import "./rpc-DbBe389F.js";
+import "./cjs-gAnoDF_x.js";
+import { r as vitePluginRsc, t as getPluginApi } from "./plugin-cXbi5HUa.js";
+import "./transforms-B2EJTNXG.js";
+import "./rpc-EIuXyQpO.js";
 
 export { vitePluginRsc as default, getPluginApi };

package/dist/{picocolors-kt7Y18A3.js → picocolors-BRyoHAlU.js}

@@ -1,4 +1,4 @@
-import { t as __commonJSMin } from "./chunk-BFhhoFQb.js";
+import { t as __commonJSMin } from "./chunk-Dj_d7TT4.js";
 
 //#region ../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js
 var require_picocolors = /* @__PURE__ */ __commonJSMin(((exports, module) => {