@travetto/transformer 7.0.2 → 7.0.4

package/README.md

@@ -27,9 +27,9 @@ Below is an example of a transformer that upper cases all `class`, `method` and
 
 **Code: Sample Transformer - Upper case all declarations**
 ```typescript
-import ts from 'typescript';
+import type ts from 'typescript';
 
-import { OnProperty, TransformerState, OnMethod, OnClass } from '@travetto/transformer';
+import { TransformerHandler, type TransformerState } from '@travetto/transformer';
 
 export class MakeUpper {
 
@@ -37,7 +37,12 @@ export class MakeUpper {
     return state.importName !== '@travetto/transformer/doc/upper.ts';
   }
 
-  @OnProperty()
+  static {
+    TransformerHandler(this, this.handleClass, 'before', 'class');
+    TransformerHandler(this, this.handleMethod, 'before', 'method');
+    TransformerHandler(this, this.handleProperty, 'before', 'property');
+  }
+
   static handleProperty(state: TransformerState, node: ts.PropertyDeclaration): ts.PropertyDeclaration {
     return !this.isValid(state) ? node : state.factory.updatePropertyDeclaration(
       node,
@@ -49,7 +54,6 @@ export class MakeUpper {
     );
   }
 
-  @OnClass()
   static handleClass(state: TransformerState, node: ts.ClassDeclaration): ts.ClassDeclaration {
     return !this.isValid(state) ? node : state.factory.updateClassDeclaration(
       node,
@@ -61,7 +65,6 @@ export class MakeUpper {
     );
   }
 
-  @OnMethod()
   static handleMethod(state: TransformerState, node: ts.MethodDeclaration): ts.MethodDeclaration {
     return !this.isValid(state) ? node : state.factory.updateMethodDeclaration(
       node,
@@ -96,9 +99,9 @@ export class Test {
 **Code: Sample Output**
 ```javascript
 import * as Δfunction from "@travetto/runtime/src/function.js";
