js-confuser-vm 0.0.9 → 0.1.1

package/src/transforms/bytecode/specializedOpcodes.ts

@@ -1,12 +1,6 @@
 import type { Bytecode, InstrOperand, Instruction } from "../../types.ts";
 import { Compiler, SOURCE_NODE_SYM } from "../../compiler.ts";
-import {
-  getInstructionSize,
-  nextFreeSlot,
-  U16_MAX,
-} from "../../utils/op-utils.ts";
-import * as t from "@babel/types";
-import * as b from "../../types.ts";
+import { getInstructionSize, nextFreeSlot } from "../../utils/op-utils.ts";
 
 export const nSizedOps = [
   "MAKE_CLOSURE",
@@ -19,9 +13,11 @@ export const nSizedOps = [
 
 // Creates specialized opcodes for the most frequent (OPCODE + single_integer_operand) pairs.
 // Example: [OP.LOAD_CONST, 1] becomes [SPECIALIZED_LOAD_CONST_1].
-// Only instructions with *exactly one numeric operand* are considered.
+// Only instructions that are fixed-sized are considered.
 // MAKE_CLOSURE and other N-sized instructions cannot be specialized
-// Runs after selfModifying but before resolveLabels (operands stay plain numbers).
+// Operands are converted into objects and marked as 'placeholder' - other passes can mutate and the reference stays intact
+// We need a reference throughout the pipeline so that final AST generation can place the actual value
+// The 'placeholder' flag drops the operand from the final bytecode - any size calculation must not count these
 export function specializedOpcodes(
   bc: Bytecode,
   compiler: Compiler,
@@ -39,6 +35,8 @@ export function specializedOpcodes(
     }
   >();
 
+  const instrToOperandKey = new WeakMap<Instruction, string>();
+
   for (const instr of bc) {
     const op = instr[0];
     if (op === null || disallowedOps.has(op)) continue;
@@ -49,21 +47,26 @@ export function specializedOpcodes(
 
     // Convert numbers into operand objects so they can be modified elsewhere and preserved
     const oldOperands = instr.slice(1);
-    const operands = oldOperands.map((operand) => {
+
+    let operands = [];
+
+    for (const operand of oldOperands) {
       if (typeof operand === "number") {
-        return {
+        operands.push({
           type: "number",
           value: operand,
           resolvedValue: operand,
-        } as InstrOperand;
+        } as InstrOperand);
+      } else {
+        operands.push(operand as InstrOperand);
       }
-      return operand;
-    });
+    }
 
     instr.length = 1;
     instr.push(...operands);
 
     const operandsKey = JSON.stringify(operands);
+    instrToOperandKey.set(instr, operandsKey);
 
     const key = `${op},${operandsKey}`;
     const entry = freqMap.get(key);
@@ -82,7 +85,8 @@ export function specializedOpcodes(
   // ── Step 2: keep combinations that appear >= 2 times, sort by frequency ───
   const candidates = Array.from(freqMap.values())
     .filter((e) => e.occurences >= 1)
-    .sort((a, b) => b.occurences - a.occurences);
+    .sort((a, b) => b.occurences - a.occurences)
+    .slice(0, 1000);
 
   if (candidates.length === 0) return { bytecode: bc };
 
@@ -90,10 +94,10 @@ export function specializedOpcodes(
   const sigToSpecial = new Map<string, number>();
   const specializedOps: Compiler["SPECIALIZED_OPS"] = {};
 
-  for (let i = 0; i < candidates.length; i++) {
+  for (const candidate of candidates) {
     const specialOp = nextFreeSlot(compiler);
     if (specialOp === -1) break;
-    const { op: originalOp, operands, operandsKey } = candidates[i];
+    const { op: originalOp, operands, operandsKey } = candidate;
 
     const key = `${originalOp},${operandsKey}`;
     sigToSpecial.set(key, specialOp);
@@ -102,8 +106,7 @@ export function specializedOpcodes(
 
     // Register a human-readable name for disassembly / debugging
     const originalName = compiler.OP_NAME[originalOp] ?? `OP_${originalOp}`;
-    compiler.OP_NAME[specialOp] =
-      `${originalName}_${JSON.stringify(operandsKey)}`;
+    compiler.OP_NAME[specialOp] = `${originalName}_${operandsKey}`;
   }
 
   // Store mapping so the interpreter knows how to dispatch the specialized op
@@ -121,7 +124,11 @@ export function specializedOpcodes(
     }
 
     const operands = instr.slice(1);
-    const operandsKey = JSON.stringify(operands);
+    const operandsKey = instrToOperandKey.get(instr);
+    if (!operandsKey) {
+      result.push(instr);
+      continue;
+    }
 
     const key = `${op},${operandsKey}`;
 

package/src/transforms/bytecode/stringConcealing.ts

@@ -0,0 +1,130 @@
+// String Concealing
+//
+// Encodes every string constant in each function with base64, then inserts a
+// decode closure (atob) that is called immediately after each LOAD_CONST to
+// recover the original value at runtime.
+//
+// ── How it works ─────────────────────────────────────────────────────────────
+//
+// Each function that contains at least one string LOAD_CONST gets:
+//
+//   rClosure — a register holding the decode closure, created ONCE at function
+//              entry (hoisted).  All decode calls within the function reuse it.
+//
+// The decode function is compiled ONCE (shared across all functions) from a
+// Template:
+//
+//   function decode(encoded) { return atob(encoded); }
+//
+// String constant transformations:
+//
+//   Original:  LOAD_CONST  rDst, "hello"
+//   Becomes:   LOAD_CONST  rDst, "aGVsbG8="        (base64-encoded)
+//              CALL        rDst, rClosure, 1, rDst  (decode in-place)
+//
+// ── Pipeline position ─────────────────────────────────────────────────────────
+// Runs BEFORE resolveRegisters and resolveLabels (same slot as Dispatcher/CFF).
+
+import { Compiler } from "../../compiler.ts";
+import { Template } from "../../template.ts";
+import type { Bytecode, RegisterOperand } from "../../types.ts";
+import * as b from "../../types.ts";
+import { ref, buildMaxIdMap, allocReg, forEachFunction } from "../../utils/pass-utils.ts";
+
+// ── Per-function transformation ──────────────────────────────────────────────
+
+function processFunctionBlock(
+  instrs: Bytecode,
+  fnId: number,
+  compiler: Compiler,
+  maxId: Map<number, number>,
+  decodeDesc: any,
+): { instrs: Bytecode } {
+  const OP = compiler.OP;
+
+  // Only transform functions that contain string constants.
+  const hasStringConst = instrs.some((instr) => {
+    if (instr[0] !== OP.LOAD_CONST) return false;
+    const operands = instr.slice(1);
+    return (
+      operands.length === 2 &&
+      (operands[1] as any)?.type === "constant" &&
+      typeof (operands[1] as any).value === "string"
+    );
+  });
+  if (!hasStringConst) return { instrs };
+
+  const rClosure = allocReg(fnId, maxId);
+  const out: Bytecode = [];
+
+  // Hoist: create the decode closure once at function entry.
+  out.push([
+    OP.MAKE_CLOSURE!,
+    ref(rClosure),
+    { type: "label", label: decodeDesc.entryLabel },
+    decodeDesc.paramCount, // 1 (encoded)
+    b.fnRegCountOperand(decodeDesc._fnIdx),
+    0, // no upvalues
+    0, // hasRest = false
+  ]);
+
+  // Transform each instruction.
+  for (const instr of instrs) {
+    if (
+      instr[0] === OP.LOAD_CONST &&
+      instr.length === 3 &&
+      (instr[2] as any)?.type === "constant" &&
+      typeof (instr[2] as any).value === "string"
+    ) {
+      const dst = instr[1] as RegisterOperand;
+      const constOp = instr[2] as any;
+
+      // Encode the string in-place.
+      constOp.value = Buffer.from(constOp.value as string, "utf-8").toString(
+        "base64",
+      );
+
+      out.push(instr);
+
+      // Decode: rDst = decode(rDst)
+      out.push([
+        OP.CALL!,
+        ref(dst),       // dst — receives decoded string
+        ref(rClosure),  // the hoisted decode closure
+        1,              // argc
+        ref(dst),       // arg[0] = encoded value
+      ]);
+    } else {
+      out.push(instr);
+    }
+  }
+
+  return { instrs: out };
+}
+
+// ── Pass entry point ──────────────────────────────────────────────────────────
+export function stringConcealing(
+  bc: Bytecode,
+  compiler: Compiler,
+): { bytecode: Bytecode } {
+  const maxId = buildMaxIdMap(bc);
+
+  // Compile the decode function ONCE — all functions share the same closure body.
+  const decodeTemplate = new Template(`
+    function decode(encoded) {
+      return atob(encoded);
+    }
+  `).compile({}, compiler);
+  const decodeDesc = decodeTemplate.functions[0];
+
+  const { bytecode } = forEachFunction(bc, compiler, (fnInstrs, fnId) =>
+    processFunctionBlock(fnInstrs, fnId, compiler, maxId, decodeDesc),
+  );
+
+  // Append the decode function's bytecode at the end (defines its entryLabel).
+  // This is a single shared closure, not per-function, so it lives outside
+  // forEachFunction's tail mechanism.
+  bytecode.push(...decodeTemplate.bytecode);
+
+  return { bytecode };
+}

package/src/transforms/runtime/classObfuscation.ts

@@ -0,0 +1,59 @@
+import { Compiler } from "../../compiler.ts";
+import * as t from "@babel/types";
+import { shuffle } from "../../utils/random-utils.ts";
+
+function hasComment(node: t.Node, text: string): boolean {
+  const all = [
+    ...((node as any).leadingComments ?? []),
+    ...((node as any).innerComments ?? []),
+    ...((node as any).trailingComments ?? []),
+  ];
+  return all.some((c) => c.value.includes(text));
+}
+
+function isPrototypeAssignment(stmt: t.Statement): boolean {
+  if (!t.isExpressionStatement(stmt)) return false;
+  const expr = stmt.expression;
+  if (!t.isAssignmentExpression(expr)) return false;
+  const left = expr.left;
+  return (
+    t.isMemberExpression(left) &&
+    t.isMemberExpression(left.object) &&
+    t.isIdentifier((left.object as t.MemberExpression).property, {
+      name: "prototype",
+    })
+  );
+}
+
+export function applyClassObfuscation(ast: t.File, _compiler: Compiler): void {
+  const body = ast.program.body;
+
+  // Split at the first statement that carries the @BOOT comment.
+  // Everything from that statement onward is the boot section and must stay last.
+  let bootIdx = body.findIndex((stmt) => hasComment(stmt, "@BOOT"));
+  if (bootIdx === -1) bootIdx = body.length;
+
+  const shufflable = body.slice(0, bootIdx);
+  const boot = body.slice(bootIdx);
+
+  // Partition the shufflable section into two independent groups.
+  // Group A: variable/function declarations (constructors, standalone vars).
+  // Group B: prototype method assignments (X.prototype.Y = ...).
+  // Both groups are shuffled independently; A always precedes B so that
+  // constructors are defined before methods reference them.
+  const varDecls: t.Statement[] = [];
+  const methodDefs: t.Statement[] = [];
+
+  for (const stmt of shufflable) {
+    if (isPrototypeAssignment(stmt)) {
+      methodDefs.push(stmt);
+    } else {
+      varDecls.push(stmt);
+    }
+  }
+
+  shuffle(varDecls);
+  shuffle(methodDefs);
+
+  ast.program.body = [...varDecls, ...methodDefs, ...boot];
+}

package/src/transforms/runtime/specializedOpcodes.ts

@@ -27,6 +27,8 @@ function extractCaseBody(switchCase: t.SwitchCase): t.Statement[] {
 // *exactly one* numeric operand, every `_operand()` call inside the original
 // handler is replaced by the constant value that was baked into the opcode.
 function inlineFixedOperands(
+  newName: string, // for debugging
+  info: any,
   bodyStmts: t.Statement[],
   resolvedValues: number[],
 ): void {
@@ -66,10 +68,12 @@ function inlineFixedOperands(
     },
   });
 
-  ok(
-    replaced === resolvedValues.length,
-    `Expected to replace ${resolvedValues.length} operands, but replaced ${replaced}`,
-  );
+  if (replaced !== resolvedValues.length) {
+    console.error(resolvedValues, info);
+    throw new Error(
+      `Specialized Opcode Inline Error: Given ${resolvedValues.length} operands to replace, but only found ${replaced} for ${newName}`,
+    );
+  }
 }
 
 // Append a generated switch case for every entry in compiler.SPECIALIZED_OPS.
@@ -119,12 +123,13 @@ export function applySpecializedOpcodes(ast: t.File, compiler: Compiler): void {
     const placedOperands = info.operands;
     ok(placedOperands, `Could not find operand for original opcode ${newName}`);
 
-    const resolvedValues = placedOperands.map((placedOperand) => {
-      return (placedOperand as any)?.resolvedValue ?? placedOperand;
-    });
+    const resolvedValues = placedOperands
+      // .filter((x) => !(x as any)?.placeholder)
+      .map((placedOperand) => {
+        return (placedOperand as any)?.resolvedValue ?? placedOperand;
+      });
 
     if (resolvedValues.find((v) => typeof v !== "number")) {
-      console.error(info);
       throw new Error("Expected all resolved operand values to be numbers");
     }
 
@@ -132,7 +137,7 @@ export function applySpecializedOpcodes(ast: t.File, compiler: Compiler): void {
     compiler.OP_NAME[specialOpCode] = newName;
 
     // Replace this._operand() with the baked-in constant
-    inlineFixedOperands(bodyStmts, resolvedValues);
+    inlineFixedOperands(newName, info, bodyStmts, resolvedValues);
 
     // Add a leading comment so the generated source stays readable
     if (bodyStmts.length > 0) {

package/src/types.ts

@@ -1,22 +1,68 @@
 // Bytecode supports both real instructions and IR pseudo-instructions
-// Real instruction: [OP.ADD, 5]  or multi-operand: [OP.MAKE_CLOSURE, labelRef, 2, 3, 0]
+// Real instruction: [OP.ADD, 5]  or multi-operand: [OP.MAKE_CLOSURE, labelRef, 2, 3, 0, 0]
 // IR instruction: [null, { type: "defineLabel", label: "FN_ENTRY_1" }]
 
 // IR instructions are used to hold symbolic information during compilation
 // All "null" instructions are dropped before assembly time.
 // Instructions may carry any number of operands; the flat output serializes
 // each operand as a separate u16 slot in the bytecode array.
+// A virtual register reference emitted by the compiler.
+// fnId identifies which function's register file this belongs to.
+// resolveRegisters() replaces these with concrete slot indices (type:"number").
+export type RegisterOperand = Op<{
+  type: "register";
+  id: number;
+  fnId: number;
+  kind?: string;
+  scopeId?: string | number;
+  // If true, resolveRegisters always assigns this register to the "local::"
+  // pool (no slot reuse).  Set by passes that emit registers whose live ranges
+  // span CFF dispatch-loop back-edges — regions the linear-scan liveness
+  // analysis cannot reason about.
+  pinned?: boolean;
+}>;
+
+// A placeholder for a function's concrete regCount, emitted in MAKE_CLOSURE.
+// resolveRegisters() fills resolvedValue once it knows the concrete slot count.
+export type FnRegCountOperand = Op<{ type: "fnRegCount"; fnId: number }>;
+
+// IR pseudo-instruction that marks the end of a register's live range.
+// Emitted as [null, FreeRegOperand] so it is dropped before final assembly.
+//
+// NOTE: resolveRegisters() already computes correct lastUse from the last real
+// operand appearance, so freeReg is EXTRANEOUS for any programmatically generated
+// IR — the scanner will find the tightest possible range without it.
+// It is only useful when a register has a late syntactic appearance that does
+// NOT reflect its true logical end-of-life (e.g. a read emitted purely for
+// side-effects long after the value is logically dead). No current pass in this
+// codebase emits freeReg; it is kept as an extension point only.
+export type FreeRegOperand = Op<{
+  type: "freeReg";
+  fnId: number;
+  id: number;
+  kind?: string;
+  scopeId?: string | number;
+}>;
+
 export type InstrOperand =
   | number
   | Op<{ type: "number"; value?: number }>
-  | Op<{ type: "label"; label: string; offset?: number }>
+  | Op<{
+      type: "label";
+      label: string;
+      offset?: number;
+      transform?: (resolvedPC: number) => number;
+    }>
   | Op<{ type: "defineLabel"; label: string }>
-  | Op<{ type: "constant"; value: any }>;
+  | Op<{ type: "constant"; value: any }>
+  | RegisterOperand
+  | FnRegCountOperand
+  | FreeRegOperand;
 
 export interface Operand {
   type: string;
-  placeholder?: boolean;
-  resolvedValue?: number;
+  placeholder?: boolean; // This operand will not be emitted in the final bytecode, but used as a reference
+  resolvedValue?: number; // This operand knows its resolved value, but kept as a object to keep metadata info available
 }
 
 type Op<T extends object> = Operand & T;
@@ -31,3 +77,58 @@ export function constantOperand(value: any): Instruction[1] {
     value: value,
   };
 }
+
+export function registerOperand(
+  id: number,
+  fnId: number,
+  metadata: Partial<Pick<RegisterOperand, "kind" | "scopeId">> = {},
+): RegisterOperand {
+  return { type: "register", id, fnId, ...metadata };
+}
+
+export function fnRegCountOperand(fnId: number): FnRegCountOperand {
+  return { type: "fnRegCount", fnId };
+}
+
+export function freeRegOperand(reg: RegisterOperand): FreeRegOperand {
+  const op: FreeRegOperand = { type: "freeReg", fnId: reg.fnId, id: reg.id };
+  if (reg.kind !== undefined) op.kind = reg.kind;
+  if (reg.scopeId !== undefined) op.scopeId = reg.scopeId;
+  return op;
+}
+
+export interface ObfuscationResult {
+  code: string;
+  profileData?: {
+    handlerCount: number;
+
+    /**
+     * How long the entire obfuscation process takes (ms)
+     */
+    obfuscationTime?: number;
+
+    /**
+     * How long @babel/parser takes (ms)
+     */
+    parseTime?: number;
+
+    /**
+     * How long @babel/generator takes (ms)
+     */
+    generateTime?: number;
+
+    /**
+     * How long the Compiler#compileAST takes (ms)
+     */
+    compileTime?: number;
+
+    transforms: {
+      [transformName: string]: {
+        fileSize?: number;
+        bytecodeSize?: number;
+        transformTime?: number;
+        handlerCount?: number;
+      };
+    };
+  };
+}

package/src/utils/ast-utils.ts

@@ -0,0 +1,19 @@
+import * as t from "@babel/types";
+import traverseImport from "@babel/traverse";
+
+const traverse = (traverseImport.default ||
+  traverseImport) as typeof traverseImport.default;
+
+export function getSwitchStatement(ast: t.File) {
+  let switchStatement: t.SwitchStatement | null = null;
+  traverse(ast, {
+    SwitchStatement(path) {
+      if (path.node.leadingComments?.some((c) => c.value.includes("@SWITCH"))) {
+        switchStatement = path.node;
+        path.stop();
+      }
+    },
+  });
+
+  return switchStatement;
+}

package/src/utils/op-utils.ts

@@ -21,7 +21,6 @@ export function nextFreeSlot(compiler: Compiler): number {
     while (attempts++ < 512) {
       const candidate = getRandomInt(0, U16_MAX);
       if (!usedOpcodes.has(candidate)) {
-        usedOpcodes.add(candidate);
         return candidate;
       }
     }
@@ -32,7 +31,6 @@ export function nextFreeSlot(compiler: Compiler): number {
   for (let i = 0; i <= U16_MAX; i++) {
     const v = (start + i) & U16_MAX;
     if (!usedOpcodes.has(v)) {
-      usedOpcodes.add(v);
       return v;
     }
   }
@@ -40,6 +38,8 @@ export function nextFreeSlot(compiler: Compiler): number {
 }
 
 export function getInstructionSize(instr: b.Instruction): number {
+  if (instr[0] === null) return 0;
+
   const size = instr.filter((op) => (op as any)?.placeholder !== true).length;
 
   return size;

package/src/utils/pass-utils.ts

@@ -0,0 +1,126 @@
+// Shared utilities for bytecode transformation passes.
+//
+// All three patterns below are identical across dispatcher, controlFlowFlattening,
+// and stringConcealing.  Centralising them here keeps each pass focused on its
+// own logic and makes the shared contract explicit.
+
+import type { Bytecode, RegisterOperand, InstrOperand } from "../types.ts";
+import * as b from "../types.ts";
+import { Compiler } from "../compiler.ts";
+
+// Return a fresh RegisterOperand object with the same (id, fnId).
+// IMPORTANT: operand objects must be unique throughout compilation —
+// other passes (e.g. specializedOpcodes) mutate operands in-place and a
+// shared reference would corrupt both sites.
+export function ref(r: RegisterOperand): RegisterOperand {
+  return b.registerOperand(r.id, r.fnId);
+}
+
+// Scan bc and return the highest virtual register id seen for each fnId.
+// Used by passes that allocate new registers after the compiler has finished.
+export function buildMaxIdMap(bc: Bytecode): Map<number, number> {
+  const maxId = new Map<number, number>();
+  for (const instr of bc) {
+    for (let j = 1; j < instr.length; j++) {
+      const op = instr[j] as any;
+      if (op && op.type === "register") {
+        const cur = maxId.get(op.fnId) ?? -1;
+        if (op.id > cur) maxId.set(op.fnId, op.id);
+      }
+    }
+  }
+  return maxId;
+}
+
+// Allocate the next virtual register id for fnId, updating maxId in-place.
+export function allocReg(
+  fnId: number,
+  maxId: Map<number, number>,
+): RegisterOperand {
+  const next = (maxId.get(fnId) ?? -1) + 1;
+  maxId.set(fnId, next);
+  return b.registerOperand(next, fnId);
+}
+
+// Return the label string if the operand is a { type:"label" } object,
+// otherwise return null.  Used by passes that need to identify jump targets.
+export function extractLabel(op: InstrOperand | undefined): string | null {
+  if (op && typeof op === "object" && (op as any).type === "label")
+    return (op as any).label as string;
+  return null;
+}
+
+// Walk bc, call transform() for every function body, and reassemble the output.
+//
+// For each function entry label the scanner collects all instructions up to the
+// next entry label (or end-of-bytecode) into fnInstrs and passes them to
+// transform() along with the function's fnId.
+//
+// The transform callback returns:
+//   instrs — the (possibly rewritten) function body to emit in place of fnInstrs
+//   tail   — optional bytecode to append AFTER all function bodies
+//             (e.g. template-compiled decode closures)
+//
+// Instructions that appear before any entry label (the top-level preamble) are
+// passed through unchanged.
+export function forEachFunction(
+  bc: Bytecode,
+  compiler: Compiler,
+  transform: (
+    fnInstrs: Bytecode,
+    fnId: number,
+  ) => { instrs: Bytecode; tail?: Bytecode },
+): { bytecode: Bytecode } {
+  const entryLabels = new Set(compiler.fnDescriptors.map((d) => d.entryLabel));
+  const entryLabelToFnId = new Map(
+    compiler.fnDescriptors.map((d) => [d.entryLabel!, d._fnIdx!]),
+  );
+
+  const result: Bytecode = [];
+  const tails: Bytecode[] = [];
+  let i = 0;
+
+  while (i < bc.length) {
+    const instr = bc[i];
+    const [op, operand0] = instr;
+    const isEntryLabel =
+      op === null &&
+      (operand0 as any)?.type === "defineLabel" &&
+      entryLabels.has((operand0 as any).label);
+
+    if (!isEntryLabel) {
+      result.push(instr);
+      i++;
+      continue;
+    }
+
+    const entryLabel = (operand0 as any).label as string;
+    const fnId = entryLabelToFnId.get(entryLabel)!;
+    i++; // step past the defineLabel itself
+
+    const fnInstrs: Bytecode = [];
+    while (i < bc.length) {
+      const next = bc[i];
+      const [nextOp, nextOp0] = next;
+      if (
+        nextOp === null &&
+        (nextOp0 as any)?.type === "defineLabel" &&
+        entryLabels.has((nextOp0 as any).label)
+      )
+        break;
+      fnInstrs.push(next);
+      i++;
+    }
+
+    result.push(instr); // emit the entry defineLabel
+    const { instrs, tail } = transform(fnInstrs, fnId);
+    result.push(...instrs);
+    if (tail && tail.length > 0) tails.push(tail);
+  }
+
+  for (const tail of tails) {
+    result.push(...tail);
+  }
+
+  return { bytecode: result };
+}

package/src/utils/profile-utils.ts

@@ -0,0 +1,3 @@
+export function now() {
+  return performance?.now() || Date.now();
+}

package/tsconfig.json

@@ -6,7 +6,7 @@
     "rootDir": "./",
     "strict": false,
     "noEmit": true,
-    "types": ["node"],
+    "types": ["node", "jest"],
     "allowImportingTsExtensions": true
   }
 }