tor-browser

source-node.js (13793B)

---

/* -*- Mode: js; js-indent-level: 2; -*- */
/*
* Copyright 2011 Mozilla Foundation and contributors
* Licensed under the New BSD license. See LICENSE or:
* http://opensource.org/licenses/BSD-3-Clause
*/

const SourceMapGenerator = require("./source-map-generator").SourceMapGenerator;
const util = require("./util");

// Matches a Windows-style `\r\n` newline or a `\n` newline used by all other
// operating systems these days (capturing the result).
const REGEX_NEWLINE = /(\r?\n)/;

// Newline character code for charCodeAt() comparisons
const NEWLINE_CODE = 10;

// Private symbol for identifying `SourceNode`s when multiple versions of
// the source-map library are loaded. This MUST NOT CHANGE across
// versions!
const isSourceNode = "$$$isSourceNode$$$";

/**
* SourceNodes provide a way to abstract over interpolating/concatenating
* snippets of generated JavaScript source code while maintaining the line and
* column information associated with the original source code.
*
* @param aLine The original line number.
* @param aColumn The original column number.
* @param aSource The original source's filename.
* @param aChunks Optional. An array of strings which are snippets of
*        generated JS, or other SourceNodes.
* @param aName The original identifier.
*/
class SourceNode {
 constructor(aLine, aColumn, aSource, aChunks, aName) {
   this.children = [];
   this.sourceContents = {};
   this.line = aLine == null ? null : aLine;
   this.column = aColumn == null ? null : aColumn;
   this.source = aSource == null ? null : aSource;
   this.name = aName == null ? null : aName;
   this[isSourceNode] = true;
   if (aChunks != null) this.add(aChunks);
 }

 /**
  * Creates a SourceNode from generated code and a SourceMapConsumer.
  *
  * @param aGeneratedCode The generated code
  * @param aSourceMapConsumer The SourceMap for the generated code
  * @param aRelativePath Optional. The path that relative sources in the
  *        SourceMapConsumer should be relative to.
  */
 static fromStringWithSourceMap(
   aGeneratedCode,
   aSourceMapConsumer,
   aRelativePath
 ) {
   // The SourceNode we want to fill with the generated code
   // and the SourceMap
   const node = new SourceNode();

   // All even indices of this array are one line of the generated code,
   // while all odd indices are the newlines between two adjacent lines
   // (since `REGEX_NEWLINE` captures its match).
   // Processed fragments are accessed by calling `shiftNextLine`.
   const remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
   let remainingLinesIndex = 0;
   const shiftNextLine = function () {
     const lineContents = getNextLine();
     // The last line of a file might not have a newline.
     const newLine = getNextLine() || "";
     return lineContents + newLine;

     function getNextLine() {
       return remainingLinesIndex < remainingLines.length
         ? remainingLines[remainingLinesIndex++]
         : undefined;
     }
   };

   // We need to remember the position of "remainingLines"
   let lastGeneratedLine = 1,
     lastGeneratedColumn = 0;

   // The generate SourceNodes we need a code range.
   // To extract it current and last mapping is used.
   // Here we store the last mapping.
   let lastMapping = null;
   let nextLine;

   aSourceMapConsumer.eachMapping(function (mapping) {
     if (lastMapping !== null) {
       // We add the code from "lastMapping" to "mapping":
       // First check if there is a new line in between.
       if (lastGeneratedLine < mapping.generatedLine) {
         // Associate first line with "lastMapping"
         addMappingWithCode(lastMapping, shiftNextLine());
         lastGeneratedLine++;
         lastGeneratedColumn = 0;
         // The remaining code is added without mapping
       } else {
         // There is no new line in between.
         // Associate the code between "lastGeneratedColumn" and
         // "mapping.generatedColumn" with "lastMapping"
         nextLine = remainingLines[remainingLinesIndex] || "";
         const code = nextLine.substr(
           0,
           mapping.generatedColumn - lastGeneratedColumn
         );
         remainingLines[remainingLinesIndex] = nextLine.substr(
           mapping.generatedColumn - lastGeneratedColumn
         );
         lastGeneratedColumn = mapping.generatedColumn;
         addMappingWithCode(lastMapping, code);
         // No more remaining code, continue
         lastMapping = mapping;
         return;
       }
     }
     // We add the generated code until the first mapping
     // to the SourceNode without any mapping.
     // Each line is added as separate string.
     while (lastGeneratedLine < mapping.generatedLine) {
       node.add(shiftNextLine());
       lastGeneratedLine++;
     }
     if (lastGeneratedColumn < mapping.generatedColumn) {
       nextLine = remainingLines[remainingLinesIndex] || "";
       node.add(nextLine.substr(0, mapping.generatedColumn));
       remainingLines[remainingLinesIndex] = nextLine.substr(
         mapping.generatedColumn
       );
       lastGeneratedColumn = mapping.generatedColumn;
     }
     lastMapping = mapping;
   }, this);
   // We have processed all mappings.
   if (remainingLinesIndex < remainingLines.length) {
     if (lastMapping) {
       // Associate the remaining code in the current line with "lastMapping"
       addMappingWithCode(lastMapping, shiftNextLine());
     }
     // and add the remaining lines without any mapping
     node.add(remainingLines.splice(remainingLinesIndex).join(""));
   }

   // Copy sourcesContent into SourceNode
   aSourceMapConsumer.sources.forEach(function (sourceFile) {
     const content = aSourceMapConsumer.sourceContentFor(sourceFile);
     if (content != null) {
       if (aRelativePath != null) {
         sourceFile = util.join(aRelativePath, sourceFile);
       }
       node.setSourceContent(sourceFile, content);
     }
   });

   return node;

   function addMappingWithCode(mapping, code) {
     if (mapping === null || mapping.source === undefined) {
       node.add(code);
     } else {
       const source = aRelativePath
         ? util.join(aRelativePath, mapping.source)
         : mapping.source;
       node.add(
         new SourceNode(
           mapping.originalLine,
           mapping.originalColumn,
           source,
           code,
           mapping.name
         )
       );
     }
   }
 }