-var mod_1 = ["@travetto/transformer", "doc/upper.ts"];
+var Δm_1 = ["@travetto/transformer", "doc/upper.ts"];
 export class TEST {
-    static { Δfunction.registerFunction(TEST, mod_1, { hash: 649563175, lines: [1, 9] }, { COMPUTEAGE: { hash: 1286718349, lines: [6, 8, 7] } }, false); }
+    static { Δfunction.registerFunction(TEST, Δm_1, { hash: 649563175, lines: [1, 9] }, { COMPUTEAGE: { hash: 1286718349, lines: [6, 8, 7] } }, false); }
     NAME;
     AGE;
     DOB;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/transformer",
-  "version": "7.0.2",
+  "version": "7.0.4",
   "type": "module",
   "description": "Functionality for AST transformations, with transformer registration, and general utils",
   "keywords": [
@@ -25,7 +25,7 @@
     "directory": "module/transformer"
   },
   "dependencies": {
-    "@travetto/manifest": "^7.0.1",
+    "@travetto/manifest": "^7.0.3",
     "tslib": "^2.8.1",
     "typescript": "^5.9.3"
   },

package/src/importer.ts

@@ -2,10 +2,10 @@ import ts from 'typescript';
 
 import { ManifestModuleUtil, PackageUtil, path } from '@travetto/manifest';
 
-import { AnyType, TransformResolver, ManagedType, MappedType } from './resolver/types.ts';
+import type { AnyType, TransformResolver, ManagedType, MappedType } from './resolver/types.ts';
 import { ImportUtil } from './util/import.ts';
 import { CoreUtil } from './util/core.ts';
-import { Import } from './types/shared.ts';
+import type { Import } from './types/shared.ts';
 import { LiteralUtil } from './util/literal.ts';
 import { DeclarationUtil } from './util/declaration.ts';
 

package/src/manager.ts

@@ -1,8 +1,8 @@
-import ts from 'typescript';
+import type ts from 'typescript';
 
-import { ManifestIndex, ManifestModuleUtil } from '@travetto/manifest';
+import type { ManifestIndex } from '@travetto/manifest';
 
-import { NodeTransformer } from './types/visitor.ts';
+import type { NodeTransformer } from './types/visitor.ts';
 import { VisitorFactory } from './visitor.ts';
 import { TransformerState } from './state.ts';
 import { getAllTransformers } from './register.ts';
@@ -25,7 +25,7 @@ export class TransformerManager {
 
     for (const file of transformerFiles) { // Exclude based on blacklist
       const entry = manifestIndex.getEntry(file)!;
-      transformers.push(...getAllTransformers(await import(ManifestModuleUtil.withOutputExtension(entry.import)), entry.module));
+      transformers.push(...getAllTransformers(await import(entry.import), entry.module));
     }
 
     for (const transformer of transformers) {

package/src/register.ts

@@ -1,6 +1,4 @@
-import ts from 'typescript';
-
-import { DecoratorMeta, NodeTransformer, State, TransformPhase, TransformerType, Transformer, ModuleNameSymbol } from './types/visitor.ts';
+import { type NodeTransformer, type TransformPhase, type TransformerType, type Transformer, ModuleNameSymbol } from './types/visitor.ts';
 
 const HandlersSymbol = Symbol();
 
@@ -30,240 +28,6 @@ export function getAllTransformers(inputs: Record<string, { [HandlersSymbol]?: N
 }
 
 // Store handlers in class
-function storeHandler(cls: TransformerWithHandlers, fn: Function, phase: TransformPhase, type: TransformerType, target?: string[]): void {
+export function TransformerHandler(cls: TransformerWithHandlers, fn: Function, phase: TransformPhase, type: TransformerType, target?: string[]): void {
   (cls[HandlersSymbol] ??= []).push({ key: fn.name, [phase]: fn.bind(cls), type, target });
-}
-
-/**
- * Wraps entire file before transforming
- */
-export function OnFile(...target: string[]) {
-  return <S extends State = State, R extends ts.Node = ts.Node>(
-    instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.SourceFile) => R>
-  ): void => storeHandler(instance, descriptor.value!, 'before', 'file', target);
-}
-
-/**
- * Wraps entire file after transforming
- */
-export function AfterFile(...target: string[]) {
-  return <S extends State = State, R extends ts.Node = ts.Node>(
-    instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.SourceFile) => R>
-  ): void => storeHandler(instance, descriptor.value!, 'before', 'file', target);
-}
-
-/**
- * Listens for a `ts.CallExpression`, on descent
- */
-export function OnCall(...target: string[]) {
-  return <S extends State = State, R extends ts.Node = ts.Node>(
-    instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.CallExpression) => R>
-  ): void => storeHandler(instance, descriptor.value!, 'before', 'call', target);
-}
-
-/**
- * Listens for a `ts.FunctionDeclaration`, on descent
- */
-export function OnFunction(...target: string[]) {
-  return <S extends State = State, R extends ts.Node = ts.Node>(
-    instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.FunctionDeclaration | ts.FunctionExpression) => R>
-  ): void => storeHandler(instance, descriptor.value!, 'before', 'function', target);
-}
-
-/**
- * Listens for a `ts.ParameterDeclaration`, on descent
- */
-export function OnParameter(...target: string[]) {
-  return <S extends State = State, R extends ts.Node = ts.Node>(
-    instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.ParameterDeclaration, meta?: DecoratorMeta) => R>
-  ): void => storeHandler(instance, descriptor.value!, 'before', 'parameter', target);
-}
-
-/**
- * Listens for a `ts.PropertyDeclaration`, on descent
- */
-export function OnProperty(...target: string[]) {
-  return <S extends State = State, R extends ts.Node = ts.Node>(
-    instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.PropertyDeclaration, meta?: DecoratorMeta) => R>
-  ): void => storeHandler(instance, descriptor.value!, 'before', 'property', target);
-}
-
-/**
- * Listens for a `ts.GetAccessorDeclaration`, on descent
- */
-export function OnGetter(...target: string[]) {
-  return <S extends State = State, R extends ts.Node = ts.Node>(
-    instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.GetAccessorDeclaration, meta?: DecoratorMeta) => R>
-  ): void => storeHandler(instance, descriptor.value!, 'before', 'getter', target);
-}
-
-/**
- * Listens for a `ts.SetAccessorDeclaration`, on descent
- */
-export function OnSetter(...target: string[]) {
-  return <S extends State = State, R extends ts.Node = ts.Node>(
-    instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.SetAccessorDeclaration, meta?: DecoratorMeta) => R>
-  ): void => storeHandler(instance, descriptor.value!, 'before', 'setter', target);
-}
-
-/**
- * Listens for a `ts.MethodDeclaration`, on descent
- */
-export function OnMethod(...target: string[]) {
-  return <S extends State = State, R extends ts.Node = ts.Node>(
-    instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.MethodDeclaration, meta?: DecoratorMeta) => R>
-  ): void => storeHandler(instance, descriptor.value!, 'before', 'method', target);
-}
-
-/**
- * Listens for a `ts.ConstructorDeclaration`, on descent
- */
-export function OnConstructor(...target: string[]) {
-  return <S extends State = State, R extends ts.Node = ts.Node>(
-    instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.ConstructorDeclaration, meta?: DecoratorMeta) => R>
-  ): void => storeHandler(instance, descriptor.value!, 'before', 'constructor', target);
-}
-
-/**
- * Listens for a static `ts.MethodDeclaration`, on descent
- */
-export function OnStaticMethod(...target: string[]) {
-  return <S extends State = State, R extends ts.Node = ts.Node>(
-    instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.MethodDeclaration, meta?: DecoratorMeta) => R>
-  ): void => storeHandler(instance, descriptor.value!, 'before', 'static-method', target);
-}
-
-/**
- * Listens for a `ts.ClassDeclaration`, on descent
- */
-export function OnClass(...target: string[]) {
-  return <S extends State = State, R extends ts.Node = ts.Node>(
-    instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.ClassDeclaration, meta?: DecoratorMeta) => R>
-  ): void => storeHandler(instance, descriptor.value!, 'before', 'class', target);
-}
-
-/**
- * Listens for a `ts.TypeAliasDeclaration` on descent
- */
-export function OnTypeAlias(...target: string[]) {
-  return <S extends State = State, R extends ts.Node = ts.Node>(
-    instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.TypeAliasDeclaration) => R>
-  ): void => storeHandler(instance, descriptor.value!, 'before', 'type', target);
-}
-
-/**
- * Listens for a `ts.InterfaceDeclaration` on descent
- */
-export function OnInterface(...target: string[]) {
-  return <S extends State = State, R extends ts.Node = ts.Node>(
-    instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.InterfaceDeclaration) => R>
-  ): void => storeHandler(instance, descriptor.value!, 'before', 'interface', target);
-}
-
-/**
- * Listens for a `ts.CallExpression`, on ascent
- */
-export function AfterCall(...target: string[]) {
-  return <S extends State = State, R extends ts.Node = ts.Node>(
-    instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.CallExpression, meta?: DecoratorMeta) => R>
-  ): void => storeHandler(instance, descriptor.value!, 'after', 'call', target);
-}
-
-/**
- * Listens for a `ts.FunctionDeclaration`, on descent
- */
-export function AfterFunction(...target: string[]) {
-  return <S extends State = State, R extends ts.Node = ts.Node>(
-    instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.FunctionDeclaration | ts.FunctionExpression) => R>
-  ): void => storeHandler(instance, descriptor.value!, 'after', 'function', target);
-}
-
-/**
- * Listens for a `ts.ParameterDeclaration`, on ascent
- */
-export function AfterParameter(...target: string[]) {
-  return <S extends State = State, R extends ts.Node = ts.Node>(
-    instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.ParameterDeclaration, meta?: DecoratorMeta) => R>
-  ): void => storeHandler(instance, descriptor.value!, 'after', 'parameter', target);
-}
-
-/**
- * Listens for a `ts.PropertyDeclaration`, on ascent
- */
-export function AfterProperty(...target: string[]) {
-  return <S extends State = State, R extends ts.Node = ts.Node>(
-    instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.PropertyDeclaration, meta?: DecoratorMeta) => R>
-  ): void => storeHandler(instance, descriptor.value!, 'after', 'property', target);
-}
-
-/**
- * Listens for a `ts.GetAccessorDeclaration`, on ascent
- */
-export function AfterGetter(...target: string[]) {
-  return <S extends State = State, R extends ts.Node = ts.Node>(
-    instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.GetAccessorDeclaration, meta?: DecoratorMeta) => R>
-  ): void => storeHandler(instance, descriptor.value!, 'after', 'getter', target);
-}
-
-/**
- * Listens for a `ts.SetAccessorDeclaration`, on ascent
- */
-export function AfterSetter(...target: string[]) {
-  return <S extends State = State, R extends ts.Node = ts.Node>(
-    instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.SetAccessorDeclaration, meta?: DecoratorMeta) => R>
-  ): void => storeHandler(instance, descriptor.value!, 'after', 'setter', target);
-}
-
-/**
- * Listens for a `ts.MethodDeclaration`, on ascent
- */
-export function AfterMethod(...target: string[]) {
-  return <S extends State = State, R extends ts.Node = ts.Node>(
-    instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.MethodDeclaration, meta?: DecoratorMeta) => R>
-  ): void => storeHandler(instance, descriptor.value!, 'after', 'method', target);
-}
-
-/**
- * Listens for a `ts.ConstructorDeclaration`, on ascent
- */
-export function AfterConstructor(...target: string[]) {
-  return <S extends State = State, R extends ts.Node = ts.Node>(
-    instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.ConstructorDeclaration, meta?: DecoratorMeta) => R>
-  ): void => storeHandler(instance, descriptor.value!, 'after', 'constructor', target);
-}
-
-/**
- * Listens for a static `ts.MethodDeclaration`, on ascent
- */
-export function AfterStaticMethod(...target: string[]) {
-  return <S extends State = State, R extends ts.Node = ts.Node>(
-    instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.MethodDeclaration, meta?: DecoratorMeta) => R>
-  ): void => storeHandler(instance, descriptor.value!, 'after', 'static-method', target);
-}
-
-/**
- * Listens for a `ts.ClassDeclaration`, on ascent
- */
-export function AfterClass(...target: string[]) {
-  return <S extends State = State, R extends ts.Node = ts.Node>(
-    instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.ClassDeclaration, meta?: DecoratorMeta) => R>
-  ): void => storeHandler(instance, descriptor.value!, 'after', 'class', target);
-}
-
-/**
- * Listens for a `ts.TypeAliasDeclaration` on ascent
- */
-export function AfterTypeAlias(...target: string[]) {
-  return <S extends State = State, R extends ts.Node = ts.Node>(
-    instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.TypeAliasDeclaration) => R>
-  ): void => storeHandler(instance, descriptor.value!, 'after', 'type', target);
-}
-
-/**
- * Listens for a `ts.InterfaceDeclaration` on ascent
- */
-export function AfterInterface(...target: string[]) {
-  return <S extends State = State, R extends ts.Node = ts.Node>(
-    instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.InterfaceDeclaration) => R>
-  ): void => storeHandler(instance, descriptor.value!, 'after', 'interface', target);
-}
+}

