@marko/language-server 2.1.5 → 2.1.6

package/dist/marko.internal.d.ts

@@ -0,0 +1,583 @@
+// This is a typescript file which defines utilities used in the output of the typescript extractor.
+declare global {
+  namespace Marko {
+    export interface Directives {}
+
+    // Extend the Body type to keep track of what is yielded (used for scope hoisted types).
+    export interface Body<
+      in Params extends readonly any[] = [],
+      out Return = void,
+    > {
+      (...params: Params): MarkoReturn<Return>;
+    }
+
+    /**
+     * Do not use or you will be fired.
+     */
+    namespace _ {
+      export const voidReturn: MarkoReturn<void>;
+      export const scope: unique symbol;
+      export const out: Marko.Out;
+      export const never: never;
+      export const any: any;
+
+      export function getGlobal<Override>(
+        override: Override,
+      ): [0] extends [1 & Override] ? Marko.Global : Override;
+
+      export function attrTagNames<Tag>(
+        tag: Tag,
+        fn: (input: AttrTagNames<Marko.Input<Tag>>) => void,
+      ): void;
+      export function nestedAttrTagNames<Input>(
+        input: Input,
+        fn: (input: AttrTagNames<Input>) => void,
+      ): void;
+
+      export const content: DefaultBodyContentKey;
+
+      export function contentFor<Name>(
+        tag: Name,
+      ): Name extends { api: infer API }
+        ? API extends "tags"
+          ? "content"
+          : API extends "class"
+            ? "renderBody"
+            : DefaultBodyContentKey
+        : DefaultBodyContentKey;
+
+      export const Template: new <Overrides = unknown>() => {
+        [K in Exclude<
+          keyof Marko.Template,
+          keyof Overrides
+        >]: Marko.Template[K];
+      } & Overrides;
+
+      export function noop(value: any): void;
+
+      export function tuple<T extends readonly any[]>(...v: T): T;
+
+      export function interpolated(
+        strs: TemplateStringsArray,
+        ...exprs: (string | number | void | null | false)[]
+      ): string;
+
+      export function state<Component>(
+        component: Component,
+      ): Component extends {
+        state: infer State extends object;
+      }
+        ? State
+        : never;
+
+      export type ReturnWithScope<Input, Return> = ReturnAndScope<
+        Scopes<Input>,
+        Return
+      >;
+
+      export function instance<Constructor>(
+        constructor: Constructor,
+      ): Constructor extends abstract new (...args: any) => infer Instance
+        ? Instance
+        : never;
+
+      export function readScopes<Rendered>(rendered: Rendered): MergeScopes<
+        {
+          [K in keyof Rendered]: Rendered[K] extends infer Value
+            ? undefined extends Value
+              ? Value extends { scope: infer Scope }
+                ? [0] extends [1 & Scope]
+                  ? never
+                  : Partial<Scope>
+                : never
+              : Value extends { scope: infer Scope }
+                ? [0] extends [1 & Scope]
+                  ? never
+                  : Scope
+                : never
+            : never;
+        }[keyof Rendered]
+      > &
+        Record<any, never>;
+
+      export function readScope<Value>(
+        value: Value,
+      ): MergeScopes<
+        undefined extends Value
+          ? Value extends { scope: infer Scope }
+            ? [0] extends [1 & Scope]
+              ? never
+              : Partial<Scope>
+            : never
+          : Value extends { scope: infer Scope }
+            ? [0] extends [1 & Scope]
+              ? never
+              : Scope
+            : never
+      > &
+        Record<any, never>;
+
+      export function mutable<Lookup>(lookup: Lookup): UnionToIntersection<
+        Lookup extends readonly (infer Item)[]
+          ? Item extends
+              | readonly [infer LocalName extends string, infer Data]
+              | readonly [infer LocalName, infer SourceName, infer Data]
+            ? Data extends {
+                [K in `${SourceName extends string
+                  ? SourceName
+                  : LocalName}Change`]: (value: infer V, ...args: any[]) => any;
+              }
+              ? { [K in LocalName]: V }
+              : { readonly [K in LocalName]: unknown }
+            : never
+          : never
+      >;
+
+      export function bind<
+        Owner extends Marko.Component,
+        OwnerHandlers extends ComponentEventHandlers<Owner>,
+        Handler extends
+          | keyof OwnerHandlers
+          | ((...args: any) => any)
+          | false
+          | void,
+        Args extends readonly any[],
+      >(
+        owner: Owner,
+        handler: Handler,
+        ...args: Args
+      ): Args extends readonly []
+        ? Handler extends keyof OwnerHandlers
+          ? OwnerHandlers[Handler]
+          : Handler
+        : (...args: any) => any; // If typescript ever actually supports partial application maybe we do this.
+
+      export function renderTemplate<Name extends Marko.Template<any, any>>(
+        template: Name,
+      ): TemplateRenderer<Name>;
+      export function renderNativeTag<Name extends string>(
+        tag: Name,
+      ): NativeTagRenderer<Name>;
+      export const missingTag: DefaultRenderer;
+      export function resolveTemplate<Template>(
+        imported: Promise<{ default: Template }>,
+      ): Template;
+      export function fallbackTemplate<Tag, Template>(
+        tag: Tag,
+        fallback: Promise<{ default: Template }>,
+      ): [0] extends [1 & Tag] ? Template : Tag;
+      export function input<Name>(tag: Name): Marko.Input<Name>;
+      export function renderDynamicTag<Name>(tag: Name): DynamicRenderer<Name>;
+
+      export function returnTag<
+        Input extends { value: unknown; valueChange?: (value: any) => void },
+      >(input: Input): Input;
+
+      export function forOfTag<
+        Value extends Iterable,
+        Item extends [0] extends [1 & Value]
+          ? any
+          : Value extends readonly (infer Item)[] | Iterable<infer Item>
+            ? Item
+            : never,
+        BodyContent extends Marko.Body<
+          [item: Item, index: number, all: Value],
+          void
+        >,
+      >(
+        input: {
+          of: Value | false | void | null;
+          by?: ((item: Item, index: number) => string) | string;
+        },
+        content: BodyContent,
+      ): ReturnAndScope<BodyContentScope<BodyContent>, void>;
+
+      export function forInTag<
+        Value,
+        BodyContent extends Marko.Body<
+          [key: keyof Value, value: Value[keyof Value]],
+          void
+        >,
+      >(
+        input: {
+          in: Value | false | void | null;
+          by?: (value: Value[keyof Value], key: keyof Value) => string;
+        },
+        content: BodyContent,
+      ): ReturnAndScope<BodyContentScope<BodyContent>, void>;
+
+      export function forToTag<
+        From extends void | number,
+        To extends number,
+        Step extends void | number,
+        BodyContent extends Marko.Body<[index: number], void>,
+      >(
+        input: {
+          from?: From;
+          to: To;
+          step?: Step;
+          by?: (index: number) => string;
+        },
+        content: BodyContent,
+      ): ReturnAndScope<BodyContentScope<BodyContent>, void>;
+
+      export function forTag<BodyContent extends AnyMarkoBody>(
+        input: (
+          | {
+              from?: number;
+              to: number;
+              step?: number;
+            }
+          | {
+              in: object | false | void | null;
+            }
+          | {
+              of: Iterable<unknown> | readonly unknown[] | false | void | null;
+            }
+        ) & { by?: (...args: unknown[]) => string },
+        content: BodyContent,
+      ): ReturnAndScope<BodyContentScope<BodyContent>, void>;
+
+      export function forOfAttrTag<
+        Value extends Iterable,
+        Item extends [0] extends [1 & Value]
+          ? any
+          : Value extends readonly (infer Item)[] | Iterable<infer Item>
+            ? Item
+            : never,
+        const Return,
+      >(
+        input: {
+          of: Value | false | void | null;
+        },
+        content: (value: Item, index: number, all: Value) => Return,
+      ): {
+        [Key in keyof Return]: Return[Key] extends
+          | readonly (infer Item)[]
+          | (infer Item extends Record<PropertyKey, any>)
+          ? AttrTagByListSize<Value, Item>
+          : never;
+      };
+
+      export function forInAttrTag<Value extends object, const Return>(
+        input: {
+          in: Value | false | void | null;
+        },
+        content: (key: keyof Value, value: Value[keyof Value]) => Return,
+      ): {
+        [Key in keyof Return]: Return[Key] extends
+          | readonly (infer Item)[]
+          | (infer Item extends Record<PropertyKey, any>)
+          ? AttrTagByObjectSize<Value, Item>
+          : never;
+      };
+
+      export function forToAttrTag<
+        From extends void | number,
+        To extends number,
+        Step extends void | number,
+        const Return,
+      >(
+        input: {
+          from?: From;
+          to: To;
+          step?: Step;
+        },
+        content: (index: number) => Return,
+      ): {
+        [Key in keyof Return]: Return[Key] extends
+          | readonly (infer Item)[]
+          | (infer Item extends Record<PropertyKey, any>)
+          ? number extends From | To | Step
+            ? undefined | Marko.AttrTag<Item>
+            : Step extends 0
+              ? never
+              : [To] extends [From extends void ? 0 : From]
+                ? undefined
+                : Marko.AttrTag<Item>
+          : never;
+      };
+
+      export function forAttrTag<const Return>(
+        input:
+          | {
+              of: Iterable<unknown> | readonly unknown[] | false | void | null;
+            }
+          | {
+              in: object;
+            }
+          | {
+              from?: number;
+              to: number;
+              step?: number;
+            },
+        content: (...args: unknown[]) => Return,
+      ): {
+        [Key in keyof Return]: Return[Key] extends
+          | readonly (infer Item)[]
+          | (infer Item extends Record<PropertyKey, any>)
+          ? undefined | Marko.AttrTag<Item>
+          : never;
+      };
+
+      export function mergeAttrTags<Attrs extends readonly any[]>(
+        ...attrs: Attrs
+      ): MergeAttrTags<Attrs>;
+      export function attrTag<AttrTag>(attrTags: AttrTag[]): AttrTag;
+      export function attrTagFor<Tag, Path extends readonly string[]>(
+        tag: Tag,
+        ...path: Path
+      ): <
+        AttrTag extends [0] extends [1 & Tag]
+          ? Marko.AttrTag<unknown>
+          : Marko.Input<Tag> extends infer Input
+            ? [0] extends [1 & Input]
+              ? Marko.AttrTag<unknown>
+              : AttrTagValue<Marko.Input<Tag>, Path>
+            : Marko.AttrTag<unknown>,
+      >(
+        attrTags: AttrTag[],
+      ) => AttrTag extends Marko.AttrTag<infer Input>
+        ? Marko.AttrTag<Input>
+        : any;
+
+      // TODO: this could be improved.
+      // currently falls back to DefaultRenderer too eagerly.
+      export type DynamicRenderer<Name> = [0] extends [1 & Name]
+        ? DefaultRenderer
+        : [Name] extends [Marko.Template<any, any>]
+          ? TemplateRenderer<Name>
+          : [Name] extends [string]
+            ? NativeTagRenderer<Name>
+            : [Name] extends [AnyMarkoBody]
+              ? BodyRenderer<Name>
+              : [Name] extends [
+                    {
+                      [BodyContentKey in DefaultBodyContentKey]?: infer BodyValue extends
+                        AnyMarkoBody;
+                    },
+                  ]
+                ? BodyRenderer<BodyValue>
+                : DefaultRenderer;
+
+      export type TemplateRenderer<Template> = Template extends {
+        _: infer Renderer;
+      }
+        ? Renderer
+        : Template extends Marko.Template<infer Input, infer Return>
+          ? BaseRenderer<Input, Return>
+          : never;
+
+      export interface NativeTagRenderer<Name extends string> {
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-constraint
+        (): () => <__marko_internal_input extends unknown>(
+          input: Marko.Directives &
+            Marko.NativeTags[Name]["input"] &
+            Relate<
+              __marko_internal_input,
+              Marko.Directives & Marko.NativeTags[Name]["input"]
+            >,
+        ) => ReturnAndScope<
+          Scopes<__marko_internal_input>,
+          Marko.NativeTags[Name]["return"]
+        >;
+      }
+
+      export interface BodyRenderer<Body extends AnyMarkoBody> {
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-constraint
+        (): () => <__marko_internal_input extends unknown>(
+          ...args: BodyParamsWithDefault<Body> &
+            Relate<__marko_internal_input, BodyParamsWithDefault<Body>>
+        ) => ReturnAndScope<
+          Scopes<__marko_internal_input>,
+          BodyReturnType<Body>
+        >;
+      }
+
+      export interface BaseRenderer<Input, Return = void> {
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-constraint
+        (): () => <__marko_input_with_scope extends unknown>(
+          input: Marko.Directives &
+            Input &
+            Relate<__marko_input_with_scope, Marko.Directives & Input>,
+        ) => ReturnAndScope<Scopes<__marko_input_with_scope>, Return>;
+      }
+
+      export interface DefaultRenderer {
+        (): () => <Input>(input: Input) => ReturnAndScope<Scopes<Input>, void>;
+      }
+
+      export type Relate<A, B> = B extends A ? A : B;
+    }
+  }
+}
+
+declare abstract class MarkoReturn<Return> {
+  return: Return;
+}
+
+type AnyMarkoBody = Marko.Body<any, any>;
+
+type BodyContentScope<BodyContent> = BodyContent extends (...params: any) => {
+  [Marko._.scope]: infer Scope;
+}
+  ? Scope
+  : never;
+
+type ReturnAndScope<Scope, Return> = {
+  return: Return;
+  scope: Scope;
+};
+
+type BodyParamsWithDefault<Body extends AnyMarkoBody> =
+  Body extends Marko.Body<infer Params, any>
+    ? Params extends []
+      ? [input?: Record<string, never>]
+      : Params
+    : never;
+
+type Scopes<Input> = [0] extends [1 & Input]
+  ? never
+  : MergeScopes<FlatScopes<Input>>;
+
+type ComponentEventHandlers<Component extends Marko.Component> = {
+  [K in Exclude<
+    keyof Component,
+    Exclude<
+      keyof Marko.Component,
+      "emit" | "setState" | "setStateDirty" | "forceUpdate"
+    >
+  >]: Component[K] extends (...args: any) => any ? Component[K] : never;
+};
+
+type FlatScopes<Input> = [0] extends [1 & Input]
+  ? never
+  :
+      | (Input[("content" | "renderBody") & keyof Input] extends infer Prop
+          ? Prop extends (...args: any[]) => { [Marko._.scope]: infer Scope }
+            ? Scope
+            : never
+          : never)
+      | (Input[string & keyof Input] extends infer Prop
+          ? Prop extends { [Symbol.iterator]: any }
+            ? Prop extends readonly any[]
+              ? never
+              : FlatScopes<Prop>
+            : never
+          : never);
+
+type MergeScopes<Scopes> = {
+  [K in Scopes extends Scopes ? keyof Scopes : never]: Scopes extends Scopes
+    ? Scopes[K & keyof Scopes]
+    : never;
+};
+
+type MergeOptionalScopes<Scopes> = {
+  [K in Scopes extends Scopes ? keyof Scopes : never]: Scopes extends Scopes
+    ? K extends keyof Scopes
+      ? Scopes[K]
+      : undefined
+    : never;
+};
+
+type MergeAttrTags<Attrs extends readonly any[]> = Attrs extends readonly [
+  infer A,
+  infer B,
+  ...infer Rest,
+]
+  ? MergeAttrTags<[MergeAttrTag<A, B>, ...Rest]>
+  : Attrs extends readonly [infer A]
+    ? A
+    : never;
+
+type MergeAttrTag<A, B> = {
+  [K in keyof A | keyof B]: K extends keyof A
+    ? K extends keyof B
+      ? MergeAttrTagValue<A[K], B[K]>
+      : A[K]
+    : K extends keyof B
+      ? B[K]
+      : never;
+};
+
+type MergeAttrTagValue<A, B> = A extends readonly (infer AType)[]
+  ? B extends readonly (infer BType)[]
+    ? AType | BType
+    : B extends void
+      ? A
+      : AType | B
+  : A extends void
+    ? B
+    : B extends void
+      ? A
+      : A | B;
+
+type AttrTagByListSize<T, Item> = T extends
+  | readonly [any, ...any[]]
+  | readonly [...any[], any]
+  ? Marko.AttrTag<Item>
+  : T extends readonly []
+    ? undefined
+    : undefined | Marko.AttrTag<Item>;
+
+type AttrTagByObjectSize<
+  Value,
+  Item,
+  Keys = RecordKeys<Value>,
+  KnownKeys = KnownRecordKeys<Value>,
+> = CheckNever<
+  Keys,
+  undefined,
+  CheckNever<KnownKeys, Marko.AttrTag<Item>, undefined | Marko.AttrTag<Item>>
+>;
+
+type AttrTagValue<Input, Path extends readonly string[]> = Path extends [
+  infer Prop extends keyof Input,
+  ...infer Rest extends readonly string[],
+]
+  ? Input[Prop] & Marko.AttrTag<unknown> extends infer Value
+    ? Rest extends readonly []
+      ? Value
+      : AttrTagValue<Value, Rest>
+    : Marko.AttrTag<unknown>
+  : Marko.AttrTag<unknown>;
+
+type AttrTagNames<Input> = Record<string, never> &
+  (Input extends infer Input extends {}
+    ? {
+        [Key in keyof Input & string as `@${Input[Key] extends infer Value
+          ? Value extends Marko.AttrTag<any>
+            ? Key
+            : never
+          : never}`]: Input[Key];
+      }
+    : never);
+
+type RecordKeys<T> = keyof {
+  [K in keyof T as CheckNever<T[K], never, K>]: 0;
+};
+
+type KnownRecordKeys<T> = keyof {
+  [Key in keyof T as string extends Key
+    ? never
+    : number extends Key
+      ? never
+      : symbol extends Key
+        ? never
+        : CheckNever<T[Key], never, Key>]: 0;
+};
+
+type CheckNever<T, If, Else> = [T] extends [never] ? If : Else;
+
+type UnionToIntersection<T> = (T extends any ? (_: T) => any : never) extends (
+  _: infer U,
+) => any
+  ? U
+  : never;
+
+type DefaultBodyContentKey = keyof Exclude<
+  Marko.Renderable,
+  Marko.Template<any, any> | Marko.Body<any, any> | string
+>;
+
+export {};