 /**
  * Add a chunk of generated JS to this source node.
  *
  * @param aChunk A string snippet of generated JS code, another instance of
  *        SourceNode, or an array where each member is one of those things.
  */
 add(aChunk) {
   if (Array.isArray(aChunk)) {
     aChunk.forEach(function (chunk) {
       this.add(chunk);
     }, this);
   } else if (aChunk[isSourceNode] || typeof aChunk === "string") {
     if (aChunk) {
       this.children.push(aChunk);
     }
   } else {
     throw new TypeError(
       "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " +
         aChunk
     );
   }
   return this;
 }

 /**
  * Add a chunk of generated JS to the beginning of this source node.
  *
  * @param aChunk A string snippet of generated JS code, another instance of
  *        SourceNode, or an array where each member is one of those things.
  */
 prepend(aChunk) {
   if (Array.isArray(aChunk)) {
     for (let i = aChunk.length - 1; i >= 0; i--) {
       this.prepend(aChunk[i]);
     }
   } else if (aChunk[isSourceNode] || typeof aChunk === "string") {
     this.children.unshift(aChunk);
   } else {
     throw new TypeError(
       "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " +
         aChunk
     );
   }
   return this;
 }

 /**
  * Walk over the tree of JS snippets in this node and its children. The
  * walking function is called once for each snippet of JS and is passed that
  * snippet and the its original associated source's line/column location.
  *
  * @param aFn The traversal function.
  */
 walk(aFn) {
   let chunk;
   for (let i = 0, len = this.children.length; i < len; i++) {
     chunk = this.children[i];
     if (chunk[isSourceNode]) {
       chunk.walk(aFn);
     } else if (chunk !== "") {
       aFn(chunk, {
         source: this.source,
         line: this.line,
         column: this.column,
         name: this.name,
       });
     }
   }
 }

 /**
  * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
  * each of `this.children`.
  *
  * @param aSep The separator.
  */
 join(aSep) {
   let newChildren;
   let i;
   const len = this.children.length;
   if (len > 0) {
     newChildren = [];
     for (i = 0; i < len - 1; i++) {
       newChildren.push(this.children[i]);
       newChildren.push(aSep);
     }
     newChildren.push(this.children[i]);
     this.children = newChildren;
   }
   return this;
 }