package/src/resolver/builder.ts

@@ -7,9 +7,9 @@ import { DocUtil } from '../util/doc.ts';
 import { CoreUtil } from '../util/core.ts';
 import { DeclarationUtil } from '../util/declaration.ts';
 import { LiteralUtil } from '../util/literal.ts';
-import { transformCast, TemplateLiteralPart } from '../types/shared.ts';
+import { transformCast, type TemplateLiteralPart } from '../types/shared.ts';
 
-import { Type, AnyType, CompositionType, TransformResolver, TemplateType, MappedType } from './types.ts';
+import type { Type, AnyType, CompositionType, TransformResolver, TemplateType, MappedType } from './types.ts';
 import { CoerceUtil } from './coerce.ts';
 
 const UNDEFINED = Symbol();

package/src/resolver/cache.ts

@@ -1,4 +1,4 @@
-import ts from 'typescript';
+import type ts from 'typescript';
 import type { AnyType } from './types.ts';
 
 /**

package/src/resolver/coerce.ts

@@ -1,4 +1,4 @@
-const REGEX_PAT = /[\/](.*)[\/](i|g|m|s)?/;
+const REGEX_PATTERN = /[\/](.*)[\/](i|g|m|s)?/;
 
 export class CoerceUtil {
   /**
@@ -18,9 +18,9 @@ export class CoerceUtil {
   static #toRegex(input: string | RegExp): RegExp {
     if (input instanceof RegExp) {
       return input;
-    } else if (REGEX_PAT.test(input)) {
-      const [, pat, mod] = input.match(REGEX_PAT) ?? [];
-      return new RegExp(pat, mod);
+    } else if (REGEX_PATTERN.test(input)) {
+      const [, pattern, module] = input.match(REGEX_PATTERN) ?? [];
+      return new RegExp(pattern, module);
     } else {
       return new RegExp(input);
     }

package/src/resolver/service.ts

@@ -1,6 +1,6 @@
-import ts from 'typescript';
+import type ts from 'typescript';
 
-import { path, ManifestIndex, ManifestModuleUtil, IndexedFile } from '@travetto/manifest';
+import { path, type ManifestIndex, ManifestModuleUtil, type IndexedFile } from '@travetto/manifest';
 
 import type { AnyType, TransformResolver } from './types.ts';
 import { TypeCategorize, TypeBuilder } from './builder.ts';

package/src/resolver/types.ts

@@ -1,5 +1,5 @@
 import type ts from 'typescript';
-import { TemplateLiteral } from '../types/shared.ts';
+import type { TemplateLiteral } from '../types/shared.ts';
 
 /**
  * Base type for a simplistic type structure

package/src/state.ts

@@ -1,12 +1,12 @@
 import ts from 'typescript';
 
-import { path, ManifestIndex } from '@travetto/manifest';
+import { path, type ManifestIndex } from '@travetto/manifest';
 
-import { ManagedType, AnyType, ForeignType, MappedType } from './resolver/types.ts';
-import { State, DecoratorMeta, Transformer, ModuleNameSymbol } from './types/visitor.ts';
+import type { ManagedType, AnyType, ForeignType, MappedType } from './resolver/types.ts';
+import { type State, type DecoratorMeta, type Transformer, ModuleNameSymbol } from './types/visitor.ts';
 import { SimpleResolver } from './resolver/service.ts';
 import { ImportManager } from './importer.ts';
-import { Import } from './types/shared.ts';
+import type { Import } from './types/shared.ts';
 
 import { DocUtil } from './util/doc.ts';
 import { DecoratorUtil } from './util/decorator.ts';
@@ -169,11 +169,11 @@ export class TransformerState implements State {
     const type = this.#resolver.getType(identifier);
     const declaration = DeclarationUtil.getOptionalPrimaryDeclarationNode(type);
     const source = declaration?.getSourceFile().fileName;
-    const mod = source ? this.#resolver.getFileImportName(source, true) : undefined;
-    const file = this.#manifestIndex.getFromImport(mod ?? '')?.outputFile;
+    const moduleImport = source ? this.#resolver.getFileImportName(source, true) : undefined;
+    const file = this.#manifestIndex.getFromImport(moduleImport ?? '')?.outputFile;
     const targets = DocUtil.readAugments(type);
     const example = DocUtil.readExample(type);
-    const module = file ? mod : undefined;
+    const module = file ? moduleImport : undefined;
     const name = identifier ?
       identifier.escapedText?.toString()! :
       undefined;
@@ -285,7 +285,7 @@ export class TransformerState implements State {
    */
   getModuleIdentifier(): ts.Expression {
     if (this.#moduleIdentifier === undefined) {
-      this.#moduleIdentifier = this.factory.createUniqueName('mod');
+      this.#moduleIdentifier = this.factory.createUniqueName('Δm');
       const entry = this.#resolver.getFileImport(this.source.fileName);
       const declaration = this.factory.createVariableDeclaration(this.#moduleIdentifier, undefined, undefined,
         this.fromLiteral([entry?.module, entry?.relativeFile ?? ''])
@@ -304,10 +304,10 @@ export class TransformerState implements State {
    * @param name
    * @param module
    */
-  findDecorator(mod: string | Transformer, node: ts.Node, name: string, module?: string): ts.Decorator | undefined {
+  findDecorator(input: string | Transformer, node: ts.Node, name: string, module?: string): ts.Decorator | undefined {
     module = module?.replace(/[.]ts$/, ''); // Replace extension if exists
-    mod = typeof mod === 'string' ? mod : mod[ModuleNameSymbol]!;
-    const target = `${mod}:${name}`;
+    const targetScope = typeof input === 'string' ? input : input[ModuleNameSymbol]!;
+    const target = `${targetScope}:${name}`;
     const list = this.getDecoratorList(node);
     return list.find(meta => meta.targets?.includes(target) && (!module || meta.name === name && meta.module === module))?.decorator;
   }

package/src/types/visitor.ts

@@ -1,4 +1,4 @@
-import ts from 'typescript';
+import type ts from 'typescript';
 
 /**
  * Decorator metadata

package/src/util/doc.ts

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 
-import { transformCast, DeclDocumentation } from '../types/shared.ts';
+import { transformCast, type DeclDocumentation } from '../types/shared.ts';
 import { CoreUtil } from './core.ts';
 import { DeclarationUtil } from './declaration.ts';
 

package/src/util/import.ts

@@ -2,7 +2,7 @@ import ts from 'typescript';
 
 import { path, ManifestModuleUtil, PackageUtil } from '@travetto/manifest';
 
-import { Import } from '../types/shared.ts';
+import type { Import } from '../types/shared.ts';
 
 /**
  * Import utilities

package/src/util/literal.ts

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 
-import { transformCast, TemplateLiteral } from '../types/shared.ts';
+import { transformCast, type TemplateLiteral } from '../types/shared.ts';
 
 const TypedObject: {
   keys<T = unknown, K extends keyof T = keyof T>(value: T): K[];

package/src/visitor.ts

@@ -1,8 +1,8 @@
 import ts from 'typescript';
 
-import { ManifestModuleFolderType, ManifestModuleUtil } from '@travetto/manifest';
+import { type ManifestModuleFolderType, ManifestModuleUtil } from '@travetto/manifest';
 
-import { DecoratorMeta, TransformerType, NodeTransformer, TransformerSet, State, TransformPhase } from './types/visitor.ts';
+import type { DecoratorMeta, TransformerType, NodeTransformer, TransformerSet, State, TransformPhase } from './types/visitor.ts';
 import { CoreUtil } from './util/core.ts';
 
 const COMPILER_SOURCE = new Set<ManifestModuleFolderType>(['support', 'src', '$index']);