svelte/compiler

const VERSION: string;

function compile(
	source: string,
	options: CompileOptions
): CompileResult;

function compileModule(
	source: string,
	options: ModuleCompileOptions
): CompileResult;

function migrate(
	source: string,
	{
		filename,
		use_ts
	}?:
		| {
				filename?: string;
				use_ts?: boolean;
		  }
		| undefined
): {
	code: string;
};

function parse(
	source: string,
	options: {
		filename?: string;
		modern: true;
		loose?: boolean;
	}
): AST.Root;

function parse(
	source: string,
	options?:
		| {
				filename?: string;
				modern?: false;
				loose?: boolean;
		  }
		| undefined
): Record<string, any>;

function preprocess(
	source: string,
	preprocessor: PreprocessorGroup | PreprocessorGroup[],
	options?:
		| {
				filename?: string;
		  }
		| undefined
): Promise<Processed>;

function walk(): never;

namespace AST {
	export interface BaseNode {
		type: string;
		start: number;
		end: number;
	}

	export interface Fragment {
		type: 'Fragment';
		nodes: Array<
			Text | Tag | ElementLike | Block | Comment
		>;
	}

	export interface Root extends BaseNode {
		type: 'Root';
		/**
		 * Les options inline fournies par `<svelte:options>` — celles-ci écrasent celles passées à `compile(...)`
		 */
		options: SvelteOptions | null;
		fragment: Fragment;
		/** L'élément `<style>` parsé, s'il existe */
		css: AST.CSS.StyleSheet | null;
		/** L'élément `<script>` parsé, s'il existe */
		instance: Script | null;
		/** L'élément `<script module>` parsé, s'il existe */
		module: Script | null;
	}

	export interface SvelteOptions {
		// des infos start/end (nécéssaires pour les warnings et pour notre plugin Prettier)
		start: number;
		end: number;
		// options
		runes?: boolean;
		immutable?: boolean;
		accessors?: boolean;
		preserveWhitespace?: boolean;
		namespace?: Namespace;
		css?: 'injected';
		customElement?: {
			tag?: string;
			shadow?: 'open' | 'none';
			props?: Record<
				string,
				{
					attribute?: string;
					reflect?: boolean;
					type?:
						| 'Array'
						| 'Boolean'
						| 'Number'
						| 'Object'
						| 'String';
				}
			>;
			/**
			 * Est de type
			 * ```ts
			 * (ceClass: new () => HTMLElement) => new () => HTMLElement
			 * ```
			 */
			extend?: ArrowFunctionExpression | Identifier;
		};
		attributes: Attribute[];
	}

	/** Texte statique */
	export interface Text extends BaseNode {
		type: 'Text';
		/** Du texte avec les entités HTML décodées */
		data: string;
	  /** Le texte original, avec les entités HTML non décodées */
		raw: string;
	}

	/** Une expression de template (possiblement réactive) — `{...}` */
	export interface ExpressionTag extends BaseNode {
		type: 'ExpressionTag';
		expression: Expression;
	}

	/** Une expression de template HTML (possiblement réactive) — `{@html...}` */
	export interface HtmlTag extends BaseNode {
		type: 'HtmlTag';
		expression: Expression;
	}

	/** Un commentaire HTML */
	// TODO rename to disambiguate
	export interface Comment extends BaseNode {
		type: 'Comment';
	  /** le contenu du commentaire */
		data: string;
	}

	/** Une balise `{@const ...}` */
	export interface ConstTag extends BaseNode {
		type: 'ConstTag';
		declaration: VariableDeclaration & {
			declarations: [
				VariableDeclarator & {
					id: Pattern;
					init: Expression;
				}
			];
		};
	}

	/** Une balise `{@debug ...}` */
	export interface DebugTag extends BaseNode {
		type: 'DebugTag';
		identifiers: Identifier[];
	}

	/** Une balise `{@render foo(...)} */
	export interface RenderTag extends BaseNode {
		type: 'RenderTag';
		expression:
			| SimpleCallExpression
			| (ChainExpression & {
					expression: SimpleCallExpression;
			  });
	}

	/** Une directive `animate:` */
	export interface AnimateDirective extends BaseNode {
		type: 'AnimateDirective';
		/** Le 'x' de `animate:x` */
		name: string;
		/** Le 'y' de `animate:x={y}` */
		expression: null | Expression;
	}