package/dist/marko.runtime.d.ts

@@ -0,0 +1,408 @@
+import "./tags-html";
+
+declare module "*.marko" {
+  const template: Marko.Template;
+  export default template;
+}
+
+declare global {
+  namespace NodeJS {
+    interface ReadableStream {}
+  }
+
+  namespace Marko {
+    /** A mutable global object for the current render. */
+    export interface Global {
+      [x: PropertyKey]: unknown;
+      /** An AbortSignal instance that, when aborted, stops further streamed content. */
+      signal?: AbortSignal;
+      /** A CSP Nonce to add to each script output from Marko. */
+      cspNonce?: string;
+      /** Used for rendering multiple Marko templates in a single hydrated page. */
+      renderId?: string;
+      /** Used to uniquely identify a instance of a Marko runtime. */
+      runtimeId?: string;
+      /** A list of globals that should be serialized to the browser. */
+      serializedGlobals?: Record<string, boolean>;
+      /** @deprecated prefer `renderId` */
+      widgetIdPrefix?: string;
+      /** @deprecated prefer `renderId` */
+      componentIdPrefix?: string;
+    }
+
+    export type TemplateInput<Input> = Input & {
+      $global?: Global;
+    };
+
+    /** The result of calling `template.render`. */
+    export type RenderedTemplate<Component = unknown> = Promise<
+      Component extends Marko.Component ? RenderResult<Component> : string
+    > &
+      AsyncIterable<string> & {
+        toReadable(): ReadableStream<Uint8Array<ArrayBufferLike>>;
+        pipe(stream: {
+          write(chunk: string): unknown;
+          end(): unknown;
+          flush?(): void;
+        }): void;
+        toString(): string;
+      };
+
+    /** The result of calling `template.mount`. */
+    export type MountedTemplate<Input = unknown, Return = unknown> = {
+      get value(): Return extends { value: infer Value } ? Value : void;
+      set value(
+        next: Return extends { valueChange?(next: infer Next): any }
+          ? Next
+          : never,
+      );
+      update(input: Marko.TemplateInput<Input>): void;
+      destroy(): void;
+    };
+
+    export interface Out<Component = unknown>
+      extends Marko.RenderedTemplate<Component> {
+      /** The underlying ReadableStream Marko is writing into. */
+      stream: unknown;
+      /** A mutable global object for the current render. */
+      global: Global;
+      /** Disable all async rendering. Will error if something beings async. */
+      sync(): void;
+      /** Returns true if async rendering is disabled. */
+      isSync(): boolean;
+      /** Write unescaped text at the current stream position. */
+      write(val: string | void): this;
+      /** Write javascript content to be merged with the scripts Marko sends out on the next flush. */
+      script(val: string | void): this;
+      /** Starts a new async/forked stream. */
+      beginAsync(options?: {
+        name?: string;
+        timeout?: number;
+        last?: boolean;
+      }): Out;
+      /** Marks the current stream as complete (async streams may still be executing). */
+      end(val?: string | void): this;
+      emit(eventName: PropertyKey, ...args: any[]): boolean;
+      on(eventName: PropertyKey, listener: (...args: any[]) => any): this;
+      once(eventName: PropertyKey, listener: (...args: any[]) => any): this;
+      prependListener(
+        eventName: PropertyKey,
+        listener: (...args: any[]) => any,
+      ): this;
+      removeListener(
+        eventName: PropertyKey,
+        listener: (...args: any[]) => any,
+      ): this;
+      /** Register a callback executed when the last async out has completed. */
+      onLast(listener: (next: () => void) => unknown): this;
+      /** Emits an error on the stream. */
+      error(e: Error): this;
+      /** Schedules a Marko to flush buffered html to the underlying stream. */
+      flush(): this;
+      /** Creates a detached out stream (used for out of order flushing). */
+      createOut(): Out;
+      /** Write escaped text at the current stream position. */
+      text(val: string | void): void;
+    }
+
+    /** Body content created from by a component, typically held in an object with a renderBody property. */
+
+    export interface Body<
+      in Params extends readonly any[] = [],
+      out Return = void,
+    > {}
+
+    /** Valid data types which can be passed in as a <${dynamic}/> tag name. */
+    export type Renderable =
+      | { renderBody: Body<any, any> | Template | string }
+      | Body<any, any>
+      | Template
+      | string;
+
+    /** Extract the return tag type from a renderBody. */
+    export type BodyReturnType<B> =
+      B extends Body<any, infer Return> ? Return : never;
+
+    /** Extract the tag parameter types received by a renderBody. */
+    export type BodyParameters<B> =
+      B extends Body<infer Params, any> ? Params : never;
+
+    export class Component<Input = unknown, State = unknown>
+      implements Emitter
+    {
+      /** A unique id for this instance. */
+      public readonly id: string;
+      /** The top level element rendered by this instance. */
+      public readonly el: Element | void;
+      /** The attributes passed to this instance. */
+      public readonly input: Input;
+      /** @deprecated */
+      public readonly els: Element[];
+      /** Mutable state that when changed causes a rerender. */
+      state: State;
+
+      /** Returns the amount of event handlers listening to a specific event. */
+      listenerCount(eventName: PropertyKey): number;
+      /**
+       * Used to wrap an existing event emitted and ensure that all events are
+       * cleaned up once this component is destroyed
+       * */
+      subscribeTo(
+        emitter: unknown,
+      ): Omit<Emitter, "listenerCount" | "prependListener" | "emit">;
+      /** Emits an event on the component instance. */
+      emit(eventName: PropertyKey, ...args: any[]): boolean;
+      /** Listen to an event on the component instance. */
+      on(eventName: PropertyKey, listener: (...args: any[]) => any): this;
+      /** Listen to an event on the component instance once. */
+      once(eventName: PropertyKey, listener: (...args: any[]) => any): this;
+      /** Listen to an event on the component instance before all other listeners. */
+      prependListener(
+        eventName: PropertyKey,
+        listener: (...args: any[]) => any,
+      ): this;
+      /** Remove a listener from the component instance. */
+      removeListener(
+        eventName: PropertyKey,
+        listener: (...args: any[]) => any,
+      ): this;
+      /** Remove all listeners from the component instance. */
+      removeAllListeners(eventName?: PropertyKey): this;
+      /** Removes the component instance from the DOM and cleans up all active event handlers including all children. */
+      destroy(): void;
+      /** Schedule an update (similar to if a state had been changed). */
+      forceUpdate(): void;
+      /** Generates a unique id derived from the current unique instance id (similar to :scoped in the template). */
+      elId(key?: string, index?: number): string;
+      /** @alias elId */
+      getElId(key?: string, index?: number): string;
+      /** Gets an element reference by its `key` attribute in the template. */
+      getEl<T extends Element | void = Element | void>(
+        key?: string,
+        index?: number,
+      ): T;
+      /** Gets all element references by their `key` attribute in the template. */
+      getEls<T extends Element[] = Element[]>(key: string): T;
+      /** Gets a component reference by its `key` attribute in the template. */
+      getComponent<T extends Component | void = Component | void>(
+        key: string,
+        index?: number,
+      ): T;
+      /** Gets all component references by their `key` attribute in the template. */
+      getComponents<T extends Component[] = Component[]>(key: string): T;
+      /** True if this instance has been removed from the dom. */
+      /** True if this instance is scheduled to rerender. */
+      isDestroyed(): boolean;
+      /** Replace the entire state object with a new one, removing old properties. */
+      replaceState(state: this["state"]): void;
+      /**
+       * Update a property on this.state (should prefer mutating this.state directly).
+       * When passed an object as the first argument, it will be merged into the state.
+       */
+      setState<Key extends PropertyKey>(
+        name: Key & keyof this["state"],
+        value: (this["state"] & Record<PropertyKey, unknown>)[Key],
+      ): void;
+      setState(value: Partial<this["state"]>): void;
+
+      /** Schedules an update related to a specific state property and optionally updates the value. */
+      setStateDirty<Key extends PropertyKey>(
+        name: Key & keyof this["state"],
+        value?: (this["state"] & Record<PropertyKey, unknown>)[Key],
+      ): void;
+      /** Synchronously flush any scheduled updates. */
+      update(): void;
+      /** Appends the dom for the current instance to a parent DOM element. */
+      appendTo(target: ParentNode): this;
+      /** Inserts the dom for the current instance after a sibling DOM element. */
+      insertAfter(target: ChildNode): this;
+      /** Inserts the dom for the current instance before a sibling DOM element. */
+      insertBefore(target: ChildNode): this;
+      /** Prepends the dom for the current instance to a parent DOM element. */
+      prependTo(target: ParentNode): this;
+      /** Replaces an existing DOM element with the dom for the current instance. */
+      replace(target: ChildNode): this;
+      /** Replaces the children of an existing DOM element with the dom for the current instance. */
+      replaceChildrenOf(target: ParentNode): this;
+      // /** Called when the component is firsted created. */
+      // onCreate?(input: this["input"], out: Marko.Out): void;
+      // /** Called every time the component receives input from it's parent. */
+      // onInput?(input: this["input"], out: Marko.Out): void | this["input"];
+      // /** Called after a component has successfully rendered, but before it's update has been applied to the dom. */
+      // onRender?(out: Marko.Out): void;
+      // /** Called after the first time the component renders and is attached to the dom. */
+      // onMount?(): void;
+      // /** Called when a components render has been applied to the DOM (excluding when it is initially mounted). */
+      // onUpdate?(): void;
+      // /** Called when a component is destroyed and removed from the dom. */
+      // onDestroy?(): void;
+    }
+
+    /** The top level api for a Marko Template. */
+    export abstract class Template<Input = unknown, Return = unknown> {
+      /** Creates a Marko compatible output stream. */
+      createOut(): Out;
+
+      /**
+       * The folowing types are processed up by the @marko/language-tools
+       * and inlined into the compiled template.
+       *
+       * This is done to support generics on each of these methods
+       * until TypeScript supports higher kinded types.
+       *
+       * https://github.com/microsoft/TypeScript/issues/1213
+       */
+
+      /** @marko-overload-start */
+      /** Asynchronously render the template. */
+      abstract render(
+        input: Marko.TemplateInput<Input>,
+        stream?: {
+          write: (chunk: string) => void;
+          end: (chunk?: string) => void;
+        },
+      ): Marko.Out<Marko.Component>;
+
+      /** Asynchronously render the template in buffered mode. */
+      abstract render(
+        input: Marko.TemplateInput<Input>,
+        cb?: (
+          err: Error | null,
+          result: Marko.RenderResult<Marko.Component>,
+        ) => void,
+      ): Marko.Out<Marko.Component>;
+
+      /** Synchronously render the template. */
+      abstract renderSync(
+        input: Marko.TemplateInput<Input>,
+      ): Marko.RenderResult<Marko.Component>;
+
+      /** Synchronously render a template to a string. */
+      abstract renderToString(input: Marko.TemplateInput<Input>): string;
+
+      /** Render a template and return a stream.Readable in nodejs or a ReadableStream in a web worker environment. */
+      abstract stream(
+        input: Marko.TemplateInput<Input>,
+      ): ReadableStream<string> & NodeJS.ReadableStream;
+
+      /** Render and attach the template to a DOM node. */
+      abstract mount(
+        input: Marko.TemplateInput<Input>,
+        reference: Node,
+        position?: "afterbegin" | "afterend" | "beforebegin" | "beforeend",
+      ): Marko.MountedTemplate<typeof input>;
+      /** @marko-overload-end */
+    }
+
+    export interface RenderResult<
+      out Component extends Marko.Component = Marko.Component,
+    > {
+      /** Returns the component created as a result of rendering the template. */
+      getComponent(): Component;
+      getComponents(selector?: any): any;
+      /** Triggers the mount lifecycle of a component without necessarily attaching it to the DOM. */
+      afterInsert(host?: any): this;
+      /** Gets the DOM node rendered by a template. */
+      getNode(host?: any): Node;
+      /** Gets the HTML output of the rendered template. */
+      toString(): string;
+      /** Appends the dom of the rendered template to a parent DOM element. */
+      appendTo(target: ParentNode): this;
+      /** Inserts the dom of the rendered template after a sibling DOM element. */
+      insertAfter(target: ChildNode): this;
+      /** Inserts the dom of the rendered template before a sibling DOM element. */
+      insertBefore(target: ChildNode): this;
+      /** Prepends the dom of the rendered template to a parent DOM element. */
+      prependTo(target: ParentNode): this;
+      /** Replaces an existing DOM element with the dom of the rendered template. */
+      replace(target: ChildNode): this;
+      /** Replaces the children of an existing DOM element with the dom of the rendered template. */
+      replaceChildrenOf(target: ParentNode): this;
+      out: Out<Component>;
+      /** @deprecated */
+      document: any;
+      /** @deprecated */
+      getOutput(): string;
+      /** @deprecated */
+      html: string;
+      /** @deprecated */
+      context: Out<Component>;
+    }
+
+    export interface Emitter {
+      listenerCount(eventName: PropertyKey): number;
+      emit(eventName: PropertyKey, ...args: any[]): boolean;
+      on(eventName: PropertyKey, listener: (...args: any[]) => any): this;
+      once(eventName: PropertyKey, listener: (...args: any[]) => any): this;
+      prependListener(
+        eventName: PropertyKey,
+        listener: (...args: any[]) => any,
+      ): this;
+      removeListener(
+        eventName: PropertyKey,
+        listener: (...args: any[]) => any,
+      ): this;
+      removeAllListeners(eventName?: PropertyKey): this;
+    }
+
+    export type AttrTag<T> = T & {
+      [Symbol.iterator](): Iterator<T>;
+    };
+
+    export interface NativeTag<
+      Input extends Record<string, any>,
+      Return extends Element,
+    > {
+      input: Input;
+      return: { value: () => Return };
+    }
+    export interface NativeTags {
+      [name: string]: NativeTag<Record<string, any>, Element>;
+    }
+
+    export type Input<Name> = 0 extends 1 & Name
+      ? any
+      : Name extends string
+        ? Name extends keyof NativeTags
+          ? NativeTags[Name]["input"]
+          : Record<string, unknown>
+        : Name extends
+              | Template<infer Input, any>
+              | { _(): () => (input: infer Input) => any }
+          ? Input
+          : Name extends Body<infer Args, any>
+            ? Args extends {
+                length: infer Length;
+              }
+              ? number extends Length
+                ? Args[0] | undefined
+                : 0 extends Length
+                  ? undefined
+                  : Args[0]
+              : never
+            : never;
+
+    export type Return<Name> = 0 extends 1 & Name
+      ? any
+      : Name extends string
+        ? Name extends keyof NativeTags
+          ? NativeTags[Name]["return"]
+          : () => Element
+        : Name extends
+              | { _(): () => (input: any) => { return: infer Return } }
+              | Template<any, infer Return>
+              | Body<any, infer Return>
+          ? Return
+          : never;
+
+    /** @deprecated @see {@link Marko.AttrTag} */
+    export type RepeatableAttrTag<T> = AttrTag<T>;
+
+    /** @deprecated @see {@link Marko.Input} */
+    export type NativeTagInput<Name extends keyof NativeTags> =
+      NativeTags[Name]["input"];
+    /** @deprecated @see {@link Marko.Return} */
+    export type NativeTagReturn<Name extends keyof NativeTags> =
+      NativeTags[Name]["return"];
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@marko/language-server",
   "description": "Marko Language Server",
-  "version": "2.1.5",
+  "version": "2.1.6",
   "bin": {
     "marko-language-server": "./bin.js"
   },