smiles-js 2.0.3 → 2.2.0

package/src/codegen/branch-crossing-ring.js

@@ -76,14 +76,35 @@ export function buildBranchCrossingRingSMILES(ring, buildSMILES) {
 
     if (attachments[i] && attachments[i].length > 0) {
       if (hasInlineBranchAfter) {
-        // Delay attachments - output after inline branch closes back to this depth
-        const processedAttachments = attachments[i].map((att) => {
-          if (att.metaIsSibling !== undefined) {
-            return att;
+        // Determine the branchId of the inline continuation (next ring position)
+        const metaBranchIds = ring.metaBranchIds || [];
+        const inlineBranchId = i < size ? (metaBranchIds[i] || Infinity) : Infinity;
+
+        // Separate: siblings that come BEFORE the inline branch (emit now)
+        // vs siblings that come AFTER (delay), and non-siblings (delay)
+        const emitNow = [];
+        const delay = [];
+        attachments[i].forEach((att) => {
+          const isSibling = att.metaIsSibling !== undefined ? att.metaIsSibling : true;
+          if (!isSibling) {
+            delay.push(att);
+          } else if (att.metaBranchId !== undefined && att.metaBranchId < inlineBranchId) {
+            emitNow.push(att);
+          } else if (att.metaBeforeInline === true) {
+            emitNow.push(att);
+          } else {
+            // Default: delay sibling (beforeInline defaults to false)
+            delay.push({ ...att, metaIsSibling: true });
           }
-          return { ...att, metaIsSibling: true };
         });
-        pendingAttachments.set(i, { depth: posDepth, attachments: processedAttachments });
+        // Emit siblings that come before the inline branch
+        emitNow.forEach((attachment) => {
+          emitAttachment(parts, attachment, buildSMILES);
+        });
+        // Delay the rest
+        if (delay.length > 0) {
+          pendingAttachments.set(i, { depth: posDepth, attachments: delay });
+        }
       } else {
         // Output attachments immediately
         attachments[i].forEach((attachment) => {

package/src/codegen/interleaved-fused-ring.js

@@ -103,11 +103,33 @@ export function buildInterleavedFusedRingSMILES(fusedRing, buildSMILES) {
   // Pending attachments: depth -> attachment[]
   const pendingAttachments = new Map();
 
+  const branchIdMap = fusedRing.metaBranchIdMap || new Map();
+  let prevBranchId = null;
+
   allPositions.forEach((pos, idx) => {
     const entry = atomSequence[pos];
     if (!entry) return;
 
     const posDepth = branchDepthMap.get(pos) || 0;
+    const posBranchId = branchIdMap.get(pos);
+
+    // Detect sibling branch switch: same depth, different branch ID
+    // Need to close current branch and reopen a new one
+    if (posDepth > 0 && posDepth === depthRef.value && prevBranchId !== null
+        && posBranchId !== prevBranchId && posBranchId !== null) {
+      // Close the current branch and reopen
+      parts.push(')');
+      // Emit any pending attachments at the parent depth
+      const parentDepth = posDepth - 1;
+      if (pendingAttachments.has(parentDepth)) {
+        const attachmentsToOutput = pendingAttachments.get(parentDepth);
+        attachmentsToOutput.forEach((attachment) => {
+          emitAttachment(parts, attachment, buildSMILES);
+        });
+        pendingAttachments.delete(parentDepth);
+      }
+      parts.push('(');
+    }
 
     // Handle branch depth changes
     openBranches(parts, depthRef, posDepth);
@@ -164,6 +186,8 @@ export function buildInterleavedFusedRingSMILES(fusedRing, buildSMILES) {
         });
       }
     }
+
+    prevBranchId = posBranchId;
   });
 
   // Close any remaining open branches

package/src/decompiler.js

@@ -9,11 +9,13 @@ import {
   isRingNode,
   isLinearNode,
 } from './ast.js';
+import { buildSMILES } from './codegen/index.js';
+import { createRingNode } from './node-creators.js';
 
 // Helper to call decompileNode (satisfies no-loop-func rule)
-function decompileChildNode(node, indent, nextVar) {
+function decompileChildNode(node, indent, nextVar, verbose) {
   // eslint-disable-next-line no-use-before-define
-  return decompileNode(node, indent, nextVar);
+  return decompileNode(node, indent, nextVar, verbose);
 }
 
 /**
@@ -110,22 +112,43 @@ function generateSubstitutionCode(ring, indent, nextVar, initialVar) {
  * Generate code for ring attachments
  * @returns {{ lines: string[], currentVar: string }}
  */
-function generateAttachmentCode(ring, indent, nextVar, initialVar) {
+function generateAttachmentCode(ring, indent, nextVar, initialVar, verbose = true) {
   const lines = [];
   let currentVar = initialVar;
 
   if (ring.attachments && Object.keys(ring.attachments).length > 0) {
+    // Determine inline branchId for sibling ordering
+    const metaBranchIds = ring.metaBranchIds || [];
+    const normalizedDepths = ring.metaBranchDepths || [];
+
     Object.entries(ring.attachments).forEach(([pos, attachmentList]) => {
+      const posIdx = Number(pos) - 1; // 0-indexed
+      const nextIdx = posIdx + 1;
+      const posDepth = normalizedDepths[posIdx] || 0;
+      const nextDepth = nextIdx < normalizedDepths.length ? (normalizedDepths[nextIdx] || 0) : 0;
+      const hasInlineBranchAfter = nextDepth > posDepth;
+      const inlineBranchId = hasInlineBranchAfter ? (metaBranchIds[nextIdx] || Infinity) : Infinity;
+
       attachmentList.forEach((attachment) => {
-        const attachResult = decompileChildNode(attachment, indent, nextVar);
+        const attachResult = decompileChildNode(attachment, indent, nextVar, verbose);
         lines.push(attachResult.code);
 
         const newVar = nextVar();
         const isSibling = attachment.metaIsSibling;
+        const optParts = [];
         if (isSibling === true) {
-          lines.push(`${indent}const ${newVar} = ${currentVar}.attach(${pos}, ${attachResult.finalVar}, { sibling: true });`);
+          optParts.push('sibling: true');
+          // Encode beforeInline for sibling ordering in branch-crossing rings
+          // Only emit when true since false is the default
+          if (hasInlineBranchAfter && attachment.metaBranchId !== undefined
+              && attachment.metaBranchId < inlineBranchId) {
+            optParts.push('beforeInline: true');
+          }
         } else if (isSibling === false) {
-          lines.push(`${indent}const ${newVar} = ${currentVar}.attach(${pos}, ${attachResult.finalVar}, { sibling: false });`);
+          optParts.push('sibling: false');
+        }
+        if (optParts.length > 0) {
+          lines.push(`${indent}const ${newVar} = ${currentVar}.attach(${pos}, ${attachResult.finalVar}, { ${optParts.join(', ')} });`);
         } else {
           lines.push(`${indent}const ${newVar} = ${currentVar}.attach(${pos}, ${attachResult.finalVar});`);
         }
@@ -137,13 +160,72 @@ function generateAttachmentCode(ring, indent, nextVar, initialVar) {
   return { lines, currentVar };
 }
 
+/**
+ * Compute the SMILES for a ring node with substitutions but without attachments.
+ * Used in non-verbose mode to emit Fragment('SMILES') for the substituted ring.
+ */
+function getRingWithSubsSmiles(ring) {
+  const tempNode = createRingNode(
+    ring.atoms,
+    ring.size,
+    ring.ringNumber,
+    ring.offset,
+    ring.substitutions,
+    {},
+    ring.bonds,
+    ring.metaBranchDepths,
+  );
+  if (ring.metaLeadingBond) {
+    tempNode.metaLeadingBond = ring.metaLeadingBond;
+  }
+  return buildSMILES(tempNode);
+}
+
 /**
  * Decompile a Ring node
  */
-function decompileRing(ring, indent, nextVar) {
+function decompileRing(ring, indent, nextVar, verbose = true) {
   const lines = [];
   const varName = nextVar();
 
+  if (!verbose && !ring.metaLeadingBond) {
+    // Non-verbose: emit Fragment('SMILES') for base ring
+    const baseSmiles = buildSMILES(createRingNode(
+      ring.atoms,
+      ring.size,
+      ring.ringNumber,
+      ring.offset,
+      {},
+      {},
+      ring.bonds,
+      ring.metaBranchDepths,
+    ));
+    lines.push(`${indent}const ${varName} = Fragment('${baseSmiles}');`);
+
+    // Substitutions: each becomes an independent Fragment('SMILES')
+    let currentVar = varName;
+    if (Object.keys(ring.substitutions).length > 0) {
+      const subsSmiles = getRingWithSubsSmiles(ring);
+      const newVar = nextVar();
+      lines.push(`${indent}const ${newVar} = Fragment('${subsSmiles}');`);
+      currentVar = newVar;
+    }
+
+    // Attachments stay as .attach() calls
+    const { lines: attLines, currentVar: attVar } = generateAttachmentCode(
+      ring,
+      indent,
+      nextVar,
+      currentVar,
+      verbose,
+    );
+    lines.push(...attLines);
+    currentVar = attVar;
+
+    return { code: lines.join('\n'), finalVar: currentVar };
+  }
+
+  // Verbose mode (original behavior)
   // Build options object (include branchDepths for full decompilation)
   const { optionsStr } = buildRingOptions(ring, { includeBranchDepths: true });
   lines.push(`${indent}const ${varName} = Ring({ ${optionsStr} });`);
@@ -164,6 +246,7 @@ function decompileRing(ring, indent, nextVar) {
     indent,
     nextVar,
     currentVar,
+    verbose,
   );
   lines.push(...attLines);
   currentVar = attVar;
@@ -174,7 +257,7 @@ function decompileRing(ring, indent, nextVar) {
 /**
  * Decompile a Linear node
  */
-function decompileLinear(linear, indent, nextVar) {
+function decompileLinear(linear, indent, nextVar, verbose = true) {
   const lines = [];
   const varName = nextVar();
 
@@ -184,7 +267,13 @@ function decompileLinear(linear, indent, nextVar) {
   const hasNonNullBonds = linear.bonds.some((b) => b !== null);
   const hasLeadingBond = linear.metaLeadingBond !== undefined;
 
-  if (hasNonNullBonds && hasLeadingBond) {
+  // Non-verbose: use Fragment('SMILES') when possible (no bonds, no leadingBond)
+  if (!verbose && !hasNonNullBonds && !hasLeadingBond) {
+    // Compute SMILES without attachments for the base linear node
+    const baseLinear = { ...linear, attachments: {} };
+    const smiles = buildSMILES(baseLinear);
+    lines.push(`${indent}const ${varName} = Fragment('${smiles}');`);
+  } else if (hasNonNullBonds && hasLeadingBond) {
     lines.push(`${indent}const ${varName} = Linear([${atomsStr}], [${formatBondsArray(linear.bonds)}], {}, '${linear.metaLeadingBond}');`);
   } else if (hasNonNullBonds) {
     lines.push(`${indent}const ${varName} = Linear([${atomsStr}], [${formatBondsArray(linear.bonds)}]);`);
@@ -201,7 +290,7 @@ function decompileLinear(linear, indent, nextVar) {
     Object.entries(linear.attachments).forEach(([pos, attachmentList]) => {
       attachmentList.forEach((attachment) => {
         // eslint-disable-next-line no-use-before-define
-        const attachRes = decompileNode(attachment, indent, nextVar);
+        const attachRes = decompileNode(attachment, indent, nextVar, verbose);
         const { code: aCode, finalVar: aFinalVar } = attachRes;
         lines.push(aCode);
 
@@ -402,7 +491,7 @@ function computeSharedPositions(fusedRing) {
  * Emits .fuse() for the first pair and .addRing() for subsequent rings.
  * The resulting code goes through the simple codegen path (offset-based).
  */
-function decompileSimpleFusedRing(fusedRing, indent, nextVar) {
+function decompileSimpleFusedRing(fusedRing, indent, nextVar, verbose = true) {
   const lines = [];
   const ringFinalVars = [];
 
@@ -465,20 +554,52 @@ function decompileSimpleFusedRing(fusedRing, indent, nextVar) {
     }
 
     const varName = nextVar();
-    const { optionsStr } = buildRingOptions(effectiveRing, { includeBranchDepths: true });
-    lines.push(`${indent}const ${varName} = Ring({ ${optionsStr} });`);
 
-    const {
-      lines: subLines, currentVar: subVar,
-    } = generateSubstitutionCode(effectiveRing, indent, nextVar, varName);
-    lines.push(...subLines);
+    if (!verbose && !effectiveRing.metaLeadingBond) {
+      // Non-verbose: use Fragment for ring constructor
+      const baseSmiles = buildSMILES(createRingNode(
+        effectiveRing.atoms,
+        effectiveRing.size,
+        effectiveRing.ringNumber,
+        effectiveRing.offset,
+        {},
+        {},
+        effectiveRing.bonds,
+        effectiveRing.metaBranchDepths,
+      ));
+      lines.push(`${indent}const ${varName} = Fragment('${baseSmiles}');`);
+
+      let currentVar = varName;
+      if (Object.keys(effectiveRing.substitutions || {}).length > 0) {
+        const subsSmiles = getRingWithSubsSmiles(effectiveRing);
+        const newVar = nextVar();
+        lines.push(`${indent}const ${newVar} = Fragment('${subsSmiles}');`);
+        currentVar = newVar;
+      }
+
+      const {
+        lines: attLines, currentVar: attVar,
+      } = generateAttachmentCode(effectiveRing, indent, nextVar, currentVar, verbose);
+      lines.push(...attLines);
 
-    const {
-      lines: attLines, currentVar: attVar,
-    } = generateAttachmentCode(effectiveRing, indent, nextVar, subVar);
-    lines.push(...attLines);
+      ringFinalVars.push(attVar);
+    } else {
+      // Verbose: original behavior
+      const { optionsStr } = buildRingOptions(effectiveRing, { includeBranchDepths: true });
+      lines.push(`${indent}const ${varName} = Ring({ ${optionsStr} });`);
+
+      const {
+        lines: subLines, currentVar: subVar,
+      } = generateSubstitutionCode(effectiveRing, indent, nextVar, varName);
+      lines.push(...subLines);
+
+      const {
+        lines: attLines, currentVar: attVar,
+      } = generateAttachmentCode(effectiveRing, indent, nextVar, subVar, verbose);
+      lines.push(...attLines);
 
-    ringFinalVars.push(attVar);
+      ringFinalVars.push(attVar);
+    }
   });
 
   const leadingBond = fusedRing.metaLeadingBond;
@@ -520,7 +641,7 @@ function decompileSimpleFusedRing(fusedRing, indent, nextVar) {
  * rings to a fused ring. The codegen uses this metadata to correctly interleave
  * ring markers and handle branch depths.
  */
-function decompileComplexFusedRing(fusedRing, indent, nextVar) {
+function decompileComplexFusedRing(fusedRing, indent, nextVar, verbose = true) {
   const lines = [];
   const sequentialRings = fusedRing.metaSequentialRings || [];
   const seqAtomAttachments = fusedRing.metaSeqAtomAttachments || new Map();
@@ -528,17 +649,45 @@ function decompileComplexFusedRing(fusedRing, indent, nextVar) {
   // Step 1: Decompile the base fused ring
   const ringVars = [];
   fusedRing.rings.forEach((ring) => {
-    const { optionsStr } = buildRingOptions(ring, { includeBranchDepths: true });
     const varName = nextVar();
-    lines.push(`${indent}const ${varName} = Ring({ ${optionsStr} });`);
 
-    const subResult = generateSubstitutionCode(ring, indent, nextVar, varName);
-    lines.push(...subResult.lines);
+    if (!verbose && !ring.metaLeadingBond) {
+      const baseSmiles = buildSMILES(createRingNode(
+        ring.atoms,
+        ring.size,
+        ring.ringNumber,
+        ring.offset,
+        {},
+        {},
+        ring.bonds,
+        ring.metaBranchDepths,
+      ));
+      lines.push(`${indent}const ${varName} = Fragment('${baseSmiles}');`);
+
+      let currentVar = varName;
+      if (Object.keys(ring.substitutions || {}).length > 0) {
+        const subsSmiles = getRingWithSubsSmiles(ring);
+        const newVar = nextVar();
+        lines.push(`${indent}const ${newVar} = Fragment('${subsSmiles}');`);
+        currentVar = newVar;
+      }
+
+      const attResult = generateAttachmentCode(ring, indent, nextVar, currentVar, verbose);
+      lines.push(...attResult.lines);
+
+      ringVars.push({ var: attResult.currentVar, ring });
+    } else {
+      const { optionsStr } = buildRingOptions(ring, { includeBranchDepths: true });
+      lines.push(`${indent}const ${varName} = Ring({ ${optionsStr} });`);
 
-    const attResult = generateAttachmentCode(ring, indent, nextVar, subResult.currentVar);
-    lines.push(...attResult.lines);
+      const subResult = generateSubstitutionCode(ring, indent, nextVar, varName);
+      lines.push(...subResult.lines);
+
+      const attResult = generateAttachmentCode(ring, indent, nextVar, subResult.currentVar, verbose);
+      lines.push(...attResult.lines);
 
-    ringVars.push({ var: attResult.currentVar, ring });
+      ringVars.push({ var: attResult.currentVar, ring });
+    }
   });
 
   // Decompile seqAtomAttachments BEFORE fuse so their vars are declared early
@@ -548,7 +697,7 @@ function decompileComplexFusedRing(fusedRing, indent, nextVar) {
     seqAtomAttachments.forEach((attachments, pos) => {
       const attVars = [];
       attachments.forEach((att) => {
-        const attResult = decompileChildNode(att, indent, nextVar);
+        const attResult = decompileChildNode(att, indent, nextVar, verbose);
         lines.push(attResult.code);
         attVars.push(attResult.finalVar);
       });
@@ -670,17 +819,45 @@ function decompileComplexFusedRing(fusedRing, indent, nextVar) {
     // Decompile sequential rings
     const seqRingVars = [];
     sequentialRings.forEach((ring) => {
-      const { optionsStr } = buildRingOptions(ring, { includeBranchDepths: true });
       const varName = nextVar();
-      lines.push(`${indent}const ${varName} = Ring({ ${optionsStr} });`);
 
-      const subResult = generateSubstitutionCode(ring, indent, nextVar, varName);
-      lines.push(...subResult.lines);
+      if (!verbose && !ring.metaLeadingBond) {
+        const baseSmiles = buildSMILES(createRingNode(
+          ring.atoms,
+          ring.size,
+          ring.ringNumber,
+          ring.offset,
+          {},
+          {},
+          ring.bonds,
+          ring.metaBranchDepths,
+        ));
+        lines.push(`${indent}const ${varName} = Fragment('${baseSmiles}');`);
+
+        let currentVar = varName;
+        if (Object.keys(ring.substitutions || {}).length > 0) {
+          const subsSmiles = getRingWithSubsSmiles(ring);
+          const newVar = nextVar();
+          lines.push(`${indent}const ${newVar} = Fragment('${subsSmiles}');`);
+          currentVar = newVar;
+        }
 
-      const attResult = generateAttachmentCode(ring, indent, nextVar, subResult.currentVar);
-      lines.push(...attResult.lines);
+        const attResult = generateAttachmentCode(ring, indent, nextVar, currentVar, verbose);
+        lines.push(...attResult.lines);
 
-      seqRingVars.push(attResult.currentVar);
+        seqRingVars.push(attResult.currentVar);
+      } else {
+        const { optionsStr } = buildRingOptions(ring, { includeBranchDepths: true });
+        lines.push(`${indent}const ${varName} = Ring({ ${optionsStr} });`);
+
+        const subResult = generateSubstitutionCode(ring, indent, nextVar, varName);
+        lines.push(...subResult.lines);
+
+        const attResult = generateAttachmentCode(ring, indent, nextVar, subResult.currentVar, verbose);
+        lines.push(...attResult.lines);
+
+        seqRingVars.push(attResult.currentVar);
+      }
     });
 
     // Decompile chain atom attachments
@@ -689,7 +866,7 @@ function decompileComplexFusedRing(fusedRing, indent, nextVar) {
         const attachments = seqAtomAttachments.get(entry.attachmentPos) || [];
         const attVars = [];
         attachments.forEach((att) => {
-          const attResult = decompileChildNode(att, indent, nextVar);
+          const attResult = decompileChildNode(att, indent, nextVar, verbose);
           lines.push(attResult.code);
           attVars.push(attResult.finalVar);
         });
@@ -758,6 +935,7 @@ function decompileComplexFusedRing(fusedRing, indent, nextVar) {
     const atomValueMap = fusedRing.metaAtomValueMap || new Map();
     const bondMap = fusedRing.metaBondMap || new Map();
     const ringOrderMap = fusedRing.metaRingOrderMap;
+    const branchIdMap = fusedRing.metaBranchIdMap || new Map();
 
     // Helper to format a single atom entry with all available metadata
     function formatAtomEntry(pos) {
@@ -768,6 +946,9 @@ function decompileComplexFusedRing(fusedRing, indent, nextVar) {
       if (ringOrderMap && ringOrderMap.has(pos)) {
         parts.push(`rings: [${ringOrderMap.get(pos).join(', ')}]`);
       }
+      if (branchIdMap.has(pos) && branchIdMap.get(pos) !== null) {
+        parts.push(`branchId: ${branchIdMap.get(pos)}`);
+      }
       if (seqAtomAttachmentVarMap.has(pos)) {
         parts.push(`attachments: [${seqAtomAttachmentVarMap.get(pos).join(', ')}]`);
       }
@@ -820,24 +1001,24 @@ function decompileComplexFusedRing(fusedRing, indent, nextVar) {
  * - Sequential rings or interleaved codegen → preserves metadata (needs it for correct SMILES)
  * - Everything else → structural API calls only (no metadata)
  */
-function decompileFusedRing(fusedRing, indent, nextVar) {
+function decompileFusedRing(fusedRing, indent, nextVar, verbose = true) {
   const seqRings = fusedRing.metaSequentialRings;
   const hasSeqRings = seqRings && seqRings.length > 0;
   const isInterleaved = needsInterleavedCodegen(fusedRing);
 
   // Use complex decompilation for sequential rings or genuinely interleaved fused rings
   if (hasSeqRings || isInterleaved) {
-    return decompileComplexFusedRing(fusedRing, indent, nextVar);
+    return decompileComplexFusedRing(fusedRing, indent, nextVar, verbose);
   }
 
   // Everything else goes through the simple path (no metadata)
-  return decompileSimpleFusedRing(fusedRing, indent, nextVar);
+  return decompileSimpleFusedRing(fusedRing, indent, nextVar, verbose);
 }
 
 /**
  * Decompile a Molecule node
  */
-function decompileMolecule(molecule, indent, nextVar) {
+function decompileMolecule(molecule, indent, nextVar, verbose = true) {
   const lines = [];
   const { components } = molecule;
 
@@ -853,7 +1034,7 @@ function decompileMolecule(molecule, indent, nextVar) {
   const componentFinalVars = [];
   components.forEach((component) => {
     // eslint-disable-next-line no-use-before-define
-    const { code: componentCode, finalVar } = decompileNode(component, indent, nextVar);
+    const { code: componentCode, finalVar } = decompileNode(component, indent, nextVar, verbose);
     lines.push(componentCode);
     // Note: metaLeadingBond is now handled in component constructors via metadata
     // or leadingBond option, so no mutation needed here
@@ -868,21 +1049,21 @@ function decompileMolecule(molecule, indent, nextVar) {
   return { code: lines.join('\n'), finalVar: finalVarName };
 }
 
-function decompileNode(node, indent, nextVar) {
+function decompileNode(node, indent, nextVar, verbose = true) {
   if (isRingNode(node)) {
-    return decompileRing(node, indent, nextVar);
+    return decompileRing(node, indent, nextVar, verbose);
   }
 
   if (isLinearNode(node)) {
-    return decompileLinear(node, indent, nextVar);
+    return decompileLinear(node, indent, nextVar, verbose);
   }
 
   if (isFusedRingNode(node)) {
-    return decompileFusedRing(node, indent, nextVar);
+    return decompileFusedRing(node, indent, nextVar, verbose);
   }
 
   if (isMoleculeNode(node)) {
-    return decompileMolecule(node, indent, nextVar);
+    return decompileMolecule(node, indent, nextVar, verbose);
   }
 
   throw new Error(`Unknown node type: ${node.type}`);
@@ -894,15 +1075,19 @@ function decompileNode(node, indent, nextVar) {
  * @param {Object} options - Options
  * @param {number} options.indent - Indentation level (default 0)
  * @param {string} options.varName - Variable name prefix (default 'v')
+ * @param {boolean} options.verbose - Use verbose constructor syntax (default false).
+ *   When false, uses Fragment('SMILES') for Ring and simple Linear nodes.
  * @param {boolean} options.includeMetadata - Include metadata assignments
  *   (default true). Set to false for cleaner output (but code may not work)
  */
 export function decompile(node, options = {}) {
-  const { indent = 0, varName = 'v', includeMetadata = true } = options;
+  const {
+    indent = 0, varName = 'v', includeMetadata = true, verbose = false,
+  } = options;
   const indentStr = '  '.repeat(indent);
   const nextVar = createCounter(varName);
 
-  const { code } = decompileNode(node, indentStr, nextVar);
+  const { code } = decompileNode(node, indentStr, nextVar, verbose);
 
   // Always use export for declarations
   let result = code.replace(/^(\s*)(const|let) /gm, '$1export $2 ');