sv 0.12.2 → 0.12.3

package/dist/core-VSHdSalh.d.mts

@@ -1,788 +0,0 @@
-import { TomlTable } from "smol-toml";
-import * as estree from "estree";
-import { BaseNode as BaseNode$1 } from "estree";
-import { AST as SvelteAst } from "svelte/compiler";
-import * as yaml from "yaml";
-import { log } from "@clack/prompts";
-import dedent from "dedent";
-import * as Walker from "zimmerframe";
-import { AgentName } from "package-manager-detector";
-import { resolveCommand } from "package-manager-detector/commands";
-
-//#region lib/core/tooling/js/ts-estree.d.ts
-declare module "estree" {
-  interface TSTypeAnnotation {
-    type: "TSTypeAnnotation";
-    typeAnnotation: TSStringKeyword | TSTypeReference | TSUnionType | TSIndexedAccessType;
-  }
-  interface TSStringKeyword {
-    type: "TSStringKeyword";
-  }
-  interface TSNullKeyword {
-    type: "TSNullKeyword";
-  }
-  interface TSTypeReference {
-    type: "TSTypeReference";
-    typeName: Identifier;
-  }
-  interface TSAsExpression extends BaseNode {
-    type: "TSAsExpression";
-    expression: Expression;
-    typeAnnotation: TSTypeAnnotation["typeAnnotation"];
-  }
-  interface TSModuleDeclaration extends BaseNode {
-    type: "TSModuleDeclaration";
-    global: boolean;
-    declare: boolean;
-    id: Identifier;
-    body: TSModuleBlock;
-  }
-  interface TSModuleBlock extends BaseNode {
-    type: "TSModuleBlock";
-    body: Array<TSModuleDeclaration | TSInterfaceDeclaration>;
-  }
-  interface TSInterfaceDeclaration extends BaseNode {
-    type: "TSInterfaceDeclaration";
-    id: Identifier;
-    body: TSInterfaceBody;
-  }
-  interface TSInterfaceBody extends BaseNode {
-    type: "TSInterfaceBody";
-    body: TSPropertySignature[];
-  }
-  interface TSPropertySignature extends BaseNode {
-    type: "TSPropertySignature";
-    computed: boolean;
-    key: Identifier;
-    optional?: boolean;
-    typeAnnotation: TSTypeAnnotation;
-  }
-  interface TSProgram extends Omit<Program, "body"> {
-    body: Array<Directive | Statement | ModuleDeclaration | TSModuleDeclaration>;
-  }
-  interface TSUnionType {
-    type: "TSUnionType";
-    types: Array<TSNullKeyword | TSTypeReference | TSImportType>;
-  }
-  interface TSImportType {
-    type: "TSImportType";
-    argument: Literal;
-    qualifier: Identifier;
-  }
-  interface TSIndexedAccessType {
-    type: "TSIndexedAccessType";
-    objectType: TSImportType;
-    indexType: TSLiteralType;
-  }
-  interface TSLiteralType {
-    type: "TSLiteralType";
-    literal: Literal;
-  }
-  interface TSSatisfiesExpression extends BaseNode {
-    type: "TSSatisfiesExpression";
-    expression: Expression;
-    typeAnnotation: TSTypeAnnotation["typeAnnotation"];
-  }
-  interface BaseNodeWithoutComments {
-    type: string;
-    loc?: SourceLocation | null | undefined;
-    range?: [number, number] | undefined;
-    start?: number;
-    end?: number;
-  }
-  interface Identifier {
-    typeAnnotation?: TSTypeAnnotation;
-  }
-  interface ExpressionMap {
-    TSAsExpression: TSAsExpression;
-    TSSatisfiesExpression: TSSatisfiesExpression;
-  }
-  interface NodeMap {
-    TSModuleDeclaration: TSModuleDeclaration;
-    TSInterfaceDeclaration: TSInterfaceDeclaration;
-  }
-  interface ImportDeclaration {
-    importKind: "type" | "value";
-  }
-}
-//#endregion
-//#region lib/core/tooling/index.d.ts
-declare function parseYaml$1(content: string): ReturnType<typeof yaml.parseDocument>;
-type CommentType = {
-  type: "Line" | "Block";
-  value: string;
-};
-declare class Comments {
-  private original;
-  private leading;
-  private trailing;
-  constructor();
-  add(node: BaseNode$1, comment: CommentType, options?: {
-    position?: "leading" | "trailing";
-  }): void;
-  remove(predicate: (comment: estree.Comment) => boolean | undefined | null): void;
-}
-//#endregion
-//#region lib/core/tooling/parsers.d.ts
-type ParseBase = {
-  source: string;
-  /**
-  * Generate the code after manipulating the `ast`.
-  *
-  * ```ts
-  * import { svelte } from 'sv/core';
-  * const { ast, generateCode } = parse.svelte(content);
-  *
-  * svelte.addFragment(ast, '<p>Hello World</p>');
-  *
-  * const code = generateCode();
-  * ```
-  */
-  generateCode(): string;
-};
-declare function parseScript(source: string): {
-  ast: estree.Program;
-  comments: Comments;
-} & ParseBase;
-declare function parseCss(source: string): {
-  ast: Omit<SvelteAst.CSS.StyleSheetBase, "attributes" | "content">;
-} & ParseBase;
-declare function parseHtml(source: string): {
-  ast: SvelteAst.Fragment;
-} & ParseBase;
-declare function parseJson(source: string): {
-  data: any;
-} & ParseBase;
-declare function parseYaml(source: string): {
-  data: ReturnType<typeof parseYaml$1>;
-} & ParseBase;
-declare function parseSvelte(source: string): {
-  ast: SvelteAst.Root;
-} & ParseBase;
-declare function parseToml(source: string): {
-  data: TomlTable;
-} & ParseBase;
-//#endregion
-//#region lib/addons/_engine/official.d.ts
-type OfficialAddons = {
-  prettier: Addon<any>;
-  eslint: Addon<any>;
-  vitest: Addon<any>;
-  playwright: Addon<any>;
-  tailwindcss: Addon<any>;
-  sveltekitAdapter: Addon<any>;
-  devtoolsJson: Addon<any>;
-  drizzle: Addon<any>;
-  betterAuth: Addon<any>;
-  mdsvex: Addon<any>;
-  paraglide: Addon<any>;
-  storybook: Addon<any>;
-  mcp: Addon<any>;
-};
-declare const officialAddons: OfficialAddons;
-//#endregion
-//#region lib/core/addon/options.d.ts
-type BooleanQuestion = {
-  type: "boolean";
-  default: boolean;
-};
-type StringQuestion = {
-  type: "string";
-  default: string;
-  validate?: (value: string | undefined) => string | Error | undefined;
-  placeholder?: string;
-};
-type NumberQuestion = {
-  type: "number";
-  default: number;
-  validate?: (value: string | undefined) => string | Error | undefined;
-  placeholder?: string;
-};
-type SelectQuestion<Value$1> = {
-  type: "select";
-  default: NoInfer<Value$1>;
-  options: Array<{
-    value: Value$1;
-    label?: string;
-    hint?: string;
-  }>;
-};
-type MultiSelectQuestion<Value$1> = {
-  type: "multiselect";
-  default: NoInfer<Value$1[]>;
-  options: Array<{
-    value: Value$1;
-    label?: string;
-    hint?: string;
-  }>;
-  required: boolean;
-};
-type BaseQuestion<Args extends OptionDefinition> = {
-  question: string;
-  group?: string;
-  /**
-  * When this condition explicitly returns `false`, the question's value will
-  * always be `undefined` and will not fallback to the specified `default` value.
-  */
-  condition?: (options: OptionValues<Args>) => boolean;
-};
-type Question<Args extends OptionDefinition = OptionDefinition> = BaseQuestion<Args> & (BooleanQuestion | StringQuestion | NumberQuestion | SelectQuestion<any> | MultiSelectQuestion<any>);
-type OptionDefinition = Record<string, Question<any>>;
-type OptionValues<Args extends OptionDefinition> = { [K in keyof Args]: Args[K] extends StringQuestion ? string : Args[K] extends BooleanQuestion ? boolean : Args[K] extends NumberQuestion ? number : Args[K] extends SelectQuestion<infer Value> ? Value : Args[K] extends MultiSelectQuestion<infer Value> ? Value[] : "ERROR: The value for this type is invalid. Ensure that the `default` value exists in `options`." };
-//#endregion
-//#region lib/core/addon/workspace.d.ts
-type WorkspaceOptions<Args extends OptionDefinition> = OptionValues<Args>;
-type Workspace = {
-  cwd: string;
-  /**
-  * Returns the dependency version declared in the package.json.
-  * This may differ from the installed version.
-  * Includes both dependencies and devDependencies.
-  * Also checks parent package.json files if called in a monorepo.
-  * @param pkg the package to check for
-  * @returns the dependency version with any leading characters such as ^ or ~ removed
-  */
-  dependencyVersion: (pkg: string) => string | undefined;
-  /** to know if the workspace is using typescript or javascript */
-  language: "ts" | "js";
-  files: {
-    viteConfig: "vite.config.js" | "vite.config.ts";
-    svelteConfig: "svelte.config.js" | "svelte.config.ts";
-    /** `${kit.routesDirectory}/layout.css` or `src/app.css` */
-    stylesheet: `${string}/layout.css` | "src/app.css";
-    package: "package.json";
-    gitignore: ".gitignore";
-    prettierignore: ".prettierignore";
-    prettierrc: ".prettierrc";
-    eslintConfig: "eslint.config.js";
-    vscodeSettings: ".vscode/settings.json";
-    /** Get the relative path between two files */
-    getRelative: ({
-      from,
-      to
-    }: {
-      from?: string;
-      to: string;
-    }) => string;
-  };
-  /** If we are in a kit project, this object will contain the lib and routes directories */
-  kit: {
-    libDirectory: string;
-    routesDirectory: string;
-  } | undefined;
-  /** The package manager used to install dependencies */
-  packageManager: PackageManager;
-};
-type PackageManager = "npm" | "yarn" | "pnpm" | "bun" | "deno";
-//#endregion
-//#region lib/core/addon/config.d.ts
-type ConditionDefinition = (Workspace: Workspace) => boolean;
-type PackageDefinition = {
-  name: string;
-  version: string;
-  dev: boolean;
-  condition?: ConditionDefinition;
-};
-type Scripts = {
-  description: string;
-  args: string[];
-  stdio: "inherit" | "pipe";
-  condition?: ConditionDefinition;
-};
-type SvApi = {
-  /** Add a package to the pnpm build dependencies. */
-  pnpmBuildDependency: (pkg: string) => void;
-  /** Add a package to the dependencies. */
-  dependency: (pkg: string, version: string) => void;
-  /** Add a package to the dev dependencies. */
-  devDependency: (pkg: string, version: string) => void;
-  /** Execute a command in the workspace. */
-  execute: (args: string[], stdio: "inherit" | "pipe") => Promise<void>;
-  /** Edit a file in the workspace. (will create it if it doesn't exist) */
-  file: (path: string, edit: (content: string) => string) => void;
-};
-type Addon<Args extends OptionDefinition, Id extends string = string> = {
-  id: Id;
-  alias?: string;
-  shortDescription?: string;
-  homepage?: string;
-  /** If true, this addon won't appear in the interactive prompt but can still be used via CLI */
-  hidden?: boolean;
-  options: Args;
-  /** Setup the addon. Will be called before the addon is run. */
-  setup?: (workspace: Workspace & {
-    /** On what official addons does this addon depend on? */
-    dependsOn: (name: keyof typeof officialAddons) => void;
-    /** Why is this addon not supported?
-    *
-    * @example
-    * if (!kit) unsupported('Requires SvelteKit');
-    */
-    unsupported: (reason: string) => void;
-    /** On what official addons does this addon run after? */
-    runsAfter: (name: keyof typeof officialAddons) => void;
-  }) => MaybePromise<void>;
-  /** Run the addon. The actual execution of the addon... Add files, edit files, etc. */
-  run: (workspace: Workspace & {
-    /** Add-on options */
-    options: WorkspaceOptions<Args>;
-    /** Api to interact with the workspace. */
-    sv: SvApi;
-    /** Cancel the addon at any time!
-    * @example
-    * return cancel('There is a problem with...');
-    */
-    cancel: (reason: string) => void;
-  }) => MaybePromise<void>;
-  /** Next steps to display after the addon is run. */
-  nextSteps?: (data: Workspace & {
-    options: WorkspaceOptions<Args>;
-  }) => string[];
-};
-/**
-* The entry point for your addon, It will hold every thing! (options, setup, run, nextSteps, ...)
-*/
-declare function defineAddon<const Id extends string, Args extends OptionDefinition>(config: Addon<Args, Id>): Addon<Args, Id>;
-/**
-* Stage 1: Raw CLI input - what the user typed
-*/
-type AddonInput = {
-  readonly specifier: string;
-  readonly options: string[];
-};
-/**
-* Stage 2: Classified source - knows where addon comes from
-*/
-type AddonSource = {
-  readonly kind: "official";
-  readonly id: string;
-} | {
-  readonly kind: "file";
-  readonly path: string;
-} | {
-  readonly kind: "npm";
-  readonly packageName: string;
-  readonly npmUrl: string;
-  readonly registryUrl: string;
-  readonly tag: string;
-};
-type AddonReference = {
-  readonly specifier: string;
-  readonly options: string[];
-  readonly source: AddonSource;
-};
-/**
-* Stage 3: Code loaded - addon definition is always present
-*/
-type LoadedAddon = {
-  readonly reference: AddonReference;
-  readonly addon: AddonDefinition;
-};
-/**
-* Stage 4: Setup done - has dependency info
-*/
-type PreparedAddon = LoadedAddon & {
-  readonly setupResult: SetupResult;
-};
-/**
-* Stage 5: User configured - has answers to questions
-*/
-type ConfiguredAddon = PreparedAddon & {
-  readonly answers: OptionValues<any>;
-};
-/**
-* Stage 6: Execution result
-*/
-type AddonResult = {
-  readonly id: string;
-  readonly status: "success" | {
-    canceled: string[];
-  };
-  readonly files: string[];
-};
-/**
-* Generates an inline error hint based on the addon source
-*/
-declare function getErrorHint(source: AddonSource): string;
-type SetupResult = {
-  dependsOn: string[];
-  unsupported: string[];
-  runsAfter: string[];
-};
-type AddonDefinition<Id extends string = string> = Addon<Record<string, Question<any>>, Id>;
-type Tests = {
-  expectProperty: (selector: string, property: string, expectedValue: string) => Promise<void>;
-  elementExists: (selector: string) => Promise<void>;
-  click: (selector: string, path?: string) => Promise<void>;
-  expectUrlPath: (path: string) => void;
-};
-type TestDefinition<Args extends OptionDefinition> = {
-  name: string;
-  run: (tests: Tests) => Promise<void>;
-  condition?: (options: OptionValues<Args>) => boolean;
-};
-type MaybePromise<T> = Promise<T> | T;
-type Verification = {
-  name: string;
-  run: () => MaybePromise<{
-    success: boolean;
-    message: string | undefined;
-  }>;
-};
-type Prettify<T> = { [K in keyof T]: T[K] } & unknown;
-type OptionBuilder<T extends OptionDefinition> = {
-  /**
-  * This type is a bit complex, but in usage, it's quite simple!
-  *
-  * The idea is to `add()` options one by one, with the key and the question.
-  *
-  * ```ts
-  *   .add('demo', {
-  *     question: 'Do you want to add a demo?',
-  *     type: 'boolean',  // string, number, select, multiselect
-  *     default: true,
-  *     // condition: (o) => o.previousOption === 'ok',
-  *   })
-  * ```
-  */
-  add<K$1 extends string, const Q extends Question<T & Record<K$1, Q>>>(key: K$1, question: Q): OptionBuilder<T & Record<K$1, Q>>;
-  /** Finalize all options of your `add-on`. */
-  build(): Prettify<T>;
-};
-/**
-* Options for an addon.
-*
-* Will be prompted to the user if there are not answered by args when calling the cli.
-*
-* ```ts
-* const options = defineAddonOptions()
-*   .add('demo', {
-*     question: `demo? ${color.optional('(a cool one!)')}`
-*     type: string | boolean | number | select | multiselect,
-*     default: true,
-*   })
-*   .build();
-* ```
-*
-* To define by args, you can do
-* ```sh
-* npx sv add <addon>=<option1>:<value1>+<option2>:<value2>
-* ```
-*/
-declare function defineAddonOptions(): OptionBuilder<{}>;
-//#endregion
-//#region lib/cli/add/utils.d.ts
-declare function fileExists(cwd: string, filePath: string): boolean;
-declare const color: {
-  addon: (str: string) => string;
-  command: (str: string) => string;
-  env: (str: string) => string;
-  path: (str: string) => string;
-  route: (str: string) => string;
-  website: (str: string) => string;
-  optional: (str: string) => string;
-  dim: (str: string) => string;
-  success: (str: string) => string;
-  warning: (str: string) => string;
-  error: (str: string) => string;
-};
-//#endregion
-//#region lib/core/common.d.ts
-declare function isVersionUnsupportedBelow(versionStr: string, belowStr: string): boolean | undefined;
-//#endregion
-//#region lib/addons/_engine/common.d.ts
-declare function addToDemoPage(existingContent: string, path: string, language: "ts" | "js"): string;
-/**
-* Returns the corresponding `@types/node` version for the version of Node.js running in the current process.
-*
-* If the installed version of Node.js is from a `Current` release, then the major is decremented to
-* the nearest `LTS` release version.
-*/
-declare function getNodeTypesVersion(): string;
-//#endregion
-//#region lib/core/utils.d.ts
-type Printer = (content: string, alt?: string) => string;
-declare function createPrinter(...conditions: boolean[]): Printer[];
-declare namespace index_d_exports$3 {
-  export { addAtRule, addDeclaration, addImports, addRule };
-}
-declare function addRule(node: SvelteAst.CSS.StyleSheetBase, options: {
-  selector: string;
-}): SvelteAst.CSS.Rule;
-declare function addDeclaration(node: SvelteAst.CSS.Rule, options: {
-  property: string;
-  value: string;
-}): void;
-declare function addImports(node: SvelteAst.CSS.StyleSheetBase, options: {
-  imports: string[];
-}): void;
-declare function addAtRule(node: SvelteAst.CSS.StyleSheetBase, options: {
-  name: string;
-  params: string;
-  append: boolean;
-}): SvelteAst.CSS.Atrule;
-declare namespace array_d_exports {
-  export { append, create$1 as create, prepend };
-}
-declare function create$1(): estree.ArrayExpression;
-declare function append(node: estree.ArrayExpression, element: string | estree.Expression | estree.SpreadElement): void;
-declare function prepend(node: estree.ArrayExpression, element: string | estree.Expression | estree.SpreadElement): void;
-declare namespace object_d_exports {
-  export { create, overrideProperties, property, propertyNode };
-}
-type ObjectPrimitiveValues = string | number | boolean | undefined | null;
-type ObjectValues = ObjectPrimitiveValues | Record<string, any> | ObjectValues[];
-type ObjectMap = Record<string, ObjectValues | estree.Expression>;
-declare function property<T extends estree.Expression | estree.Identifier>(node: estree.ObjectExpression, options: {
-  name: string;
-  fallback: T;
-}): T;
-declare function propertyNode<T extends estree.Expression | estree.Identifier>(node: estree.ObjectExpression, options: {
-  name: string;
-  fallback: T;
-}): estree.Property;
-declare function create(properties: ObjectMap): estree.ObjectExpression;
-declare function overrideProperties(objectExpression: estree.ObjectExpression, properties: ObjectMap): void;
-declare namespace common_d_exports {
-  export { addJsDocComment, addJsDocTypeComment, appendFromString, appendStatement, areNodesEqual, contains, createBlockStatement, createExpressionStatement, createLiteral, createSatisfies, createSpread, createTypeProperty, hasTypeProperty, parseExpression, parseFromString, parseStatement, typeAnnotate };
-}
-declare function addJsDocTypeComment(node: estree.Node, comments: Comments, options: {
-  type: string;
-}): void;
-declare function addJsDocComment(node: estree.Node, comments: Comments, options: {
-  params: Record<string, string>;
-}): void;
-declare function typeAnnotate(node: estree.Expression, options: {
-  type: string;
-}): estree.TSAsExpression;
-declare function createSatisfies(node: estree.Expression, options: {
-  type: string;
-}): estree.TSSatisfiesExpression;
-declare function createSpread(argument: estree.Expression): estree.SpreadElement;
-declare function createLiteral(value: string | number | boolean | null): estree.Literal;
-declare function areNodesEqual(node: estree.Node, otherNode: estree.Node): boolean;
-declare function createBlockStatement(): estree.BlockStatement;
-declare function createExpressionStatement(options: {
-  expression: estree.Expression;
-}): estree.ExpressionStatement;
-declare function appendFromString(node: estree.BlockStatement | estree.Program, options: {
-  code: string;
-  comments?: Comments;
-}): void;
-declare function parseExpression(code: string): estree.Expression;
-declare function parseStatement(code: string): estree.Statement;
-declare function parseFromString<T extends estree.Node>(code: string): T;
-/** Appends the statement to body of the block if it doesn't already exist */
-declare function appendStatement(node: estree.BlockStatement | estree.Program, options: {
-  statement: estree.Statement;
-}): void;
-/** Returns `true` if the provided node exists in the AST */
-declare function contains(node: estree.Node, targetNode: estree.Node): boolean;
-declare function hasTypeProperty(node: estree.TSInterfaceDeclaration["body"]["body"][number], options: {
-  name: string;
-}): boolean;
-declare function createTypeProperty(name: string, value: string, optional?: boolean): estree.TSInterfaceBody["body"][number];
-declare namespace function_d_exports {
-  export { createArrow, createCall, getArgument };
-}
-declare function createCall(options: {
-  name: string;
-  args: string[];
-  useIdentifiers?: boolean;
-}): estree.CallExpression;
-declare function createArrow(options: {
-  body: estree.Expression | estree.BlockStatement;
-  async: boolean;
-}): estree.ArrowFunctionExpression;
-declare function getArgument<T extends estree.Expression>(node: estree.CallExpression, options: {
-  index: number;
-  fallback: T;
-}): T;
-declare namespace imports_d_exports {
-  export { addDefault, addEmpty, addNamed, addNamespace$1 as addNamespace, find, remove };
-}
-declare function addEmpty(node: estree.Program, options: {
-  from: string;
-}): void;
-declare function addNamespace$1(node: estree.Program, options: {
-  from: string;
-  as: string;
-}): void;
-declare function addDefault(node: estree.Program, options: {
-  from: string;
-  as: string;
-}): void;
-declare function addNamed(node: estree.Program, options: {
-  /**
-  * ```ts
-  * imports: { 'name': 'alias' } | ['name']
-  * ```
-  */
-  imports: Record<string, string> | string[];
-  from: string;
-  isType?: boolean;
-}): void;
-declare function find(ast: estree.Program, options: {
-  name: string;
-  from: string;
-}): {
-  statement: estree.ImportDeclaration;
-  alias: string;
-} | {
-  statement: undefined;
-  alias: undefined;
-};
-declare function remove(ast: estree.Program, options: {
-  name: string;
-  from: string;
-  statement?: estree.ImportDeclaration;
-}): void;
-declare namespace variables_d_exports {
-  export { createIdentifier, declaration, typeAnnotateDeclarator };
-}
-declare function declaration(node: estree.Program | estree.Declaration, options: {
-  kind: "const" | "let" | "var";
-  name: string;
-  value: estree.Expression;
-}): estree.VariableDeclaration;
-declare function createIdentifier(name: string): estree.Identifier;
-declare function typeAnnotateDeclarator(node: estree.VariableDeclarator, options: {
-  typeName: string;
-}): estree.VariableDeclarator;
-declare namespace exports_d_exports {
-  export { ExportDefaultResult, addNamespace, createDefault, createNamed };
-}
-type ExportDefaultResult<T> = {
-  astNode: estree.ExportDefaultDeclaration;
-  value: T;
-  isFallback: boolean;
-};
-declare function createDefault<T extends estree.Expression>(node: estree.Program, options: {
-  fallback: T;
-}): ExportDefaultResult<T>;
-declare function createNamed(node: estree.Program, options: {
-  name: string;
-  fallback: estree.VariableDeclaration;
-}): estree.ExportNamedDeclaration;
-declare function addNamespace(node: estree.Program, options: {
-  from: string;
-  as?: string;
-}): void;
-declare namespace kit_d_exports {
-  export { addGlobalAppInterface, addHooksHandle };
-}
-declare function addGlobalAppInterface(node: estree.TSProgram, options: {
-  name: "Error" | "Locals" | "PageData" | "PageState" | "Platform";
-}): estree.TSInterfaceDeclaration;
-declare function addHooksHandle(node: estree.Program, options: {
-  language: "ts" | "js";
-  newHandleName: string;
-  handleContent: string;
-  comments: Comments;
-}): void;
-declare namespace vite_d_exports {
-  export { addPlugin, getConfig };
-}
-declare const addPlugin: (ast: estree.Program, options: {
-  code: string;
-  /** default: `append` */
-  mode?: "append" | "prepend";
-}) => void;
-declare const getConfig: (ast: estree.Program) => estree.ObjectExpression;
-declare namespace index_d_exports$2 {
-  export { estree as AstTypes, Comments, array_d_exports as array, common_d_exports as common, exports_d_exports as exports, function_d_exports as functions, imports_d_exports as imports, kit_d_exports as kit, object_d_exports as object, variables_d_exports as variables, vite_d_exports as vite };
-}
-declare namespace index_d_exports$1 {
-  export { addAttribute, addFromRawHtml, appendElement, createElement, insertElement };
-}
-declare function createElement(tagName: string, attributes?: Record<string, string>): SvelteAst.RegularElement;
-declare function addAttribute(element: SvelteAst.RegularElement, name: string, value: string): void;
-declare function insertElement(fragment: SvelteAst.Fragment, elementToInsert: SvelteAst.Fragment["nodes"][0]): void;
-declare function appendElement(fragment: SvelteAst.Fragment, elementToAppend: SvelteAst.Fragment["nodes"][0]): void;
-declare function addFromRawHtml(fragment: SvelteAst.Fragment, html: string): void;
-declare namespace text_d_exports {
-  export { upsert };
-}
-type CommentEntry = {
-  text: string;
-  mode: "append" | "prepend";
-};
-type CommentOption = string | Array<string | CommentEntry>;
-/**
-* Upsert a line into flat file content (.env, .gitignore, etc.)
-* - key + value → "KEY=value" (skips if KEY= already present)
-* - key only → "key" line (skips if already present, e.g. gitignore entry)
-* - comment → string, string[], or { text, mode }[] for prepend/append comments
-* - separator → adds a blank line before this entry (for visual grouping)
-*/
-declare function upsert(content: string, key: string, options?: {
-  value?: string;
-  comment?: CommentOption;
-  separator?: boolean;
-}): string;
-declare namespace json_d_exports {
-  export { arrayUpsert, packageScriptsUpsert };
-}
-declare function arrayUpsert(data: any, key: string, value: any, options?: {
-  /** default: `append` */
-  mode?: "append" | "prepend";
-}): void;
-declare function packageScriptsUpsert(data: any, key: string, value: string, options?: {
-  mode?: "append" | "prepend";
-}): void;
-declare namespace index_d_exports {
-  export { addFragment, addSlot, ensureScript };
-}
-type RootWithInstance = SvelteAst.Root & {
-  instance: SvelteAst.Script;
-};
-declare function ensureScript(ast: SvelteAst.Root, options?: {
-  language?: "ts" | "js";
-}): asserts ast is RootWithInstance;
-declare function addSlot(ast: SvelteAst.Root, options: {
-  svelteVersion: string;
-  language?: "ts" | "js";
-}): void;
-declare function addFragment(ast: SvelteAst.Root, content: string, options?: {
-  mode?: "append" | "prepend";
-}): void;
-//#endregion
-//#region lib/core/addon/processors.d.ts
-type FileEditor = Workspace & {
-  content: string;
-};
-type FileType = {
-  name: (options: Workspace) => string;
-  condition?: ConditionDefinition;
-  content: (editor: FileEditor) => string;
-};
-//#endregion
-//#region lib/core.d.ts
-/**
-* Will help you `parse` code into an `ast` from all supported languages.
-* Then manipulate the `ast` as you want,
-* and finally `generateCode()` to write it back to the file.
-*
-* ```ts
-* import { parse } from 'sv/core';
-*
-* const { ast, generateCode } = parse.css('body { color: red; }');
-* const { ast, generateCode } = parse.html('<div>Hello, world!</div>');
-* const { ast, generateCode } = parse.json('{ "name": "John", "age": 30 }');
-* const { ast, generateCode } = parse.script('function add(a, b) { return a + b; }');
-* const { ast, generateCode } = parse.svelte('<div>Hello, world!</div>');
-* const { ast, generateCode } = parse.toml('name = "John"');
-* const { ast, generateCode } = parse.yaml('name: John');
-* ```
-*/
-declare const parse: {
-  css: typeof parseCss;
-  html: typeof parseHtml;
-  json: typeof parseJson;
-  script: typeof parseScript;
-  svelte: typeof parseSvelte;
-  toml: typeof parseToml;
-  yaml: typeof parseYaml;
-};
-//#endregion
-export { officialAddons as $, PackageDefinition as A, getErrorHint as B, AddonReference as C, ConfiguredAddon as D, ConditionDefinition as E, TestDefinition as F, BooleanQuestion as G, Workspace as H, Tests as I, OptionDefinition as J, MultiSelectQuestion as K, Verification as L, Scripts as M, SetupResult as N, LoadedAddon as O, SvApi as P, StringQuestion as Q, defineAddon as R, AddonInput as S, AddonSource as T, WorkspaceOptions as U, PackageManager as V, BaseQuestion as W, Question as X, OptionValues as Y, SelectQuestion as Z, isVersionUnsupportedBelow as _, resolveCommand as a, Addon as b, index_d_exports as c, index_d_exports$1 as d, Comments as et, index_d_exports$2 as f, getNodeTypesVersion as g, addToDemoPage as h, parse as i, PreparedAddon as j, OptionBuilder as k, json_d_exports as l, createPrinter as m, dedent as n, estree as nt, FileEditor as o, index_d_exports$3 as p, NumberQuestion as q, log as r, FileType as s, Walker as t, SvelteAst as tt, text_d_exports as u, color as v, AddonResult as w, AddonDefinition as x, fileExists as y, defineAddonOptions as z };