svelte2tsx 0.6.14 → 0.6.16

package/index.js

@@ -1252,17 +1252,16 @@ class MagicString {
 	}
 }
 
-function parseAttributeValue(value) {
-    return /^['"]/.test(value) ? value.slice(1, -1) : value;
-}
 function parseAttributes(str, start) {
     const attrs = [];
-    str.split(/\s+/)
-        .filter(Boolean)
-        .forEach((attr) => {
+    const pattern = /([\w-$]+\b)(?:=(?:"([^"]*)"|'([^']*)'|(\S+)))?/g;
+    let match;
+    while ((match = pattern.exec(str)) !== null) {
+        const attr = match[0];
+        const name = match[1];
+        const value = match[2] || match[3] || match[4];
         const attrStart = start + str.indexOf(attr);
-        const [name, value] = attr.split('=');
-        attrs[name] = value ? parseAttributeValue(value) : name;
+        attrs[name] = value !== null && value !== void 0 ? value : name;
         attrs.push({
             type: 'Attribute',
             name,
@@ -1271,13 +1270,13 @@ function parseAttributes(str, start) {
                     type: 'Text',
                     start: attrStart + attr.indexOf('=') + 1,
                     end: attrStart + attr.length,
-                    raw: parseAttributeValue(value)
+                    raw: value
                 }
             ],
             start: attrStart,
             end: attrStart + attr.length
         });
-    });
+    }
     return attrs;
 }
 function extractTag(htmlx, tag) {
@@ -2343,7 +2342,11 @@ const oneWayBindingAttributes = new Set([
     'ended',
     'readyState',
     'naturalWidth',
-    'naturalHeight'
+    'naturalHeight',
+    'contentRect',
+    'contentBoxSize',
+    'borderBoxSize',
+    'devicePixelContentBoxSize'
 ]);
 /**
  * List of all binding names that are transformed to sth like `binding = variable`.
@@ -2788,7 +2791,9 @@ function convertHtmlxToJsx(str, ast, onWalk = null, onLeave = null, options = {}
     stripDoctype(str);
     let element;
     compiler.walk(ast, {
-        enter: (node, parent, prop, index) => {
+        enter: (estreeTypedNode, estreeTypedParent, prop, index) => {
+            const node = estreeTypedNode;
+            const parent = estreeTypedParent;
             try {
                 switch (node.type) {
                     case 'IfBlock':
@@ -2889,7 +2894,9 @@ function convertHtmlxToJsx(str, ast, onWalk = null, onLeave = null, options = {}
                 throw e;
             }
         },
-        leave: (node, parent, prop, index) => {
+        leave: (estreeTypedNode, estreeTypedParent, prop, index) => {
+            const node = estreeTypedNode;
+            const parent = estreeTypedParent;
             try {
                 switch (node.type) {
                     case 'IfBlock':
@@ -3943,7 +3950,7 @@ class ExportedNames {
         if (exportModifier) {
             const isLet = node.declarationList.flags === ts.NodeFlags.Let;
             const isConst = node.declarationList.flags === ts.NodeFlags.Const;
-            this.handleExportedVariableDeclarationList(node.declarationList, (_, ...args) => this.addExport(...args));
+            this.handleExportedVariableDeclarationList(node.declarationList, (_, ...args) => this.addExportForBindingPattern(...args));
             if (isLet) {
                 this.propTypeAssertToUserDefined(node.declarationList);
             }
@@ -4150,12 +4157,6 @@ class ExportedNames {
      * Adds export to map
      */
     addExport(name, isLet, target = null, type = null, required = false) {
-        if (name.kind != ts.SyntaxKind.Identifier) {
-            throw Error('export source kind not supported ' + name);
-        }
-        if (target && target.kind != ts.SyntaxKind.Identifier) {
-            throw Error('export target kind not supported ' + target);
-        }
         const existingDeclaration = this.possibleExports.get(name.text);
         if (target) {
             this.exports.set(name.text, {
@@ -4178,6 +4179,17 @@ class ExportedNames {
             this.propTypeAssertToUserDefined(existingDeclaration.declaration);
         }
     }
+    addExportForBindingPattern(name, isLet, target = null, type = null, required = false) {
+        if (ts.isIdentifier(name)) {
+            if (!target || ts.isIdentifier(target)) {
+                this.addExport(name, isLet, target, type, required);
+            }
+            return;
+        }
+        name.elements.forEach((child) => {
+            this.addExportForBindingPattern(child.name, isLet, undefined, type, required);
+        });
+    }
     getDoc(target) {
         var _a, _b;
         let doc = undefined;
@@ -5255,16 +5267,29 @@ function getLineOffsets(text) {
 }
 
 class Generics {
-    constructor(str, astOffset) {
+    constructor(str, astOffset, script) {
+        var _a, _b;
         this.str = str;
         this.astOffset = astOffset;
         this.definitions = [];
         this.typeReferences = [];
         this.references = [];
+        this.genericsAttr = script.attributes.find((attr) => attr.name === 'generics');
+        const generics = (_b = (_a = this.genericsAttr) === null || _a === void 0 ? void 0 : _a.value[0]) === null || _b === void 0 ? void 0 : _b.raw;
+        if (generics) {
+            this.definitions = generics.split(',').map((g) => g.trim());
+            this.references = this.definitions.map((def) => def.split(/\s/)[0]);
+        }
+        else {
+            this.genericsAttr = undefined;
+        }
     }
     addIfIsGeneric(node) {
         var _a, _b;
         if (ts.isTypeAliasDeclaration(node) && this.is$$GenericType(node.type)) {
+            if (this.genericsAttr) {
+                throw new Error('Invalid $$Generic declaration: $$Generic definitions are not allowed when the generics attribute is present on the script tag');
+            }
             if (((_a = node.type.typeArguments) === null || _a === void 0 ? void 0 : _a.length) > 1) {
                 throw new Error('Invalid $$Generic declaration: Only one type argument allowed');
             }
@@ -5386,7 +5411,7 @@ function processInstanceScriptContent(str, script, events, implicitStoreValues,
     const tsAst = ts.createSourceFile('component.ts.svelte', scriptContent, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
     const astOffset = script.content.start;
     const exportedNames = new ExportedNames(str, astOffset, basename);
-    const generics = new Generics(str, astOffset);
+    const generics = new Generics(str, astOffset, script);
     const interfacesAndTypes = new InterfacesAndTypes();
     const implicitTopLevelNames = new ImplicitTopLevelNames(str, astOffset);
     let uses$$props = false;
@@ -5613,7 +5638,11 @@ function processModuleScriptTag(str, script, implicitStoreValues) {
     const scriptContent = htmlx.substring(script.content.start, script.content.end);
     const tsAst = ts.createSourceFile('component.module.ts.svelte', scriptContent, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
     const astOffset = script.content.start;
-    const generics = new Generics(str, astOffset);
+    const generics = new Generics(str, astOffset, script);
+    if (generics.genericsAttr) {
+        const start = htmlx.indexOf('generics', script.start);
+        throwError(start, start + 8, 'The generics attribute is only allowed on the instance script', str.original);
+    }
     const walk = (node) => {
         resolveImplicitStoreValue(node, implicitStoreValues, str, astOffset);
         generics.throwIfIsGeneric(node);
@@ -5832,7 +5861,25 @@ function createRenderFunction({ str, scriptTag, scriptDestination, slots, events
         //I couldn't get magicstring to let me put the script before the <> we prepend during conversion of the template to jsx, so we just close it instead
         const scriptTagEnd = htmlx.lastIndexOf('>', scriptTag.content.start) + 1;
         str.overwrite(scriptTag.start, scriptTag.start + 1, ';');
-        str.overwrite(scriptTag.start + 1, scriptTagEnd, `function render${generics.toDefinitionString(true)}() {${propsDecl}\n`);
+        if (generics.genericsAttr) {
+            let start = generics.genericsAttr.value[0].start;
+            let end = generics.genericsAttr.value[0].end;
+            if (htmlx.charAt(start) === '"' || htmlx.charAt(start) === "'") {
+                start++;
+                end--;
+            }
+            str.overwrite(scriptTag.start + 1, start - 1, `function render`);
+            str.overwrite(start - 1, start, `<`); // if the generics are unused, only this char is colored opaque
+            if (end < scriptTagEnd) {
+                str.overwrite(end, scriptTagEnd, `>() {${propsDecl}\n`);
+            }
+            else {
+                str.prependRight(end, `>() {${propsDecl}\n`);
+            }
+        }
+        else {
+            str.overwrite(scriptTag.start + 1, scriptTagEnd, `function render${generics.toDefinitionString(true)}() {${propsDecl}\n`);
+        }
         const scriptEndTagStart = htmlx.lastIndexOf('<', scriptTag.end - 1);
         // wrap template with callback
         str.overwrite(scriptEndTagStart, scriptTag.end, `${slotsDeclaration};\nasync () => {`, {
@@ -5840,8 +5887,7 @@ function createRenderFunction({ str, scriptTag, scriptDestination, slots, events
         });
     }
     else {
-        str.prependRight(scriptDestination, `;function render${generics.toDefinitionString(true)}() {` +
-            `${propsDecl}${slotsDeclaration}\nasync () => {`);
+        str.prependRight(scriptDestination, `;function render() {` + `${propsDecl}${slotsDeclaration}\nasync () => {`);
     }
     const slotsAsDef = uses$$SlotsInterface
         ? '{} as unknown as $$Slots'
@@ -6104,7 +6150,7 @@ function svelte2tsx(svelte, options = {}) {
     const implicitStoreValues = new ImplicitStoreValues(resolvedStores, renderFunctionStart);
     //move the instance script and process the content
     let exportedNames = new ExportedNames(str, 0, basename);
-    let generics = new Generics(str, 0);
+    let generics = new Generics(str, 0, { attributes: [] });
     let uses$$SlotsInterface = false;
     if (scriptTag) {
         //ensure it is between the module script and the rest of the template (the variables need to be declared before the jsx template)
@@ -6154,6 +6200,7 @@ function svelte2tsx(svelte, options = {}) {
         // Prepend the import which is used for TS files
         // The other shims need to be provided by the user ambient-style,
         // for example through filenames.push(require.resolve('svelte2tsx/svelte-shims.d.ts'))
+        // TODO replace with SvelteComponent for Svelte 5, keep old for backwards compatibility with Svelte 3
         str.prepend('import { SvelteComponentTyped } from "svelte"\n' + '\n');
         let code = str.toString();
         // Remove all tsx occurences and the template part from the output

package/index.mjs

@@ -1232,17 +1232,16 @@ class MagicString {
 	}
 }
 
-function parseAttributeValue(value) {
-    return /^['"]/.test(value) ? value.slice(1, -1) : value;
-}
 function parseAttributes(str, start) {
     const attrs = [];
-    str.split(/\s+/)
-        .filter(Boolean)
-        .forEach((attr) => {
+    const pattern = /([\w-$]+\b)(?:=(?:"([^"]*)"|'([^']*)'|(\S+)))?/g;
+    let match;
+    while ((match = pattern.exec(str)) !== null) {
+        const attr = match[0];
+        const name = match[1];
+        const value = match[2] || match[3] || match[4];
         const attrStart = start + str.indexOf(attr);
-        const [name, value] = attr.split('=');
-        attrs[name] = value ? parseAttributeValue(value) : name;
+        attrs[name] = value !== null && value !== void 0 ? value : name;
         attrs.push({
             type: 'Attribute',
             name,
@@ -1251,13 +1250,13 @@ function parseAttributes(str, start) {
                     type: 'Text',
                     start: attrStart + attr.indexOf('=') + 1,
                     end: attrStart + attr.length,
-                    raw: parseAttributeValue(value)
+                    raw: value
                 }
             ],
             start: attrStart,
             end: attrStart + attr.length
         });
-    });
+    }
     return attrs;
 }
 function extractTag(htmlx, tag) {
@@ -2323,7 +2322,11 @@ const oneWayBindingAttributes = new Set([
     'ended',
     'readyState',
     'naturalWidth',
-    'naturalHeight'
+    'naturalHeight',
+    'contentRect',
+    'contentBoxSize',
+    'borderBoxSize',
+    'devicePixelContentBoxSize'
 ]);
 /**
  * List of all binding names that are transformed to sth like `binding = variable`.
@@ -2768,7 +2771,9 @@ function convertHtmlxToJsx(str, ast, onWalk = null, onLeave = null, options = {}
     stripDoctype(str);
     let element;
     walk$1(ast, {
-        enter: (node, parent, prop, index) => {
+        enter: (estreeTypedNode, estreeTypedParent, prop, index) => {
+            const node = estreeTypedNode;
+            const parent = estreeTypedParent;
             try {
                 switch (node.type) {
                     case 'IfBlock':
@@ -2869,7 +2874,9 @@ function convertHtmlxToJsx(str, ast, onWalk = null, onLeave = null, options = {}
                 throw e;
             }
         },
-        leave: (node, parent, prop, index) => {
+        leave: (estreeTypedNode, estreeTypedParent, prop, index) => {
+            const node = estreeTypedNode;
+            const parent = estreeTypedParent;
             try {
                 switch (node.type) {
                     case 'IfBlock':
@@ -3923,7 +3930,7 @@ class ExportedNames {
         if (exportModifier) {
             const isLet = node.declarationList.flags === ts.NodeFlags.Let;
             const isConst = node.declarationList.flags === ts.NodeFlags.Const;
-            this.handleExportedVariableDeclarationList(node.declarationList, (_, ...args) => this.addExport(...args));
+            this.handleExportedVariableDeclarationList(node.declarationList, (_, ...args) => this.addExportForBindingPattern(...args));
             if (isLet) {
                 this.propTypeAssertToUserDefined(node.declarationList);
             }
@@ -4130,12 +4137,6 @@ class ExportedNames {
      * Adds export to map
      */
     addExport(name, isLet, target = null, type = null, required = false) {
-        if (name.kind != ts.SyntaxKind.Identifier) {
-            throw Error('export source kind not supported ' + name);
-        }
-        if (target && target.kind != ts.SyntaxKind.Identifier) {
-            throw Error('export target kind not supported ' + target);
-        }
         const existingDeclaration = this.possibleExports.get(name.text);
         if (target) {
             this.exports.set(name.text, {
@@ -4158,6 +4159,17 @@ class ExportedNames {
             this.propTypeAssertToUserDefined(existingDeclaration.declaration);
         }
     }
+    addExportForBindingPattern(name, isLet, target = null, type = null, required = false) {
+        if (ts.isIdentifier(name)) {
+            if (!target || ts.isIdentifier(target)) {
+                this.addExport(name, isLet, target, type, required);
+            }
+            return;
+        }
+        name.elements.forEach((child) => {
+            this.addExportForBindingPattern(child.name, isLet, undefined, type, required);
+        });
+    }
     getDoc(target) {
         var _a, _b;
         let doc = undefined;
@@ -5235,16 +5247,29 @@ function getLineOffsets(text) {
 }
 
 class Generics {
-    constructor(str, astOffset) {
+    constructor(str, astOffset, script) {
+        var _a, _b;
         this.str = str;
         this.astOffset = astOffset;
         this.definitions = [];
         this.typeReferences = [];
         this.references = [];
+        this.genericsAttr = script.attributes.find((attr) => attr.name === 'generics');
+        const generics = (_b = (_a = this.genericsAttr) === null || _a === void 0 ? void 0 : _a.value[0]) === null || _b === void 0 ? void 0 : _b.raw;
+        if (generics) {
+            this.definitions = generics.split(',').map((g) => g.trim());
+            this.references = this.definitions.map((def) => def.split(/\s/)[0]);
+        }
+        else {
+            this.genericsAttr = undefined;
+        }
     }
     addIfIsGeneric(node) {
         var _a, _b;
         if (ts.isTypeAliasDeclaration(node) && this.is$$GenericType(node.type)) {
+            if (this.genericsAttr) {
+                throw new Error('Invalid $$Generic declaration: $$Generic definitions are not allowed when the generics attribute is present on the script tag');
+            }
             if (((_a = node.type.typeArguments) === null || _a === void 0 ? void 0 : _a.length) > 1) {
                 throw new Error('Invalid $$Generic declaration: Only one type argument allowed');
             }
@@ -5366,7 +5391,7 @@ function processInstanceScriptContent(str, script, events, implicitStoreValues,
     const tsAst = ts.createSourceFile('component.ts.svelte', scriptContent, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
     const astOffset = script.content.start;
     const exportedNames = new ExportedNames(str, astOffset, basename);
-    const generics = new Generics(str, astOffset);
+    const generics = new Generics(str, astOffset, script);
     const interfacesAndTypes = new InterfacesAndTypes();
     const implicitTopLevelNames = new ImplicitTopLevelNames(str, astOffset);
     let uses$$props = false;
@@ -5593,7 +5618,11 @@ function processModuleScriptTag(str, script, implicitStoreValues) {
     const scriptContent = htmlx.substring(script.content.start, script.content.end);
     const tsAst = ts.createSourceFile('component.module.ts.svelte', scriptContent, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
     const astOffset = script.content.start;
-    const generics = new Generics(str, astOffset);
+    const generics = new Generics(str, astOffset, script);
+    if (generics.genericsAttr) {
+        const start = htmlx.indexOf('generics', script.start);
+        throwError(start, start + 8, 'The generics attribute is only allowed on the instance script', str.original);
+    }
     const walk = (node) => {
         resolveImplicitStoreValue(node, implicitStoreValues, str, astOffset);
         generics.throwIfIsGeneric(node);
@@ -5812,7 +5841,25 @@ function createRenderFunction({ str, scriptTag, scriptDestination, slots, events
         //I couldn't get magicstring to let me put the script before the <> we prepend during conversion of the template to jsx, so we just close it instead
         const scriptTagEnd = htmlx.lastIndexOf('>', scriptTag.content.start) + 1;
         str.overwrite(scriptTag.start, scriptTag.start + 1, ';');
-        str.overwrite(scriptTag.start + 1, scriptTagEnd, `function render${generics.toDefinitionString(true)}() {${propsDecl}\n`);
+        if (generics.genericsAttr) {
+            let start = generics.genericsAttr.value[0].start;
+            let end = generics.genericsAttr.value[0].end;
+            if (htmlx.charAt(start) === '"' || htmlx.charAt(start) === "'") {
+                start++;
+                end--;
+            }
+            str.overwrite(scriptTag.start + 1, start - 1, `function render`);
+            str.overwrite(start - 1, start, `<`); // if the generics are unused, only this char is colored opaque
+            if (end < scriptTagEnd) {
+                str.overwrite(end, scriptTagEnd, `>() {${propsDecl}\n`);
+            }
+            else {
+                str.prependRight(end, `>() {${propsDecl}\n`);
+            }
+        }
+        else {
+            str.overwrite(scriptTag.start + 1, scriptTagEnd, `function render${generics.toDefinitionString(true)}() {${propsDecl}\n`);
+        }
         const scriptEndTagStart = htmlx.lastIndexOf('<', scriptTag.end - 1);
         // wrap template with callback
         str.overwrite(scriptEndTagStart, scriptTag.end, `${slotsDeclaration};\nasync () => {`, {
@@ -5820,8 +5867,7 @@ function createRenderFunction({ str, scriptTag, scriptDestination, slots, events
         });
     }
     else {
-        str.prependRight(scriptDestination, `;function render${generics.toDefinitionString(true)}() {` +
-            `${propsDecl}${slotsDeclaration}\nasync () => {`);
+        str.prependRight(scriptDestination, `;function render() {` + `${propsDecl}${slotsDeclaration}\nasync () => {`);
     }
     const slotsAsDef = uses$$SlotsInterface
         ? '{} as unknown as $$Slots'
@@ -6084,7 +6130,7 @@ function svelte2tsx(svelte, options = {}) {
     const implicitStoreValues = new ImplicitStoreValues(resolvedStores, renderFunctionStart);
     //move the instance script and process the content
     let exportedNames = new ExportedNames(str, 0, basename);
-    let generics = new Generics(str, 0);
+    let generics = new Generics(str, 0, { attributes: [] });
     let uses$$SlotsInterface = false;
     if (scriptTag) {
         //ensure it is between the module script and the rest of the template (the variables need to be declared before the jsx template)
@@ -6134,6 +6180,7 @@ function svelte2tsx(svelte, options = {}) {
         // Prepend the import which is used for TS files
         // The other shims need to be provided by the user ambient-style,
         // for example through filenames.push(require.resolve('svelte2tsx/svelte-shims.d.ts'))
+        // TODO replace with SvelteComponent for Svelte 5, keep old for backwards compatibility with Svelte 3
         str.prepend('import { SvelteComponentTyped } from "svelte"\n' + '\n');
         let code = str.toString();
         // Remove all tsx occurences and the template part from the output

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte2tsx",
-  "version": "0.6.14",
+  "version": "0.6.16",
   "description": "Convert Svelte components to TSX for type checking",
   "author": "David Pershouse",
   "license": "MIT",
@@ -24,10 +24,13 @@
     "@rollup/plugin-json": "^6.0.0",
     "@rollup/plugin-node-resolve": "^15.0.0",
     "@rollup/plugin-typescript": "^10.0.0",
+    "@types/estree": "^0.0.42",
     "@types/mocha": "^9.1.0",
     "@types/node": "^16.0.0",
     "@types/unist": "^2.0.3",
     "@types/vfile": "^3.0.2",
+    "builtin-modules": "^3.3.0",
+    "estree-walker": "^2.0.1",
     "magic-string": "^0.27.0",
     "mocha": "^9.2.0",
     "periscopic": "^2.0.2",
@@ -37,18 +40,12 @@
     "svelte": "~3.57.0",
     "tiny-glob": "^0.2.6",
     "tslib": "^2.4.0",
-    "typescript": "^5.0.3"
+    "typescript": "^5.1.3"
   },
   "peerDependencies": {
-    "svelte": "^3.55",
+    "svelte": "^3.55 || ^4.0.0-next.0 || ^4.0",
     "typescript": "^4.9.4 || ^5.0.0"
   },
-  "scripts": {
-    "build": "rollup -c",
-    "prepublishOnly": "npm run build",
-    "dev": "rollup -c -w",
-    "test": "mocha test/test.ts"
-  },
   "files": [
     "index.mjs",
     "index.js",
@@ -56,12 +53,18 @@
     "README.md",
     "LICENSE",
     "svelte-jsx.d.ts",
+    "svelte-jsx-v4.d.ts",
     "svelte-native-jsx.d.ts",
     "svelte-shims.d.ts",
-    "svelte-html-do-not-use.d.ts"
+    "svelte-shims-v4.d.ts"
   ],
   "dependencies": {
     "dedent-js": "^1.0.1",
     "pascal-case": "^3.1.1"
+  },
+  "scripts": {
+    "build": "rollup -c",
+    "dev": "rollup -c -w",
+    "test": "mocha test/test.ts"
   }
-}
+}

package/svelte-jsx-v4.d.ts

@@ -0,0 +1,229 @@
+/// <reference lib="dom" />
+
+declare namespace svelteHTML {
+
+  // Every namespace eligible for use needs to implement the following two functions
+  /**
+   * @internal do not use
+   */
+  function mapElementTag<K extends keyof ElementTagNameMap>(
+    tag: K
+  ): ElementTagNameMap[K];
+  function mapElementTag<K extends keyof SVGElementTagNameMap>(
+    tag: K
+  ): SVGElementTagNameMap[K];
+  function mapElementTag(
+    tag: any
+  ): any; // needs to be any because used in context of <svelte:element>
+
+  /**
+   * @internal do not use
+   */
+  function createElement<Elements extends IntrinsicElements, Key extends keyof Elements>(
+    // "undefined | null" because of <svelte:element>
+    element: Key | undefined | null, attrs: string extends Key ? import('svelte/elements').HTMLAttributes<any> : Elements[Key]
+  ): Key extends keyof ElementTagNameMap ? ElementTagNameMap[Key] : Key extends keyof SVGElementTagNameMap ? SVGElementTagNameMap[Key] : any;
+  function createElement<Elements extends IntrinsicElements, Key extends keyof Elements, T>(
+    // "undefined | null" because of <svelte:element>
+    element: Key | undefined | null, attrsEnhancers: T, attrs: (string extends Key ? import('svelte/elements').HTMLAttributes<any> : Elements[Key]) & T
+  ): Key extends keyof ElementTagNameMap ? ElementTagNameMap[Key] : Key extends keyof SVGElementTagNameMap ? SVGElementTagNameMap[Key] : any;
+
+  // For backwards-compatibility and ease-of-use, in case someone enhanced the typings from import('svelte/elements').HTMLAttributes/SVGAttributes
+  interface HTMLAttributes<T extends EventTarget = any> {}
+  interface SVGAttributes<T extends EventTarget = any> {}
+
+  /**
+   * @internal do not use
+   */
+  type HTMLProps<Property extends string, Override> =
+    Omit<import('svelte/elements').SvelteHTMLElements[Property], keyof Override> & Override;
+
+  interface IntrinsicElements {
+    a: HTMLProps<'a', HTMLAttributes>;
+    abbr: HTMLProps<'abbr', HTMLAttributes>;
+    address: HTMLProps<'address', HTMLAttributes>;
+    area: HTMLProps<'area', HTMLAttributes>;
+    article: HTMLProps<'article', HTMLAttributes>;
+    aside: HTMLProps<'aside', HTMLAttributes>;
+    audio: HTMLProps<'audio', HTMLAttributes>;
+    b: HTMLProps<'b', HTMLAttributes>;
+    base: HTMLProps<'base', HTMLAttributes>;
+    bdi: HTMLProps<'bdi', HTMLAttributes>;
+    bdo: HTMLProps<'bdo', HTMLAttributes>;
+    big: HTMLProps<'big', HTMLAttributes>;
+    blockquote: HTMLProps<'blockquote', HTMLAttributes>;
+    body: HTMLProps<'body', HTMLAttributes>;
+    br: HTMLProps<'br', HTMLAttributes>;
+    button: HTMLProps<'button', HTMLAttributes>;
+    canvas: HTMLProps<'canvas', HTMLAttributes>;
+    caption: HTMLProps<'caption', HTMLAttributes>;
+    cite: HTMLProps<'cite', HTMLAttributes>;
+    code: HTMLProps<'code', HTMLAttributes>;
+    col: HTMLProps<'col', HTMLAttributes>;
+    colgroup: HTMLProps<'colgroup', HTMLAttributes>;
+    data: HTMLProps<'data', HTMLAttributes>;
+    datalist: HTMLProps<'datalist', HTMLAttributes>;
+    dd: HTMLProps<'dd', HTMLAttributes>;
+    del: HTMLProps<'del', HTMLAttributes>;
+    details: HTMLProps<'details', HTMLAttributes>;
+    dfn: HTMLProps<'dfn', HTMLAttributes>;
+    dialog: HTMLProps<'dialog', HTMLAttributes>;
+    div: HTMLProps<'div', HTMLAttributes>;
+    dl: HTMLProps<'dl', HTMLAttributes>;
+    dt: HTMLProps<'dt', HTMLAttributes>;
+    em: HTMLProps<'em', HTMLAttributes>;
+    embed: HTMLProps<'embed', HTMLAttributes>;
+    fieldset: HTMLProps<'fieldset', HTMLAttributes>;
+    figcaption: HTMLProps<'figcaption', HTMLAttributes>;
+    figure: HTMLProps<'figure', HTMLAttributes>;
+    footer: HTMLProps<'footer', HTMLAttributes>;
+    form: HTMLProps<'form', HTMLAttributes>;
+    h1: HTMLProps<'h1', HTMLAttributes>;
+    h2: HTMLProps<'h2', HTMLAttributes>;
+    h3: HTMLProps<'h3', HTMLAttributes>;
+    h4: HTMLProps<'h4', HTMLAttributes>;
+    h5: HTMLProps<'h5', HTMLAttributes>;
+    h6: HTMLProps<'h6', HTMLAttributes>;
+    head: HTMLProps<'head', HTMLAttributes>;
+    header: HTMLProps<'header', HTMLAttributes>;
+    hgroup: HTMLProps<'hgroup', HTMLAttributes>;
+    hr: HTMLProps<'hr', HTMLAttributes>;
+    html: HTMLProps<'html', HTMLAttributes>;
+    i: HTMLProps<'i', HTMLAttributes>;
+    iframe: HTMLProps<'iframe', HTMLAttributes>;
+    img: HTMLProps<'img', HTMLAttributes>;
+    input: HTMLProps<'input', HTMLAttributes>;
+    ins: HTMLProps<'ins', HTMLAttributes>;
+    kbd: HTMLProps<'kbd', HTMLAttributes>;
+    keygen: HTMLProps<'keygen', HTMLAttributes>;
+    label: HTMLProps<'label', HTMLAttributes>;
+    legend: HTMLProps<'legend', HTMLAttributes>;
+    li: HTMLProps<'li', HTMLAttributes>;
+    link: HTMLProps<'link', HTMLAttributes>;
+    main: HTMLProps<'main', HTMLAttributes>;
+    map: HTMLProps<'map', HTMLAttributes>;
+    mark: HTMLProps<'mark', HTMLAttributes>;
+    menu: HTMLProps<'menu', HTMLAttributes>;
+    menuitem: HTMLProps<'menuitem', HTMLAttributes>;
+    meta: HTMLProps<'meta', HTMLAttributes>;
+    meter: HTMLProps<'meter', HTMLAttributes>;
+    nav: HTMLProps<'nav', HTMLAttributes>;
+    noscript: HTMLProps<'noscript', HTMLAttributes>;
+    object: HTMLProps<'object', HTMLAttributes>;
+    ol: HTMLProps<'ol', HTMLAttributes>;
+    optgroup: HTMLProps<'optgroup', HTMLAttributes>;
+    option: HTMLProps<'option', HTMLAttributes>;
+    output: HTMLProps<'output', HTMLAttributes>;
+    p: HTMLProps<'p', HTMLAttributes>;
+    param: HTMLProps<'param', HTMLAttributes>;
+    picture: HTMLProps<'picture', HTMLAttributes>;
+    pre: HTMLProps<'pre', HTMLAttributes>;
+    progress: HTMLProps<'progress', HTMLAttributes>;
+    q: HTMLProps<'q', HTMLAttributes>;
+    rp: HTMLProps<'rp', HTMLAttributes>;
+    rt: HTMLProps<'rt', HTMLAttributes>;
+    ruby: HTMLProps<'ruby', HTMLAttributes>;
+    s: HTMLProps<'s', HTMLAttributes>;
+    samp: HTMLProps<'samp', HTMLAttributes>;
+    slot: HTMLProps<'slot', HTMLAttributes>;
+    script: HTMLProps<'script', HTMLAttributes>;
+    section: HTMLProps<'section', HTMLAttributes>;
+    select: HTMLProps<'select', HTMLAttributes>;
+    small: HTMLProps<'small', HTMLAttributes>;
+    source: HTMLProps<'source', HTMLAttributes>;
+    span: HTMLProps<'span', HTMLAttributes>;
+    strong: HTMLProps<'strong', HTMLAttributes>;
+    style: HTMLProps<'style', HTMLAttributes>;
+    sub: HTMLProps<'sub', HTMLAttributes>;
+    summary: HTMLProps<'summary', HTMLAttributes>;
+    sup: HTMLProps<'sup', HTMLAttributes>;
+    table: HTMLProps<'table', HTMLAttributes>;
+    template: HTMLProps<'template', HTMLAttributes>;
+    tbody: HTMLProps<'tbody', HTMLAttributes>;
+    td: HTMLProps<'td', HTMLAttributes>;
+    textarea: HTMLProps<'textarea', HTMLAttributes>;
+    tfoot: HTMLProps<'tfoot', HTMLAttributes>;
+    th: HTMLProps<'th', HTMLAttributes>;
+    thead: HTMLProps<'thead', HTMLAttributes>;
+    time: HTMLProps<'time', HTMLAttributes>;
+    title: HTMLProps<'title', HTMLAttributes>;
+    tr: HTMLProps<'tr', HTMLAttributes>;
+    track: HTMLProps<'track', HTMLAttributes>;
+    u: HTMLProps<'u', HTMLAttributes>;
+    ul: HTMLProps<'ul', HTMLAttributes>;
+    var: HTMLProps<'var', HTMLAttributes>;
+    video: HTMLProps<'video', HTMLAttributes>;
+    wbr: HTMLProps<'wbr', HTMLAttributes>;
+    webview: HTMLProps<'webview', HTMLAttributes>;
+    // SVG
+    svg: HTMLProps<'svg', SVGAttributes>;
+
+    animate: HTMLProps<'animate', SVGAttributes>;
+    animateMotion: HTMLProps<'animateMotion', SVGAttributes>;
+    animateTransform: HTMLProps<'animateTransform', SVGAttributes>;
+    circle: HTMLProps<'circle', SVGAttributes>;
+    clipPath: HTMLProps<'clipPath', SVGAttributes>;
+    defs: HTMLProps<'defs', SVGAttributes>;
+    desc: HTMLProps<'desc', SVGAttributes>;
+    ellipse: HTMLProps<'ellipse', SVGAttributes>;
+    feBlend: HTMLProps<'feBlend', SVGAttributes>;
+    feColorMatrix: HTMLProps<'feColorMatrix', SVGAttributes>;
+    feComponentTransfer: HTMLProps<'feComponentTransfer', SVGAttributes>;
+    feComposite: HTMLProps<'feComposite', SVGAttributes>;
+    feConvolveMatrix: HTMLProps<'feConvolveMatrix', SVGAttributes>;
+    feDiffuseLighting: HTMLProps<'feDiffuseLighting', SVGAttributes>;
+    feDisplacementMap: HTMLProps<'feDisplacementMap', SVGAttributes>;
+    feDistantLight: HTMLProps<'feDistantLight', SVGAttributes>;
+    feDropShadow: HTMLProps<'feDropShadow', SVGAttributes>;
+    feFlood: HTMLProps<'feFlood', SVGAttributes>;
+    feFuncA: HTMLProps<'feFuncA', SVGAttributes>;
+    feFuncB: HTMLProps<'feFuncB', SVGAttributes>;
+    feFuncG: HTMLProps<'feFuncG', SVGAttributes>;
+    feFuncR: HTMLProps<'feFuncR', SVGAttributes>;
+    feGaussianBlur: HTMLProps<'feGaussianBlur', SVGAttributes>;
+    feImage: HTMLProps<'feImage', SVGAttributes>;
+    feMerge: HTMLProps<'feMerge', SVGAttributes>;
+    feMergeNode: HTMLProps<'feMergeNode', SVGAttributes>;
+    feMorphology: HTMLProps<'feMorphology', SVGAttributes>;
+    feOffset: HTMLProps<'feOffset', SVGAttributes>;
+    fePointLight: HTMLProps<'fePointLight', SVGAttributes>;
+    feSpecularLighting: HTMLProps<'feSpecularLighting', SVGAttributes>;
+    feSpotLight: HTMLProps<'feSpotLight', SVGAttributes>;
+    feTile: HTMLProps<'feTile', SVGAttributes>;
+    feTurbulence: HTMLProps<'feTurbulence', SVGAttributes>;
+    filter: HTMLProps<'filter', SVGAttributes>;
+    foreignObject: HTMLProps<'foreignObject', SVGAttributes>;
+    g: HTMLProps<'g', SVGAttributes>;
+    image: HTMLProps<'image', SVGAttributes>;
+    line: HTMLProps<'line', SVGAttributes>;
+    linearGradient: HTMLProps<'linearGradient', SVGAttributes>;
+    marker: HTMLProps<'marker', SVGAttributes>;
+    mask: HTMLProps<'mask', SVGAttributes>;
+    metadata: HTMLProps<'metadata', SVGAttributes>;
+    mpath: HTMLProps<'mpath', SVGAttributes>;
+    path: HTMLProps<'path', SVGAttributes>;
+    pattern: HTMLProps<'pattern', SVGAttributes>;
+    polygon: HTMLProps<'polygon', SVGAttributes>;
+    polyline: HTMLProps<'polyline', SVGAttributes>;
+    radialGradient: HTMLProps<'radialGradient', SVGAttributes>;
+    rect: HTMLProps<'rect', SVGAttributes>;
+    stop: HTMLProps<'stop', SVGAttributes>;
+    switch: HTMLProps<'switch', SVGAttributes>;
+    symbol: HTMLProps<'symbol', SVGAttributes>;
+    text: HTMLProps<'text', SVGAttributes>;
+    textPath: HTMLProps<'textPath', SVGAttributes>;
+    tspan: HTMLProps<'tspan', SVGAttributes>;
+    use: HTMLProps<'use', SVGAttributes>;
+    view: HTMLProps<'view', SVGAttributes>;
+
+    // Svelte specific
+    'svelte:window': HTMLProps<'svelte:window', HTMLAttributes>;
+    'svelte:body': HTMLProps<'svelte:body', HTMLAttributes>;
+    'svelte:fragment': { slot?: string };
+    'svelte:options': { [name: string]: any };
+    'svelte:head': { [name: string]: any };
+
+    [name: string]: { [name: string]: any };
+  }
+
+}

package/svelte-shims-v4.d.ts

@@ -0,0 +1,227 @@
+// Whenever a ambient declaration changes, its number should be increased
+// This way, we avoid the situation where multiple ambient versions of svelte2tsx
+// are loaded and their declarations conflict each other
+// See https://github.com/sveltejs/language-tools/issues/1059 for an example bug that stems from it
+// If you change anything in this file, think about whether or not it should be backported to svelte-shims.d.ts
+
+type AConstructorTypeOf<T, U extends any[] = any[]> = new (...args: U) => T;
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteComponentConstructor<T, U extends import('svelte').ComponentConstructorOptions<any>> = new (options: U) => T;
+
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteActionReturnType = {
+	update?: (args: any) => void,
+	destroy?: () => void
+} | void
+
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteTransitionConfig = {
+    delay?: number,
+    duration?: number,
+    easing?: (t: number) => number,
+    css?: (t: number, u: number) => string,
+    tick?: (t: number, u: number) => void
+}
+
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteTransitionReturnType = SvelteTransitionConfig | (() => SvelteTransitionConfig)
+
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteAnimationReturnType = {
+    delay?: number,
+    duration?: number,
+    easing?: (t: number) => number,
+    css?: (t: number, u: number) => string,
+    tick?: (t: number, u: number) => void
+}
+
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteWithOptionalProps<Props, Keys extends keyof Props> = Omit<Props, Keys> & Partial<Pick<Props, Keys>>;
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteAllProps = { [index: string]: any }
+/** @internal PRIVATE API, DO NOT USE */
+type SveltePropsAnyFallback<Props> = {[K in keyof Props]: Props[K] extends never ? never : Props[K] extends undefined ? any : Props[K]}
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteSlotsAnyFallback<Slots> = {[K in keyof Slots]: {[S in keyof Slots[K]]: Slots[K][S] extends undefined ? any : Slots[K][S]}}
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteRestProps = { [index: string]: any }
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteSlots = { [index: string]: any }
+/** @internal PRIVATE API, DO NOT USE */
+type SvelteStore<T> = { subscribe: (run: (value: T) => any, invalidate?: any) => any }
+
+// Forces TypeScript to look into the type which results in a better representation of it
+// which helps for error messages and is necessary for d.ts file transformation so that
+// no ambient type references are left in the output
+/** @internal PRIVATE API, DO NOT USE */
+type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;
+
+/** @internal PRIVATE API, DO NOT USE */
+type KeysMatching<Obj, V> = {[K in keyof Obj]-?: Obj[K] extends V ? K : never}[keyof Obj]
+/** @internal PRIVATE API, DO NOT USE */
+declare type __sveltets_2_CustomEvents<T> = {[K in KeysMatching<T, CustomEvent>]: T[K] extends CustomEvent ? T[K]['detail']: T[K]}
+
+declare var process: NodeJS.Process & { browser: boolean }
+declare function __sveltets_2_ensureRightProps<Props>(props: Props): {};
+declare function __sveltets_2_instanceOf<T = any>(type: AConstructorTypeOf<T>): T;
+declare function __sveltets_2_allPropsType(): SvelteAllProps
+declare function __sveltets_2_restPropsType(): SvelteRestProps
+declare function __sveltets_2_slotsType<Slots, Key extends keyof Slots>(slots: Slots): Record<Key, boolean>;
+
+// Overload of the following two functions is necessary.
+// An empty array of optionalProps makes OptionalProps type any, which means we lose the prop typing.
+// optionalProps need to be first or its type cannot be infered correctly.
+
+declare function __sveltets_2_partial<Props = {}, Events = {}, Slots = {}>(
+    render: {props: Props, events: Events, slots: Slots }
+): {props: Expand<SveltePropsAnyFallback<Props>>, events: Events, slots: Expand<SvelteSlotsAnyFallback<Slots>> }
+declare function __sveltets_2_partial<Props = {}, Events = {}, Slots = {}, OptionalProps extends keyof Props = any>(
+    optionalProps: OptionalProps[],
+    render: {props: Props, events: Events, slots: Slots }
+): {props: Expand<SvelteWithOptionalProps<SveltePropsAnyFallback<Props>, OptionalProps>>, events: Events, slots: Expand<SvelteSlotsAnyFallback<Slots>> }
+
+declare function __sveltets_2_partial_with_any<Props = {}, Events = {}, Slots = {}>(
+    render: {props: Props, events: Events, slots: Slots }
+): {props: Expand<SveltePropsAnyFallback<Props> & SvelteAllProps>, events: Events, slots: Expand<SvelteSlotsAnyFallback<Slots>> }
+declare function __sveltets_2_partial_with_any<Props = {}, Events = {}, Slots = {}, OptionalProps extends keyof Props = any>(
+    optionalProps: OptionalProps[],
+    render: {props: Props, events: Events, slots: Slots }
+): {props: Expand<SvelteWithOptionalProps<SveltePropsAnyFallback<Props>, OptionalProps> & SvelteAllProps>, events: Events, slots: Expand<SvelteSlotsAnyFallback<Slots>> }
+
+
+declare function __sveltets_2_with_any<Props = {}, Events = {}, Slots = {}>(
+    render: {props: Props, events: Events, slots: Slots }
+): {props: Expand<Props & SvelteAllProps>, events: Events, slots: Slots }
+
+declare function __sveltets_2_with_any_event<Props = {}, Events = {}, Slots = {}>(
+    render: {props: Props, events: Events, slots: Slots }
+): {props: Props, events: Events & {[evt: string]: CustomEvent<any>;}, slots: Slots }
+
+declare function __sveltets_2_store_get<T = any>(store: SvelteStore<T>): T
+declare function __sveltets_2_store_get<Store extends SvelteStore<any> | undefined | null>(store: Store): Store extends SvelteStore<infer T> ? T : Store;
+declare function __sveltets_2_any(dummy: any): any;
+// declare function __sveltets_1_empty(...dummy: any[]): {};
+// declare function __sveltets_1_componentType(): AConstructorTypeOf<import("svelte").SvelteComponentTyped<any, any, any>>
+declare function __sveltets_2_invalidate<T>(getValue: () => T): T
+
+declare function __sveltets_2_mapWindowEvent<K extends keyof HTMLBodyElementEventMap>(
+    event: K
+): HTMLBodyElementEventMap[K];
+declare function __sveltets_2_mapBodyEvent<K extends keyof WindowEventMap>(
+    event: K
+): WindowEventMap[K];
+declare function __sveltets_2_mapElementEvent<K extends keyof HTMLElementEventMap>(
+    event: K
+): HTMLElementEventMap[K];
+
+declare function __sveltets_2_bubbleEventDef<Events, K extends keyof Events>(
+    events: Events, eventKey: K
+): Events[K];
+declare function __sveltets_2_bubbleEventDef(
+    events: any, eventKey: string
+): any;
+
+declare const __sveltets_2_customEvent: CustomEvent<any>;
+declare function __sveltets_2_toEventTypings<Typings>(): {[Key in keyof Typings]: CustomEvent<Typings[Key]>};
+
+declare function __sveltets_2_unionType<T1, T2>(t1: T1, t2: T2): T1 | T2;
+declare function __sveltets_2_unionType<T1, T2, T3>(t1: T1, t2: T2, t3: T3): T1 | T2 | T3;
+declare function __sveltets_2_unionType<T1, T2, T3, T4>(t1: T1, t2: T2, t3: T3, t4: T4): T1 | T2 | T3 | T4;
+declare function __sveltets_2_unionType(...types: any[]): any;
+
+declare function __sveltets_2_createSvelte2TsxComponent<Props, Events, Slots>(
+    render: {props: Props, events: Events, slots: Slots }
+): SvelteComponentConstructor<import("svelte").SvelteComponentTyped<Props, Events, Slots>,import('svelte').ComponentConstructorOptions<Props>>;
+
+declare function __sveltets_2_unwrapArr<T>(arr: ArrayLike<T>): T
+declare function __sveltets_2_unwrapPromiseLike<T>(promise: PromiseLike<T> | T): T
+
+// v2
+declare function __sveltets_2_createCreateSlot<Slots = Record<string, Record<string, any>>>(): <SlotName extends keyof Slots>(slotName: SlotName, attrs: Slots[SlotName]) => Record<string, any>;
+declare function __sveltets_2_createComponentAny(props: Record<string, any>): import("svelte").SvelteComponentTyped<any, any, any>;
+
+declare function __sveltets_2_any(...dummy: any[]): any;
+declare function __sveltets_2_empty(...dummy: any[]): {};
+declare function __sveltets_2_union<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>(t1:T1,t2?:T2,t3?:T3,t4?:T4,t5?:T5,t6?:T6,t7?:T7,t8?:T8,t9?:T9,t10?:T10): T1 & T2 & T3 & T4 & T5 & T6 & T7 & T8 & T9 & T10;
+declare function __sveltets_2_nonNullable<T>(type: T): NonNullable<T>;
+
+declare function __sveltets_2_cssProp(prop: Record<string, any>): {};
+
+/** @internal PRIVATE API, DO NOT USE */
+type __sveltets_2_SvelteAnimationReturnType = {
+    delay?: number,
+    duration?: number,
+    easing?: (t: number) => number,
+    css?: (t: number, u: number) => string,
+    tick?: (t: number, u: number) => void
+}
+declare var __sveltets_2_AnimationMove: { from: DOMRect, to: DOMRect }
+declare function __sveltets_2_ensureAnimation(animationCall: __sveltets_2_SvelteAnimationReturnType): {};
+
+/** @internal PRIVATE API, DO NOT USE */
+type __sveltets_2_SvelteActionReturnType = {
+	update?: (args: any) => void,
+	destroy?: () => void,
+    $$_attributes?: Record<string, any>,
+} | void
+declare function __sveltets_2_ensureAction<T extends __sveltets_2_SvelteActionReturnType>(actionCall: T): T extends  {$$_attributes?: any} ? T['$$_attributes'] : {};
+
+/** @internal PRIVATE API, DO NOT USE */
+type __sveltets_2_SvelteTransitionConfig = {
+    delay?: number,
+    duration?: number,
+    easing?: (t: number) => number,
+    css?: (t: number, u: number) => string,
+    tick?: (t: number, u: number) => void
+}
+/** @internal PRIVATE API, DO NOT USE */
+type __sveltets_2_SvelteTransitionReturnType = __sveltets_2_SvelteTransitionConfig | (() => __sveltets_2_SvelteTransitionConfig)
+declare function __sveltets_2_ensureTransition(transitionCall: __sveltets_2_SvelteTransitionReturnType): {};
+
+// Includes undefined and null for all types as all usages also allow these
+declare function __sveltets_2_ensureType<T>(type: AConstructorTypeOf<T>, el: T | undefined | null): {};
+declare function __sveltets_2_ensureType<T1, T2>(type1: AConstructorTypeOf<T1>, type2: AConstructorTypeOf<T2>, el: T1 | T2 | undefined | null): {};
+
+// The following is necessary because there are two clashing errors that can't be solved at the same time
+// when using Svelte2TsxComponent, more precisely the event typings in
+// __sveltets_2_ensureComponent<T extends new (..) => _SvelteComponent<any,||any||<-this,any>>(type: T): T;
+// If we type it as "any", we have an error when using sth like {a: CustomEvent<any>}
+// If we type it as "{}", we have an error when using sth like {[evt: string]: CustomEvent<any>}
+// If we type it as "unknown", we get all kinds of follow up errors which we want to avoid
+// Therefore introduce two more base classes just for this case.
+/**
+ * Ambient type only used for intellisense, DO NOT USE IN YOUR PROJECT
+ */
+declare type ATypedSvelteComponent = {
+    /**
+     * @internal This is for type checking capabilities only
+     * and does not exist at runtime. Don't use this property.
+     */
+    $$prop_def: any;
+    /**
+     * @internal This is for type checking capabilities only
+     * and does not exist at runtime. Don't use this property.
+     */
+    $$events_def: any;
+    /**
+     * @internal This is for type checking capabilities only
+     * and does not exist at runtime. Don't use this property.
+     */
+    $$slot_def: any;
+
+    $on(event: string, handler: ((e: any) => any) | null | undefined): () => void;
+}
+/**
+ * Ambient type only used for intellisense, DO NOT USE IN YOUR PROJECT.
+ * 
+ * If you're looking for the type of a Svelte Component, use `SvelteComponentTyped` and `ComponentType` instead:
+ *
+ * ```ts
+ * import type { ComponentType, SvelteComponentTyped } from "svelte";
+ * let myComponentConstructor: ComponentType<SvelteComponentTyped> = ..;
+ * ```
+ */
+declare type ConstructorOfATypedSvelteComponent = new (args: {target: any, props?: any}) => ATypedSvelteComponent
+declare function __sveltets_2_ensureComponent<T extends ConstructorOfATypedSvelteComponent | null | undefined>(type: T): NonNullable<T>;
+
+declare function __sveltets_2_ensureArray<T extends ArrayLike<unknown> | Iterable<unknown>>(array: T): T extends ArrayLike<infer U> ? U[] : T extends Iterable<infer U> ? Iterable<U> : any[];

package/svelte-shims.d.ts

@@ -2,6 +2,7 @@
 // This way, we avoid the situation where multiple ambient versions of svelte2tsx
 // are loaded and their declarations conflict each other
 // See https://github.com/sveltejs/language-tools/issues/1059 for an example bug that stems from it
+// If you change anything in this file, think about whether or not it should also be added to svelte-shims-v4.d.ts
 
 // -- start svelte-ls-remove --
 declare module '*.svelte' {