rapydscript-ng 0.7.24 → 0.8.1

package/tools/{msgfmt.js → msgfmt.mjs}

@@ -1,10 +1,10 @@
 /* vim:fileencoding=utf-8
- * 
+ *
  * Copyright (C) 2015 Kovid Goyal <kovid at kovidgoyal.net>
  *
  * Distributed under terms of the BSD license
  */
-"use strict";  /*jshint node:true */
+"use strict";
 
 function unesc(string) {
     return string.replace(/\\"/g, '"').replace(/\\n/g, '\n').replace(/\\r/g, '\r').replace(/\\t/g, '\t').replace(/\\\\/g, '\\');
@@ -41,7 +41,7 @@ function parse(data, on_error) {
                 var match = /^nplurals\s*=\s*(\d+)\s*;/.exec(plural_forms);
                 if (!match || match[1] === undefined) fatal('Invalid Plural-Forms header:', plural_forms);
                 nplurals = parseInt(match[1]);
-            } 
+            }
             else if (line.startsWith('Language:')) {
                 language = line.slice('Language:'.length).trim();
             }
@@ -87,7 +87,7 @@ function parse(data, on_error) {
         } else if (line.startsWith('msgid ')) {
             current_entry.msgid = read_string(line.slice('msgid '.length));
             current_entry.lnum = lnum;
-            state = function(line, lines) { 
+            state = function(line, lines) {
                 continuation(line, lines, function(x) { current_entry.msgid += x; }, after_msgid);
             };
         } else {
@@ -98,16 +98,16 @@ function parse(data, on_error) {
     function after_msgid(line, lines) {
         if (line.startsWith('msgid_plural ')) {
             current_entry.msgid_plural = read_string(line.slice('msgid_plural '.length));
-            state = function(line, lines) { 
+            state = function(line, lines) {
                 continuation(line, lines, function(x) { current_entry.msgid_plural += x; }, msgstr);
             };
-        } 
-        
+        }
+
         else if (line.startsWith('msgstr ') || line.startsWith('msgstr[')) {
             state = msgstr;
             msgstr(line, lines);
-        } 
-        
+        }
+
         else fatal('Expecting either msgstr or msgid_plural at line number:', lnum);
 
     }
@@ -116,10 +116,10 @@ function parse(data, on_error) {
         if (line.startsWith('msgstr ')) {
             if (current_entry.msgid_plural !== null) fatal('Expecting msgstr[0] at line number:', lnum);
             current_entry.msgstr.push(read_string(line.slice('msgstr '.length)));
-            state = function(line, lines) { 
+            state = function(line, lines) {
                 continuation(line, lines, function(x) { current_entry.msgstr[current_entry.msgstr.length - 1] += x; }, msgstr);
             };
-        } 
+        }
 
         else if (line[0] === '#' || line.startsWith('msgid ')) {
             if (!current_entry.msgstr.length) fatal('Expecting msgstr at line number:', lnum);
@@ -134,7 +134,7 @@ function parse(data, on_error) {
             if (!pnum || pnum[1] === undefined) fatal('Malformed msgstr at line number:', lnum);
             var idx = parseInt(pnum[1]);
             current_entry.msgstr[idx] = read_string(line.slice(pnum[0].length));
-            state = function(line, lines) { 
+            state = function(line, lines) {
                 continuation(line, lines, function(x) { current_entry.msgstr[idx] += x; }, msgstr);
             };
         }
@@ -159,9 +159,9 @@ function read_stdin(cont) {
     var chunks = [];
     process.stdin.setEncoding('utf8');
 
-    process.stdin.on('readable', function () { 
+    process.stdin.on('readable', function () {
         var chunk = process.stdin.read();
-        if (chunk) chunks.push(chunk); 
+        if (chunk) chunks.push(chunk);
     });
 
     process.stdin.on('end', function() { cont(chunks.join('')); });
@@ -176,12 +176,12 @@ function serialize_catalog(catalog, options) {
     return JSON.stringify({'plural_forms':catalog.plural_forms, 'entries':entries, 'language':catalog.language});
 }
 
-module.exports.cli = function(argv, base_path, src_path, lib_path) {
+export function cli(argv, base_path, src_path, lib_path) {
     read_stdin(function process(data) {
         var catalog = parse(data);
         console.log(serialize_catalog(catalog, argv));
     });
-};
+}
 
-module.exports.parse = parse;
-module.exports.build = function(data, options) { return serialize_catalog(parse(data), options); };
+export { parse };
+export function build(data, options) { return serialize_catalog(parse(data), options); }

package/tools/{repl.js → repl.mjs}

@@ -4,20 +4,26 @@
  *
  * Distributed under terms of the BSD license.
  */
-"use strict";  /*jshint node:true */
-
-var fs = require('fs');
-var path = require('path');
-var vm = require('vm');
-var util = require('util');
-var utils = require('./utils');
-var completelib = require('./completer');
+"use strict";
+
+import fs from 'fs';
+import path from 'path';
+import vm from 'vm';
+import util from 'util';
+import { createRequire } from 'module';
+import * as utils from './utils.mjs';
+import { EMBEDDED_STDLIB_PREFIX } from './compiler.mjs';
+import completelib from './completer.mjs';
+
 var colored = utils.safe_colored;
-var RapydScript = (typeof create_rapydscript_compiler === 'function') ? create_rapydscript_compiler() : require('./compiler').create_compiler();
+var _rapydscript_compiler = typeof create_rapydscript_compiler !== 'undefined' ? create_rapydscript_compiler : globalThis.create_rapydscript_compiler;
 var has_prop = Object.prototype.hasOwnProperty.call.bind(Object.prototype.hasOwnProperty);
 
+// In Node.js ESM context, require is not available; use createRequire.
+var _cjs_require = typeof require !== 'undefined' ? require : createRequire(process.cwd() + '/');
+
 function create_ctx(baselib, show_js, console) {
-    var ctx = vm.createContext({'console':console, 'show_js': !!show_js, 'RapydScript':RapydScript, 'require':require});
+    var ctx = vm.createContext({'console':console, 'show_js': !!show_js, 'RapydScript':null, 'require':_cjs_require});
 	vm.runInContext(baselib, ctx, {'filename':'baselib-plain-pretty.js'});
     vm.runInContext('var __name__ = "__repl__";', ctx);
     return ctx;
@@ -42,40 +48,57 @@ function repl_defaults(options) {
     if (!options.ps1) options.ps1 = '>>> ';
     if (!options.ps2) options.ps2 = '... ';
     if (!options.console) options.console = console;
-    if (!options.readline) options.readline = require('readline');
+    if (!options.readline) options.readline = _cjs_require('readline');
     if (options.terminal === undefined) options.terminal = options.output.isTTY;
     if (options.histfile === undefined) options.histfile = path.join(cachedir, 'rapydscript-repl.history');
-        
+
     options.colored = (options.terminal) ? colored : (function (string) { return string; });
     options.historySize = options.history_size || 1000;
     return options;
 }
 
-function read_history(options) {
+async function read_history(options) {
     if (options.histfile) {
         try {
-            return fs.readFileSync(options.histfile, 'utf-8').split('\n');
+            return (await fs.promises.readFile(options.histfile, 'utf-8')).split('\n');
         } catch (e) { return []; }
     }
+    return [];
 }
 
-function write_history(options, history) {
+async function write_history(options, history) {
     if (options.histfile) {
-        history = history.join('\n');
         try {
-            return fs.writeFileSync(options.histfile, history, 'utf-8');
+            await fs.promises.writeFile(options.histfile, history.join('\n'), 'utf-8');
         } catch (e) {}
     }
 }
 
 
-module.exports = function(options) {
+export default async function(options) {
+    var RapydScript = _rapydscript_compiler();
     options = repl_defaults(options);
     options.completer = completer;
     var rl = options.readline.createInterface(options);
 	var ps1 = options.colored(options.ps1, 'green');
 	var ps2 = options.colored(options.ps2, 'yellow');
-	var ctx = create_ctx(print_ast(RapydScript.parse('(def ():\n yield 1\n)'), true), options.show_js, options.console);
+
+    // Read baselib synchronously: the repl must initialize synchronously so
+    // that the readline interface and prompt are ready before returning.
+    const _embedded = globalThis.__rapydscript_embedded__;
+    var baselib_plain = _embedded?.['baselib-plain-pretty.js'] ??
+        fs.readFileSync(path.join(options.lib_path, 'baselib-plain-pretty.js'), 'utf-8');
+
+    function print_ast(ast, keep_baselib) {
+        var output_options = {omit_baselib:!keep_baselib, write_name:false, private_scope:false, beautify:true, keep_docstrings:true};
+        if (keep_baselib) output_options.baselib_plain = baselib_plain;
+        var output = new RapydScript.OutputStream(output_options);
+        ast.print(output);
+        return output.get();
+    }
+
+	var ctx = create_ctx(print_ast(await RapydScript.parse('(def ():\n yield 1\n)'), true), options.show_js, options.console);
+    ctx.RapydScript = RapydScript;
     var buffer = [];
     var more = false;
     var LINE_CONTINUATION_CHARS = ':\\';
@@ -90,15 +113,6 @@ module.exports = function(options) {
         options.console.log(options.colored('Use show_js=True to have the REPL show the compiled JavaScript before executing it.', 'green', true));
     options.console.log();
 
-    function print_ast(ast, keep_baselib) {
-        var output_options = {omit_baselib:!keep_baselib, write_name:false, private_scope:false, beautify:true, keep_docstrings:true};
-        if (keep_baselib) output_options.baselib_plain = fs.readFileSync(path.join(options.lib_path, 'baselib-plain-pretty.js'), 'utf-8');
-        var output = new RapydScript.OutputStream(output_options);
-        ast.print(output);
-        return output.get();
-    }
-
-
     function resetbuffer() { buffer = []; }
 
     function completer(line) {
@@ -142,14 +156,14 @@ module.exports = function(options) {
         }
     }
 
-    function compile_source(source) {
+    async function compile_source(source) {
         var classes = (toplevel) ? toplevel.classes : undefined;
         var scoped_flags = (toplevel) ? toplevel.scoped_flags: undefined;
         try {
-            toplevel = RapydScript.parse(source, {
+            toplevel = await RapydScript.parse(source, {
                 'filename':'<repl>',
                 'basedir': process.cwd(),
-                'libdir': options.imp_path,
+                'libdir': globalThis.__rapydscript_embedded__ ? EMBEDDED_STDLIB_PREFIX : options.imp_path,
                 'import_dirs': import_dirs,
                 'classes': classes,
                 'scoped_flags': scoped_flags,
@@ -174,33 +188,33 @@ module.exports = function(options) {
         return false;
     }
 
-    function push(line) {
+    async function push(line) {
         buffer.push(line);
         var ll = line.trimRight();
         if (ll && LINE_CONTINUATION_CHARS.indexOf(ll.substr(ll.length - 1)) > -1)
             return true;
         var source = buffer.join('\n');
         if (!source.trim()) { resetbuffer(); return false; }
-        var incomplete = compile_source(source);
+        var incomplete = await compile_source(source);
         if (!incomplete) resetbuffer();
         return incomplete;
     }
 
-	rl.on('line', function(line) {
+	rl.on('line', async function(line) {
         if (more) {
-            // We are in a block 
+            // We are in a block
             var line_is_empty = !line.trimLeft();
             if (line_is_empty && buffer.length && !buffer[buffer.length - 1].trimLeft()) {
                 // We have two empty lines, evaluate the block
-                more = push(line.trimLeft());
+                more = await push(line.trimLeft());
             } else buffer.push(line);
-        } else more = push(line);  // Not in a block, evaluate line
+        } else more = await push(line);  // Not in a block, evaluate line
 		prompt();
 	})
-	
-	.on('close', function() {
+
+	.on('close', async function() {
 		options.console.log('Bye!');
-        if (rl.history) write_history(options, rl.history);
+        if (rl.history) await write_history(options, rl.history);
 		process.exit(0);
 	})
 
@@ -216,6 +230,6 @@ module.exports = function(options) {
 		prompt();
 	});
 
-    rl.history = read_history(options);
+    read_history(options).then(function(history) { rl.history = history; });
 	prompt();
-};
+}

package/tools/{self.js → self.mjs}

@@ -4,25 +4,31 @@
  *
  * Distributed under terms of the BSD license.
  */
-"use strict";  /*jshint node:true */
 
-var path = require('path');
-var crypto = require('crypto');
-var fs = require('fs');
-var vm = require('vm');
-var zlib = require('zlib');
+import path from 'path';
+import crypto from 'crypto';
+import fs from 'fs';
+import vm from 'vm';
+import zlib from 'zlib';
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import { create_compiler } from './compiler.mjs';
 
-function compile_baselib(RapydScript, src_path) {
-    var items = fs.readdirSync(src_path).filter(function(name) {
+const require = createRequire(import.meta.url);
+const __filename = fileURLToPath(import.meta.url);
+
+async function compile_baselib(RapydScript, src_path) {
+    var items = (await fs.promises.readdir(src_path)).filter(function(name) {
         return name.slice(0, 'baselib-'.length) === 'baselib-' && name.slice(-4) == '.pyj';
     });
     var ans = {'pretty': '', 'ugly': ''};
 
-    items.sort().forEach(function(fname) {
+    items.sort();
+    for (const fname of items) {
         var name = fname.slice('baselib-'.length, -4), ast;
-        var raw = fs.readFileSync(path.join(src_path, fname), 'utf-8');
+        var raw = await fs.promises.readFile(path.join(src_path, fname), 'utf-8');
         try {
-            ast = RapydScript.parse(raw, {filename:fname, basedir:src_path});
+            ast = await RapydScript.parse(raw, {filename:fname, basedir:src_path});
         } catch (e) {
             if (!(e instanceof RapydScript.SyntaxError)) throw e;
             console.error(e.toString());
@@ -30,52 +36,56 @@ function compile_baselib(RapydScript, src_path) {
         }
         [true, false].forEach(function (beautify) {
             var output = new RapydScript.OutputStream({
-                beautify: beautify, write_name: false, private_scope:false, omit_baselib: true,  
+                beautify: beautify, write_name: false, private_scope:false, omit_baselib: true,
             });
             ast.print(output);
             ans[(beautify) ? 'pretty' : 'ugly'] += output.get();
         });
-    });
+    }
     return ans;
 }
 
-function check_for_changes(base_path, src_path, signatures) {
+async function check_for_changes(base_path, src_path, signatures) {
     // Check if any of the files involved in the build process have changed,
     // as compared to the saved sha1 hashes from the last build
     var saved_hashes = {}, hashes = {}, sources = {};
     var compiler_changed = false, compiler_hash, source_hash;
     try {
-        saved_hashes = JSON.parse(fs.readFileSync(signatures, 'utf-8'));
+        saved_hashes = JSON.parse(await fs.promises.readFile(signatures, 'utf-8'));
     } catch (e) {
         if (e.code != 'ENOENT') throw (e);
     }
 
     var src_file_names = [];
 
-    function process_dir(p) {
-        fs.readdirSync(p).forEach(function(name) {
+    async function process_dir(p) {
+        var entries = await fs.promises.readdir(p);
+        for (const name of entries) {
             var fp = path.join(p, name);
             if (name.substr(-4) === '.pyj') src_file_names.push(path.relative(src_path, fp));
-            else if (name != 'lib' && fs.statSync(fp).isDirectory()) process_dir(fp);
-        });
+            else if (name != 'lib') {
+                var stat = await fs.promises.stat(fp);
+                if (stat.isDirectory()) await process_dir(fp);
+            }
+        }
     }
-    process_dir(src_path);
+    await process_dir(src_path);
 
     compiler_hash = crypto.createHash('sha1');
     source_hash = crypto.createHash('sha1');
-    src_file_names.forEach(function(fname) {
+    for (const fname of src_file_names) {
         var src = path.join(src_path, fname);
-        sources[src] = fs.readFileSync(src, 'utf-8');
+        sources[src] = await fs.promises.readFile(src, 'utf-8');
         compiler_hash.update(sources[src]);
         source_hash.update(sources[src]);
         var h = crypto.createHash('sha1');
         h.update(sources[src]);
         hashes[fname.split('.')[0]] = h.digest('hex');
-    });
-    var compiler_files = [module.filename, path.join(base_path, 'tools', 'compiler.js')];
-    compiler_files.forEach(function(fpath) { 
-        compiler_hash.update(fs.readFileSync(fpath, 'utf-8'));
-    });
+    }
+    var compiler_files = [__filename, path.join(base_path, 'tools', 'compiler.mjs')];
+    for (const fpath of compiler_files) {
+        compiler_hash.update(await fs.promises.readFile(fpath, 'utf-8'));
+    }
     hashes['#compiler#'] = compiler_hash.digest('hex');
     hashes['#compiled_with#'] = saved_hashes['#compiler#'] || 'unknown';
     source_hash = source_hash.digest('hex');
@@ -91,15 +101,15 @@ function check_for_changes(base_path, src_path, signatures) {
 }
 
 
-function compile(src_path, lib_path, sources, source_hash, profile) {
+async function compile(src_path, lib_path, sources, source_hash, profile) {
     var file = path.join(src_path, 'compiler.pyj');
     var t1 = new Date().getTime();
-    var RapydScript = require('./compiler').create_compiler();
+    var RapydScript = await create_compiler();
     var output_options, profiler, cpu_profile;
-    var compiled_baselib = compile_baselib(RapydScript, src_path);
+    var compiled_baselib = await compile_baselib(RapydScript, src_path);
     var out_path = path.join(path.dirname(lib_path), 'dev');
     try {
-        fs.mkdirSync(out_path);
+        await fs.promises.mkdir(out_path);
     } catch (e) {
         if (e.code != 'EEXIST') throw e;
     }
@@ -107,8 +117,8 @@ function compile(src_path, lib_path, sources, source_hash, profile) {
 
     var raw = sources[file], toplevel;
 
-	function parse_file(code, file) {
-		return RapydScript.parse(code, {
+	async function parse_file(code, file) {
+		return await RapydScript.parse(code, {
 			filename: file,
 			basedir: path.dirname(file),
 			libdir: path.join(src_path, 'lib'),
@@ -120,10 +130,10 @@ function compile(src_path, lib_path, sources, source_hash, profile) {
             profiler = require('v8-profiler');
             profiler.startProfiling();
         }
-        toplevel = parse_file(raw, file);
+        toplevel = await parse_file(raw, file);
         if (profile) {
             cpu_profile = profiler.stopProfiling();
-            fs.writeFileSync('self.cpuprofile', JSON.stringify(cpu_profile), 'utf-8');
+            await fs.promises.writeFile('self.cpuprofile', JSON.stringify(cpu_profile), 'utf-8');
         }
     } catch (e) {
         if (!(e instanceof RapydScript.SyntaxError)) throw e;
@@ -133,30 +143,45 @@ function compile(src_path, lib_path, sources, source_hash, profile) {
     var output = new RapydScript.OutputStream(output_options);
     toplevel.print(output);
     output = output.get().replace('__COMPILER_VERSION__', source_hash);
-    fs.writeFileSync(path.join(out_path, 'compiler.js'), output, "utf8");
-    fs.writeFileSync(path.join(out_path, 'baselib-plain-pretty.js'), compiled_baselib.pretty, 'utf-8');
-    fs.writeFileSync(path.join(out_path, 'baselib-plain-ugly.js'), compiled_baselib.ugly, 'utf-8');
+    await fs.promises.writeFile(path.join(out_path, 'compiler.js'), output, "utf8");
+    await fs.promises.writeFile(path.join(out_path, 'baselib-plain-pretty.js'), compiled_baselib.pretty, 'utf-8');
+    await fs.promises.writeFile(path.join(out_path, 'baselib-plain-ugly.js'), compiled_baselib.ugly, 'utf-8');
     console.log('Compiler built in', (new Date().getTime() - t1)/1000, 'seconds\n');
     return output;
 }
 
-function run_single_compile(base_path, src_path, lib_path, profile) {
+async function run_single_compile(base_path, src_path, lib_path, profile) {
     var out_path = path.join(path.dirname(lib_path), 'dev');
     var signatures = path.join(out_path, 'signatures.json');
-    var temp = check_for_changes(base_path, src_path, signatures);
+    var temp = await check_for_changes(base_path, src_path, signatures);
     var source_hash = temp[0], compiler_changed = temp[1], sources = temp[2], hashes = temp[3];
-    
+
     if (compiler_changed) {
-        compile(src_path, lib_path, sources, source_hash, profile);
-        fs.writeFileSync(signatures, JSON.stringify(hashes, null, 4));
+        await compile(src_path, lib_path, sources, source_hash, profile);
+        await fs.promises.writeFile(signatures, JSON.stringify(hashes, null, 4));
     } else console.log('Compiler is built with the up-to-date version of itself');
     return compiler_changed;
 }
 
-module.exports = function compile_self(base_path, src_path, lib_path, complete, profile) {
+async function write_stdlib_modules(src_path, out_path) {
+    var lib_dir = path.join(src_path, 'lib');
+    var entries = await fs.promises.readdir(lib_dir);
+    var modules = entries
+        .filter(function (name) { return name.slice(-4) === '.pyj'; })
+        .map(function (name) { return name.slice(0, -4); })
+        .sort();
+    await fs.promises.writeFile(
+        path.join(out_path, 'stdlib_modules.json'),
+        JSON.stringify(modules),
+        'utf-8'
+    );
+}
+
+export default async function compile_self(base_path, src_path, lib_path, complete, profile) {
     var changed;
     do {
-        changed = run_single_compile(base_path, src_path, lib_path, profile);
+        changed = await run_single_compile(base_path, src_path, lib_path, profile);
         lib_path = path.join(path.dirname(lib_path), 'dev');
     } while (changed && complete);
-};
+    await write_stdlib_modules(src_path, lib_path);
+}

package/tools/sourcemap.mjs

@@ -0,0 +1,123 @@
+/*
+ * sourcemap.js
+ * Copyright (C) 2015 Kovid Goyal <kovid at kovidgoyal.net>
+ *
+ * Distributed under terms of the BSD license.
+ */
+"use strict";
+
+import path from 'path';
+
+// Base64 VLQ encoding for source maps (see http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/)
+var BASE64_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+var VLQ_BASE_SHIFT = 5;
+var VLQ_BASE = 1 << VLQ_BASE_SHIFT;          // 32
+var VLQ_BASE_MASK = VLQ_BASE - 1;             // 31
+var VLQ_CONTINUATION_BIT = VLQ_BASE;          // 32
+
+function to_vlq_signed(value) {
+    return (value < 0) ? ((-value) << 1) + 1 : (value << 1);
+}
+
+function encode_vlq(value) {
+    var encoded = '';
+    var vlq = to_vlq_signed(value);
+    do {
+        var digit = vlq & VLQ_BASE_MASK;
+        vlq >>>= VLQ_BASE_SHIFT;
+        if (vlq > 0) digit |= VLQ_CONTINUATION_BIT;
+        encoded += BASE64_CHARS[digit];
+    } while (vlq > 0);
+    return encoded;
+}
+
+function encode_segment(fields) {
+    return fields.map(encode_vlq).join('');
+}
+
+// Generate a source map JSON object from an array of segments.
+// Each segment is: [gen_line_0based, gen_col, src_file, src_line_0based, src_col]
+// output_file: the name of the generated JS file
+// source_root: optional prefix for source paths
+function generate_source_map(segments, output_file, source_root) {
+    if (!segments || !segments.length) {
+        return JSON.stringify({
+            version: 3,
+            file: output_file || '',
+            sourceRoot: source_root || '',
+            sources: [],
+            names: [],
+            mappings: ''
+        });
+    }
+
+    // Build sources index
+    var sources_index = {};
+    var sources = [];
+    segments.forEach(function(seg) {
+        var src = seg[2];
+        if (src && !(src in sources_index)) {
+            sources_index[src] = sources.length;
+            sources.push(src);
+        }
+    });
+
+    // Sort segments by generated position
+    var sorted = segments.slice().sort(function(a, b) {
+        if (a[0] !== b[0]) return a[0] - b[0];
+        return a[1] - b[1];
+    });
+
+    // Remove duplicate segments at the same generated position
+    var deduped = [];
+    var prev_gen_line = -1, prev_gen_col = -1;
+    sorted.forEach(function(seg) {
+        if (seg[0] === prev_gen_line && seg[1] === prev_gen_col) return;
+        prev_gen_line = seg[0];
+        prev_gen_col = seg[1];
+        deduped.push(seg);
+    });
+
+    // Find max line
+    var max_line = 0;
+    deduped.forEach(function(seg) { if (seg[0] > max_line) max_line = seg[0]; });
+
+    // Group segments by generated line
+    var by_line = [];
+    for (var i = 0; i <= max_line; i++) by_line.push([]);
+    deduped.forEach(function(seg) { by_line[seg[0]].push(seg); });
+
+    // Encode mappings
+    var prev_src_idx = 0, prev_src_line = 0, prev_src_col = 0;
+    var mappings_lines = by_line.map(function(line_segs) {
+        var prev_col = 0;
+        return line_segs.map(function(seg) {
+            var gen_col = seg[1];
+            var src_idx = sources_index[seg[2]];
+            var src_line = seg[3];
+            var src_col = seg[4];
+            var result = encode_segment([
+                gen_col - prev_col,
+                src_idx - prev_src_idx,
+                src_line - prev_src_line,
+                src_col - prev_src_col
+            ]);
+            prev_col = gen_col;
+            prev_src_idx = src_idx;
+            prev_src_line = src_line;
+            prev_src_col = src_col;
+            return result;
+        }).join(',');
+    });
+
+    return JSON.stringify({
+        version: 3,
+        file: output_file ? path.basename(output_file) : '',
+        sourceRoot: source_root || '',
+        sources: sources,
+        names: [],
+        mappings: mappings_lines.join(';')
+    });
+}
+
+export { generate_source_map };