	/** Une directive `bind:` */
	export interface BindDirective extends BaseNode {
		type: 'BindDirective';
		/** Le 'x' de `bind:x` */
		name: string;
		/** Le 'y' in `bind:x={y}` */
		expression:
			| Identifier
			| MemberExpression
			| SequenceExpression;
	}

	/** Une directive `class:` */
	export interface ClassDirective extends BaseNode {
		type: 'ClassDirective';
		/** Le 'x' de `class:x` */
		name: 'class';
		/** Le 'y' de `class:x={y}`, ou le `x` de `class:x` */
		expression: Expression;
	}

	/** Une directive `let:` */
	export interface LetDirective extends BaseNode {
		type: 'LetDirective';
		/** Le 'x' de `let:x` */
		name: string;
		/** Le 'y' de `let:x={y}` */
		expression:
			| null
			| Identifier
			| ArrayExpression
			| ObjectExpression;
	}

	/** Une directive `on:` */
	export interface OnDirective extends BaseNode {
		type: 'OnDirective';
		/** Le 'x' de `on:x` */
		name: string;
		/** Le 'y' de `on:x={y}` */
		expression: null | Expression;
		modifiers: string[];
	}

	/** Une directive `style:` */
	export interface StyleDirective extends BaseNode {
		type: 'StyleDirective';
		/** Le 'x' de `style:x` */
		name: string;
		/** Le 'y' de `style:x={y}` */
		value:
			| true
			| ExpressionTag
			| Array<ExpressionTag | Text>;
		modifiers: Array<'important'>;
	}

	// TODO have separate in/out/transition directives
	/** Une directive `transition:`, `in:` ou `out:` */
	export interface TransitionDirective extends BaseNode {
		type: 'TransitionDirective';
		/** Le 'x' de `transition:x` */
		name: string;
		/** Le 'y' de `transition:x={y}` */
		expression: null | Expression;
		modifiers: Array<'local' | 'global'>;
		/** `true` si ceci est une directive `transition:` ou `in:` */
		intro: boolean;
		/** `true` si ceci est une directive `transition:` ou `out:` */
		outro: boolean;
	}

	/** Une directive `use:` */
	export interface UseDirective extends BaseNode {
		type: 'UseDirective';
		/** Le 'x' de `use:x` */
		name: string;
		/** Le 'y' de `use:x={y}` */
		expression: null | Expression;
	}

	interface BaseElement extends BaseNode {
		name: string;
		attributes: Array<
			Attribute | SpreadAttribute | Directive
		>;
		fragment: Fragment;
	}

	export interface Component extends BaseElement {
		type: 'Component';
	}

	export interface TitleElement extends BaseElement {
		type: 'TitleElement';
		name: 'title';
	}

	export interface SlotElement extends BaseElement {
		type: 'SlotElement';
		name: 'slot';
	}

	export interface RegularElement extends BaseElement {
		type: 'RegularElement';
	}

	export interface SvelteBody extends BaseElement {
		type: 'SvelteBody';
		name: 'svelte:body';
	}

	export interface SvelteComponent extends BaseElement {
		type: 'SvelteComponent';
		name: 'svelte:component';
		expression: Expression;
	}

	export interface SvelteDocument extends BaseElement {
		type: 'SvelteDocument';
		name: 'svelte:document';
	}

	export interface SvelteElement extends BaseElement {
		type: 'SvelteElement';
		name: 'svelte:element';
		tag: Expression;
	}

	export interface SvelteFragment extends BaseElement {
		type: 'SvelteFragment';
		name: 'svelte:fragment';
	}

	export interface SvelteBoundary extends BaseElement {
		type: 'SvelteBoundary';
		name: 'svelte:boundary';
	}

	export interface SvelteHead extends BaseElement {
		type: 'SvelteHead';
		name: 'svelte:head';
	}

	/** Ceci n'est qu'une représentation intermédiaire lors du parsing, elle n'existe pas dans l'AST final */
	export interface SvelteOptionsRaw extends BaseElement {
		type: 'SvelteOptions';
		name: 'svelte:options';
	}

	export interface SvelteSelf extends BaseElement {
		type: 'SvelteSelf';
		name: 'svelte:self';
	}

	export interface SvelteWindow extends BaseElement {
		type: 'SvelteWindow';
		name: 'svelte:window';
	}

