chore: import type

src/builders.ts

@@ -2,7 +2,7 @@ import * as recast from "recast";
 import { proxifyFunctionCall } from "./proxy/function-call";
 import { proxifyNewExpression } from "./proxy/new-expression";
 import { literalToAst } from "./proxy/_utils";
-import { Proxified } from "./types";
+import type { Proxified } from "./types";
 import { parseExpression } from "./code";
 
 const b = recast.types.builders;

src/error.ts

@@ -1,4 +1,4 @@
-import { ASTNode } from "./types";
+import type { ASTNode } from "./types";
 
 export interface MagicastErrorOptions {
   ast?: ASTNode;

src/helpers/config.ts

@@ -1,4 +1,4 @@
-import { ProxifiedModule } from "../types";
+import type { ProxifiedModule } from "../types";
 
 export function getDefaultExportOptions(magicast: ProxifiedModule<any>) {
   return magicast.exports.default.$type === "function-call"

src/helpers/deep-merge.ts

@@ -1,4 +1,4 @@
-import { Proxified } from "../types";
+import type { Proxified } from "../types";
 
 export function deepMergeObject(magicast: Proxified<any>, object: any) {
   if (typeof object === "object") {

src/helpers/nuxt.ts

@@ -1,4 +1,4 @@
-import { ProxifiedModule } from "../proxy/types";
+import type { ProxifiedModule } from "../proxy/types";
 import { getDefaultExportOptions } from "./config";
 import { deepMergeObject } from "./deep-merge";
 

src/helpers/vite.ts

@@ -1,5 +1,5 @@
+import type { ProxifiedFunctionCall, ProxifiedModule } from "../proxy/types";
 import { builders } from "../builders";
-import { ProxifiedFunctionCall, ProxifiedModule } from "../proxy/types";
 import { getDefaultExportOptions } from "./config";
 import { deepMergeObject } from "./deep-merge";
 

src/proxy/_utils.ts

@@ -1,6 +1,6 @@
 import * as recast from "recast";
-import { MagicastError } from "../error";
 import type { ASTNode } from "../types";
+import { MagicastError } from "../error";
 
 export const LITERALS_AST = new Set([
   "Literal",

src/proxy/array.ts

@@ -1,7 +1,7 @@
-import { ASTNode } from "../types";
+import type { ASTNode } from "../types";
+import type { ProxifiedArray, ProxifiedModule } from "./types";
 import { literalToAst, createProxy } from "./_utils";
 import { proxify } from "./proxify";
-import { ProxifiedArray, ProxifiedModule } from "./types";
 
 export function proxifyArrayElements<T extends any[]>(
   node: ASTNode,

src/proxy/exports.ts

@@ -1,8 +1,8 @@
 import * as recast from "recast";
-import { Program } from "@babel/types";
+import type { Program } from "@babel/types";
+import type { ProxifiedModule } from "./types";
 import { createProxy, literalToAst } from "./_utils";
 import { proxify } from "./proxify";
-import { ProxifiedModule } from "./types";
 
 const b = recast.types.builders;
 
@@ -51,10 +51,10 @@ export function createExportsProxy(root: Program, mod: ProxifiedModule) {
       key === "default"
         ? b.exportDefaultDeclaration(node)
         : (b.exportNamedDeclaration(
-            b.variableDeclaration("const", [
-              b.variableDeclarator(b.identifier(key), node),
-            ])
-          ) as any)
+          b.variableDeclaration("const", [
+            b.variableDeclarator(b.identifier(key), node),
+          ])
+        ) as any)
     );
   };
 

src/proxy/function-call.ts

@@ -1,8 +1,8 @@
-import { ASTNode } from "../types";
+import type { ASTNode } from "../types";
+import type { ProxifiedFunctionCall, ProxifiedModule } from "./types";
 import { MagicastError } from "../error";
 import { createProxy } from "./_utils";
 import { proxifyArrayElements } from "./array";
-import { ProxifiedFunctionCall, ProxifiedModule } from "./types";
 
 export function proxifyFunctionCall<T extends []>(
   node: ASTNode,

src/proxy/identifier.ts

@@ -1,4 +1,4 @@
-import { ASTNode, ProxifiedIdentifier } from "../types";
+import type { ASTNode, ProxifiedIdentifier } from "../types";
 import { MagicastError } from "../error";
 import { createProxy } from "./_utils";
 

src/proxy/imports.ts

@@ -1,20 +1,20 @@
 /* eslint-disable unicorn/no-nested-ternary */
 import * as recast from "recast";
-import {
+import type {
   ImportDeclaration,
   ImportDefaultSpecifier,
   ImportNamespaceSpecifier,
   ImportSpecifier,
   Program,
 } from "@babel/types";
-import { MagicastError } from "../error";
-import { createProxy } from "./_utils";
-import {
+import type {
   ImportItemInput,
   ProxifiedImportItem,
   ProxifiedImportsMap,
   ProxifiedModule,
 } from "./types";
+import { MagicastError } from "../error";
+import { createProxy } from "./_utils";
 
 const b = recast.types.builders;
 const _importProxyCache = new WeakMap<any, ProxifiedImportItem>();
@@ -146,8 +146,8 @@ export function createImportsProxy(
       value.imported === "default"
         ? b.importDefaultSpecifier(b.identifier(local))
         : value.imported === "*"
-        ? b.importNamespaceSpecifier(b.identifier(local))
-        : b.importSpecifier(b.identifier(value.imported), b.identifier(local));
+          ? b.importNamespaceSpecifier(b.identifier(local))
+          : b.importSpecifier(b.identifier(value.imported), b.identifier(local));
 
     const declaration = imports.find(
       (i) => i.from === value.from

src/proxy/module.ts

@@ -1,8 +1,8 @@
 /* eslint-disable unicorn/no-nested-ternary */
-import { ParsedFileNode } from "../types";
+import type { ParsedFileNode } from "../types";
+import type { ProxifiedModule } from "./types";
 import { MagicastError } from "../error";
 import { generateCode } from "../code";
-import { ProxifiedModule } from "./types";
 import { createImportsProxy } from "./imports";
 import { createExportsProxy } from "./exports";
 import { createProxy } from "./_utils";

src/proxy/new-expression.ts

@@ -1,8 +1,8 @@
-import { ASTNode } from "../types";
+import type { ASTNode } from "../types";
+import type { ProxifiedModule, ProxifiedNewExpression } from "./types";
 import { MagicastError } from "../error";
 import { createProxy } from "./_utils";
 import { proxifyArrayElements } from "./array";
-import { ProxifiedModule, ProxifiedNewExpression } from "./types";
 
 export function proxifyNewExpression<T extends []>(
   node: ASTNode,

src/proxy/object.ts

@@ -1,9 +1,9 @@
 import * as recast from "recast";
-import { ASTNode } from "../types";
+import type { ASTNode } from "../types";
+import type { ProxifiedModule, ProxifiedObject } from "./types";
 import { MagicastError } from "../error";
 import { literalToAst, createProxy, isValidPropName } from "./_utils";
 import { proxify } from "./proxify";
-import { ProxifiedModule, ProxifiedObject } from "./types";
 
 const b = recast.types.builders;
 

src/proxy/proxify.ts

@@ -1,11 +1,11 @@
+import type { Proxified, ProxifiedModule, ProxifiedValue } from "./types";
+import type { ASTNode } from "../types";
 import { MagicastError } from "../error";
-import { ASTNode } from "../types";
 import { proxifyArray } from "./array";
 import { proxifyFunctionCall } from "./function-call";
 import { proxifyObject } from "./object";
 import { proxifyNewExpression } from "./new-expression";
 import { proxifyIdentifier } from "./identifier";
-import { Proxified, ProxifiedModule, ProxifiedValue } from "./types";
 import { LITERALS_AST, LITERALS_TYPEOF } from "./_utils";
 
 const _cache = new WeakMap<ASTNode, any>();

src/proxy/types.ts

@@ -1,10 +1,10 @@
-import {
+import type {
   ImportDeclaration,
   ImportDefaultSpecifier,
   ImportNamespaceSpecifier,
   ImportSpecifier,
 } from "@babel/types";
-import { ASTNode, GenerateOptions } from "../types";
+import type { ASTNode, GenerateOptions } from "../types";
 
 export interface ProxyBase {
   $ast: ASTNode;
@@ -13,8 +13,8 @@ export interface ProxyBase {
 export type ProxifiedArray<T extends any[] = unknown[]> = {
   [K in keyof T]: Proxified<T[K]>;
 } & ProxyBase & {
-    $type: "array";
-  };
+  $type: "array";
+};
 
 export type ProxifiedFunctionCall<Args extends any[] = unknown[]> =
   ProxyBase & {
@@ -33,8 +33,8 @@ export type ProxifiedNewExpression<Args extends any[] = unknown[]> =
 export type ProxifiedObject<T extends object = object> = {
   [K in keyof T]: Proxified<T[K]>;
 } & ProxyBase & {
-    $type: "object";
-  };
+  $type: "object";
+};
 
 export type ProxifiedIdentifier = ProxyBase & {
   $type: "identifier";
@@ -52,16 +52,16 @@ export type Proxified<T = any> = T extends
   ? T
   : T extends any[]
   ? {
-      [K in keyof T]: Proxified<T[K]>;
-    } & ProxyBase & {
-        $type: "array";
-      }
+    [K in keyof T]: Proxified<T[K]>;
+  } & ProxyBase & {
+    $type: "array";
+  }
   : T extends object
   ? ProxyBase & {
-      [K in keyof T]: Proxified<T[K]>;
-    } & {
-      $type: "object";
-    }
+    [K in keyof T]: Proxified<T[K]>;
+  } & {
+    $type: "object";
+  }
   : T;
 
 export type ProxifiedModule<T extends object = Record<string, any>> =

src/types.ts

@@ -1,8 +1,8 @@
 import type { Program } from "@babel/types";
 import { Options as ParseOptions } from "recast";
 import { CodeFormatOptions } from "./format";
-export type { Node as ASTNode } from "@babel/types";
 
+export type { Node as ASTNode } from "@babel/types";
 export * from "./proxy/types";
 
 export interface Loc {