 /**
  * Call String.prototype.replace on the very right-most source snippet. Useful
  * for trimming whitespace from the end of a source node, etc.
  *
  * @param aPattern The pattern to replace.
  * @param aReplacement The thing to replace the pattern with.
  */
 replaceRight(aPattern, aReplacement) {
   const lastChild = this.children[this.children.length - 1];
   if (lastChild[isSourceNode]) {
     lastChild.replaceRight(aPattern, aReplacement);
   } else if (typeof lastChild === "string") {
     this.children[this.children.length - 1] = lastChild.replace(
       aPattern,
       aReplacement
     );
   } else {
     this.children.push("".replace(aPattern, aReplacement));
   }
   return this;
 }

 /**
  * Set the source content for a source file. This will be added to the SourceMapGenerator
  * in the sourcesContent field.
  *
  * @param aSourceFile The filename of the source file
  * @param aSourceContent The content of the source file
  */
 setSourceContent(aSourceFile, aSourceContent) {
   this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
 }

 /**
  * Walk over the tree of SourceNodes. The walking function is called for each
  * source file content and is passed the filename and source content.
  *
  * @param aFn The traversal function.
  */
 walkSourceContents(aFn) {
   for (let i = 0, len = this.children.length; i < len; i++) {
     if (this.children[i][isSourceNode]) {
       this.children[i].walkSourceContents(aFn);
     }
   }

   const sources = Object.keys(this.sourceContents);
   for (let i = 0, len = sources.length; i < len; i++) {
     aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
   }
 }

 /**
  * Return the string representation of this source node. Walks over the tree
  * and concatenates all the various snippets together to one string.
  */
 toString() {
   let str = "";
   this.walk(function (chunk) {
     str += chunk;
   });
   return str;
 }

 /**
  * Returns the string representation of this source node along with a source
  * map.
  */
 toStringWithSourceMap(aArgs) {
   const generated = {
     code: "",
     line: 1,
     column: 0,
   };
   const map = new SourceMapGenerator(aArgs);
   let sourceMappingActive = false;
   let lastOriginalSource = null;
   let lastOriginalLine = null;
   let lastOriginalColumn = null;
   let lastOriginalName = null;
   this.walk(function (chunk, original) {
     generated.code += chunk;
     if (
       original.source !== null &&
       original.line !== null &&
       original.column !== null
     ) {
       if (
         lastOriginalSource !== original.source ||
         lastOriginalLine !== original.line ||
         lastOriginalColumn !== original.column ||
         lastOriginalName !== original.name
       ) {
         map.addMapping({
           source: original.source,
           original: {
             line: original.line,
             column: original.column,
           },
           generated: {
             line: generated.line,
             column: generated.column,
           },
           name: original.name,
         });
       }
       lastOriginalSource = original.source;
       lastOriginalLine = original.line;
       lastOriginalColumn = original.column;
       lastOriginalName = original.name;
       sourceMappingActive = true;
     } else if (sourceMappingActive) {
       map.addMapping({
         generated: {
           line: generated.line,
           column: generated.column,
         },
       });
       lastOriginalSource = null;
       sourceMappingActive = false;
     }
     for (let idx = 0, length = chunk.length; idx < length; idx++) {
       if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
         generated.line++;
         generated.column = 0;
         // Mappings end at eol
         if (idx + 1 === length) {
           lastOriginalSource = null;
           sourceMappingActive = false;
         } else if (sourceMappingActive) {
           map.addMapping({
             source: original.source,
             original: {
               line: original.line,
               column: original.column,
             },
             generated: {
               line: generated.line,
               column: generated.column,
             },
             name: original.name,
           });
         }
       } else {
         generated.column++;
       }
     }
   });
   this.walkSourceContents(function (sourceFile, sourceContent) {
     map.setSourceContent(sourceFile, sourceContent);
   });

   return { code: generated.code, map };
 }
}

exports.SourceNode = SourceNode;