diff --git a/src/autoProcess.ts b/src/autoProcess.ts
index 75db9467..684b929c 100644
--- a/src/autoProcess.ts
+++ b/src/autoProcess.ts
@@ -83,6 +83,7 @@ export function autoPreprocess(
 ): PreprocessorGroup {
   markupTagName = markupTagName.toLocaleLowerCase();
 
+  const markupCache: Record<string, string> = {};
   const optionsCache: Record<string, any> = {};
   const transformers = rest.transformers || (rest as Transformers);
   const markupPattern = new RegExp(
@@ -141,7 +142,11 @@ export function autoPreprocess(
     const transformed = await runTransformer(
       lang,
       getTransformerOptions(lang, alias),
-      { content: stripIndent(content), filename },
+      {
+        content: stripIndent(content),
+        filename,
+        markup: markupCache[svelteFile.filename],
+      },
     );
 
     return {
@@ -170,7 +175,7 @@ export function autoPreprocess(
         const transformed = await runTransformer(
           'replace',
           transformers.replace,
-          { content, filename },
+          { content, filename, markup: content },
         );
 
         content = transformed.code;
@@ -180,6 +185,9 @@ export function autoPreprocess(
 
       /** If no <template> was found, just return the original markup */
       if (!templateMatch) {
+
+        markupCache[filename] = content;
+
         return { code: content };
       }
 
@@ -207,6 +215,8 @@ export function autoPreprocess(
         content.slice(0, templateMatch.index) +
         code +
         content.slice(templateMatch.index + fullMatch.length);
+        
+      markupCache[filename] = code;
 
       return { code, map, dependencies };
     },
@@ -214,7 +224,7 @@ export function autoPreprocess(
       const transformResult: Processed = await scriptTransformer({
         content,
         attributes,
-        filename,
+        filename
       });
 
       if (transformResult == null) return;
@@ -226,6 +236,7 @@ export function autoPreprocess(
           content: code,
           map,
           filename,
+          markup: markupCache[filename]
         });
 
         code = transformed.code;
@@ -251,7 +262,7 @@ export function autoPreprocess(
         const transformed = await runTransformer(
           'postcss',
           transformers.postcss,
-          { content: code, map, filename },
+          { content: code, map, filename, markup: markupCache[filename] },
         );
 
         code = transformed.code;
@@ -264,6 +275,7 @@ export function autoPreprocess(
           content: code,
           map,
           filename,
+          markup: markupCache[filename],
         });
 
         code = transformed.code;
diff --git a/src/processors/typescript.ts b/src/processors/typescript.ts
index 90fbc8e9..11a94bb4 100644
--- a/src/processors/typescript.ts
+++ b/src/processors/typescript.ts
@@ -1,7 +1,13 @@
 import { Options, PreprocessorGroup } from '../types';
 import { concat, parseFile } from '../utils';
 
+const markupCache: Record<string, string> = {};
+
 export default (options: Options.Typescript): PreprocessorGroup => ({
+  markup({ content, filename }: { content: string; filename: string }) {
+    markupCache[filename] = content;
+    return { code: content };
+  },
   async script(svelteFile) {
     const { default: transformer } = await import('../transformers/typescript');
     const { content, filename, lang, dependencies } = await parseFile(
@@ -10,7 +16,13 @@ export default (options: Options.Typescript): PreprocessorGroup => ({
     );
     if (lang !== 'typescript') return { code: content };
 
-    const transformed = await transformer({ content, filename, options });
+    const transformed = await transformer({
+      content,
+      filename,
+      options,
+      markup: markupCache[svelteFile.filename],
+    });
+
     return {
       ...transformed,
       dependencies: concat(dependencies, transformed.dependencies),
diff --git a/src/transformers/typescript.ts b/src/transformers/typescript.ts
index 61cb9a8a..2d87d604 100644
--- a/src/transformers/typescript.ts
+++ b/src/transformers/typescript.ts
@@ -80,10 +80,130 @@ const importTransformer: ts.TransformerFactory<ts.SourceFile> = context => {
   return node => ts.visitNode(node, visit);
 };
 
-const TS_TRANSFORMERS = {
-  before: [importTransformer],
+function findImportUsages(
+  node: ts.Node,
+  context: ts.TransformationContext,
+): { [name: string]: number } {
+  const usages: { [name: string]: number } = {};
+
+  let locals = new Set<string>();
+
+  const enterScope = <T>(action: () => T) => {
+    const oldLocals = locals;
+    locals = new Set([...locals]);
+    const result = action();
+    locals = oldLocals;
+    return result;
+  };
+
+  const findUsages: ts.Visitor = node => {
+    if (ts.isImportClause(node)) {
+      const bindings = node.namedBindings;
+      if (bindings && 'elements' in bindings) {
+        bindings.elements.forEach(
+          binding => (usages[binding.name.escapedText as string] = 0),
+        );
+      }
+      return node;
+    }
+
+    if (ts.isFunctionDeclaration(node)) {
+      return enterScope(() => {
+        node.parameters
+          .map(p => p.name)
+          .filter(ts.isIdentifier)
+          .forEach(p => locals.add(p.escapedText as string));
+        return ts.visitEachChild(node, child => findUsages(child), context);
+      });
+    }
+
+    if (ts.isBlock(node)) {
+      return enterScope(() =>
+        ts.visitEachChild(node, child => findUsages(child), context),
+      );
+    }
+
+    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
+      locals.add(node.name.escapedText as string);
+    } else if (ts.isIdentifier(node)) {
+      const identifier = node.escapedText as string;
+      if (!locals.has(identifier) && usages[identifier] != undefined) {
+        usages[identifier]++;
+      }
+    }
+
+    return ts.visitEachChild(node, child => findUsages(child), context);
+  };
+
+  ts.visitNode(node, findUsages);
+
+  return usages;
+}
+
+const removeNonEmittingImports: (
+  mainFile?: string,
+) => ts.TransformerFactory<ts.SourceFile> = mainFile => context => {
+  function createVisitor(usages: { [name: string]: number }) {
+    const visit: ts.Visitor = node => {
+      if (ts.isImportDeclaration(node)) {
+        let importClause = node.importClause;
+        const bindings = importClause.namedBindings;
+
+        if (bindings && ts.isNamedImports(bindings)) {
+          const namedImports = bindings.elements.filter(
+            element => usages[element.name.getText()] > 0,
+          );
+
+          if (namedImports.length !== bindings.elements.length) {
+            return ts.createImportDeclaration(
+              node.decorators,
+              node.modifiers,
+              namedImports.length == 0
+                ? undefined
+                : ts.createImportClause(
+                    importClause.name,
+                    ts.createNamedImports(namedImports),
+                  ),
+              node.moduleSpecifier,
+            );
+          }
+        }
+
+        return node;
+      }
+
+      if (
+        ts.isVariableStatement(node) &&
+        node.modifiers &&
+        node.modifiers[0] &&
+        node.modifiers[0].kind == ts.SyntaxKind.ExportKeyword
+      ) {
+        const name = node.declarationList.declarations[0].name;
+
+        if (ts.isIdentifier(name) && name.escapedText == '___used_tags__') {
+          return undefined;
+        }
+      }
+
+      return ts.visitEachChild(node, child => visit(child), context);
+    };
+
+    return visit;
+  }
+
+  return node =>
+    !mainFile || ts.sys.resolvePath(node.fileName) === mainFile
+      ? ts.visitNode(node, createVisitor(findImportUsages(node, context)))
+      : node;
 };
 
+function createTransforms(mainFile?: string) {
+  return {
+    before: [importTransformer],
+    after: [removeNonEmittingImports(mainFile)],
+  };
+}
+
 const TS2552_REGEX = /Cannot find name '\$([a-zA-Z0-9_]+)'. Did you mean '([a-zA-Z0-9_]+)'\?/i;
 function isValidSvelteReactiveValueDiagnostic(
   filename: string,
@@ -103,6 +223,25 @@ function isValidSvelteReactiveValueDiagnostic(
   return !(usedVar && proposedVar && usedVar === proposedVar);
 }
 
+function findTagsInMarkup(markup: string) {
+  if (!markup) {
+    return [];
+  }
+
+  let match: RegExpExecArray;
+  const result: string[] = [];
+  const findTag = /<([A-Z][^\s\/>]*)([\s\S]*?)>/g;
+  const template = markup
+    .replace(/<script([\s\S]*?)(?:>([\s\S]*)<\/script>|\/>)/g, '')
+    .replace(/<style([\s\S]*?)(?:>([\s\S]*)<\/style>|\/>)/g, '');
+
+  while ((match = findTag.exec(template)) !== null) {
+    result.push(match[1]);
+  }
+
+  return result;
+}
+
 function compileFileFromMemory(
   compilerOptions: CompilerOptions,
   { filename, content }: { filename: string; content: string },
@@ -112,7 +251,7 @@ function compileFileFromMemory(
 
   const realHost = ts.createCompilerHost(compilerOptions, true);
   const dummyFileName = ts.sys.resolvePath(filename);
-
+  const dummyBaseName = basename(dummyFileName);
   const isDummyFile = (fileName: string) =>
     ts.sys.resolvePath(fileName) === dummyFileName;
 
@@ -142,10 +281,13 @@ function compileFileFromMemory(
     readFile: fileName =>
       isDummyFile(fileName) ? content : realHost.readFile(fileName),
     writeFile: (fileName, data) => {
-      if (fileName.endsWith('.map')) {
-        map = data;
-      } else {
-        code = data;
+      switch (basename(fileName)) {
+        case dummyBaseName + '.js.map':
+          map = data;
+          break;
+        case dummyBaseName + '.js':
+          code = data;
+          break;
       }
     },
     directoryExists:
@@ -162,12 +304,13 @@ function compileFileFromMemory(
   };
 
   const program = ts.createProgram([dummyFileName], compilerOptions, host);
+
   const emitResult = program.emit(
     undefined,
     undefined,
     undefined,
     undefined,
-    TS_TRANSFORMERS,
+    createTransforms(dummyFileName),
   );
 
   // collect diagnostics without svelte import errors
@@ -187,6 +330,7 @@ const transformer: Transformer<Options.Typescript> = ({
   content,
   filename,
   options,
+  markup,
 }) => {
   // default options
   const compilerOptionsJSON = {
@@ -242,7 +386,20 @@ const transformer: Transformer<Options.Typescript> = ({
     );
   }
 
+  // Force module kind to es2015, so we keep the correct names.
+  compilerOptions.module = ts.ModuleKind.ES2015;
+
+  // Generate separate source maps.
+  compilerOptions.sourceMap = true;
+  compilerOptions.inlineSourceMap = false;
+
+  const tagsInMarkup = findTagsInMarkup(markup);
+
   let code, map, diagnostics;
+
+  // Append all used tags
+  content += '\nexport const __used_tags__=[' + tagsInMarkup.join(',') + '];';
+
   if (options.transpileOnly || compilerOptions.transpileOnly) {
     ({ outputText: code, sourceMapText: map, diagnostics } = ts.transpileModule(
       content,
@@ -250,7 +407,7 @@ const transformer: Transformer<Options.Typescript> = ({
         fileName: filename,
         compilerOptions: compilerOptions,
         reportDiagnostics: options.reportDiagnostics !== false,
-        transformers: TS_TRANSFORMERS,
+        transformers: createTransforms(),
       },
     ));
   } else {
diff --git a/src/types/index.ts b/src/types/index.ts
index 9fad0b75..3fea35f1 100644
--- a/src/types/index.ts
+++ b/src/types/index.ts
@@ -23,6 +23,7 @@ export interface TransformerArgs<T> {
   map?: string | object;
   dianostics?: Array<unknown>;
   options?: T;
+  markup?: string;
 }
 
 export type Processed = SvelteProcessed & {
diff --git a/src/types/options.ts b/src/types/options.ts
index a247b4a5..299d3402 100644
--- a/src/types/options.ts
+++ b/src/types/options.ts
@@ -60,4 +60,5 @@ export interface Typescript {
   tsconfigDirectory?: string | boolean;
   transpileOnly?: boolean;
   reportDiagnostics?: boolean;
+  removeNonEmittingImports?: boolean;
 }
diff --git a/src/utils.ts b/src/utils.ts
index 40de7b19..10f0a397 100644
--- a/src/utils.ts
+++ b/src/utils.ts
@@ -130,13 +130,13 @@ const TRANSFORMERS = {} as {
 export const runTransformer = async (
   name: string,
   options: TransformerOptions<any>,
-  { content, map, filename }: TransformerArgs<any>,
+  { content, map, filename, markup }: TransformerArgs<any>,
 ): Promise<ReturnType<Transformer<unknown>>> => {
   // remove any unnecessary indentation (useful for coffee, pug and sugarss)
   content = stripIndent(content);
 
   if (typeof options === 'function') {
-    return options({ content, map, filename });
+    return options({ content, map, filename, markup });
   }
 
   try {
@@ -150,6 +150,7 @@ export const runTransformer = async (
     return TRANSFORMERS[name]({
       content,
       filename,
+      markup,
       map,
       options: typeof options === 'boolean' ? null : options,
     });
diff --git a/test/fixtures/References.svelte b/test/fixtures/References.svelte
new file mode 100644
index 00000000..4c82ed63
--- /dev/null
+++ b/test/fixtures/References.svelte
@@ -0,0 +1,10 @@
+<script lang="typescript">
+  import { Box, Circle, Triangle, Dot } from "./fixtures/shapes"
+
+  export let triangle: Dot;
+</script>
+
+<Box color="green">
+  <Circle color="orange">
+  </Circle>
+</Box>
\ No newline at end of file
diff --git a/test/fixtures/exports.ts b/test/fixtures/exports.ts
new file mode 100644
index 00000000..6605e000
--- /dev/null
+++ b/test/fixtures/exports.ts
@@ -0,0 +1,6 @@
+export interface IFace {
+  readonly value: string;
+}
+
+export class ExportedClass {
+}
diff --git a/test/fixtures/shapes.ts b/test/fixtures/shapes.ts
new file mode 100644
index 00000000..9eb46dd4
--- /dev/null
+++ b/test/fixtures/shapes.ts
@@ -0,0 +1,11 @@
+export class Box {
+}
+
+export class Circle {
+}
+
+export function Triangle() {
+}
+
+export interface Dot {
+}
\ No newline at end of file
diff --git a/test/transformers/babel.test.ts b/test/transformers/babel.test.ts
index e2814285..9068abee 100644
--- a/test/transformers/babel.test.ts
+++ b/test/transformers/babel.test.ts
@@ -27,11 +27,11 @@ describe('transformer - babel', () => {
     });
     const preprocessed = await preprocess(template, opts);
     expect(preprocessed.code).toMatchInlineSnapshot(`
-      "<script>var _ref;
+      "<script>var _foo$b;
 
       var foo = {};
 
-      $: bar = (_ref = foo == null ? void 0 : foo.b) != null ? _ref : 120;</script>"
+      $: bar = (_foo$b = foo == null ? void 0 : foo.b) != null ? _foo$b : 120;</script>"
     `);
   });
 });
diff --git a/test/transformers/typescript.test.ts b/test/transformers/typescript.test.ts
index a4a6364e..dece2eb0 100644
--- a/test/transformers/typescript.test.ts
+++ b/test/transformers/typescript.test.ts
@@ -31,6 +31,79 @@ describe('transformer - typescript', () => {
     'script.ts',
   )}</script>`;
 
+  it('should keep tags referenced in the markup', async () => {
+    const opts = getAutoPreprocess({});
+    const preprocessed = await preprocess(
+      getFixtureContent('References.svelte'),
+      opts,
+    );
+    expect(preprocessed.toString()).toMatchInlineSnapshot(`
+      "<script lang=\\"typescript\\">import { Box, Circle } from \\"./fixtures/shapes\\";
+      export let triangle;
+      //# sourceMappingURL=App.svelte.js.map</script>
+
+      <Box color=\\"green\\">
+        <Circle color=\\"orange\\">
+        </Circle>
+      </Box>"
+    `);
+  });
+
+  it('should keep tags referenced in the markup when only transpiling', async () => {
+    const opts = getAutoPreprocess({
+      typescript: {
+        transpileOnly: true,
+      },
+    });
+    const preprocessed = await preprocess(
+      getFixtureContent('References.svelte'),
+      opts,
+    );
+    expect(preprocessed.toString()).toMatchInlineSnapshot(`
+      "<script lang=\\"typescript\\">import { Box, Circle } from \\"./fixtures/shapes\\";
+      export let triangle;
+      //# sourceMappingURL=App.svelte.js.map</script>
+
+      <Box color=\\"green\\">
+        <Circle color=\\"orange\\">
+        </Circle>
+      </Box>"
+    `);
+  });
+
+  it('should remove unused named imports', async () => {
+    const { code } = await transpile(
+      'import { IFace, ExportedClass } from "./fixtures/exports"',
+    );
+    expect(code).toMatchInlineSnapshot(`
+      "import \\"./fixtures/exports\\";
+      //# sourceMappingURL=App.svelte.js.map"
+    `);
+  });
+
+  it('should remove unused named imports but leave used ones', async () => {
+    const { code } = await transpile(
+      'import { IFace, ExportedClass } from "./fixtures/exports"\nnew ExportedClass()',
+    );
+    expect(code).toMatchInlineSnapshot(`
+      "import { ExportedClass } from \\"./fixtures/exports\\";
+      new ExportedClass();
+      //# sourceMappingURL=App.svelte.js.map"
+    `);
+  });
+
+  it('should remove unused named imports that conflict with local variables', async () => {
+    const { code } = await transpile(
+      'import { IFace as name } from "./fixtures/exports"\nexport let iface: name\nfunction func(name: string) { return name }',
+    );
+    expect(code).toMatchInlineSnapshot(`
+      "import \\"./fixtures/exports\\";
+      export let iface;
+      function func(name) { return name; }
+      //# sourceMappingURL=App.svelte.js.map"
+    `);
+  });
+
   it('should disallow transpilation to es5 or lower', async () => {
     expect(
       transpile('export let foo = 10', { target: 'es3' }),
@@ -151,7 +224,7 @@ describe('transformer - typescript', () => {
       );
       expect(diagnostics.some(d => d.code === 2552)).toBe(false);
     });
-    
+
     it('should report a mismatched variable name error', async () => {
       const { diagnostics } = await transpile(
         `
@@ -161,6 +234,5 @@ describe('transformer - typescript', () => {
       );
       expect(diagnostics.some(d => d.code === 2552)).toBe(true);
     });
-
   });
 });