How to Extract Code from Source Map Files: Memory-Efficient CLI Reconstruction

# Check if sourcesContent exists and count embedded files
node -e '
const fs = require("fs");
const fd = fs.openSync("bundle.js.map", "r");
const buf = Buffer.alloc(1024 * 64);
fs.readSync(fd, buf, 0, buf.length, 0);
fs.closeSync(fd);
const head = buf.toString("utf8");
console.log("Has sourcesContent:", head.includes("\"sourcesContent\""));
'

# Run extraction with expanded V8 heap allocation if handling files > 100MB
node --max-old-space-size=4096 -e '
const fs = require("fs");
const path = require("path");

const rawMap = JSON.parse(fs.readFileSync("bundle.js.map", "utf8"));
if (!rawMap.sourcesContent || !rawMap.sources) {
  console.error("Error: Map file does not contain inline sourcesContent.");
  process.exit(1);
}

rawMap.sources.forEach((sourcePath, index) => {
  const content = rawMap.sourcesContent[index];
  if (!content) return;
  
  // Sanitize path to prevent directory traversal
  const cleanPath = path.normalize(sourcePath).replace(/^(\.\.[\/\\])+/, "");
  const targetPath = path.join(process.cwd(), "extracted_src", cleanPath);
  
  fs.mkdirSync(path.dirname(targetPath), { recursive: true });
  fs.writeFileSync(targetPath, content, "utf8");
});
console.log(`Reconstructed ${rawMap.sources.length} files successfully.`);
'

┌─────────────────────────────────────────────────────────────┐
│                    Source Map JSON (v3)                     │
├──────────────────┬───────────────────┬──────────────────────┤
│  version: 3      │  sources: [...]   │ sourcesContent: [...]│
│  file: "app.js"  │  mappings: "AAAA;"│ (Original Source)    │
└──────────────────┴───────────────────┴──────────────────────┘
         │                                       │
         ▼                                       ▼
  Browser DevTools                        Disk Extraction
(Breakpoint mapping)                    (Directory Tree Rebuild)

Incoming Stream (150MB Map File)
           │
           ▼
 ┌───────────────────┐
 │   JSON.parse()    │ ──► Exceeds New-Space allocation limits
 └───────────────────┘
           │
           ▼
 ┌──────────────────────────────────────────────────────────────┐
 │ V8 Old Generation Heap (~1.4GB default limit)               │
 │                                                              │
 │  [Raw JSON Buffer] ──► [AST Tree] ──► [10,000+ File Strings] │
 └──────────────────────────────────────────────────────────────┘
           │
     (If Heap > Limit)
           │
           ▼
 💥 FATAL ERROR: Reached heap limit Allocation failed - JavaScript heap out of memory

node --max-old-space-size=8192 extract-script.js

       Extraction Process (Async Event Loop)
                         │
        ┌────────────────┴────────────────┐
        ▼                                 ▼
 Windows (NTFS)                     Linux (ext4)
 ┌─────────────────────────┐       ┌─────────────────────────┐
 │ Master File Table (MFT) │       │ Inode Tables            │
 │ • File-lock contention  │       │ • Dentry cache churn    │
 │ • High CreateFile overhead      │ • Fast sub-ms writes    │
 └─────────────────────────┘       └─────────────────────────┘

/**
 * WasyTech Diagnostic Utilities
 * Architectural Reference: Source Map Revision 3 Extraction Pipeline
 */

const fs = require('fs');
const path = require('path');

function sanitizePath(sourcePath, rootDir) {
  // Strip dangerous traversal syntax and protocols
  const normalized = path.normalize(sourcePath)
    .replace(/^([a-zA-Z]:)?(\\|\/)+/, '') // Strip drive letters and root slashes
    .replace(/^(\.\.[\/\\])+/, '');        // Strip relative backtracking

  // Resolve absolute path and guarantee boundary confinement
  const target = path.resolve(rootDir, normalized);
  if (!target.startsWith(rootDir)) {
    throw new Error(`Security Exception: Path traversal attempt outside ${rootDir}: ${sourcePath}`);
  }
  return target;
}

function extractSourceMap(mapFilePath, outputDirectory) {
  const absoluteMapPath = path.resolve(process.cwd(), mapFilePath);
  const absoluteOutDir = path.resolve(process.cwd(), outputDirectory);

  if (!fs.existsSync(absoluteMapPath)) {
    console.error(`[CRITICAL] Map target not found: ${absoluteMapPath}`);
    process.exit(1);
  }

  console.log(`[INIT] Reading map: ${absoluteMapPath}`);
  
  // Read using modern fast string parsing
  const rawData = fs.readFileSync(absoluteMapPath, 'utf8');
  let parsedMap;
  
  try {
    parsedMap = JSON.parse(rawData);
  } catch (err) {
    console.error(`[CRITICAL] Failed to parse JSON payload. If file is large, execute with --max-old-space-size.`);
    throw err;
  }

  if (!parsedMap.sources || !parsedMap.sourcesContent) {
    console.error(`[ABORT] Source map is valid JSON but lacks "sourcesContent" array.`);
    console.error(`This map only contains symbol references/offsets, not raw authored code.`);
    process.exit(1);
  }

  const fileCount = parsedMap.sources.length;
  console.log(`[PROCESSING] Found ${fileCount} source references. Starting controlled extraction...`);

  // Ensure root output directory exists
  fs.mkdirSync(absoluteOutDir, { recursive: true });

  let extractedCount = 0;
  let skippedCount = 0;

  for (let i = 0; i < fileCount; i++) {
    const rawSourcePath = parsedMap.sources[i];
    const fileContent = parsedMap.sourcesContent[i];

    // Some source map generators insert null entries for missing source files
    if (fileContent === null || fileContent === undefined) {
      skippedCount++;
      continue;
    }

    try {
      const destination = sanitizePath(rawSourcePath, absoluteOutDir);
      const directory = path.dirname(destination);

      // Recursive mkdir is safe and optimized in modern Node.js
      fs.mkdirSync(directory, { recursive: true });
      fs.writeFileSync(destination, fileContent, { encoding: 'utf8', flag: 'w' });
      extractedCount++;
    } catch (err) {
      console.warn(`[WARN] Failed to write index ${i} (${rawSourcePath}): ${err.message}`);
    }
  }

  console.log(`\n=== Extraction Summary ===`);
  console.log(`Extracted Files : ${extractedCount}`);
  console.log(`Skipped Entries : ${skippedCount}`);
  console.log(`Output Location : ${absoluteOutDir}`);
}

// Execution Entry Point
const [,, inputMap, outputDir = 'extracted_sources'] = process.argv;

if (!inputMap) {
  console.log('Usage: node --max-old-space-size=4096 extract-map.js <path-to-map-file> [output-dir]');
  process.exit(0);
}

extractSourceMap(inputMap, outputDir);

// webpack.config.js
devtool: 'nosources-source-map' // Generates mapping offsets but omits sourcesContent