	/** Un bloc `{#each ...}` */
	export interface EachBlock extends BaseNode {
		type: 'EachBlock';
		expression: Expression;
		/** Le `entry` dans `{#each item as entry}`. `null` si `as` n'est pas fourni */
		context: Pattern | null;
		body: Fragment;
		fallback?: Fragment;
		index?: string;
		key?: Expression;
	}

	/** Un `{#if ...}` */
	export interface IfBlock extends BaseNode {
		type: 'IfBlock';
		elseif: boolean;
		test: Expression;
		consequent: Fragment;
		alternate: Fragment | null;
	}

	/** Un bloc `{#await ...}` */
	export interface AwaitBlock extends BaseNode {
		type: 'AwaitBlock';
		expression: Expression;
		// TODO can/should we move these inside the ThenBlock and CatchBlock?
	  /** La valeur résolue dans le bloc `then` */
		value: Pattern | null;
		/** La raison du rejet dans le bloc `catch` */
		error: Pattern | null;
		pending: Fragment | null;
		then: Fragment | null;
		catch: Fragment | null;
	}

	export interface KeyBlock extends BaseNode {
		type: 'KeyBlock';
		expression: Expression;
		fragment: Fragment;
	}

	export interface SnippetBlock extends BaseNode {
		type: 'SnippetBlock';
		expression: Identifier;
		parameters: Pattern[];
		body: Fragment;
	}

	export interface Attribute extends BaseNode {
		type: 'Attribute';
		name: string;
		/**
	   * Les valeurs entre guillemets sont représentées par un tableau, même si elles ne contiennent pas d'expression comme `"{x}"`
		 */
		value:
			| true
			| ExpressionTag
			| Array<Text | ExpressionTag>;
	}

	export interface SpreadAttribute extends BaseNode {
		type: 'SpreadAttribute';
		expression: Expression;
	}

	export interface Script extends BaseNode {
		type: 'Script';
		context: 'default' | 'module';
		content: Program;
		attributes: Attribute[];
	}

	export type AttributeLike =
		| Attribute
		| SpreadAttribute
		| Directive;

	export type Directive =
		| AST.AnimateDirective
		| AST.BindDirective
		| AST.ClassDirective
		| AST.LetDirective
		| AST.OnDirective
		| AST.StyleDirective
		| AST.TransitionDirective
		| AST.UseDirective;

	export type Block =
		| AST.EachBlock
		| AST.IfBlock
		| AST.AwaitBlock
		| AST.KeyBlock
		| AST.SnippetBlock;

	export type ElementLike =
		| AST.Component
		| AST.TitleElement
		| AST.SlotElement
		| AST.RegularElement
		| AST.SvelteBody
		| AST.SvelteBoundary
		| AST.SvelteComponent
		| AST.SvelteDocument
		| AST.SvelteElement
		| AST.SvelteFragment
		| AST.SvelteHead
		| AST.SvelteOptionsRaw
		| AST.SvelteSelf
		| AST.SvelteWindow
		| AST.SvelteBoundary;

	export type Tag =
		| AST.ExpressionTag
		| AST.HtmlTag
		| AST.ConstTag
		| AST.DebugTag
		| AST.RenderTag;

	export type TemplateNode =
		| AST.Root
		| AST.Text
		| Tag
		| ElementLike
		| AST.Attribute
		| AST.SpreadAttribute
		| Directive
		| AST.Comment
		| Block;

	export type SvelteNode =
		| Node
		| TemplateNode
		| AST.Fragment
		| _CSS.Node;

	export type { _CSS as CSS };
}

interface CompileError extends ICompileDiagnostic {}

interface CompileOptions extends ModuleCompileOptions {…}

interface CompileResult {…}

type MarkupPreprocessor = (options: {
	/**
	 * Le contenu complet du fichier Svelte
	 */
	content: string;
	/**
	 * Le nom du fichier Svelte
	 */
	filename?: string;
}) => Processed | void | Promise<Processed | void>;

interface ModuleCompileOptions {…}

type Preprocessor = (options: {
	/**
	 * Le contenu de la balise de script ou de style
	 */
	content: string;
	/**
	 * Les attributs de la balise de script ou de style
	 */
	attributes: Record<string, string | boolean>;
	/**
	 * Le contenu complet du fichier Svelte
	 */
	markup: string;
	/**
	 * Le nom du fichier Svelte
	 */
	filename?: string;
}) => Processed | void | Promise<Processed | void>;

interface PreprocessorGroup {…}

interface Processed {…}

interface Warning extends ICompileDiagnostic {}