# Transpiler (/developers/pinets/architecture/transpiler)



## PineTS Transpiler Architecture [#pinets-transpiler-architecture]

The transpiler is responsible for converting user-written "PineTS" code (which mimics Pine Script syntax) into executable JavaScript that runs within the PineTS runtime environment.

## The Pipeline [#the-pipeline]

The transpilation process follows a multi-pass pipeline:

```
Input Code String/Function
        ↓
┌─────────────────────────┐
│  0. Wrapper Check     │
│  • Detect if code is  │
│    already wrapped in │
│    a function         │
│  • Auto-wrap unwrapped│
│    code in (context)  │
│    => { ... }         │
└───────┬─────────────────┘
        ↓
┌─────────────────────────┐
│  1. Parse to AST      │ (using acorn)
│     (ECMAScript AST)  │
└───────┬─────────────────┘
        ↓
┌─────────────────────────┐
│  2. Pre-Processing    │
│  • Transform nested   │
│    arrow functions    │
│  • Normalize native   │
│    imports (aliasing) │
│  • Inject implicit    │
│    imports (context.*)│
│  • Identify context-  │
│    bound variables    │
└───────┬─────────────────┘
        ↓
┌─────────────────────────┐
│  3. Analysis Pass     │
│  • Register functions │
│  • Track parameters   │
│  • Build scope tree   │
│  • Destructure arrays │
└───────┬─────────────────┘
        ↓
┌─────────────────────────┐
│  4. Transformation    │
│  • Variable scoping   │
│  • Series wrapping    │
│  • Expression Unwrapping│ (Hoisting)
│  • param() injection  │
│  • ID generation      │
└───────┬─────────────────┘
        ↓
┌─────────────────────────┐
│  5. Post-Processing   │
│  • Transform == to    │
│    $.math.__eq()      │
└───────┬─────────────────┘
        ↓
┌─────────────────────────┐
│  6. Code Generation   │ (using astring)
│     (Final JS code)   │
└─────────────────────────┘
```

### Pipeline Details [#pipeline-details]

1. **Pre-Processing**:

   * **Wrapper Check**: Ensures code is wrapped in a function: `(context) => { ... }`.
   * **Implicit Imports**: Injects `const { close } = context.data` etc. if missing.
   * **Normalization**: Prevents renaming of native symbols (e.g. `const { close: c } = ...` -> `const { close } = ...`).

2. **Parsing**:

   * Uses `acorn` to parse code into an ESTree-compatible AST.

3. **Analysis Pass (`AnalysisPass.ts`)**:

   * Scans the AST to build a **Scope Tree**.
   * Registers function declarations and parameters.
   * Identifies "Context-Bound" variables (variables that come from `context.data` or `context.pine`).

4. **Transformation Pass (`MainTransformer.ts`)**:

   * Traverses the AST and modifies nodes based on rules.
   * **Variable Renaming**: Transforms `let x = 10` into `$.let.glb1_x = ...` using the `ScopeManager`.
   * **Series Wrapping**: Wraps inputs to functions with `param()`.
   * **Expression Unwrapping**: Hoists complex expressions into temporary variables to ensure correct execution order.

5. **Post-Processing**:

   * Transforms equality checks (`==`, `===`) into `$.math.__eq()` calls to handle `NaN` correctly.

6. **Code Generation**:
   * Uses `astring` to generate the final JavaScript string from the modified AST.

## Key Components [#key-components]

* **ScopeManager**: Tracks variable scopes, renames variables to avoid collisions (`glb1_`, `fn2_`), and manages unique IDs.
* **Transformers**: Specialized classes (`ExpressionTransformer`, `StatementTransformer`) that handle specific AST node types.