;
+}
+
+export {};
+
+// @filename: index.ts
+// ---cut---
+import { get } from 'svelte/store';
+
+const value = get(store);
+```
+
+## Types
+
+
+
+### Readable
+
+
+
+Readable interface for subscribing.
+
+
+
+```dts
+interface Readable
{/*…*/}
+```
+
+
+
+```dts
+subscribe(this: void, run: Subscriber
, invalidate?: Invalidator): Unsubscriber;
+```
+
+
+
+
+
+- `run` subscription callback
+- `invalidate` cleanup callback
+
+
+
+Subscribe on value changes.
+
+
+
+```dts
+type StartStopNotifier = (
+ set: (value: T) => void,
+ update: (fn: Updater) => void
+) => void | (() => void);
+```
+
+
+
+### Subscriber
+
+
+
+Callback to inform of a value updates.
+
+
+
+```dts
+type Subscriber = (value: T) => void;
+```
+
+
+
+### Unsubscriber
+
+
+
+Unsubscribes from value updates.
+
+
+
+```dts
+type Unsubscriber = () => void;
+```
+
+
+
+### Updater
+
+
+
+Callback to update a value.
+
+
+
+```dts
+type Updater = (value: T) => T;
+```
+
+
+
+### Writable
+
+
+
+Writable interface for both updating and subscribing.
+
+
+
+```dts
+interface Writable
extends Readable {/*…*/}
+```
+
+
+
+```dts
+set(this: void, value: T): void;
+```
+
+
+
+
+
+- `value` to set
+
+
+
+Set value and inform subscribers.
+
+
+
+
+```dts
+update(this: void, updater: Updater
): void;
+```
+
+
+
+
+
+- `updater` callback
+
+
+
+Update value using callback and inform subscribers.
+
+
+
+```dts
+function tweened(
+ value?: T | undefined,
+ defaults?: TweenedOptions | undefined
+): Tweened;
+```
+
+
+
+Tweened stores update their values over a fixed duration. The following options are available:
+
+- `delay` (`number`, default 0) — milliseconds before starting
+- `duration` (`number` | `function`, default 400) — milliseconds the tween lasts
+- `easing` (`function`, default `t => t`) — an [easing function](/docs/svelte-easing)
+- `interpolate` (`function`) — see below
+
+`store.set` and `store.update` can accept a second `options` argument that will override the options passed in upon instantiation.
+
+Both functions return a Promise that resolves when the tween completes. If the tween is interrupted, the promise will never resolve.
+
+Out of the box, Svelte will interpolate between two numbers, two arrays or two objects (as long as the arrays and objects are the same 'shape', and their 'leaf' properties are also numbers).
+
+```svelte
+
+
+
+ embiggen
+
+```
+
+If the initial value is `undefined` or `null`, the first value change will take effect immediately. This is useful when you have tweened values that are based on props, and don't want any motion when the component first renders.
+
+```ts
+// @filename: ambient.d.ts
+declare global {
+ var $size: number;
+ var big: number;
+}
+
+export {};
+// @filename: motion.ts
+// ---cut---
+import { tweened } from 'svelte/motion';
+import { cubicOut } from 'svelte/easing';
+
+const size = tweened(undefined, {
+ duration: 300,
+ easing: cubicOut
+});
+
+$: $size = big ? 100 : 10;
+```
+
+The `interpolate` option allows you to tween between _any_ arbitrary values. It must be an `(a, b) => t => value` function, where `a` is the starting value, `b` is the target value, `t` is a number between 0 and 1, and `value` is the result. For example, we can use the [d3-interpolate](https://github.com/d3/d3-interpolate) package to smoothly interpolate between two colours.
+
+```svelte
+
+
+{#each colors as c}
+ color.set(c)}>
+ {c}
+
+{/each}
+
+{$color}
+```
+
+## `spring`
+
+
+
+```dts
+function spring(
+ value?: T | undefined,
+ opts?: SpringOpts | undefined
+): Spring;
+```
+
+
+
+A `spring` store gradually changes to its target value based on its `stiffness` and `damping` parameters. Whereas `tweened` stores change their values over a fixed duration, `spring` stores change over a duration that is determined by their existing velocity, allowing for more natural-seeming motion in many situations. The following options are available:
+
+- `stiffness` (`number`, default `0.15`) — a value between 0 and 1 where higher means a 'tighter' spring
+- `damping` (`number`, default `0.8`) — a value between 0 and 1 where lower means a 'springier' spring
+- `precision` (`number`, default `0.01`) — determines the threshold at which the spring is considered to have 'settled', where lower means more precise
+
+All of the options above can be changed while the spring is in motion, and will take immediate effect.
+
+```js
+import { spring } from 'svelte/motion';
+
+const size = spring(100);
+size.stiffness = 0.3;
+size.damping = 0.4;
+size.precision = 0.005;
+```
+
+As with [`tweened`](/docs/svelte-motion#tweened) stores, `set` and `update` return a Promise that resolves if the spring settles.
+
+Both `set` and `update` can take a second argument — an object with `hard` or `soft` properties. `{ hard: true }` sets the target value immediately; `{ soft: n }` preserves existing momentum for `n` seconds before settling. `{ soft: true }` is equivalent to `{ soft: 0.5 }`.
+
+```js
+import { spring } from 'svelte/motion';
+
+const coords = spring({ x: 50, y: 50 });
+// updates the value immediately
+coords.set({ x: 100, y: 200 }, { hard: true });
+// preserves existing momentum for 1s
+coords.update(
+ (target_coords, coords) => {
+ return { x: target_coords.x, y: coords.y };
+ },
+ { soft: 1 }
+);
+```
+
+[See a full example on the spring tutorial.](https://learn.svelte.dev/tutorial/springs)
+
+```svelte
+
+```
+
+If the initial value is `undefined` or `null`, the first value change will take effect immediately, just as with `tweened` values (see above).
+
+```ts
+// @filename: ambient.d.ts
+declare global {
+ var $size: number;
+ var big: number;
+}
+
+export {};
+
+// @filename: motion.ts
+// ---cut---
+import { spring } from 'svelte/motion';
+
+const size = spring();
+$: $size = big ? 100 : 10;
+```
+
+## Types
+
+
+
+### Spring
+
+
+
+
+
+
+
+```dts
+interface Spring
extends Readable {/*…*/}
+```
+
+
+
+```dts
+set: (new_value: T, opts?: SpringUpdateOpts) => Promise
;
+```
+
+
+
+
+```dts
+update: (fn: Updater
, opts?: SpringUpdateOpts) => Promise;
+```
+
+
+
+
+```dts
+precision: number;
+```
+
+
+
+
+```dts
+damping: number;
+```
+
+
+
+
+```dts
+stiffness: number;
+```
+
+
+
+
+```dts
+interface Tweened
extends Readable {/*…*/}
+```
+
+
+
+```dts
+set(value: T, opts?: TweenedOptions
): Promise;
+```
+
+
+
+
+```dts
+update(updater: Updater
, opts?: TweenedOptions): Promise;
+```
+
+
+
+
+```dts
+function fade(
+ node: Element,
+ { delay, duration, easing }?: FadeParams | undefined
+): TransitionConfig;
+```
+
+
+
+```svelte
+
+transition:fade={params}
+```
+
+```svelte
+
+in:fade={params}
+```
+
+```svelte
+
+out:fade={params}
+```
+
+Animates the opacity of an element from 0 to the current opacity for `in` transitions and from the current opacity to 0 for `out` transitions.
+
+`fade` accepts the following parameters:
+
+- `delay` (`number`, default 0) — milliseconds before starting
+- `duration` (`number`, default 400) — milliseconds the transition lasts
+- `easing` (`function`, default `linear`) — an [easing function](/docs/svelte-easing)
+
+You can see the `fade` transition in action in the [transition tutorial](https://learn.svelte.dev/tutorial/transition).
+
+```svelte
+
+
+{#if condition}
+ fades in and out
+{/if}
+```
+
+## `blur`
+
+
+
+```dts
+function blur(
+ node: Element,
+ {
+ delay,
+ duration,
+ easing,
+ amount,
+ opacity
+ }?: BlurParams | undefined
+): TransitionConfig;
+```
+
+
+
+```svelte
+
+transition:blur={params}
+```
+
+```svelte
+
+in:blur={params}
+```
+
+```svelte
+
+out:blur={params}
+```
+
+Animates a `blur` filter alongside an element's opacity.
+
+`blur` accepts the following parameters:
+
+- `delay` (`number`, default 0) — milliseconds before starting
+- `duration` (`number`, default 400) — milliseconds the transition lasts
+- `easing` (`function`, default `cubicInOut`) — an [easing function](/docs/svelte-easing)
+- `opacity` (`number`, default 0) - the opacity value to animate out to and in from
+- `amount` (`number | string`, default 5) - the size of the blur. Supports css units (for example: `"4rem"`). The default unit is `px`
+
+```svelte
+
+
+{#if condition}
+ fades in and out
+{/if}
+```
+
+## `fly`
+
+
+
+```dts
+function fly(
+ node: Element,
+ {
+ delay,
+ duration,
+ easing,
+ x,
+ y,
+ opacity
+ }?: FlyParams | undefined
+): TransitionConfig;
+```
+
+
+
+```svelte
+
+transition:fly={params}
+```
+
+```svelte
+
+in:fly={params}
+```
+
+```svelte
+
+out:fly={params}
+```
+
+Animates the x and y positions and the opacity of an element. `in` transitions animate from the provided values, passed as parameters to the element's default values. `out` transitions animate from the element's default values to the provided values.
+
+`fly` accepts the following parameters:
+
+- `delay` (`number`, default 0) — milliseconds before starting
+- `duration` (`number`, default 400) — milliseconds the transition lasts
+- `easing` (`function`, default `cubicOut`) — an [easing function](/docs/svelte-easing)
+- `x` (`number | string`, default 0) - the x offset to animate out to and in from
+- `y` (`number | string`, default 0) - the y offset to animate out to and in from
+- `opacity` (`number`, default 0) - the opacity value to animate out to and in from
+
+x and y use `px` by default but support css units, for example `x: '100vw'` or `y: '50%'`.
+You can see the `fly` transition in action in the [transition tutorial](https://learn.svelte.dev/tutorial/adding-parameters-to-transitions).
+
+```svelte
+
+
+{#if condition}
+
+ flies in and out
+
+{/if}
+```
+
+## `slide`
+
+
+
+```dts
+function slide(
+ node: Element,
+ {
+ delay,
+ duration,
+ easing,
+ axis
+ }?: SlideParams | undefined
+): TransitionConfig;
+```
+
+
+
+```svelte
+
+transition:slide={params}
+```
+
+```svelte
+
+in:slide={params}
+```
+
+```svelte
+
+out:slide={params}
+```
+
+Slides an element in and out.
+
+`slide` accepts the following parameters:
+
+- `delay` (`number`, default 0) — milliseconds before starting
+- `duration` (`number`, default 400) — milliseconds the transition lasts
+- `easing` (`function`, default `cubicOut`) — an [easing function](/docs/svelte-easing)
+
+* `axis` (`x` | `y`, default `y`) — the axis of motion along which the transition occurs
+
+```svelte
+
+
+{#if condition}
+
+ slides in and out horizontally
+
+{/if}
+```
+
+## `scale`
+
+
+
+```dts
+function scale(
+ node: Element,
+ {
+ delay,
+ duration,
+ easing,
+ start,
+ opacity
+ }?: ScaleParams | undefined
+): TransitionConfig;
+```
+
+
+
+```svelte
+
+transition:scale={params}
+```
+
+```svelte
+
+in:scale={params}
+```
+
+```svelte
+
+out:scale={params}
+```
+
+Animates the opacity and scale of an element. `in` transitions animate from an element's current (default) values to the provided values, passed as parameters. `out` transitions animate from the provided values to an element's default values.
+
+`scale` accepts the following parameters:
+
+- `delay` (`number`, default 0) — milliseconds before starting
+- `duration` (`number`, default 400) — milliseconds the transition lasts
+- `easing` (`function`, default `cubicOut`) — an [easing function](/docs/svelte-easing)
+- `start` (`number`, default 0) - the scale value to animate out to and in from
+- `opacity` (`number`, default 0) - the opacity value to animate out to and in from
+
+```svelte
+
+
+{#if condition}
+
+ scales in and out
+
+{/if}
+```
+
+## `draw`
+
+
+
+```dts
+function draw(
+ node: SVGElement & {
+ getTotalLength(): number;
+ },
+ {
+ delay,
+ speed,
+ duration,
+ easing
+ }?: DrawParams | undefined
+): TransitionConfig;
+```
+
+
+
+```svelte
+
+transition:draw={params}
+```
+
+```svelte
+
+in:draw={params}
+```
+
+```svelte
+
+out:draw={params}
+```
+
+Animates the stroke of an SVG element, like a snake in a tube. `in` transitions begin with the path invisible and draw the path to the screen over time. `out` transitions start in a visible state and gradually erase the path. `draw` only works with elements that have a `getTotalLength` method, like `` and ``.
+
+`draw` accepts the following parameters:
+
+- `delay` (`number`, default 0) — milliseconds before starting
+- `speed` (`number`, default undefined) - the speed of the animation, see below.
+- `duration` (`number` | `function`, default 800) — milliseconds the transition lasts
+- `easing` (`function`, default `cubicInOut`) — an [easing function](/docs/svelte-easing)
+
+The `speed` parameter is a means of setting the duration of the transition relative to the path's length. It is a modifier that is applied to the length of the path: `duration = length / speed`. A path that is 1000 pixels with a speed of 1 will have a duration of `1000ms`, setting the speed to `0.5` will double that duration and setting it to `2` will halve it.
+
+```svelte
+
+
+
+ {#if condition}
+
+```
+
+## `crossfade`
+
+
+
+```dts
+function crossfade({
+ fallback,
+ ...defaults
+}: CrossfadeParams & {
+ fallback?:
+ | ((
+ node: Element,
+ params: CrossfadeParams,
+ intro: boolean
+ ) => TransitionConfig)
+ | undefined;
+}): [
+ (
+ node: any,
+ params: CrossfadeParams & {
+ key: any;
+ }
+ ) => () => TransitionConfig,
+ (
+ node: any,
+ params: CrossfadeParams & {
+ key: any;
+ }
+ ) => () => TransitionConfig
+];
+```
+
+
+
+The `crossfade` function creates a pair of [transitions](/docs/element-directives#transition-fn) called `send` and `receive`. When an element is 'sent', it looks for a corresponding element being 'received', and generates a transition that transforms the element to its counterpart's position and fades it out. When an element is 'received', the reverse happens. If there is no counterpart, the `fallback` transition is used.
+
+`crossfade` accepts the following parameters:
+
+- `delay` (`number`, default 0) — milliseconds before starting
+- `duration` (`number` | `function`, default 800) — milliseconds the transition lasts
+- `easing` (`function`, default `cubicOut`) — an [easing function](/docs/svelte-easing)
+- `fallback` (`function`) — A fallback [transition](/docs/element-directives#transition-fn) to use for send when there is no matching element being received, and for receive when there is no element being sent.
+
+```svelte
+
+
+{#if condition}
+ BIG ELEM
+{:else}
+ small elem
+{/if}
+```
+
+## Types
+
+
+
+### BlurParams
+
+
+
+
+
+
+
+```dts
+interface BlurParams {/*…*/}
+```
+
+
+
+```dts
+delay?: number;
+```
+
+
+
+
+
+
+```dts
+duration?: number;
+```
+
+
+
+
+
+
+```dts
+easing?: EasingFunction;
+```
+
+
+
+
+
+
+```dts
+amount?: number | string;
+```
+
+
+
+
+
+
+```dts
+opacity?: number;
+```
+
+
+
+
+```dts
+interface CrossfadeParams {/*…*/}
+```
+
+
+
+```dts
+delay?: number;
+```
+
+
+
+
+
+
+```dts
+duration?: number | ((len: number) => number);
+```
+
+
+
+
+
+
+```dts
+easing?: EasingFunction;
+```
+
+
+
+
+```dts
+interface DrawParams {/*…*/}
+```
+
+
+
+```dts
+delay?: number;
+```
+
+
+
+
+
+
+```dts
+speed?: number;
+```
+
+
+
+
+
+
+```dts
+duration?: number | ((len: number) => number);
+```
+
+
+
+
+
+
+```dts
+easing?: EasingFunction;
+```
+
+
+
+
+```dts
+type EasingFunction = (t: number) => number;
+```
+
+
+
+### FadeParams
+
+
+
+
+
+
+
+```dts
+interface FadeParams {/*…*/}
+```
+
+
+
+```dts
+delay?: number;
+```
+
+
+
+
+
+
+```dts
+duration?: number;
+```
+
+
+
+
+
+
+```dts
+easing?: EasingFunction;
+```
+
+
+
+
+```dts
+interface FlyParams {/*…*/}
+```
+
+
+
+```dts
+delay?: number;
+```
+
+
+
+
+
+
+```dts
+duration?: number;
+```
+
+
+
+
+
+
+```dts
+easing?: EasingFunction;
+```
+
+
+
+
+
+
+```dts
+x?: number | string;
+```
+
+
+
+
+
+
+```dts
+y?: number | string;
+```
+
+
+
+
+
+
+```dts
+opacity?: number;
+```
+
+
+
+
+```dts
+interface ScaleParams {/*…*/}
+```
+
+
+
+```dts
+delay?: number;
+```
+
+
+
+
+
+
+```dts
+duration?: number;
+```
+
+
+
+
+
+
+```dts
+easing?: EasingFunction;
+```
+
+
+
+
+
+
+```dts
+start?: number;
+```
+
+
+
+
+
+
+```dts
+opacity?: number;
+```
+
+
+
+
+```dts
+interface SlideParams {/*…*/}
+```
+
+
+
+```dts
+delay?: number;
+```
+
+
+
+
+
+
+```dts
+duration?: number;
+```
+
+
+
+
+
+
+```dts
+easing?: EasingFunction;
+```
+
+
+
+
+
+
+```dts
+axis?: 'x' | 'y';
+```
+
+
+
+
+```dts
+interface TransitionConfig {/*…*/}
+```
+
+
+
+```dts
+delay?: number;
+```
+
+
+
+
+
+
+```dts
+duration?: number;
+```
+
+
+
+
+
+
+```dts
+easing?: EasingFunction;
+```
+
+
+
+
+
+
+```dts
+css?: (t: number, u: number) => string;
+```
+
+
+
+
+
+
+```dts
+tick?: (t: number, u: number) => void;
+```
+
+
+
+
+```dts
+function flip(
+ node: Element,
+ {
+ from,
+ to
+ }: {
+ from: DOMRect;
+ to: DOMRect;
+ },
+ params?: FlipParams
+): AnimationConfig;
+```
+
+
+
+```svelte
+
+animate:flip={params}
+```
+
+The `flip` function calculates the start and end position of an element and animates between them, translating the `x` and `y` values. `flip` stands for [First, Last, Invert, Play](https://aerotwist.com/blog/flip-your-animations/).
+
+`flip` accepts the following parameters:
+
+- `delay` (`number`, default 0) — milliseconds before starting
+- `duration` (`number` | `function`, default `d => Math.sqrt(d) * 120`) — see below
+- `easing` (`function`, default `cubicOut`) — an [easing function](/docs/svelte-easing)
+
+`duration` can be provided as either:
+
+- a `number`, in milliseconds.
+- a function, `distance: number => duration: number`, receiving the distance the element will travel in pixels and returning the duration in milliseconds. This allows you to assign a duration that is relative to the distance travelled by each element.
+
+You can see a full example on the [animations tutorial](https://learn.svelte.dev/tutorial/animate).
+
+```svelte
+
+
+{#each list as n (n)}
+
+ {n}
+
+{/each}
+```
+
+## Types
+
+
+
+### AnimationConfig
+
+
+
+
+
+
+
+```dts
+interface AnimationConfig {/*…*/}
+```
+
+
+
+```dts
+delay?: number;
+```
+
+
+
+
+
+
+```dts
+duration?: number;
+```
+
+
+
+
+
+
+```dts
+easing?: (t: number) => number;
+```
+
+
+
+
+
+
+```dts
+css?: (t: number, u: number) => string;
+```
+
+
+
+
+
+
+```dts
+tick?: (t: number, u: number) => void;
+```
+
+
+
+
+```dts
+interface FlipParams {/*…*/}
+```
+
+
+
+```dts
+delay?: number;
+```
+
+
+
+
+
+
+```dts
+duration?: number | ((len: number) => number);
+```
+
+
+
+
+
+
+```dts
+easing?: (t: number) => number;
+```
+
+
+
+```
+
+An action can have a parameter. If the returned value has an `update` method, it will be called immediately after Svelte has applied updates to the markup whenever that parameter changes.
+
+> Don't worry that we're redeclaring the `foo` function for every component instance — Svelte will hoist any functions that don't depend on local state out of the component definition.
+
+```svelte
+
+
+
+
+```
+
+## Attributes
+
+Sometimes actions emit custom events and apply custom attributes to the element they are applied to. To support this, actions typed with `Action` or `ActionReturn` type can have a last parameter, `Attributes`:
+
+```svelte
+
+
+
+
+```
+
+## Types
+
+
+
+### Action
+
+
+
+Actions are functions that are called when an element is created.
+You can use this interface to type such actions.
+The following example defines an action that only works on `` elements
+and optionally accepts a parameter which it has a default value for:
+```ts
+export const myAction: Action
= (node, param = { someProperty: true }) => {
+ // ...
+}
+```
+`Action` and `Action` both signal that the action accepts no parameters.
+
+You can return an object with methods `update` and `destroy` from the function and type which additional attributes and events it has.
+See interface `ActionReturn` for more details.
+
+Docs: https://svelte.dev/docs/svelte-action
+
+
+
+```dts
+interface Action<
+ Element = HTMLElement,
+ Parameter = undefined,
+ Attributes extends Record
= Record<
+ never,
+ any
+ >
+> {/*…*/}
+```
+
+
+
+```dts
+
(
+ ...args: undefined extends Parameter
+ ? [node: Node, parameter?: Parameter]
+ : [node: Node, parameter: Parameter]
+): void | ActionReturn;
+```
+
+
+ ` both
+ mean that the action accepts no parameters.
+- destroy: Method that is called after the element is unmounted
+
+Additionally, you can specify which additional attributes and events the action enables on the applied element.
+This applies to TypeScript typings only and has no effect at runtime.
+
+Example usage:
+```ts
+interface Attributes {
+ newprop?: string;
+ 'on:event': (e: CustomEvent) => void;
+}
+
+export function myAction(node: HTMLElement, parameter: Parameter): ActionReturn {
+ // ...
+ return {
+ update: (updatedParameter) => {...},
+ destroy: () => {...}
+ };
+}
+```
+
+Docs: https://svelte.dev/docs/svelte-action
+
+
+
+```dts
+interface ActionReturn<
+ Parameter = undefined,
+ Attributes extends Record
= Record<
+ never,
+ any
+ >
+> {/*…*/}
+```
+
+
+
+```dts
+update?: (parameter: Parameter) => void;
+```
+
+
+
+
+```dts
+destroy?: () => void;
+```
+
+
+
+
+```dts
+function compile(
+ source: string,
+ options?: CompileOptions
+): CompileResult;
+```
+
+
+
+This is where the magic happens. `svelte.compile` takes your component source code, and turns it into a JavaScript module that exports a class.
+
+```js
+// @filename: ambient.d.ts
+declare global {
+ var source: string
+}
+
+export {}
+
+// @filename: index.ts
+// ---cut---
+import { compile } from 'svelte/compiler';
+
+const result = compile(source, {
+ // options
+});
+```
+
+Refer to [CompileOptions](#types-compileoptions) for all the available options.
+
+The returned `result` object contains the code for your component, along with useful bits of metadata.
+
+```ts
+// @filename: ambient.d.ts
+declare global {
+ const source: string;
+}
+
+export {};
+
+// @filename: main.ts
+import { compile } from 'svelte/compiler';
+// ---cut---
+const { js, css, ast, warnings, vars, stats } = compile(source);
+```
+
+Refer to [CompileResult](#types-compileresult) for a full description of the compile result.
+
+## parse
+
+
+
+```dts
+function parse(
+ template: string,
+ options?: ParserOptions
+): Ast;
+```
+
+
+
+The `parse` function parses a component, returning only its abstract syntax tree. Unlike compiling with the `generate: false` option, this will not perform any validation or other analysis of the component beyond parsing it. Note that the returned AST is not considered public API, so breaking changes could occur at any point in time.
+
+```js
+// @filename: ambient.d.ts
+declare global {
+ var source: string;
+}
+
+export {};
+
+// @filename: main.ts
+// ---cut---
+import { parse } from 'svelte/compiler';
+
+const ast = parse(source, { filename: 'App.svelte' });
+```
+
+## preprocess
+
+
+
+```dts
+function preprocess(
+ source: string,
+ preprocessor: PreprocessorGroup | PreprocessorGroup[],
+ options?:
+ | {
+ filename?: string | undefined;
+ }
+ | undefined
+): Promise
;
+```
+
+