svelte2tsx 0.6.9 → 0.6.11

package/index.js

@@ -23,7 +23,6 @@ function _interopNamespaceDefault(e) {
     return Object.freeze(n);
 }
 
-var ts__namespace = /*#__PURE__*/_interopNamespaceDefault(ts);
 var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
 
 const comma = ','.charCodeAt(0);
@@ -2341,7 +2340,10 @@ const oneWayBindingAttributes = new Set([
     'seekable',
     'seeking',
     'played',
-    'ended'
+    'ended',
+    'readyState',
+    'naturalWidth',
+    'naturalHeight'
 ]);
 /**
  * List of all binding names that are transformed to sth like `binding = variable`.
@@ -2827,6 +2829,7 @@ function convertHtmlxToJsx(str, ast, onWalk = null, onLeave = null, options = {}
                     case 'Window':
                     case 'Head':
                     case 'Title':
+                    case 'Document':
                     case 'Body':
                     case 'Slot':
                     case 'SlotTemplate':
@@ -2903,6 +2906,7 @@ function convertHtmlxToJsx(str, ast, onWalk = null, onLeave = null, options = {}
                     case 'Head':
                     case 'Title':
                     case 'Body':
+                    case 'Document':
                     case 'Slot':
                     case 'SlotTemplate':
                         if (node.name !== '!DOCTYPE') {
@@ -3690,14 +3694,14 @@ function upserKitRouteFile(ts, basename, getSource, surround) {
     const load = exports.get('load');
     if ((load === null || load === void 0 ? void 0 : load.type) === 'function' && load.node.parameters.length === 1 && !load.hasTypeDefinition) {
         const pos = load.node.parameters[0].getEnd();
-        const inserted = surround(`: import('./$types').${basename.includes('layout') ? 'Layout' : 'Page'}${basename.includes('server') ? 'Server' : ''}LoadEvent`);
+        const inserted = surround(`: import('./$types.js').${basename.includes('layout') ? 'Layout' : 'Page'}${basename.includes('server') ? 'Server' : ''}LoadEvent`);
         insert(pos, inserted);
     }
     // add type to actions variable if not explicitly typed
     const actions = exports.get('actions');
     if ((actions === null || actions === void 0 ? void 0 : actions.type) === 'var' && !actions.hasTypeDefinition && actions.node.initializer) {
         const pos = actions.node.initializer.getEnd();
-        const inserted = surround(` satisfies import('./$types').Actions`);
+        const inserted = surround(` satisfies import('./$types.js').Actions`);
         insert(pos, inserted);
     }
     addTypeToVariable(exports, surround, insert, 'prerender', `boolean | 'auto'`);
@@ -3706,7 +3710,7 @@ function upserKitRouteFile(ts, basename, getSource, surround) {
     addTypeToVariable(exports, surround, insert, 'csr', `boolean`);
     // add types to GET/PUT/POST/PATCH/DELETE/OPTIONS if not explicitly typed
     const insertApiMethod = (name) => {
-        addTypeToFunction(ts, exports, surround, insert, name, `import('./$types').RequestEvent`, `Response | Promise<Response>`);
+        addTypeToFunction(ts, exports, surround, insert, name, `import('./$types.js').RequestEvent`, `Response | Promise<Response>`);
     };
     insertApiMethod('GET');
     insertApiMethod('PUT');
@@ -3893,6 +3897,13 @@ function updatePrepends(str, index, toAppend, removeExisting) {
     str.__prepends__.set(index, prepends);
     return prepends;
 }
+/**
+ * Returns the prepends that were added at the given index (if any).
+ */
+function getCurrentPrepends(str, index) {
+    var _a;
+    return ((_a = str.__prepends__) === null || _a === void 0 ? void 0 : _a.get(index)) || [];
+}
 
 function is$$PropsDeclaration(node) {
     return isInterfaceOrTypeDeclaration(node) && node.name.text === '$$Props';
@@ -3928,7 +3939,7 @@ class ExportedNames {
                         const isKitExport = internalHelpers.isKitRouteFile(this.basename) &&
                             n.name.getText() === 'snapshot';
                         // TS types are not allowed in JS files, but TS will still pick it up and the ignore comment will filter out the error
-                        const kitType = isKitExport && !type ? `: import('./$types').Snapshot` : '';
+                        const kitType = isKitExport && !type ? `: import('./$types.js').Snapshot` : '';
                         const nameEnd = n.name.end + this.astOffset;
                         if (kitType) {
                             preprendStr(this.str, nameEnd, surroundWithIgnoreComments(kitType));
@@ -3993,7 +4004,7 @@ class ExportedNames {
                 (name === 'data' || name === 'form' || name === 'snapshot');
             // TS types are not allowed in JS files, but TS will still pick it up and the ignore comment will filter out the error
             const kitType = isKitExport && !type
-                ? `: import('./$types').${name === 'data'
+                ? `: import('./$types.js').${name === 'data'
                     ? this.basename.includes('layout')
                         ? 'LayoutData'
                         : 'PageData'
@@ -4608,7 +4619,16 @@ class ImplicitStoreValues {
         const nodeEnd = ts.isVariableDeclarationList(node.parent) && node.parent.declarations.length > 1
             ? node.parent.declarations[node.parent.declarations.length - 1].getEnd()
             : node.getEnd();
-        str.appendRight(nodeEnd + astOffset, storeDeclarations);
+        // Quick-fixing https://github.com/sveltejs/language-tools/issues/1950
+        // TODO think about a SourceMap-wrapper that does these things for us,
+        // or investigate altering the inner workings of SourceMap, or investigate
+        // if we can always use prependStr here (and elsewhere, too)
+        if (getCurrentPrepends(str, nodeEnd + astOffset).length) {
+            preprendStr(str, nodeEnd + astOffset, storeDeclarations);
+        }
+        else {
+            str.appendRight(nodeEnd + astOffset, storeDeclarations);
+        }
     }
     attachStoreValueDeclarationToReactiveAssignment(node, astOffset, str) {
         const storeNames = getNamesFromLabeledStatement(node).filter((name) => this.accessedStores.has(name));
@@ -4617,9 +4637,10 @@ class ImplicitStoreValues {
         }
         const storeDeclarations = surroundWithIgnoreComments(this.createStoreDeclarations(storeNames));
         const endPos = node.getEnd() + astOffset;
-        // Hack for quick-fixing https://github.com/sveltejs/language-tools/issues/1097
+        // Quick-fixing https://github.com/sveltejs/language-tools/issues/1097
         // TODO think about a SourceMap-wrapper that does these things for us,
-        // or investigate altering the inner workings of SourceMap
+        // or investigate altering the inner workings of SourceMap, or investigate
+        // if we can always use prependStr here (and elsewhere, too)
         if (str.original.charAt(endPos - 1) !== ';') {
             preprendStr(str, endPos, storeDeclarations);
         }
@@ -5346,7 +5367,7 @@ class InterfacesAndTypes {
 function processInstanceScriptContent(str, script, events, implicitStoreValues, mode, hasModuleScript, basename) {
     const htmlx = str.original;
     const scriptContent = htmlx.substring(script.content.start, script.content.end);
-    const tsAst = ts__namespace.createSourceFile('component.ts.svelte', scriptContent, ts__namespace.ScriptTarget.Latest, true, ts__namespace.ScriptKind.TS);
+    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);
@@ -5391,12 +5412,12 @@ function processInstanceScriptContent(str, script, events, implicitStoreValues,
             uses$$slots = true;
             return;
         }
-        if (ts__namespace.isLabeledStatement(parent) && parent.label == ident) {
+        if (ts.isLabeledStatement(parent) && parent.label == ident) {
             return;
         }
-        if (isDeclaration || ts__namespace.isParameter(parent)) {
+        if (isDeclaration || ts.isParameter(parent)) {
             if (isNotPropertyNameOfImport(ident) &&
-                (!ts__namespace.isBindingElement(ident.parent) || ident.parent.name == ident)) {
+                (!ts.isBindingElement(ident.parent) || ident.parent.name == ident)) {
                 // we are a key, not a name, so don't care
                 if (ident.text.startsWith('$') || scope == rootScope) {
                     // track all top level declared identifiers and all $ prefixed identifiers
@@ -5407,13 +5428,13 @@ function processInstanceScriptContent(str, script, events, implicitStoreValues,
         else {
             //track potential store usage to be resolved
             if (ident.text.startsWith('$')) {
-                if ((!ts__namespace.isPropertyAccessExpression(parent) || parent.expression == ident) &&
-                    (!ts__namespace.isPropertyAssignment(parent) || parent.initializer == ident) &&
-                    !ts__namespace.isPropertySignature(parent) &&
-                    !ts__namespace.isPropertyDeclaration(parent) &&
-                    !ts__namespace.isTypeReferenceNode(parent) &&
-                    !ts__namespace.isTypeAliasDeclaration(parent) &&
-                    !ts__namespace.isInterfaceDeclaration(parent)) {
+                if ((!ts.isPropertyAccessExpression(parent) || parent.expression == ident) &&
+                    (!ts.isPropertyAssignment(parent) || parent.initializer == ident) &&
+                    !ts.isPropertySignature(parent) &&
+                    !ts.isPropertyDeclaration(parent) &&
+                    !ts.isTypeReferenceNode(parent) &&
+                    !ts.isTypeAliasDeclaration(parent) &&
+                    !ts.isInterfaceDeclaration(parent)) {
                     pendingStoreResolutions.push({ node: ident, parent, scope });
                 }
             }
@@ -5432,71 +5453,69 @@ function processInstanceScriptContent(str, script, events, implicitStoreValues,
         if (is$$PropsDeclaration(node)) {
             exportedNames.uses$$Props = true;
         }
-        if (ts__namespace.isVariableStatement(node)) {
+        if (ts.isVariableStatement(node)) {
             exportedNames.handleVariableStatement(node, parent);
         }
-        if (ts__namespace.isFunctionDeclaration(node)) {
+        if (ts.isFunctionDeclaration(node)) {
             exportedNames.handleExportFunctionOrClass(node);
-            pushScope();
-            onLeaveCallbacks.push(() => popScope());
         }
-        if (ts__namespace.isClassDeclaration(node)) {
+        if (ts.isClassDeclaration(node)) {
             exportedNames.handleExportFunctionOrClass(node);
         }
-        if (ts__namespace.isBlock(node) || ts__namespace.isArrowFunction(node) || ts__namespace.isFunctionExpression(node)) {
+        if (ts.isBlock(node) || ts.isFunctionLike(node)) {
             pushScope();
             onLeaveCallbacks.push(() => popScope());
         }
-        if (ts__namespace.isExportDeclaration(node)) {
+        if (ts.isExportDeclaration(node)) {
             exportedNames.handleExportDeclaration(node);
         }
-        if (ts__namespace.isImportDeclaration(node)) {
+        if (ts.isImportDeclaration(node)) {
             handleImportDeclaration(node, str, astOffset, script.start, tsAst);
             // Check if import is the event dispatcher
             events.checkIfImportIsEventDispatcher(node);
         }
         // workaround for import statement completion
-        if (ts__namespace.isImportEqualsDeclaration(node)) {
+        if (ts.isImportEqualsDeclaration(node)) {
             const end = node.getEnd() + astOffset;
             if (str.original[end - 1] !== ';') {
                 preprendStr(str, end, ';');
             }
         }
-        if (ts__namespace.isVariableDeclaration(node)) {
+        if (ts.isVariableDeclaration(node)) {
             events.checkIfIsStringLiteralDeclaration(node);
             events.checkIfDeclarationInstantiatedEventDispatcher(node);
             implicitStoreValues.addVariableDeclaration(node);
         }
-        if (ts__namespace.isCallExpression(node)) {
+        if (ts.isCallExpression(node)) {
             events.checkIfCallExpressionIsDispatch(node);
         }
-        if (ts__namespace.isVariableDeclaration(parent) && parent.name == node) {
+        if (ts.isVariableDeclaration(parent) && parent.name == node) {
             isDeclaration = true;
             onLeaveCallbacks.push(() => (isDeclaration = false));
         }
-        if (ts__namespace.isBindingElement(parent) && parent.name == node) {
+        if (ts.isBindingElement(parent) && parent.name == node) {
             isDeclaration = true;
             onLeaveCallbacks.push(() => (isDeclaration = false));
         }
-        if (ts__namespace.isImportClause(node)) {
+        if (ts.isImportClause(node)) {
             isDeclaration = true;
             onLeaveCallbacks.push(() => (isDeclaration = false));
             implicitStoreValues.addImportStatement(node);
         }
-        if (ts__namespace.isImportSpecifier(node)) {
+        if (ts.isImportSpecifier(node)) {
             implicitStoreValues.addImportStatement(node);
         }
-        if (ts__namespace.isTypeAliasDeclaration(node) || ts__namespace.isInterfaceDeclaration(node)) {
+        if (ts.isTypeAliasDeclaration(node) || ts.isInterfaceDeclaration(node)) {
             interfacesAndTypes.node = node;
             interfacesAndTypes.add(node);
             onLeaveCallbacks.push(() => (interfacesAndTypes.node = null));
         }
         //handle stores etc
-        if (ts__namespace.isIdentifier(node)) {
+        if (ts.isIdentifier(node)) {
             handleIdentifier(node, parent);
         }
         //track implicit declarations in reactive blocks at the top level
-        if (ts__namespace.isLabeledStatement(node) &&
+        if (ts.isLabeledStatement(node) &&
             parent == tsAst && //top level
             node.label.text == '$' &&
             node.statement) {
@@ -5510,11 +5529,11 @@ function processInstanceScriptContent(str, script, events, implicitStoreValues,
         // Defensively call function (checking for undefined) because it got added only recently (TS 4.0)
         // and therefore might break people using older TS versions
         // Don't transform in ts mode because <type>value type assertions are valid in this case
-        if (mode !== 'ts' && ((_a = ts__namespace.isTypeAssertionExpression) === null || _a === void 0 ? void 0 : _a.call(ts__namespace, node))) {
+        if (mode !== 'ts' && ((_a = ts.isTypeAssertionExpression) === null || _a === void 0 ? void 0 : _a.call(ts, node))) {
             handleTypeAssertion(str, node, astOffset);
         }
         //to save a bunch of condition checks on each node, we recurse into processChild which skips all the checks for top level items
-        ts__namespace.forEachChild(node, (n) => walk(n, node));
+        ts.forEachChild(node, (n) => walk(n, node));
         //fire off the on leave callbacks
         onLeaveCallbacks.map((c) => c());
     };
@@ -5551,7 +5570,7 @@ function processInstanceScriptContent(str, script, events, implicitStoreValues,
 }
 function transformInterfacesToTypes(tsAst, str, astOffset, movedNodes) {
     tsAst.statements
-        .filter(ts__namespace.isInterfaceDeclaration)
+        .filter(ts.isInterfaceDeclaration)
         .filter((i) => !movedNodes.includes(i))
         .forEach((node) => {
         var _a;
@@ -5680,7 +5699,8 @@ class __sveltets_Render${genericsDef} {
     }
     else {
         statement +=
-            `\n\n${doc}export default class${className ? ` ${className}` : ''}${genericsDef} extends Svelte2TsxComponent<${returnType('props')}, ${returnType('events')}, ${returnType('slots')}> {` +
+            '\n\nimport { SvelteComponentTyped as __SvelteComponentTyped__ } from "svelte" \n' +
+                `${doc}export default class${className ? ` ${className}` : ''}${genericsDef} extends __SvelteComponentTyped__<${returnType('props')}, ${returnType('events')}, ${returnType('slots')}> {` +
                 exportedNames.createClassGetters() +
                 (usesAccessors ? exportedNames.createClassAccessors() : '') +
                 '\n}';
@@ -6153,6 +6173,7 @@ async function emitDts(config) {
     program.emit();
 }
 function loadTsconfig(config, svelteMap) {
+    var _a;
     const libRoot = config.libRoot || process.cwd();
     const jsconfigFile = ts.findConfigFile(libRoot, ts.sys.fileExists, 'jsconfig.json');
     let tsconfigFile = ts.findConfigFile(libRoot, ts.sys.fileExists);
@@ -6195,7 +6216,9 @@ function loadTsconfig(config, svelteMap) {
         options: {
             ...options,
             noEmit: false,
-            moduleResolution: ts.ModuleResolutionKind.NodeJs,
+            moduleResolution: 
+            // NodeJS: up to 4.9, Node10: since 5.0
+            (_a = ts.ModuleResolutionKind.NodeJs) !== null && _a !== void 0 ? _a : ts.ModuleResolutionKind.Node10,
             declaration: true,
             emitDeclarationOnly: true,
             declarationDir: config.declarationDir,
@@ -6280,6 +6303,13 @@ async function createTsCompilerHost(options, svelteMap) {
             return resolveModuleName(moduleName, containingFile, compilerOptions);
         });
     };
+    host.resolveModuleNameLiterals = (moduleLiterals, containingFile, _redirectedReference, compilerOptions) => {
+        return moduleLiterals.map((moduleLiteral) => {
+            return {
+                resolvedModule: resolveModuleName(moduleLiteral.text, containingFile, compilerOptions)
+            };
+        });
+    };
     function resolveModuleName(name, containingFile, compilerOptions) {
         // Delegate to the TS resolver first.
         // If that does not bring up anything, try the Svelte Module loader

package/index.mjs

@@ -1,7 +1,6 @@
 import { parse, walk as walk$1 } from 'svelte/compiler';
 import dedent from 'dedent-js';
-import * as ts from 'typescript';
-import ts__default from 'typescript';
+import ts from 'typescript';
 import * as path from 'path';
 import path__default from 'path';
 import { pascalCase } from 'pascal-case';
@@ -2321,7 +2320,10 @@ const oneWayBindingAttributes = new Set([
     'seekable',
     'seeking',
     'played',
-    'ended'
+    'ended',
+    'readyState',
+    'naturalWidth',
+    'naturalHeight'
 ]);
 /**
  * List of all binding names that are transformed to sth like `binding = variable`.
@@ -2807,6 +2809,7 @@ function convertHtmlxToJsx(str, ast, onWalk = null, onLeave = null, options = {}
                     case 'Window':
                     case 'Head':
                     case 'Title':
+                    case 'Document':
                     case 'Body':
                     case 'Slot':
                     case 'SlotTemplate':
@@ -2883,6 +2886,7 @@ function convertHtmlxToJsx(str, ast, onWalk = null, onLeave = null, options = {}
                     case 'Head':
                     case 'Title':
                     case 'Body':
+                    case 'Document':
                     case 'Slot':
                     case 'SlotTemplate':
                         if (node.name !== '!DOCTYPE') {
@@ -2937,33 +2941,33 @@ class ComponentDocumentation {
 }
 
 function isInterfaceOrTypeDeclaration(node) {
-    return ts__default.isTypeAliasDeclaration(node) || ts__default.isInterfaceDeclaration(node);
+    return ts.isTypeAliasDeclaration(node) || ts.isInterfaceDeclaration(node);
 }
 function findExportKeyword(node) {
     var _a;
-    return ts__default.canHaveModifiers(node)
-        ? (_a = ts__default.getModifiers(node)) === null || _a === void 0 ? void 0 : _a.find((x) => x.kind == ts__default.SyntaxKind.ExportKeyword)
+    return ts.canHaveModifiers(node)
+        ? (_a = ts.getModifiers(node)) === null || _a === void 0 ? void 0 : _a.find((x) => x.kind == ts.SyntaxKind.ExportKeyword)
         : undefined;
 }
 /**
  * Node is like `bla = ...` or `{bla} = ...` or `[bla] = ...`
  */
 function isAssignmentBinaryExpr(node) {
-    return (ts__default.isBinaryExpression(node) &&
-        node.operatorToken.kind == ts__default.SyntaxKind.EqualsToken &&
-        (ts__default.isIdentifier(node.left) ||
-            ts__default.isObjectLiteralExpression(node.left) ||
-            ts__default.isArrayLiteralExpression(node.left)));
+    return (ts.isBinaryExpression(node) &&
+        node.operatorToken.kind == ts.SyntaxKind.EqualsToken &&
+        (ts.isIdentifier(node.left) ||
+            ts.isObjectLiteralExpression(node.left) ||
+            ts.isArrayLiteralExpression(node.left)));
 }
 /**
  * Returns if node is like `$: bla = ...` or `$: ({bla} = ...)` or `$: [bla] = ...=`
  */
 function getBinaryAssignmentExpr(node) {
-    if (ts__default.isExpressionStatement(node.statement)) {
+    if (ts.isExpressionStatement(node.statement)) {
         if (isAssignmentBinaryExpr(node.statement.expression)) {
             return node.statement.expression;
         }
-        if (ts__default.isParenthesizedExpression(node.statement.expression) &&
+        if (ts.isParenthesizedExpression(node.statement.expression) &&
             isAssignmentBinaryExpr(node.statement.expression.expression)) {
             return node.statement.expression.expression;
         }
@@ -2973,20 +2977,20 @@ function getBinaryAssignmentExpr(node) {
  * Returns true if node is like `({bla} ..)` or `([bla] ...)`
  */
 function isParenthesizedObjectOrArrayLiteralExpression(node) {
-    return (ts__default.isParenthesizedExpression(node) &&
-        ts__default.isBinaryExpression(node.expression) &&
-        (ts__default.isObjectLiteralExpression(node.expression.left) ||
-            ts__default.isArrayLiteralExpression(node.expression.left)));
+    return (ts.isParenthesizedExpression(node) &&
+        ts.isBinaryExpression(node.expression) &&
+        (ts.isObjectLiteralExpression(node.expression.left) ||
+            ts.isArrayLiteralExpression(node.expression.left)));
 }
 /**
  *
  * Adapted from https://github.com/Rich-Harris/periscopic/blob/d7a820b04e1f88b452313ab3e54771b352f0defb/src/index.ts#L150
  */
 function extractIdentifiers(node, identifiers = []) {
-    if (ts__default.isIdentifier(node)) {
+    if (ts.isIdentifier(node)) {
         identifiers.push(node);
     }
-    else if (ts__default.isBindingElement(node)) {
+    else if (ts.isBindingElement(node)) {
         extractIdentifiers(node.name, identifiers);
     }
     else if (isMember$1(node)) {
@@ -2994,33 +2998,33 @@ function extractIdentifiers(node, identifiers = []) {
         while (isMember$1(object)) {
             object = object.expression;
         }
-        if (ts__default.isIdentifier(object)) {
+        if (ts.isIdentifier(object)) {
             identifiers.push(object);
         }
     }
-    else if (ts__default.isArrayBindingPattern(node) || ts__default.isObjectBindingPattern(node)) {
+    else if (ts.isArrayBindingPattern(node) || ts.isObjectBindingPattern(node)) {
         node.elements.forEach((element) => {
             extractIdentifiers(element, identifiers);
         });
     }
-    else if (ts__default.isObjectLiteralExpression(node)) {
+    else if (ts.isObjectLiteralExpression(node)) {
         node.properties.forEach((child) => {
-            if (ts__default.isSpreadAssignment(child)) {
+            if (ts.isSpreadAssignment(child)) {
                 extractIdentifiers(child.expression, identifiers);
             }
-            else if (ts__default.isShorthandPropertyAssignment(child)) {
+            else if (ts.isShorthandPropertyAssignment(child)) {
                 // in ts Ast { a = 1 } and { a } are both ShorthandPropertyAssignment
                 extractIdentifiers(child.name, identifiers);
             }
-            else if (ts__default.isPropertyAssignment(child)) {
+            else if (ts.isPropertyAssignment(child)) {
                 // { a: b }
                 extractIdentifiers(child.initializer, identifiers);
             }
         });
     }
-    else if (ts__default.isArrayLiteralExpression(node)) {
+    else if (ts.isArrayLiteralExpression(node)) {
         node.elements.forEach((element) => {
-            if (ts__default.isSpreadElement(element)) {
+            if (ts.isSpreadElement(element)) {
                 extractIdentifiers(element, identifiers);
             }
             else {
@@ -3028,13 +3032,13 @@ function extractIdentifiers(node, identifiers = []) {
             }
         });
     }
-    else if (ts__default.isBinaryExpression(node)) {
+    else if (ts.isBinaryExpression(node)) {
         extractIdentifiers(node.left, identifiers);
     }
     return identifiers;
 }
 function isMember$1(node) {
-    return ts__default.isElementAccessExpression(node) || ts__default.isPropertyAccessExpression(node);
+    return ts.isElementAccessExpression(node) || ts.isPropertyAccessExpression(node);
 }
 /**
  * Returns variable at given level with given name,
@@ -3042,8 +3046,8 @@ function isMember$1(node) {
  */
 function getVariableAtTopLevel(node, identifierName) {
     for (const child of node.statements) {
-        if (ts__default.isVariableStatement(child)) {
-            const variable = child.declarationList.declarations.find((declaration) => ts__default.isIdentifier(declaration.name) && declaration.name.text === identifierName);
+        if (ts.isVariableStatement(child)) {
+            const variable = child.declarationList.declarations.find((declaration) => ts.isIdentifier(declaration.name) && declaration.name.text === identifierName);
             if (variable) {
                 return variable;
             }
@@ -3056,12 +3060,12 @@ function getVariableAtTopLevel(node, identifierName) {
 function getLastLeadingDoc(node) {
     var _a;
     const nodeText = node.getFullText();
-    const comments = (_a = ts__default
-        .getLeadingCommentRanges(nodeText, 0)) === null || _a === void 0 ? void 0 : _a.filter((c) => c.kind === ts__default.SyntaxKind.MultiLineCommentTrivia);
+    const comments = (_a = ts
+        .getLeadingCommentRanges(nodeText, 0)) === null || _a === void 0 ? void 0 : _a.filter((c) => c.kind === ts.SyntaxKind.MultiLineCommentTrivia);
     const comment = comments === null || comments === void 0 ? void 0 : comments[(comments === null || comments === void 0 ? void 0 : comments.length) - 1];
     if (comment) {
         let commentText = nodeText.substring(comment.pos, comment.end);
-        const typedefTags = ts__default.getAllJSDocTagsOfKind(node, ts__default.SyntaxKind.JSDocTypedefTag);
+        const typedefTags = ts.getAllJSDocTagsOfKind(node, ts.SyntaxKind.JSDocTypedefTag);
         typedefTags
             .filter((tag) => tag.pos >= comment.pos)
             .map((tag) => nodeText.substring(tag.pos, tag.end))
@@ -3076,7 +3080,7 @@ function getLastLeadingDoc(node) {
  * In other words: It is not `a` in `import {a as b} from ..`
  */
 function isNotPropertyNameOfImport(identifier) {
-    return (!ts__default.isImportSpecifier(identifier.parent) || identifier.parent.propertyName !== identifier);
+    return (!ts.isImportSpecifier(identifier.parent) || identifier.parent.propertyName !== identifier);
 }
 /**
  * Extract the variable names that are assigned to out of a labeled statement.
@@ -3097,9 +3101,9 @@ function getNamesFromLabeledStatement(node) {
  */
 function moveNode(node, str, astOffset, scriptStart, sourceFile) {
     var _a;
-    const scanner = ts__default.createScanner(sourceFile.languageVersion, 
+    const scanner = ts.createScanner(sourceFile.languageVersion, 
     /*skipTrivia*/ false, sourceFile.languageVariant);
-    const comments = (_a = ts__default.getLeadingCommentRanges(node.getFullText(), 0)) !== null && _a !== void 0 ? _a : [];
+    const comments = (_a = ts.getLeadingCommentRanges(node.getFullText(), 0)) !== null && _a !== void 0 ? _a : [];
     if (!comments.some((comment) => comment.hasTrailingNewLine) &&
         isNewGroup(sourceFile, node, scanner)) {
         str.appendRight(node.getStart() + astOffset, '\n');
@@ -3126,7 +3130,7 @@ function isNewGroup(sourceFile, topLevelImportDecl, scanner) {
     let numberOfNewLines = 0;
     while (scanner.getTokenPos() < endPos) {
         const tokenKind = scanner.scan();
-        if (tokenKind === ts__default.SyntaxKind.NewLineTrivia) {
+        if (tokenKind === ts.SyntaxKind.NewLineTrivia) {
             numberOfNewLines++;
             if (numberOfNewLines >= 2) {
                 return true;
@@ -3244,16 +3248,16 @@ class ComponentEventsFromInterface {
     }
     extractEvents(node) {
         const map = new Map();
-        if (ts__default.isInterfaceDeclaration(node)) {
+        if (ts.isInterfaceDeclaration(node)) {
             this.extractProperties(node.members, map);
         }
         else {
-            if (ts__default.isTypeLiteralNode(node.type)) {
+            if (ts.isTypeLiteralNode(node.type)) {
                 this.extractProperties(node.type.members, map);
             }
-            else if (ts__default.isIntersectionTypeNode(node.type)) {
+            else if (ts.isIntersectionTypeNode(node.type)) {
                 node.type.types.forEach((type) => {
-                    if (ts__default.isTypeLiteralNode(type)) {
+                    if (ts.isTypeLiteralNode(type)) {
                         this.extractProperties(type.members, map);
                     }
                 });
@@ -3262,7 +3266,7 @@ class ComponentEventsFromInterface {
         return map;
     }
     extractProperties(members, map) {
-        members.filter(ts__default.isPropertySignature).forEach((member) => {
+        members.filter(ts.isPropertySignature).forEach((member) => {
             var _a;
             map.set(getName(member.name), {
                 type: ((_a = member.type) === null || _a === void 0 ? void 0 : _a.getText()) || 'Event',
@@ -3288,9 +3292,9 @@ class ComponentEventsFromEventsMap {
         this.eventDispatcherImport = checkIfImportIsEventDispatcher(node);
     }
     checkIfIsStringLiteralDeclaration(node) {
-        if (ts__default.isIdentifier(node.name) &&
+        if (ts.isIdentifier(node.name) &&
             node.initializer &&
-            ts__default.isStringLiteral(node.initializer)) {
+            ts.isStringLiteral(node.initializer)) {
             this.stringVars.set(node.name.text, node.initializer.text);
         }
     }
@@ -3300,12 +3304,12 @@ class ComponentEventsFromEventsMap {
             return;
         }
         const { dispatcherTyping, dispatcherName } = result;
-        if (dispatcherTyping && ts__default.isTypeLiteralNode(dispatcherTyping)) {
+        if (dispatcherTyping && ts.isTypeLiteralNode(dispatcherTyping)) {
             this.eventDispatchers.push({
                 name: dispatcherName,
                 typing: dispatcherTyping.getText()
             });
-            dispatcherTyping.members.filter(ts__default.isPropertySignature).forEach((member) => {
+            dispatcherTyping.members.filter(ts.isPropertySignature).forEach((member) => {
                 var _a;
                 this.addToEvents(getName(member.name), {
                     type: `CustomEvent<${((_a = member.type) === null || _a === void 0 ? void 0 : _a.getText()) || 'any'}>`,
@@ -3325,14 +3329,14 @@ class ComponentEventsFromEventsMap {
     }
     checkIfCallExpressionIsDispatch(node) {
         if (this.eventDispatchers.some((dispatcher) => !dispatcher.typing &&
-            ts__default.isIdentifier(node.expression) &&
+            ts.isIdentifier(node.expression) &&
             node.expression.text === dispatcher.name)) {
             const firstArg = node.arguments[0];
-            if (ts__default.isStringLiteral(firstArg)) {
+            if (ts.isStringLiteral(firstArg)) {
                 this.addToEvents(firstArg.text);
                 this.dispatchedEvents.add(firstArg.text);
             }
-            else if (ts__default.isIdentifier(firstArg)) {
+            else if (ts.isIdentifier(firstArg)) {
                 const str = this.stringVars.get(firstArg.text);
                 if (str) {
                     this.addToEvents(str);
@@ -3372,11 +3376,11 @@ class ComponentEventsFromEventsMap {
     }
 }
 function getName(prop) {
-    if (ts__default.isIdentifier(prop) || ts__default.isStringLiteral(prop)) {
+    if (ts.isIdentifier(prop) || ts.isStringLiteral(prop)) {
         return prop.text;
     }
-    if (ts__default.isComputedPropertyName(prop)) {
-        if (ts__default.isIdentifier(prop.expression)) {
+    if (ts.isComputedPropertyName(prop)) {
+        if (ts.isIdentifier(prop.expression)) {
             const identifierName = prop.expression.text;
             const identifierValue = getIdentifierValue(prop, identifierName);
             if (!identifierValue) {
@@ -3389,7 +3393,7 @@ function getName(prop) {
 }
 function getIdentifierValue(prop, identifierName) {
     const variable = getVariableAtTopLevel(prop.getSourceFile(), identifierName);
-    if (variable && ts__default.isStringLiteral(variable.initializer)) {
+    if (variable && ts.isStringLiteral(variable.initializer)) {
         return variable.initializer.text;
     }
 }
@@ -3428,11 +3432,11 @@ function getDoc(member) {
 }
 function checkIfImportIsEventDispatcher(node) {
     var _a;
-    if (ts__default.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text !== 'svelte') {
+    if (ts.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text !== 'svelte') {
         return;
     }
     const namedImports = (_a = node.importClause) === null || _a === void 0 ? void 0 : _a.namedBindings;
-    if (namedImports && ts__default.isNamedImports(namedImports)) {
+    if (namedImports && ts.isNamedImports(namedImports)) {
         const eventDispatcherImport = namedImports.elements.find(
         // If it's an aliased import, propertyName is set
         (el) => (el.propertyName || el.name).text === 'createEventDispatcher');
@@ -3443,11 +3447,11 @@ function checkIfImportIsEventDispatcher(node) {
 }
 function checkIfDeclarationInstantiatedEventDispatcher(node, eventDispatcherImport) {
     var _a;
-    if (!ts__default.isIdentifier(node.name) || !node.initializer) {
+    if (!ts.isIdentifier(node.name) || !node.initializer) {
         return;
     }
-    if (ts__default.isCallExpression(node.initializer) &&
-        ts__default.isIdentifier(node.initializer.expression) &&
+    if (ts.isCallExpression(node.initializer) &&
+        ts.isIdentifier(node.initializer.expression) &&
         node.initializer.expression.text === eventDispatcherImport) {
         const dispatcherName = node.name.text;
         const dispatcherTyping = (_a = node.initializer.typeArguments) === null || _a === void 0 ? void 0 : _a[0];
@@ -3670,14 +3674,14 @@ function upserKitRouteFile(ts, basename, getSource, surround) {
     const load = exports.get('load');
     if ((load === null || load === void 0 ? void 0 : load.type) === 'function' && load.node.parameters.length === 1 && !load.hasTypeDefinition) {
         const pos = load.node.parameters[0].getEnd();
-        const inserted = surround(`: import('./$types').${basename.includes('layout') ? 'Layout' : 'Page'}${basename.includes('server') ? 'Server' : ''}LoadEvent`);
+        const inserted = surround(`: import('./$types.js').${basename.includes('layout') ? 'Layout' : 'Page'}${basename.includes('server') ? 'Server' : ''}LoadEvent`);
         insert(pos, inserted);
     }
     // add type to actions variable if not explicitly typed
     const actions = exports.get('actions');
     if ((actions === null || actions === void 0 ? void 0 : actions.type) === 'var' && !actions.hasTypeDefinition && actions.node.initializer) {
         const pos = actions.node.initializer.getEnd();
-        const inserted = surround(` satisfies import('./$types').Actions`);
+        const inserted = surround(` satisfies import('./$types.js').Actions`);
         insert(pos, inserted);
     }
     addTypeToVariable(exports, surround, insert, 'prerender', `boolean | 'auto'`);
@@ -3686,7 +3690,7 @@ function upserKitRouteFile(ts, basename, getSource, surround) {
     addTypeToVariable(exports, surround, insert, 'csr', `boolean`);
     // add types to GET/PUT/POST/PATCH/DELETE/OPTIONS if not explicitly typed
     const insertApiMethod = (name) => {
-        addTypeToFunction(ts, exports, surround, insert, name, `import('./$types').RequestEvent`, `Response | Promise<Response>`);
+        addTypeToFunction(ts, exports, surround, insert, name, `import('./$types.js').RequestEvent`, `Response | Promise<Response>`);
     };
     insertApiMethod('GET');
     insertApiMethod('PUT');
@@ -3873,6 +3877,13 @@ function updatePrepends(str, index, toAppend, removeExisting) {
     str.__prepends__.set(index, prepends);
     return prepends;
 }
+/**
+ * Returns the prepends that were added at the given index (if any).
+ */
+function getCurrentPrepends(str, index) {
+    var _a;
+    return ((_a = str.__prepends__) === null || _a === void 0 ? void 0 : _a.get(index)) || [];
+}
 
 function is$$PropsDeclaration(node) {
     return isInterfaceOrTypeDeclaration(node) && node.name.text === '$$Props';
@@ -3894,21 +3905,21 @@ class ExportedNames {
     handleVariableStatement(node, parent) {
         const exportModifier = findExportKeyword(node);
         if (exportModifier) {
-            const isLet = node.declarationList.flags === ts__default.NodeFlags.Let;
-            const isConst = node.declarationList.flags === ts__default.NodeFlags.Const;
+            const isLet = node.declarationList.flags === ts.NodeFlags.Let;
+            const isConst = node.declarationList.flags === ts.NodeFlags.Const;
             this.handleExportedVariableDeclarationList(node.declarationList, (_, ...args) => this.addExport(...args));
             if (isLet) {
                 this.propTypeAssertToUserDefined(node.declarationList);
             }
             else if (isConst) {
                 node.declarationList.forEachChild((n) => {
-                    if (ts__default.isVariableDeclaration(n) && ts__default.isIdentifier(n.name)) {
+                    if (ts.isVariableDeclaration(n) && ts.isIdentifier(n.name)) {
                         this.addGetter(n.name);
-                        const type = n.type || ts__default.getJSDocType(n);
+                        const type = n.type || ts.getJSDocType(n);
                         const isKitExport = internalHelpers.isKitRouteFile(this.basename) &&
                             n.name.getText() === 'snapshot';
                         // TS types are not allowed in JS files, but TS will still pick it up and the ignore comment will filter out the error
-                        const kitType = isKitExport && !type ? `: import('./$types').Snapshot` : '';
+                        const kitType = isKitExport && !type ? `: import('./$types.js').Snapshot` : '';
                         const nameEnd = n.name.end + this.astOffset;
                         if (kitType) {
                             preprendStr(this.str, nameEnd, surroundWithIgnoreComments(kitType));
@@ -3918,7 +3929,7 @@ class ExportedNames {
             }
             this.removeExport(exportModifier.getStart(), exportModifier.end);
         }
-        else if (ts__default.isSourceFile(parent)) {
+        else if (ts.isSourceFile(parent)) {
             this.handleExportedVariableDeclarationList(node.declarationList, this.addPossibleExport.bind(this));
         }
     }
@@ -3936,7 +3947,7 @@ class ExportedNames {
     }
     handleExportDeclaration(node) {
         const { exportClause } = node;
-        if (ts__default.isNamedExports(exportClause)) {
+        if (ts.isNamedExports(exportClause)) {
             for (const ne of exportClause.elements) {
                 if (ne.propertyName) {
                     this.addExport(ne.propertyName, false, ne.name);
@@ -3966,14 +3977,14 @@ class ExportedNames {
         const handleTypeAssertion = (declaration) => {
             const identifier = declaration.name;
             const tsType = declaration.type;
-            const jsDocType = ts__default.getJSDocType(declaration);
+            const jsDocType = ts.getJSDocType(declaration);
             const type = tsType || jsDocType;
             const name = identifier.getText();
             const isKitExport = internalHelpers.isKitRouteFile(this.basename) &&
                 (name === 'data' || name === 'form' || name === 'snapshot');
             // TS types are not allowed in JS files, but TS will still pick it up and the ignore comment will filter out the error
             const kitType = isKitExport && !type
-                ? `: import('./$types').${name === 'data'
+                ? `: import('./$types.js').${name === 'data'
                     ? this.basename.includes('layout')
                         ? 'LayoutData'
                         : 'PageData'
@@ -3983,7 +3994,7 @@ class ExportedNames {
                 : '';
             const nameEnd = identifier.end + this.astOffset;
             const end = declaration.end + this.astOffset;
-            if (ts__default.isIdentifier(identifier) &&
+            if (ts.isIdentifier(identifier) &&
                 // Ensure initialization for proper control flow and to avoid "possibly undefined" type errors.
                 // Also ensure prop is typed as any with a type annotation in TS strict mode
                 (!declaration.initializer ||
@@ -3992,7 +4003,7 @@ class ExportedNames {
                     // Edge case: TS infers `export let bla = false` to type `false`.
                     // prevent that by adding the any-wrap in this case, too.
                     (!type &&
-                        [ts__default.SyntaxKind.FalseKeyword, ts__default.SyntaxKind.TrueKeyword].includes(declaration.initializer.kind)))) {
+                        [ts.SyntaxKind.FalseKeyword, ts.SyntaxKind.TrueKeyword].includes(declaration.initializer.kind)))) {
                 const name = identifier.getText();
                 if (nameEnd === end) {
                     preprendStr(this.str, end, surroundWithIgnoreComments(`${kitType};${name} = __sveltets_2_any(${name});`));
@@ -4008,11 +4019,11 @@ class ExportedNames {
                 preprendStr(this.str, nameEnd, surroundWithIgnoreComments(kitType));
             }
         };
-        const findComma = (target) => target.getChildren().filter((child) => child.kind === ts__default.SyntaxKind.CommaToken);
+        const findComma = (target) => target.getChildren().filter((child) => child.kind === ts.SyntaxKind.CommaToken);
         const splitDeclaration = () => {
             const commas = node
                 .getChildren()
-                .filter((child) => child.kind === ts__default.SyntaxKind.SyntaxList)
+                .filter((child) => child.kind === ts.SyntaxKind.SyntaxList)
                 .map(findComma)
                 .reduce((current, previous) => [...current, ...previous], []);
             commas.forEach((comma) => {
@@ -4029,16 +4040,16 @@ class ExportedNames {
         this.doneDeclarationTransformation.add(node);
     }
     handleExportedVariableDeclarationList(list, add) {
-        const isLet = list.flags === ts__default.NodeFlags.Let;
-        ts__default.forEachChild(list, (node) => {
-            if (ts__default.isVariableDeclaration(node)) {
-                if (ts__default.isIdentifier(node.name)) {
+        const isLet = list.flags === ts.NodeFlags.Let;
+        ts.forEachChild(list, (node) => {
+            if (ts.isVariableDeclaration(node)) {
+                if (ts.isIdentifier(node.name)) {
                     add(list, node.name, isLet, node.name, node.type, !node.initializer);
                 }
-                else if (ts__default.isObjectBindingPattern(node.name) ||
-                    ts__default.isArrayBindingPattern(node.name)) {
-                    ts__default.forEachChild(node.name, (element) => {
-                        if (ts__default.isBindingElement(element)) {
+                else if (ts.isObjectBindingPattern(node.name) ||
+                    ts.isArrayBindingPattern(node.name)) {
+                    ts.forEachChild(node.name, (element) => {
+                        if (ts.isBindingElement(element)) {
                             add(list, element.name, isLet);
                         }
                     });
@@ -4079,10 +4090,10 @@ class ExportedNames {
      * which could be exported through `export { .. }` later.
      */
     addPossibleExport(declaration, name, isLet, target = null, type = null, required = false) {
-        if (!ts__default.isIdentifier(name)) {
+        if (!ts.isIdentifier(name)) {
             return;
         }
-        if (target && ts__default.isIdentifier(target)) {
+        if (target && ts.isIdentifier(target)) {
             this.possibleExports.set(name.text, {
                 declaration,
                 isLet,
@@ -4103,10 +4114,10 @@ class ExportedNames {
      * Adds export to map
      */
     addExport(name, isLet, target = null, type = null, required = false) {
-        if (name.kind != ts__default.SyntaxKind.Identifier) {
+        if (name.kind != ts.SyntaxKind.Identifier) {
             throw Error('export source kind not supported ' + name);
         }
-        if (target && target.kind != ts__default.SyntaxKind.Identifier) {
+        if (target && target.kind != ts.SyntaxKind.Identifier) {
             throw Error('export target kind not supported ' + target);
         }
         const existingDeclaration = this.possibleExports.get(name.text);
@@ -4585,10 +4596,19 @@ class ImplicitStoreValues {
             return;
         }
         const storeDeclarations = surroundWithIgnoreComments(this.createStoreDeclarations(storeNames));
-        const nodeEnd = ts__default.isVariableDeclarationList(node.parent) && node.parent.declarations.length > 1
+        const nodeEnd = ts.isVariableDeclarationList(node.parent) && node.parent.declarations.length > 1
             ? node.parent.declarations[node.parent.declarations.length - 1].getEnd()
             : node.getEnd();
-        str.appendRight(nodeEnd + astOffset, storeDeclarations);
+        // Quick-fixing https://github.com/sveltejs/language-tools/issues/1950
+        // TODO think about a SourceMap-wrapper that does these things for us,
+        // or investigate altering the inner workings of SourceMap, or investigate
+        // if we can always use prependStr here (and elsewhere, too)
+        if (getCurrentPrepends(str, nodeEnd + astOffset).length) {
+            preprendStr(str, nodeEnd + astOffset, storeDeclarations);
+        }
+        else {
+            str.appendRight(nodeEnd + astOffset, storeDeclarations);
+        }
     }
     attachStoreValueDeclarationToReactiveAssignment(node, astOffset, str) {
         const storeNames = getNamesFromLabeledStatement(node).filter((name) => this.accessedStores.has(name));
@@ -4597,9 +4617,10 @@ class ImplicitStoreValues {
         }
         const storeDeclarations = surroundWithIgnoreComments(this.createStoreDeclarations(storeNames));
         const endPos = node.getEnd() + astOffset;
-        // Hack for quick-fixing https://github.com/sveltejs/language-tools/issues/1097
+        // Quick-fixing https://github.com/sveltejs/language-tools/issues/1097
         // TODO think about a SourceMap-wrapper that does these things for us,
-        // or investigate altering the inner workings of SourceMap
+        // or investigate altering the inner workings of SourceMap, or investigate
+        // if we can always use prependStr here (and elsewhere, too)
         if (str.original.charAt(endPos - 1) !== ';') {
             preprendStr(str, endPos, storeDeclarations);
         }
@@ -5027,10 +5048,10 @@ class ImplicitTopLevelNames {
         const start = expression.getStart() + this.astOffset;
         const end = expression.getEnd() + this.astOffset;
         // $: a = { .. }..  /  $: a = .. as ..  =>   () => ( .. )
-        if (ts__default.isObjectLiteralExpression(expression) ||
+        if (ts.isObjectLiteralExpression(expression) ||
             (expression.getText().startsWith('{') &&
                 this.isNodeStartsWithObjectLiteral(expression)) ||
-            ts__default.isAsExpression(expression)) {
+            ts.isAsExpression(expression)) {
             this.str.appendLeft(start, '(');
             this.str.appendRight(end, ')');
         }
@@ -5040,16 +5061,16 @@ class ImplicitTopLevelNames {
         // in situations where there is a line break of ; guaranteed to be present (else the code is invalid)
     }
     isNodeStartsWithObjectLiteral(node) {
-        if (ts__default.isObjectLiteralExpression(node)) {
+        if (ts.isObjectLiteralExpression(node)) {
             return true;
         }
-        if (ts__default.isElementAccessExpression(node)) {
+        if (ts.isElementAccessExpression(node)) {
             return this.isNodeStartsWithObjectLiteral(node.expression);
         }
-        if (ts__default.isBinaryExpression(node)) {
+        if (ts.isBinaryExpression(node)) {
             return this.isNodeStartsWithObjectLiteral(node.left);
         }
-        if (ts__default.isConditionalExpression(node)) {
+        if (ts.isConditionalExpression(node)) {
             return this.isNodeStartsWithObjectLiteral(node.condition);
         }
         return node
@@ -5085,7 +5106,7 @@ class ImplicitTopLevelNames {
         // If expression is of type `$: ({a} = b);`,
         // remove the surrounding braces so that the transformation
         // to `let {a} = b;` produces valid code.
-        if (ts__default.isExpressionStatement(node.statement) &&
+        if (ts.isExpressionStatement(node.statement) &&
             isParenthesizedObjectOrArrayLiteralExpression(node.statement.expression)) {
             const parenthesizedExpression = node.statement.expression;
             const parenthesisStart = parenthesizedExpression.getStart() + this.astOffset;
@@ -5207,7 +5228,7 @@ class Generics {
     }
     addIfIsGeneric(node) {
         var _a, _b;
-        if (ts__default.isTypeAliasDeclaration(node) && this.is$$GenericType(node.type)) {
+        if (ts.isTypeAliasDeclaration(node) && this.is$$GenericType(node.type)) {
             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');
             }
@@ -5224,13 +5245,13 @@ class Generics {
         }
     }
     throwIfIsGeneric(node) {
-        if (ts__default.isTypeAliasDeclaration(node) && this.is$$GenericType(node.type)) {
+        if (ts.isTypeAliasDeclaration(node) && this.is$$GenericType(node.type)) {
             throwError(this.astOffset + node.getStart(), this.astOffset + node.getEnd(), '$$Generic declarations are only allowed in the instance script', this.str.original);
         }
     }
     is$$GenericType(node) {
-        return (ts__default.isTypeReferenceNode(node) &&
-            ts__default.isIdentifier(node.typeName) &&
+        return (ts.isTypeReferenceNode(node) &&
+            ts.isIdentifier(node.typeName) &&
             node.typeName.text === '$$Generic');
     }
     getTypeReferences() {
@@ -5261,13 +5282,13 @@ function handleImportDeclaration(node, str, astOffset, scriptStart, sourceFile)
 function handleFirstInstanceImport(tsAst, astOffset, hasModuleScript, str) {
     var _a;
     const firstImport = tsAst.statements
-        .filter(ts__default.isImportDeclaration)
+        .filter(ts.isImportDeclaration)
         .sort((a, b) => a.end - b.end)[0];
     if (!firstImport) {
         return;
     }
-    const firstComment = Array.from((_a = ts__default.getLeadingCommentRanges(firstImport.getFullText(), 0)) !== null && _a !== void 0 ? _a : []).sort((a, b) => a.pos - b.pos)[0];
-    const start = firstComment && firstComment.kind === ts__default.SyntaxKind.MultiLineCommentTrivia
+    const firstComment = Array.from((_a = ts.getLeadingCommentRanges(firstImport.getFullText(), 0)) !== null && _a !== void 0 ? _a : []).sort((a, b) => a.pos - b.pos)[0];
+    const start = firstComment && firstComment.kind === ts.SyntaxKind.MultiLineCommentTrivia
         ? firstComment.pos + firstImport.getFullStart()
         : firstImport.getStart();
     str.appendRight(start + astOffset, '\n' + (hasModuleScript ? '\n' : ''));
@@ -5417,13 +5438,11 @@ function processInstanceScriptContent(str, script, events, implicitStoreValues,
         }
         if (ts.isFunctionDeclaration(node)) {
             exportedNames.handleExportFunctionOrClass(node);
-            pushScope();
-            onLeaveCallbacks.push(() => popScope());
         }
         if (ts.isClassDeclaration(node)) {
             exportedNames.handleExportFunctionOrClass(node);
         }
-        if (ts.isBlock(node) || ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+        if (ts.isBlock(node) || ts.isFunctionLike(node)) {
             pushScope();
             onLeaveCallbacks.push(() => popScope());
         }
@@ -5556,7 +5575,7 @@ function transformInterfacesToTypes(tsAst, str, astOffset, movedNodes) {
 function processModuleScriptTag(str, script, implicitStoreValues) {
     const htmlx = str.original;
     const scriptContent = htmlx.substring(script.content.start, script.content.end);
-    const tsAst = ts__default.createSourceFile('component.module.ts.svelte', scriptContent, ts__default.ScriptTarget.Latest, true, ts__default.ScriptKind.TS);
+    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 walk = (node) => {
@@ -5565,7 +5584,7 @@ function processModuleScriptTag(str, script, implicitStoreValues) {
         throwIfIs$$EventsDeclaration(node, str, astOffset);
         throwIfIs$$SlotsDeclaration(node, str, astOffset);
         throwIfIs$$PropsDeclaration(node, str, astOffset);
-        ts__default.forEachChild(node, (n) => walk(n));
+        ts.forEachChild(node, (n) => walk(n));
     };
     //walk the ast and convert to tsx as we go
     tsAst.forEachChild((n) => walk(n));
@@ -5582,16 +5601,16 @@ function processModuleScriptTag(str, script, implicitStoreValues) {
 }
 function resolveImplicitStoreValue(node, implicitStoreValues, str, astOffset) {
     var _a;
-    if (ts__default.isVariableDeclaration(node)) {
+    if (ts.isVariableDeclaration(node)) {
         implicitStoreValues.addVariableDeclaration(node);
     }
-    if (ts__default.isImportClause(node)) {
+    if (ts.isImportClause(node)) {
         implicitStoreValues.addImportStatement(node);
     }
-    if (ts__default.isImportSpecifier(node)) {
+    if (ts.isImportSpecifier(node)) {
         implicitStoreValues.addImportStatement(node);
     }
-    if ((_a = ts__default.isTypeAssertionExpression) === null || _a === void 0 ? void 0 : _a.call(ts__default, node)) {
+    if ((_a = ts.isTypeAssertionExpression) === null || _a === void 0 ? void 0 : _a.call(ts, node)) {
         handleTypeAssertion(str, node, astOffset);
     }
 }
@@ -5660,7 +5679,8 @@ class __sveltets_Render${genericsDef} {
     }
     else {
         statement +=
-            `\n\n${doc}export default class${className ? ` ${className}` : ''}${genericsDef} extends Svelte2TsxComponent<${returnType('props')}, ${returnType('events')}, ${returnType('slots')}> {` +
+            '\n\nimport { SvelteComponentTyped as __SvelteComponentTyped__ } from "svelte" \n' +
+                `${doc}export default class${className ? ` ${className}` : ''}${genericsDef} extends __SvelteComponentTyped__<${returnType('props')}, ${returnType('events')}, ${returnType('slots')}> {` +
                 exportedNames.createClassGetters() +
                 (usesAccessors ? exportedNames.createClassAccessors() : '') +
                 '\n}';
@@ -6129,13 +6149,14 @@ async function emitDts(config) {
     const svelteMap = await createSvelteMap(config);
     const { options, filenames } = loadTsconfig(config, svelteMap);
     const host = await createTsCompilerHost(options, svelteMap);
-    const program = ts__default.createProgram(filenames, options, host);
+    const program = ts.createProgram(filenames, options, host);
     program.emit();
 }
 function loadTsconfig(config, svelteMap) {
+    var _a;
     const libRoot = config.libRoot || process.cwd();
-    const jsconfigFile = ts__default.findConfigFile(libRoot, ts__default.sys.fileExists, 'jsconfig.json');
-    let tsconfigFile = ts__default.findConfigFile(libRoot, ts__default.sys.fileExists);
+    const jsconfigFile = ts.findConfigFile(libRoot, ts.sys.fileExists, 'jsconfig.json');
+    let tsconfigFile = ts.findConfigFile(libRoot, ts.sys.fileExists);
     if (!tsconfigFile && !jsconfigFile) {
         throw new Error('Failed to locate tsconfig or jsconfig');
     }
@@ -6145,7 +6166,7 @@ function loadTsconfig(config, svelteMap) {
     }
     tsconfigFile = path.isAbsolute(tsconfigFile) ? tsconfigFile : path.join(libRoot, tsconfigFile);
     const basepath = path.dirname(tsconfigFile);
-    const { error, config: tsConfig } = ts__default.readConfigFile(tsconfigFile, ts__default.sys.readFile);
+    const { error, config: tsConfig } = ts.readConfigFile(tsconfigFile, ts.sys.readFile);
     if (error) {
         throw new Error('Malformed tsconfig\n' + JSON.stringify(error, null, 2));
     }
@@ -6157,7 +6178,7 @@ function loadTsconfig(config, svelteMap) {
         tsConfig.include = [`${libPathRelative}/**/*`];
         tsConfig.files = [];
     }
-    const { options, fileNames } = ts__default.parseJsonConfigFileContent(tsConfig, ts__default.sys, basepath, { sourceMap: false, rootDir: config.libRoot }, tsconfigFile, undefined, [{ extension: 'svelte', isMixedContent: true, scriptKind: ts__default.ScriptKind.Deferred }]);
+    const { options, fileNames } = ts.parseJsonConfigFileContent(tsConfig, ts.sys, basepath, { sourceMap: false, rootDir: config.libRoot }, tsconfigFile, undefined, [{ extension: 'svelte', isMixedContent: true, scriptKind: ts.ScriptKind.Deferred }]);
     const filenames = fileNames.map((name) => {
         if (!isSvelteFilepath(name)) {
             return name;
@@ -6175,7 +6196,9 @@ function loadTsconfig(config, svelteMap) {
         options: {
             ...options,
             noEmit: false,
-            moduleResolution: ts__default.ModuleResolutionKind.NodeJs,
+            moduleResolution: 
+            // NodeJS: up to 4.9, Node10: since 5.0
+            (_a = ts.ModuleResolutionKind.NodeJs) !== null && _a !== void 0 ? _a : ts.ModuleResolutionKind.Node10,
             declaration: true,
             emitDeclarationOnly: true,
             declarationDir: config.declarationDir,
@@ -6185,7 +6208,7 @@ function loadTsconfig(config, svelteMap) {
     };
 }
 async function createTsCompilerHost(options, svelteMap) {
-    const host = ts__default.createCompilerHost(options);
+    const host = ts.createCompilerHost(options);
     // TypeScript writes the files relative to the found tsconfig/jsconfig
     // which - at least in the case of the tests - is wrong. Therefore prefix
     // the output paths. See Typescript issue #25430 for more.
@@ -6194,10 +6217,10 @@ async function createTsCompilerHost(options, svelteMap) {
         .split(path.sep)
         .join('/');
     const svelteSys = {
-        ...ts__default.sys,
+        ...ts.sys,
         fileExists(originalPath) {
             const path = ensureRealSvelteFilepath(originalPath);
-            const exists = ts__default.sys.fileExists(path);
+            const exists = ts.sys.fileExists(path);
             if (exists && isSvelteFilepath(path)) {
                 const isTsFile = svelteMap.add(path);
                 if ((isTsFile && !isTsFilepath(originalPath)) ||
@@ -6213,12 +6236,12 @@ async function createTsCompilerHost(options, svelteMap) {
                 return svelteMap.get(path);
             }
             else {
-                return ts__default.sys.readFile(path, encoding);
+                return ts.sys.readFile(path, encoding);
             }
         },
         readDirectory(path, extensions, exclude, include, depth) {
             const extensionsWithSvelte = (extensions || []).concat('.svelte');
-            return ts__default.sys.readDirectory(path, extensionsWithSvelte, exclude, include, depth);
+            return ts.sys.readDirectory(path, extensionsWithSvelte, exclude, include, depth);
         },
         writeFile(fileName, data, writeByteOrderMark) {
             fileName = pathPrefix ? path.join(pathPrefix, fileName) : fileName;
@@ -6248,7 +6271,7 @@ async function createTsCompilerHost(options, svelteMap) {
                     return `"sources":["${sourcePath}"]`;
                 });
             }
-            return ts__default.sys.writeFile(fileName, data, writeByteOrderMark);
+            return ts.sys.writeFile(fileName, data, writeByteOrderMark);
         }
     };
     host.fileExists = svelteSys.fileExists;
@@ -6260,15 +6283,22 @@ async function createTsCompilerHost(options, svelteMap) {
             return resolveModuleName(moduleName, containingFile, compilerOptions);
         });
     };
+    host.resolveModuleNameLiterals = (moduleLiterals, containingFile, _redirectedReference, compilerOptions) => {
+        return moduleLiterals.map((moduleLiteral) => {
+            return {
+                resolvedModule: resolveModuleName(moduleLiteral.text, containingFile, compilerOptions)
+            };
+        });
+    };
     function resolveModuleName(name, containingFile, compilerOptions) {
         // Delegate to the TS resolver first.
         // If that does not bring up anything, try the Svelte Module loader
         // which is able to deal with .svelte files.
-        const tsResolvedModule = ts__default.resolveModuleName(name, containingFile, compilerOptions, ts__default.sys).resolvedModule;
+        const tsResolvedModule = ts.resolveModuleName(name, containingFile, compilerOptions, ts.sys).resolvedModule;
         if (tsResolvedModule && !isVirtualSvelteFilepath(tsResolvedModule.resolvedFileName)) {
             return tsResolvedModule;
         }
-        return ts__default.resolveModuleName(name, containingFile, compilerOptions, svelteSys)
+        return ts.resolveModuleName(name, containingFile, compilerOptions, svelteSys)
             .resolvedModule;
     }
     return host;
@@ -6282,7 +6312,7 @@ async function createSvelteMap(config) {
     const svelteFiles = new Map();
     function add(path) {
         var _a, _b;
-        const code = ts__default.sys.readFile(path, 'utf-8');
+        const code = ts.sys.readFile(path, 'utf-8');
         const isTsFile = // svelte-preprocess allows default languages
          ['ts', 'typescript'].includes((_b = (_a = config.preprocess) === null || _a === void 0 ? void 0 : _a.defaultLanguages) === null || _b === void 0 ? void 0 : _b.script) ||
             /<script\s+[^>]*?lang=('|")(ts|typescript)('|")/.test(code);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte2tsx",
-  "version": "0.6.9",
+  "version": "0.6.11",
   "description": "Convert Svelte components to TSX for type checking",
   "author": "David Pershouse",
   "license": "MIT",
@@ -34,14 +34,14 @@
     "rollup": "3.7.5",
     "rollup-plugin-delete": "^2.0.0",
     "source-map-support": "^0.5.16",
-    "svelte": "~3.55.0",
+    "svelte": "~3.57.0",
     "tiny-glob": "^0.2.6",
     "tslib": "^2.4.0",
-    "typescript": "^4.9.3"
+    "typescript": "^5.0.3"
   },
   "peerDependencies": {
     "svelte": "^3.55",
-    "typescript": "^4.9.4"
+    "typescript": "^4.9.4 || ^5.0.0"
   },
   "scripts": {
     "build": "rollup -c",

package/svelte-shims.d.ts

@@ -60,12 +60,12 @@ declare class Svelte2TsxComponent<
     $inject_state(): void;
 }
 
-/** @internal PRIVATE API, DO NOT USE */
+/** @deprecated PRIVATE API, DO NOT USE, REMOVED SOON */
 interface Svelte2TsxComponentConstructorParameters<Props extends {}> {
     /**
      * An HTMLElement to render to. This option is required.
      */
-    target: Element | ShadowRoot;
+    target: Element | Document | ShadowRoot;
     /**
      * A child of `target` to render the component immediately before.
      */
@@ -82,7 +82,7 @@ interface Svelte2TsxComponentConstructorParameters<Props extends {}> {
 
 type AConstructorTypeOf<T, U extends any[] = any[]> = new (...args: U) => T;
 /** @internal PRIVATE API, DO NOT USE */
-type SvelteComponentConstructor<T, U extends Svelte2TsxComponentConstructorParameters<any>> = new (options: U) => T;
+type SvelteComponentConstructor<T, U extends import('svelte').ComponentConstructorOptions<any>> = new (options: U) => T;
 
 /** @internal PRIVATE API, DO NOT USE */
 type SvelteActionReturnType = {
@@ -207,7 +207,7 @@ 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>,Svelte2TsxComponentConstructorParameters<Props>>;
+): 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