function forSource(data, sourcePath) { if (! data) { throw new Error('Missing data in SourceMap.forSource'); } if (! sourcePath) { throw new Error('Missing sourcePath in SourceMap.forSource'); } var generator = new SourceMapGenerator({ // FIXME: or just filename? file: path.basename(sourcePath) }); generator.setSourceContent(sourcePath, data); data.split('\n').forEach(function(l, i) { generator.addMapping({ generated: { line: i + 1, column: null }, original: { line: i + 1, column: null }, source: sourcePath }); }); return fromMapObject(generator.toJSON()); }
function mergeMap(oldMap, newMap) { console.log(oldMap); console.log(newMap); var oldMapConsumer = new SM.SourceMapConsumer(oldMap) var newMapConsumer = new SM.SourceMapConsumer(newMap) var mergedMapGenerator = new SM.SourceMapGenerator() console.log(SM.SourceMapGenerator.fromSourceMap(newMapConsumer)._mappings.toArray()) newMapConsumer.eachMapping((m, idx) => { var oldOrigPos = oldMapConsumer.originalPositionFor({line: m.originalLine, column: m.originalColumn}) console.log(idx, m) console.log(idx, oldOrigPos); mergedMapGenerator.addMapping({ generated: { line: m.generatedLine, column: m.generatedColumn }, original: { line: oldOrigPos.line, column: oldOrigPos.column }, source: m.source, name: m.name }) }) mergedMapGenerator.setSourceContent('multi-transform-t-dummy.js', gen2MapFromComment.sourcesContent[0]) return JSON.parse(mergedMapGenerator.toString()) }
function generateMap(mappings, sourceRoot, mapFileBaseName, generatedLineOffset) { var SourceMapGenerator = require('source-map').SourceMapGenerator; var generator = new SourceMapGenerator({ file: mapFileBaseName }); var seenFiles = Object.create(null); for (var generatedLineNumber in mappings) { var generatedLineNumber = parseInt(generatedLineNumber, 10); var mapping = mappings[generatedLineNumber]; var originalFileName = mapping.originalFileName; generator.addMapping({ generated: { line: generatedLineNumber + generatedLineOffset, column: 0 }, original: { line: mapping.originalLineNumber, column: 0 }, source: originalFileName }); // we could call setSourceContent repeatedly, but readFileSync is slow, so // avoid doing it unnecessarily if (!(originalFileName in seenFiles)) { seenFiles[originalFileName] = true; var rootedPath = originalFileName[0] === path.sep ? originalFileName : path.join(sourceRoot, originalFileName); try { generator.setSourceContent(originalFileName, fs.readFileSync(rootedPath, 'utf-8')); } catch (e) { console.warn("sourcemapper: Unable to find original file for " + originalFileName + " at " + rootedPath); } } } fs.writeFileSync(mapFileBaseName + '.map', generator.toString()); }
function getMap(fileName, sourceName, originalSource, generatedSource, options) { var map = new sourceMap.SourceMapGenerator({ file: fileName }); var defineToken = "define(["; var commentMatcher = matcher.getComment(isFileCoffee(fileName)); var commentMatch = commentMatcher.exec(originalSource); var commentEndIndex = commentMatch.index + commentMatch[0].length; var orgCoords = getCoordinates(originalSource, commentEndIndex); var genCoords = getCoordinates(generatedSource, defineToken); var offset = orgCoords.line - (genCoords.line + 1); var lineCount = generatedSource.split(/\r?\n/).length; for (var i = genCoords.line + 1; i < lineCount; i++) { map.addMapping({ original: { line: i + offset, column: 1 }, generated: { line: i, column: 1 + getIndent(options).length, }, source: sourceName }); } return map.toString(); }
export function concatenate(sourceMaps, offsets) { var generator = new SourceMapGenerator() var consumers = sourceMaps.map(sourceMap => new SourceMapConsumer(sourceMap)) // TODO: look for content collisions in consumers? consumers.forEach((consumer, sourceMapIdx) => { consumer.sourcesContent.forEach((content, i) => { generator.setSourceContent(consumer.sources[i], content) }) var offset = offsets[sourceMapIdx] consumer.eachMapping(mapping => { generator.addMapping({ generated: { line: mapping.generatedLine + offset, column: mapping.generatedColumn }, original: { line: mapping.originalLine, column: mapping.originalColumn }, source: mapping.source, name: mapping.name }) }) }) return generator.toJSON() }
function genSourceMap(modules) { var sourceMapGen = new SourceMapGenerator({file: 'bundle.js', version: 3}); var bundleLineNo = 0; for (var i = 0; i < modules.length; i++) { var module = modules[i]; var transformedCode = module.code; var sourcePath = module.sourcePath; var sourceCode = module.sourceCode; var transformedLineCount = 0; var lastCharNewLine = false; for (var t = 0; t < transformedCode.length; t++) { if (t === 0 || lastCharNewLine) { sourceMapGen.addMapping({ generated: {line: bundleLineNo + 1, column: 0}, original: {line: transformedLineCount + 1, column: 0}, source: sourcePath }); } lastCharNewLine = transformedCode[t] === '\n'; if (lastCharNewLine) { transformedLineCount++; bundleLineNo++; } } bundleLineNo++; sourceMapGen.setSourceContent( sourcePath, sourceCode ); } return sourceMapGen.toJSON(); }
_.each(argv, function(filename) { // Read the file content. var source = getFileContents(filename); if(filename.match(literateExtension)) { // Strip out the Markdown. source = source.match(/^ {4,}.+$/mg).join('\n').replace(/^ {4}/gm, ''); } else { console.assert(filename.match(extensions), 'Filename must end with ".roy" or ".lroy"'); } exported = {}; var outputPath = filename.replace(extensions, '.js'); var SourceMapGenerator = require('source-map').SourceMapGenerator; var sourceMap = new SourceMapGenerator({file: path.basename(outputPath)}); var compiled = compile(source, env, aliases, { nodejs: !browserModules, filename: filename, run: run, exported: exported, sourceMap: sourceMap }); if(run) { // Execute the JavaScript output. output = vm.runInNewContext(compiled.output, sandbox, 'eval'); } else { // Write the JavaScript output. fs.writeFile(outputPath, compiled.output + '//@ sourceMappingURL=' + path.basename(outputPath) + '.map\n', 'utf8'); fs.writeFile(outputPath + '.map', sourceMap.toString(), 'utf8'); writeModule(env, exported, filename.replace(extensions, '.roym')); } });
function patchSourcemap(patches, rsm, smc) { var smg = new sm.SourceMapGenerator({ file: rsm.file, sourceRoot: rsm.sourceRoot }); patches = patches.reverse(); var currentLine = -1; var currentLineDiff = 0; var source = null; smc.eachMapping(function (m) { var patch = patches[patches.length - 1]; var original = { line: m.originalLine, column: m.originalColumn }; var generated = { line: m.generatedLine, column: m.generatedColumn }; if (currentLine !== generated.line) { currentLineDiff = 0; } currentLine = generated.line; generated.column += currentLineDiff; if (patch && m.generatedLine - 1 === patch.span.end.line && m.generatedColumn === patch.span.end.character) { var originalLength = patch.span.end.character - patch.span.start.character; var modifiedLength = patch.content.length; var lengthDiff = modifiedLength - originalLength; currentLineDiff += lengthDiff; generated.column += lengthDiff; patches.pop(); } source = rsm.sourceRoot ? path.relative(rsm.sourceRoot, m.source) : m.source; source = source.replace(/\\/g, '/'); smg.addMapping({ source: source, name: m.name, original: original, generated: generated }); }, null, sm.SourceMapConsumer.GENERATED_ORDER); if (source) { smg.setSourceContent(source, smc.sourceContentFor(source)); } return JSON.parse(smg.toString()); }
it('generates source map', () => { const generator = new SourceMapGenerator({ file: 'test.html' }) generator.addMapping({ source: 'test.html', original: { line: 1, column: 0 }, generated: { line: 1, column: 0 } }) const map = JSON.parse(generator.toString()) const b = new Builder() b.addLine('var a = "a"') b.addLine('var render = function () { return "test" }', map) b.addLine('var b = "b"') const result = b.generate() const smc = new SourceMapConsumer(result.map) expect(result.code).toBe(code([ 'var a = "a"', 'var render = function () { return "test" }', 'var b = "b"' ])) let pos = smc.originalPositionFor({ line: 2, column: 0 }) expect(pos.source).toBe('test.html') expect(pos.line).toBe(1) expect(pos.column).toBe(0) pos = smc.originalPositionFor({ line: 3, column: 0 }) expect(pos.source).toBe(null) expect(pos.line).toBe(null) expect(pos.column).toBe(null) })
test('parsing generated one to one mappings with last line having no original', function (t) { var gen = new Generator({ file: 'foo.js' }) var add = [ { generated: { line: 1, column: 0 }, original: { line: 1, column: 0 }, source: 'foo.js', name: null }, { generated: { line: 2, column: 0 }, original: { line: 2, column: 0 }, source: 'foo.js', name: null }, { generated: { line: 3, column: 0 }, original: { line: 3, column: 0 }, source: 'foo.js', name: null }, { generated: { line: 4, column: 0 }, original: { line: 4, column: 0 }, source: 'foo.js', name: null }, { generated: { line: 5, column: 0 }, original: { line: 5, column: 0 }, source: 'foo.js', name: null }, { generated: { line: 6, column: 0 } } ] add.forEach(gen.addMapping.bind(gen)) var addedMappings = add.map(function (m) { return m.original ? { generated: m.generated, original: m.original } : { generated: m.generated } }) var mappings = gen.toJSON().mappings , parsed = parse(mappings) t.deepEqual(parsed, addedMappings, 'parses out added mappings') });
Context.prototype.createSourceMapObject = function (obj) { var map; if (obj.map) { map = JSON.parse(obj.map); map.sourceRoot = ''; return map; } var name = path.basename(obj.file); var smg = new sourcemap.SourceMapGenerator({ file: name }); obj.data.split('\n').forEach(function (line, idx) { smg.addMapping({ source: name, original: { line: idx + 1, column: 0 }, generated: { line: idx + 1, column: 0 } }); }); smg.setSourceContent(name, obj.data); map = smg.toJSON(); map.sourceRoot = ''; return map; };
secret.mappings.forEach(function(mapping) { var sourceCursor = mapping.sourceLines.skipSpaces(mapping.sourceLoc.start) || mapping.sourceLines.lastPos(); var targetCursor = targetLines.skipSpaces(mapping.targetLoc.start) || targetLines.lastPos(); while (comparePos(sourceCursor, mapping.sourceLoc.end) < 0 && comparePos(targetCursor, mapping.targetLoc.end) < 0) { var sourceChar = mapping.sourceLines.charAt(sourceCursor); var targetChar = targetLines.charAt(targetCursor); assert.strictEqual(sourceChar, targetChar); var sourceName = mapping.sourceLines.name; smg.addMapping({ source: sourceName, original: { line: sourceCursor.line, column: sourceCursor.column }, generated: { line: targetCursor.line, column: targetCursor.column } }); if (!hasOwn.call(sourcesToContents, sourceName)) { var sourceContent = mapping.sourceLines.toString(); smg.setSourceContent(sourceName, sourceContent); sourcesToContents[sourceName] = sourceContent; } targetLines.nextPos(targetCursor, true); mapping.sourceLines.nextPos(sourceCursor, true); } });
function mergeSourceMaps( file, originalMap, secondMap) { const merged = new sourceMap.SourceMapGenerator(); const inputMap = new sourceMap.SourceMapConsumer(originalMap); new sourceMap.SourceMapConsumer(secondMap). eachMapping(mapping => { const original = inputMap.originalPositionFor({ line: mapping.originalLine, column: mapping.originalColumn }); if (original.line == null) { return; } merged.addMapping({ generated: { line: mapping.generatedLine, column: mapping.generatedColumn }, original: { line: original.line, column: original.column || 0 }, source: file, name: original.name || mapping.name }); }); return merged.toJSON(); }
function generateCss(sourcePath, fileContent) { var generator = new SourceMapGenerator({ file: sourcePath }); var ast = css.parse(fileContent, { silent: true }); function registerTokens(ast) { if (ast.position) { generator.addMapping({ original: ast.position.start, generated: ast.position.start, source: sourcePath, }); } for (var key in ast) { if (key === 'position' || !ast[key]) { break; } if (Object.prototype.toString.call(ast[key]) === '[object Object]') { registerTokens(ast[key]); } else if (Array.isArray(ast[key])) { ast[key].forEach(registerTokens); } } } registerTokens(ast); generator.setSourceContent(sourcePath, fileContent); return generator.toJSON(); }
return function* (next) { var fileType = (this.url.match(/\.(js)$/) || [])[1]; var file, content; if (fileType === 'js') { var yiminghe = this.yiminghe = this.yiminghe || {}; file = path.join(dir, this.url); content = this.body; if (!content) { var json = 0; if (!fs.existsSync(file)) { if (util.endsWith(file, '.json.js')) { file = file.slice(0, -3); json = 1; } } if (!fs.existsSync(file)) { return yield *next; } content = fs.readFileSync(file, 'utf-8'); yiminghe.source = content; if (json) { content = 'module.exports = ' + content + ';'; } } if (!option.nowrap || !option.nowrap.call(this)) { content = modularizeUtils.completeRequire(file, content, option); var leading = 'define(function (require, exports, module) {'; // no \n does not change file no var contents = content.split(/\n/); var map = new SourceMap.SourceMapGenerator({ file: 'source-mapped.js.map' }); for (var i = 0; i < contents.length; i++) { map.addMapping({ generated: { line: i + 1, column: 0 }, original: { line: i + 1, column: 0 }, source: this.url }); } yiminghe.sourceMaps = yiminghe.sourceMaps || []; // plain json yiminghe.sourceMaps.push(map.toJSON()); content = leading + content + '\n});'; } this.set('Content-Type', 'application/javascript;charset=utf-8'); this.set('Content-Length', Buffer.byteLength(content)); this.body = content; if (option.next && option.next.call(this)) { yield *next; } } else { yield *next; } };
function createDummySourceMap(tokens, options) { options = options || {} if (typeof tokens === "string") { switch (options.type) { case "js": tokens = tokens.match(jsTokens) break case "css": tokens = tokens.match(cssTokens) break default: throw new Error("If you pass in a string, you must set `options.type` to either " + "`js` or `css`. Got: " + options.type) } } else if (!Array.isArray(tokens)) { throw new Error("Either an array of tokens, or a string of JavaScript or CSS is required. " + "Got: " + tokens) } if (!options.source) { throw new Error("`options.source` is required. Got: " + options.source) } var map = new sourceMap.SourceMapGenerator({ file: path.basename(options.source) }) var line = 1 var column = 0 tokens.forEach(function(token) { if (!blank.test(token)) { map.addMapping({ generated: { line: line, column: column }, original: { line: line, column: column }, source: options.source }) } var lines = token.split(newline) var lastLine = lines.pop() var addedLines = lines.length if (addedLines) { line += addedLines column = lastLine.length } else { column += lastLine.length } }) return map.toJSON() }
var makeSourceMapGenerator = function makeSourceMapGenerator(file) { var filename = file.sourceFileName; var generator = new _sourceMap.SourceMapGenerator({ file: filename, sourceRoot: file.sourceRoot }); generator.setSourceContent(filename, file.code); return generator; };
function createSourceMap() { var map = new sourceMap.SourceMapGenerator({ file: 'forVisual.css' }); map.addMapping({ generated: { line: 2, column: 7 }, source: 'forVisual.original.css', original: { line: 102, column: 107 }, }); return map; }
function createSourceMap({ source, mappings, code }) { const generator = new SourceMapGenerator({ file: source.url }); mappings.forEach(mapping => generator.addMapping(mapping)); generator.setSourceContent(source.url, code); let consumer = SourceMapConsumer.fromSourceMap(generator); _setConsumer(source, consumer); return generator.toJSON(); }
export function makeSourceMapGenerator(file) { const filename = file.opts.sourceFileName const generator = new SourceMapGenerator({ file: filename, sourceRoot: file.opts.sourceRoot }) generator.setSourceContent(filename, file.code) return generator }
function makeSourceMapGenerator(file) { var generatorOpts = getGeneratorOpts(file); var filename = generatorOpts.sourceFileName; var generator = new SourceMapGenerator({ file: filename, sourceRoot: generatorOpts.sourceRoot }); generator.setSourceContent(filename, file.code); return generator; }
function withSourceMap(src, compiled, name, options) { //return compiled; var compiledLines = compiled.split('\n'); var generator = new SourceMapGenerator({file: name + '.js'}); var runTemplateSuffix = ''; if (options.runTemplate) { options.locals = options.locals || {}; if (options.urlPrefix) { options.locals.staticUrl = _staticUrl(options.filename, options.urlPrefix, options.__dirname); } runTemplateSuffix = "({staticUrl:"+options.locals.staticUrl+"})"; } compiledLines.forEach(function(l, lineno) { var m = l.match(/^jade(_|\.)debug\.unshift\(\{ lineno: ([0-9]+)/); if (m) { var originalLine = Number(m[2]); var generatedLine = lineno + 2; if (originalLine > 0) { generator.addMapping({ generated: { line: generatedLine, column: 0 }, source: name, original: { line: originalLine, column: 0 } }); } } var debugRe = /jade(_|\.)debug\.(shift|unshift)\([^)]*\);?/; var match; while(match = l.match(debugRe)) { l = replaceMatchWith(match, ''); } compiledLines[lineno] =l; }); generator.setSourceContent(name, src); var map = convert.fromJSON(generator.toString()); compiledLines.push(SUFFIX); compiledLines.push(runTemplateSuffix); compiledLines.push(map.toComment()); return compiledLines.join('\n'); }
Lp.getSourceMap = function(sourceMapName, sourceRoot) { if (!sourceMapName) { return null; } var targetLines = this; function updateJSON(json) { json = json || {}; isString.assert(sourceMapName); json.file = sourceMapName; if (sourceRoot) { isString.assert(sourceRoot); json.sourceRoot = sourceRoot; } return json; } var secret = getSecret(targetLines); if (secret.cachedSourceMap) { return updateJSON(secret.cachedSourceMap.toJSON()); } var smg = new sourceMap.SourceMapGenerator(updateJSON()); var sourcesToContents = {}; secret.mappings.forEach(function(mapping) { var sourceCursor = mapping.sourceLines.skipSpaces(mapping.sourceLoc.start) || mapping.sourceLines.lastPos(); var targetCursor = targetLines.skipSpaces(mapping.targetLoc.start) || targetLines.lastPos(); while (comparePos(sourceCursor, mapping.sourceLoc.end) < 0 && comparePos(targetCursor, mapping.targetLoc.end) < 0) { var sourceChar = mapping.sourceLines.charAt(sourceCursor); var targetChar = targetLines.charAt(targetCursor); assert.strictEqual(sourceChar, targetChar); var sourceName = mapping.sourceLines.name; smg.addMapping({ source: sourceName, original: { line: sourceCursor.line, column: sourceCursor.column }, generated: { line: targetCursor.line, column: targetCursor.column } }); if (!hasOwn.call(sourcesToContents, sourceName)) { var sourceContent = mapping.sourceLines.toString(); smg.setSourceContent(sourceName, sourceContent); sourcesToContents[sourceName] = sourceContent; } targetLines.nextPos(targetCursor, true); mapping.sourceLines.nextPos(sourceCursor, true); } }); secret.cachedSourceMap = smg; return smg.toJSON(); };
function xform(mapping) { var generator = new sourceMap.SourceMapGenerator({ file: "foo.js", sourceRoot: "http://example.com/" }); generator.addMapping(mapping); babel.transform("a=1", { sourceMaps: true, inputSourceMap: JSON.parse(generator.toString()), }); }
const getOldSourceMap = (mappings, { sourceRoot, source, file }) => { const oldSourceMap = new sourceMap.SourceMapGenerator({ file, sourceRoot }); mappings.forEach(mapping => { mapping.source = source; oldSourceMap.addMapping(mapping); }); return oldSourceMap.toJSON(); };
function applySourceMap( generatedId: string, url: string, code: string, mappings: Object ) { const generator = new SourceMapGenerator({ file: url }); mappings.forEach(mapping => generator.addMapping(mapping)); generator.setSourceContent(url, code); const map = createConsumer(generator.toJSON()); setSourceMap(generatedId, Promise.resolve(map)); }
exports.concatenateSourceMaps = function(sourceFilename, mapsWithOffsets, outPath) { var generated = new sourceMap.SourceMapGenerator({ file: sourceFilename }); mapsWithOffsets.forEach(function(pair) { var offset = pair[0]; var mapSource = pair[1]; var map; try { map = JSON.parse(mapSource); } catch (error) { throw new Error(mapSource + ": Invalid JSON"); } // this is odd, sourceRoot is redundant (and causes doubling) map.sourceRoot = ''; wrapSourceMap(map).eachMapping(function(mapping) { if (mapping.source.match(/^@traceur/)) { return; } generated.addMapping({ generated: { line: offset + mapping.generatedLine, column: mapping.generatedColumn }, original: { line: mapping.originalLine, column: mapping.originalColumn }, source: mapping.source }); originalLastLine = mapping.generatedLine; }); }); if (outPath) { // convert from library internals format to canonical var normalized = JSON.parse(JSON.stringify(generated)); // convert paths to relative normalized.sources = normalized.sources.map(function(source) { return path.relative(outPath, source); }); return JSON.stringify(normalized); } return generated.toString(); };
function withSourceMap(src, compiled, name) { var compiledLines = compiled.split('\n'); var generator = new SourceMapGenerator({file: name + '.js'}); compiledLines.forEach(function(l, lineno) { var m = l.match(/^jade(_|\.)debug\.unshift\(new jade\.DebugItem\( ([0-9]+)/); // Check for older jade debug line format if (!m) m = l.match(/^(pug|jade)(_|\.)debug\.unshift\(\{ lineno: ([0-9]+)/); if (m) { var originalLine = Number(m[2]); var generatedLine = lineno + 2; if (originalLine > 0) { generator.addMapping({ generated: { line: generatedLine, column: 0 }, source: name, original: { line: originalLine, column: 0 } }); } } var debugRe = /(pug|jade)(_|\.)debug\.(shift|unshift)\([^;]*\);/; var match; while(match = l.match(debugRe)) { l = replaceMatchWith(match, ''); } compiledLines[lineno] =l; }); // Remove jade debug lines at beginning and end of compiled version if (/var jade_debug = /.test(compiledLines[1])) compiledLines[1] = ''; if (/try \{/.test(compiledLines[2])) compiledLines[2] = ''; var l = compiledLines.length; if (/\} catch \(err\) \{/.test(compiledLines[l-4])) { compiledLines[l-2] = compiledLines[l-3] = compiledLines[l-4] = ''; } generator.setSourceContent(name, src); var map = convert.fromJSON(generator.toString()); compiledLines.push(map.toComment()); return compiledLines.join('\n'); }
export default function generate(pundle: Pundle, contents: Array<File>, requires: Array<string>, givenConfig: Object) { let lines = 0 const config = Helpers.fillConfig(givenConfig) const output = [] const sourceMap = new SourceMapGenerator({ skipValidation: true, }) if (config.wrapper === 'normal') { output.push(WrapperNormal) lines += Helpers.getLinesCount(WrapperNormal) } else if (config.wrapper === 'hmr') { output.push(WrapperHMR) lines += Helpers.getLinesCount(WrapperHMR) } else { lines = 1 } for (const file of (contents: Array<File>)) { const fileContents = file.contents.trim() const entry = `__sb_pundle_register('${pundle.getUniquePathID(file.filePath)}', function(module, exports) {\n${fileContents}\n});` output.push(entry) if (!config.sourceMap) { continue } const entryPath = file.filePath.replace('$root', `$${config.projectName}`) const entryMap = new SourceMapConsumer(file.sourceMap) for (const mapping of entryMap._generatedMappings) { sourceMap.addMapping({ source: entryPath, original: { line: mapping.originalLine, column: mapping.originalColumn }, generated: { line: lines + mapping.generatedLine, column: mapping.generatedColumn }, }) } lines += Helpers.getLinesCount(fileContents) lines ++ sourceMap.setSourceContent(entryPath, file.source) } for (const entry of (requires: Array<string>)) { output.push(`__require('${pundle.getUniquePathID(entry)}')`) } return { contents: output.join(''), sourceMap: config.sourceMap ? sourceMap.toJSON() : null, } }
function() { var inFile = grunt.file.read(this.data.source); var inMap = grunt.file.read(this.data.source + '.map'); var inLines = inFile.split('\n'); var i = 0; // Discover copyright header while (inLines[i].length < 2 || inLines[i].substring(0, 2) == '//') { i++; } // Fix mapping footer var postamble = this.data.postamble; if (inLines[inLines.length - 1].substring(0, 21) == '//# sourceMappingURL=') { postamble += '\n//# sourceMappingURL=' + this.target + '.map'; } if (i > 0) { var banner = inLines.slice(0, i).join('\n') + '\n'; } else { var banner = ''; } var source = inLines.slice(i, inLines.length - 1).join('\n'); grunt.file.write(this.target, banner + this.data.preamble + source + postamble); var preLines = this.data.preamble.split('\n'); var lineDelta = preLines.length; if (this.data.preamble[this.data.preamble.length - 1] == '\n') { var charDelta = 0; } else { var charDelta = preLines[lineDelta - 1].length; lineDelta -= 1; } var inMapConsumer = new sourceMap.SourceMapConsumer(inMap); var outMapGenerator = new sourceMap.SourceMapGenerator({file: this.target}); inMapConsumer.eachMapping(function(mapping) { if (mapping.generatedLine == i + 1) { mapping.generatedColumn += charDelta; } mapping.generatedLine += lineDelta; outMapGenerator.addMapping( {generated: {line: mapping.generatedLine, column: mapping.generatedColumn}, original: {line: mapping.originalLine, column: mapping.originalColumn}, source: mapping.source, name: mapping.name}); }); grunt.file.write(this.target + '.map', outMapGenerator.toString()); });