diff --git a/src/autoProcess.ts b/src/autoProcess.ts
index 20400cad..25e57e82 100644
--- a/src/autoProcess.ts
+++ b/src/autoProcess.ts
@@ -1,14 +1,15 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { PreprocessorOptions } from 'svelte/types/compiler/preprocess';
+
 import {
   PreprocessorGroup,
-  Preprocessor,
-  Processed,
   TransformerArgs,
   TransformerOptions,
   Transformers,
   Options,
 } from './types';
 import { hasDepInstalled, concat } from './modules/utils';
-import { getTagInfo } from './modules/tagInfo';
+import { getTagInfoSync } from './modules/tagInfo';
 import {
   addLanguageAlias,
   getLanguageFromAlias,
@@ -18,6 +19,7 @@ import {
 } from './modules/language';
 import { prepareContent } from './modules/prepareContent';
 import { transformMarkup } from './modules/markup';
+import { default as pipe, EventuallyProcessed } from './pipe';
 
 type AutoPreprocessGroup = PreprocessorGroup & {
   defaultLanguages: Readonly<{
@@ -56,13 +58,16 @@ type AutoPreprocessOptions = {
   [languageName: string]: TransformerOptions;
 };
 
-export const transform = async (
+export function transform<Sync>(
   name: string,
   options: TransformerOptions,
   { content, map, filename, attributes }: TransformerArgs<any>,
-): Promise<Processed> => {
+  sync: Sync,
+): EventuallyProcessed<Sync> {
   if (options === false) {
-    return { code: content };
+    const res = { code: content };
+
+    return (sync ? res : Promise.resolve(res)) as any;
   }
 
   if (typeof options === 'function') {
@@ -70,7 +75,17 @@ export const transform = async (
   }
 
   // todo: maybe add a try-catch here looking for module-not-found errors
-  const { transformer } = await import(`./transformers/${name}`);
+  const { transformer, is_sync } = require(`./transformers/${name}`);
+
+  if (sync && !is_sync) {
+    console.error(`Transfomer ${name} does not support sync calls.`)
+
+    return {
+      code: content,
+      map,
+      dependencies: [],
+    } as EventuallyProcessed<Sync>;
+  }
 
   return transformer({
     content,
@@ -79,7 +94,7 @@ export const transform = async (
     attributes,
     options: typeof options === 'boolean' ? null : options,
   });
-};
+}
 
 export function sveltePreprocess(
   {
@@ -135,10 +150,11 @@ export function sveltePreprocess(
     return opts;
   };
 
-  const getTransformerTo = (
+  const getTransformerTo = <Sync>(
     type: 'markup' | 'script' | 'style',
     targetLanguage: string,
-  ): Preprocessor => async (svelteFile) => {
+    sync: Sync,
+  ) => (svelteFile): EventuallyProcessed<Sync> => {
     let {
       content,
       filename,
@@ -146,7 +162,7 @@ export function sveltePreprocess(
       alias,
       dependencies,
       attributes,
-    } = await getTagInfo(svelteFile);
+    } = getTagInfoSync(svelteFile);
 
     if (lang == null || alias == null) {
       alias = defaultLanguages[type];
@@ -154,7 +170,7 @@ export function sveltePreprocess(
     }
 
     if (preserve.includes(lang) || preserve.includes(alias)) {
-      return { code: content };
+      return { code: content } as EventuallyProcessed<Sync>;
     }
 
     const transformerOptions = getTransformerOptions(lang, alias);
@@ -165,122 +181,216 @@ export function sveltePreprocess(
     });
 
     if (lang === targetLanguage) {
-      return { code: content, dependencies };
+      return { code: content, dependencies } as EventuallyProcessed<Sync>;
     }
 
-    const transformed = await transform(lang, transformerOptions, {
-      content,
-      filename,
-      attributes,
-    });
-
-    return {
-      ...transformed,
-      dependencies: concat(dependencies, transformed.dependencies),
-    };
+    return pipe<Sync>(
+      sync,
+      () =>
+        transform(
+          lang,
+          transformerOptions,
+          {
+            content,
+            filename,
+            attributes,
+          },
+          sync,
+        ),
+      (processed) =>
+        ({
+          ...processed,
+          dependencies: concat(dependencies, processed.dependencies),
+        } as EventuallyProcessed<Sync>),
+    );
   };
 
-  const scriptTransformer = getTransformerTo('script', 'javascript');
-  const cssTransformer = getTransformerTo('style', 'css');
-  const markupTransformer = getTransformerTo('markup', 'html');
-
-  const markup: PreprocessorGroup['markup'] = async ({ content, filename }) => {
-    if (transformers.replace) {
-      const transformed = await transform('replace', transformers.replace, {
-        content,
-        filename,
-      });
-
-      content = transformed.code;
-    }
-
-    return transformMarkup({ content, filename }, markupTransformer, {
-      // we only pass the markupTagName because the rest of options
-      // is fetched internally by the `markupTransformer`
-      markupTagName,
-    });
-  };
-
-  const script: PreprocessorGroup['script'] = async ({
-    content,
-    attributes,
-    filename,
-  }) => {
-    const transformResult: Processed = await scriptTransformer({
-      content,
-      attributes,
-      filename,
-    });
-
-    let { code, map, dependencies, diagnostics } = transformResult;
-
-    if (transformers.babel) {
-      const transformed = await transform(
-        'babel',
-        getTransformerOptions('babel'),
-        {
-          content: code,
-          map,
-          filename,
-          attributes,
+  const markupTransformer = getTransformerTo('markup', 'html', false);
+
+  function buildMarkupProcessor<Sync>(
+    sync: Sync,
+  ): (options: PreprocessorOptions) => EventuallyProcessed<Sync> {
+    return ({ content, filename }) => {
+      return pipe<Sync>(
+        sync,
+        () => {
+          if (transformers.replace) {
+            return transform<Sync>(
+              'replace',
+              transformers.replace,
+              {
+                content,
+                filename,
+              },
+              sync,
+            );
+          }
+
+          return { code: content } as EventuallyProcessed<Sync>;
         },
+        ({ code }) =>
+          transformMarkup<Sync>(
+            sync,
+            { content: code, filename },
+            markupTransformer,
+            {
+              // we only pass the markupTagName because the rest of options
+              // is fetched internally by the `markupTransformer`
+              markupTagName,
+            },
+          ),
       );
+    };
+  }
 
-      code = transformed.code;
-      map = transformed.map;
-      dependencies = concat(dependencies, transformed.dependencies);
-      diagnostics = concat(diagnostics, transformed.diagnostics);
-    }
-
-    return { code, map, dependencies, diagnostics };
-  };
-
-  const style: PreprocessorGroup['style'] = async ({
-    content,
-    attributes,
-    filename,
-  }) => {
-    const transformResult = await cssTransformer({
-      content,
-      attributes,
-      filename,
-    });
-
-    let { code, map, dependencies } = transformResult;
-
-    // istanbul ignore else
-    if (await hasDepInstalled('postcss')) {
-      if (transformers.postcss) {
-        const { alias } = getLanguage(attributes);
-
-        const transformed = await transform(
-          'postcss',
-          getTransformerOptions('postcss', alias),
-          { content: code, map, filename, attributes },
-        );
-
-        code = transformed.code;
-        map = transformed.map;
-        dependencies = concat(dependencies, transformed.dependencies);
-      }
+  function buildScriptProcessor<Sync>(
+    sync: Sync,
+  ): (options: PreprocessorOptions) => EventuallyProcessed<Sync> {
+    return ({ content, attributes, filename }) =>
+      pipe<Sync>(
+        sync,
+        () =>
+          getTransformerTo<Sync>(
+            'script',
+            'javascript',
+            sync,
+          )({
+            content,
+            attributes,
+            filename,
+          }),
+        ({ code, map, dependencies, diagnostics }) => {
+          if (transformers.babel) {
+            return pipe<Sync>(
+              sync,
+              () =>
+                transform<Sync>(
+                  'babel',
+                  getTransformerOptions('babel'),
+                  {
+                    content: code,
+                    map,
+                    filename,
+                    attributes,
+                  },
+                  sync,
+                ),
+              (transformed) => {
+                code = transformed.code;
+                map = transformed.map;
+                dependencies = concat(dependencies, transformed.dependencies);
+                diagnostics = concat(diagnostics, transformed.diagnostics);
+
+                return {
+                  code,
+                  map,
+                  dependencies,
+                  diagnostics,
+                } as EventuallyProcessed<Sync>;
+              },
+            );
+          }
+
+          return {
+            code,
+            map,
+            dependencies,
+            diagnostics,
+          } as EventuallyProcessed<Sync>;
+        },
+      );
+  }
 
-      const transformed = await transform(
-        'globalStyle',
-        getTransformerOptions('globalStyle'),
-        { content: code, map, filename, attributes },
+  function buildStyleProcessor<Sync>(
+    sync: Sync,
+  ): (options: PreprocessorOptions) => EventuallyProcessed<Sync> {
+    return ({ content, attributes, filename }) => {
+      const hasPostCss = hasDepInstalled('postcss');
+
+      return pipe<Sync>(
+        sync,
+        () =>
+          getTransformerTo<Sync>(
+            'style',
+            'css',
+            sync,
+          )({
+            content,
+            attributes,
+            filename,
+          }),
+        ({ code, map, dependencies }) => {
+          if (hasPostCss && transformers.postcss) {
+            const { alias } = getLanguage(attributes);
+
+            return pipe<Sync>(
+              sync,
+              () =>
+                transform(
+                  'postcss',
+                  getTransformerOptions('postcss', alias),
+                  { content: code, map, filename, attributes },
+                  sync,
+                ),
+              (t) =>
+                ({
+                  code: t.code,
+                  map: t.map,
+                  dependencies: concat(dependencies, t.dependencies),
+                } as EventuallyProcessed<Sync>),
+            );
+          }
+
+          return { code, map, dependencies } as EventuallyProcessed<Sync>;
+        },
+        ({ code, map, dependencies }) => {
+          if (hasPostCss) {
+            return pipe<Sync>(
+              sync,
+              () =>
+                transform(
+                  'globalStyle',
+                  getTransformerOptions('globalStyle'),
+                  { content: code, map, filename, attributes },
+                  sync,
+                ),
+              (t) =>
+                ({
+                  code: t.code,
+                  map: t.map,
+                  dependencies,
+                } as EventuallyProcessed<Sync>),
+            );
+          }
+
+          return { code, map, dependencies } as EventuallyProcessed<Sync>;
+        },
       );
+    };
+  }
 
-      code = transformed.code;
-      map = transformed.map;
-    }
+  const markup: PreprocessorGroup['markup'] = buildMarkupProcessor(false);
+  const markup_sync: PreprocessorGroup['markup_sync'] = buildMarkupProcessor<
+    true
+  >(true);
 
-    return { code, map, dependencies };
-  };
+  const script: PreprocessorGroup['script'] = buildScriptProcessor(false);
+  const script_sync: PreprocessorGroup['script_sync'] = buildScriptProcessor<
+    true
+  >(true);
+
+  const style: PreprocessorGroup['style'] = buildStyleProcessor(false);
+  const style_sync: PreprocessorGroup['style_sync'] = buildStyleProcessor<true>(
+    true,
+  );
 
   return {
     defaultLanguages,
     markup,
+    markup_sync,
     script,
+    script_sync,
     style,
+    style_sync,
   };
 }
diff --git a/src/modules/markup.ts b/src/modules/markup.ts
index 2ffa2c41..87805b11 100644
--- a/src/modules/markup.ts
+++ b/src/modules/markup.ts
@@ -1,10 +1,12 @@
+import pipe, { EventuallyProcessed } from '../pipe';
 import { Transformer, Preprocessor } from '../types';
 
-export async function transformMarkup(
+export function transformMarkup<S>(
+  sync: S,
   { content, filename }: { content: string; filename: string },
   transformer: Preprocessor | Transformer<unknown>,
   options: Record<string, any> = {},
-) {
+): EventuallyProcessed<S> {
   let { markupTagName = 'template' } = options;
 
   markupTagName = markupTagName.toLocaleLowerCase();
@@ -17,7 +19,12 @@ export async function transformMarkup(
 
   /** If no <template> was found, run the transformer over the whole thing */
   if (!templateMatch) {
-    return transformer({ content, attributes: {}, filename, options });
+    return transformer({
+      content,
+      attributes: {},
+      filename,
+      options,
+    }) as EventuallyProcessed<S>;
   }
 
   const [fullMatch, attributesStr, templateCode] = templateMatch;
@@ -36,17 +43,22 @@ export async function transformMarkup(
     }, {});
 
   /** Transform the found template code */
-  let { code, map, dependencies } = await transformer({
-    content: templateCode,
-    attributes,
-    filename,
-    options,
-  });
-
-  code =
-    content.slice(0, templateMatch.index) +
-    code +
-    content.slice(templateMatch.index + fullMatch.length);
-
-  return { code, map, dependencies };
+  return pipe<S>(
+    sync,
+    () =>
+      transformer({
+        content: templateCode,
+        attributes,
+        filename,
+        options,
+      }) as EventuallyProcessed<S>,
+    ({ code, map, dependencies }) => {
+      code =
+        content.slice(0, templateMatch.index) +
+        code +
+        content.slice(templateMatch.index + fullMatch.length);
+
+      return { code, map, dependencies } as EventuallyProcessed<S>;
+    },
+  );
 }
diff --git a/src/modules/tagInfo.ts b/src/modules/tagInfo.ts
index ce9fcb07..da687afc 100644
--- a/src/modules/tagInfo.ts
+++ b/src/modules/tagInfo.ts
@@ -1,4 +1,4 @@
-import { readFile, access } from 'fs';
+import { readFile, access, accessSync, readFileSync } from 'fs';
 import { resolve, dirname } from 'path';
 
 import { PreprocessorArgs } from '../types';
@@ -18,10 +18,68 @@ const getSrcContent = (file: string): Promise<string> => {
   });
 };
 
+const getSrcContentSync = (file: string) => {
+  const data = readFileSync(file);
+
+  return data.toString();
+};
+
 async function doesFileExist(file: string) {
   return new Promise((resolve) => access(file, 0, (err) => resolve(!err)));
 }
 
+function doesFileExistSync(file: string) {
+  try {
+    accessSync(file, 0);
+
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+export const getTagInfoSync = ({
+  attributes,
+  filename,
+  content,
+}: PreprocessorArgs) => {
+  const dependencies = [];
+  // catches empty content and self-closing tags
+  const isEmptyContent = content == null || content.trim().length === 0;
+
+  /** only include src file if content of tag is empty */
+  if (attributes.src && isEmptyContent) {
+    // istanbul ignore if
+    if (typeof attributes.src !== 'string') {
+      throw new Error('src attribute must be string');
+    }
+
+    let path = attributes.src;
+
+    /** Only try to get local files (path starts with ./ or ../) */
+    if (isValidLocalPath(path)) {
+      path = resolveSrc(filename, path);
+      if (doesFileExistSync(path)) {
+        content = getSrcContentSync(path);
+        dependencies.push(path);
+      } else {
+        console.warn(`[svelte-preprocess] The file  "${path}" was not found.`);
+      }
+    }
+  }
+
+  const { lang, alias } = getLanguage(attributes);
+
+  return {
+    filename,
+    attributes,
+    content,
+    lang,
+    alias,
+    dependencies,
+  };
+};
+
 export const getTagInfo = async ({
   attributes,
   filename,
diff --git a/src/modules/utils.ts b/src/modules/utils.ts
index 0ce0dc9b..a952d4c4 100644
--- a/src/modules/utils.ts
+++ b/src/modules/utils.ts
@@ -39,7 +39,7 @@ const cachedResult: Record<string, boolean> = {};
  * @param {string} dep
  * @returns boolean
  */
-export async function hasDepInstalled(dep: string) {
+export function hasDepInstalled(dep: string) {
   if (cachedResult[dep] != null) {
     return cachedResult[dep];
   }
@@ -47,7 +47,7 @@ export async function hasDepInstalled(dep: string) {
   let result = false;
 
   try {
-    await import(dep);
+    require(dep);
 
     result = true;
   } catch (e) {
diff --git a/src/pipe.ts b/src/pipe.ts
new file mode 100644
index 00000000..e2b68f5f
--- /dev/null
+++ b/src/pipe.ts
@@ -0,0 +1,42 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { Processed } from './types';
+
+export type EventuallyProcessed<Sync> = Sync extends true
+  ? Processed
+  : Processed | Promise<Processed>;
+
+const pipe: <Sync>(
+  sync: Sync,
+  start: () => EventuallyProcessed<Sync>,
+  ...then: Array<(processed: Processed) => EventuallyProcessed<Sync>>
+) => EventuallyProcessed<Sync> = (sync, start, ...then) =>
+  ((sync ? pipe_sync : pipe_async) as any)(start, ...then);
+
+async function pipe_async(
+  start: () => Promise<Processed>,
+  ...then: Array<(processed: Processed) => Promise<Processed>>
+) {
+  let processed = await start();
+
+  for (let i = 0; i < then.length; i++) {
+    // eslint-disable-next-line no-await-in-loop
+    processed = await then[i](processed);
+  }
+
+  return processed;
+}
+
+function pipe_sync(
+  start: () => Processed,
+  ...then: Array<(processed: Processed) => Processed>
+) {
+  let processed = start();
+
+  for (let i = 0; i < then.length; i++) {
+    processed = then[i](processed);
+  }
+
+  return processed;
+}
+
+export default pipe;
diff --git a/src/processors/pug.ts b/src/processors/pug.ts
index aed836cc..33220477 100644
--- a/src/processors/pug.ts
+++ b/src/processors/pug.ts
@@ -15,6 +15,25 @@ export default (options?: Options.Pug): PreprocessorGroup => ({
       content,
     });
 
-    return transformMarkup({ content, filename }, transformer, options);
+    return transformMarkup(false, { content, filename }, transformer, options);
+  },
+
+  markup_sync({ content, filename }) {
+    const { transformer } = require('../transformers/pug');
+
+    content = prepareContent({
+      options: {
+        ...options,
+        stripIndent: true,
+      },
+      content,
+    });
+
+    return transformMarkup<true>(
+      true,
+      { content, filename },
+      transformer,
+      options,
+    );
   },
 });
diff --git a/src/processors/typescript.ts b/src/processors/typescript.ts
index 181baa73..d4615e29 100644
--- a/src/processors/typescript.ts
+++ b/src/processors/typescript.ts
@@ -1,18 +1,14 @@
 import { Options, PreprocessorGroup } from '../types';
-import { getTagInfo } from '../modules/tagInfo';
+import { getTagInfoSync } from '../modules/tagInfo';
 import { concat } from '../modules/utils';
 import { prepareContent } from '../modules/prepareContent';
 
-export default (options?: Options.Typescript): PreprocessorGroup => ({
-  async script(svelteFile) {
-    const { transformer } = await import('../transformers/typescript');
-    let {
-      content,
-      filename,
-      attributes,
-      lang,
-      dependencies,
-    } = await getTagInfo(svelteFile);
+export default (options?: Options.Typescript): PreprocessorGroup => {
+  const script = (svelteFile) => {
+    const { transformer } = require('../transformers/typescript');
+    let { content, filename, attributes, lang, dependencies } = getTagInfoSync(
+      svelteFile,
+    );
 
     content = prepareContent({ options, content });
 
@@ -20,7 +16,7 @@ export default (options?: Options.Typescript): PreprocessorGroup => ({
       return { code: content };
     }
 
-    const transformed = await transformer({
+    const transformed = transformer({
       content,
       filename,
       attributes,
@@ -31,5 +27,10 @@ export default (options?: Options.Typescript): PreprocessorGroup => ({
       ...transformed,
       dependencies: concat(dependencies, transformed.dependencies),
     };
-  },
-});
+  };
+
+  return {
+    script,
+    script_sync: script,
+  };
+};
diff --git a/src/transformers/replace.ts b/src/transformers/replace.ts
index b538ac23..b85be9ea 100644
--- a/src/transformers/replace.ts
+++ b/src/transformers/replace.ts
@@ -1,9 +1,7 @@
+/* eslint-disable @typescript-eslint/naming-convention */
 import { Transformer, Options } from '../types';
 
-const transformer: Transformer<Options.Replace> = async ({
-  content,
-  options,
-}) => {
+const transformer: Transformer<Options.Replace> = ({ content, options }) => {
   let newContent = content;
 
   for (const [regex, replacer] of options) {
@@ -15,4 +13,6 @@ const transformer: Transformer<Options.Replace> = async ({
   };
 };
 
-export { transformer };
+const is_sync = true;
+
+export { transformer, is_sync };
diff --git a/src/transformers/typescript.ts b/src/transformers/typescript.ts
index 74bcc9b9..f7a5456e 100644
--- a/src/transformers/typescript.ts
+++ b/src/transformers/typescript.ts
@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/naming-convention */
 import { dirname } from 'path';
 
 import ts from 'typescript';
@@ -151,4 +152,6 @@ const transformer: Transformer<Options.Typescript> = ({
   };
 };
 
-export { transformer };
+const is_sync = true;
+
+export { transformer, is_sync };
diff --git a/src/types/index.ts b/src/types/index.ts
index 25ce8620..ea92740b 100644
--- a/src/types/index.ts
+++ b/src/types/index.ts
@@ -34,6 +34,8 @@ export type Transformer<T> = (
   args: TransformerArgs<T>,
 ) => Processed | Promise<Processed>;
 
+export type SyncTransformer<T> = (args: TransformerArgs<T>) => Processed;
+
 export type TransformerOptions<T = any> = boolean | T | Transformer<T>;
 
 export interface Transformers {
diff --git a/test/autoProcess/externalFiles.test.ts b/test/autoProcess/externalFiles.test.ts
index c736575d..70f44ae9 100644
--- a/test/autoProcess/externalFiles.test.ts
+++ b/test/autoProcess/externalFiles.test.ts
@@ -32,6 +32,7 @@ describe('external files', () => {
         <style src="./fixtures/style.css"></style>
         <script src="./fixtures/script.js"></script>`,
         filename: resolve(__dirname, '..', 'App.svelte'),
+        attributes: {},
       }),
       await scriptProcessor({
         content: ``,
@@ -57,6 +58,7 @@ describe('external files', () => {
     const markup = await markupProcessor({
       content: `<template src="./fixtures/template.html"/>`,
       filename: resolve(__dirname, '..', 'App.svelte'),
+      attributes: {},
     });
 
     expect(markup.code).toContain(getFixtureContent('template.html'));