webruby 0.1.0

data/modules/emscripten/tools/js_optimizer.py

@@ -0,0 +1,341 @@
+
+import os, sys, subprocess, multiprocessing, re, string, json
+import shared
+
+configuration = shared.configuration
+temp_files = configuration.get_temp_files()
+
+__rootpath__ = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
+def path_from_root(*pathelems):
+  return os.path.join(__rootpath__, *pathelems)
+
+JS_OPTIMIZER = path_from_root('tools', 'js-optimizer.js')
+
+NUM_CHUNKS_PER_CORE = 1.5
+MIN_CHUNK_SIZE = int(os.environ.get('EMCC_JSOPT_MIN_CHUNK_SIZE') or 1024*1024) # configuring this is just for debugging purposes
+MAX_CHUNK_SIZE = 20*1024*1024
+
+WINDOWS = sys.platform.startswith('win')
+
+DEBUG = os.environ.get('EMCC_DEBUG')
+
+func_sig = re.compile('( *)function ([_\w$]+)\(')
+import_sig = re.compile('var ([_\w$]+) *=[^;]+;')
+
+class Minifier:
+  '''
+    asm.js minification support. We calculate possible names and minification of
+    globals here, then pass that into the parallel js-optimizer.js runners which
+    during registerize perform minification of locals.
+  '''
+
+  def __init__(self, js, js_engine):
+    self.js = js
+    self.js_engine = js_engine
+
+    # Create list of valid short names
+
+    MAX_NAMES = 80000
+    INVALID_2 = set(['do', 'if', 'in'])
+    INVALID_3 = set(['for', 'new', 'try', 'var', 'env', 'let'])
+
+    self.names = []
+    init_possibles = string.ascii_letters + '_$'
+    later_possibles = init_possibles + string.digits
+    for a in init_possibles:
+      if len(self.names) >= MAX_NAMES: break
+      self.names.append(a)
+    for a in init_possibles:
+      for b in later_possibles:
+        if len(self.names) >= MAX_NAMES: break
+        curr = a + b
+        if curr not in INVALID_2: self.names.append(curr)
+    for a in init_possibles:
+      for b in later_possibles:
+        for c in later_possibles:
+          if len(self.names) >= MAX_NAMES: break
+          curr = a + b + c
+          if curr not in INVALID_3: self.names.append(curr)
+    #print >> sys.stderr, self.names
+
+  def minify_shell(self, shell, minify_whitespace, source_map=False):
+    #print >> sys.stderr, "MINIFY SHELL 1111111111", shell, "\n222222222222222"
+    # Run through js-optimizer.js to find and minify the global symbols
+    # We send it the globals, which it parses at the proper time. JS decides how
+    # to minify all global names, we receive a dictionary back, which is then
+    # used by the function processors
+
+    shell = shell.replace('0.0', '13371337') # avoid uglify doing 0.0 => 0
+
+    # Find all globals in the JS functions code
+    self.globs = [m.group(2) for m in func_sig.finditer(self.js)]
+
+    temp_file = temp_files.get('.minifyglobals.js').name
+    f = open(temp_file, 'w')
+    f.write(shell)
+    f.write('\n')
+    f.write('// EXTRA_INFO:' + self.serialize())
+    f.close()
+
+    output = subprocess.Popen(self.js_engine +
+        [JS_OPTIMIZER, temp_file, 'minifyGlobals', 'noPrintMetadata'] +
+        (['minifyWhitespace'] if minify_whitespace else []) +
+        (['--debug'] if source_map else []),
+        stdout=subprocess.PIPE).communicate()[0]
+
+    assert len(output) > 0 and not output.startswith('Assertion failed'), 'Error in js optimizer: ' + output
+    #print >> sys.stderr, "minified SHELL 3333333333333333", output, "\n44444444444444444444"
+    code, metadata = output.split('// EXTRA_INFO:')
+    self.globs = json.loads(metadata)
+    return code.replace('13371337', '0.0')
+
+
+  def serialize(self):
+    return json.dumps({
+      'names': self.names,
+      'globals': self.globs
+    })
+
+start_funcs_marker = '// EMSCRIPTEN_START_FUNCS\n'
+end_funcs_marker = '// EMSCRIPTEN_END_FUNCS\n'
+start_asm_marker = '// EMSCRIPTEN_START_ASM\n'
+end_asm_marker = '// EMSCRIPTEN_END_ASM\n'
+
+def run_on_chunk(command):
+  filename = command[2] # XXX hackish
+  #print >> sys.stderr, 'running js optimizer command', ' '.join(command), '""""', open(filename).read()
+  output = subprocess.Popen(command, stdout=subprocess.PIPE).communicate()[0]
+  assert len(output) > 0 and not output.startswith('Assertion failed'), 'Error in js optimizer: ' + output
+  filename = temp_files.get(os.path.basename(filename) + '.jo.js').name
+  f = open(filename, 'w')
+  f.write(output)
+  f.close()
+  if DEBUG and not shared.WINDOWS: print >> sys.stderr, '.' # Skip debug progress indicator on Windows, since it doesn't buffer well with multiple threads printing to console.
+  return filename
+
+def run_on_js(filename, passes, js_engine, jcache, source_map=False, extra_info=None):
+  if isinstance(jcache, bool) and jcache: jcache = shared.JCache
+  if jcache: shared.JCache.ensure()
+
+  if type(passes) == str:
+    passes = [passes]
+
+  js = open(filename).read()
+  if os.linesep != '\n':
+    js = js.replace(os.linesep, '\n') # we assume \n in the splitting code
+
+  # Find suffix
+  suffix_marker = '// EMSCRIPTEN_GENERATED_FUNCTIONS'
+  suffix_start = js.find(suffix_marker)
+  suffix = ''
+  if suffix_start >= 0:
+    suffix_end = js.find('\n', suffix_start)
+    suffix = js[suffix_start:suffix_end] + '\n'
+    # if there is metadata, we will run only on the generated functions. If there isn't, we will run on everything.
+    generated = set(eval(suffix[len(suffix_marker)+1:]))
+
+  # Find markers
+  start_funcs = js.find(start_funcs_marker)
+  end_funcs = js.rfind(end_funcs_marker)
+
+  know_generated = suffix or start_funcs >= 0
+
+  minify_globals = 'registerizeAndMinify' in passes and 'asm' in passes
+  if minify_globals:
+    passes = map(lambda p: p if p != 'registerizeAndMinify' else 'registerize', passes)
+    start_asm = js.find(start_asm_marker)
+    end_asm = js.rfind(end_asm_marker)
+    assert (start_asm >= 0) == (end_asm >= 0)
+
+  closure = 'closure' in passes
+  if closure:
+    passes = filter(lambda p: p != 'closure', passes) # we will do it manually
+
+  if not know_generated and jcache:
+    # JCache cannot be used without metadata, since it might reorder stuff, and that's dangerous since only generated can be reordered
+    # This means jcache does not work after closure compiler runs, for example. But you won't get much benefit from jcache with closure
+    # anyhow (since closure is likely the longest part of the build).
+    if DEBUG: print >>sys.stderr, 'js optimizer: no metadata, so disabling jcache'
+    jcache = False
+
+  if know_generated:
+    if not minify_globals:
+      pre = js[:start_funcs + len(start_funcs_marker)]
+      post = js[end_funcs + len(end_funcs_marker):]
+      js = js[start_funcs + len(start_funcs_marker):end_funcs]
+      if 'asm' not in passes: # can have Module[..] and inlining prevention code, push those to post
+        class Finals:
+          buf = []
+        def process(line):
+          if len(line) > 0 and (line.startswith(('Module[', 'if (globalScope)')) or line.endswith('["X"]=1;')):
+            Finals.buf.append(line)
+            return False
+          return True
+        js = '\n'.join(filter(process, js.split('\n')))
+        post = '\n'.join(Finals.buf) + '\n' + post
+      post = end_funcs_marker + post
+    else:
+      # We need to split out the asm shell as well, for minification
+      pre = js[:start_asm + len(start_asm_marker)]
+      post = js[end_asm:]
+      asm_shell = js[start_asm + len(start_asm_marker):start_funcs + len(start_funcs_marker)] + '''
+EMSCRIPTEN_FUNCS();
+''' + js[end_funcs + len(end_funcs_marker):end_asm + len(end_asm_marker)]
+      js = js[start_funcs + len(start_funcs_marker):end_funcs]
+
+      minifier = Minifier(js, js_engine)
+      asm_shell_pre, asm_shell_post = minifier.minify_shell(asm_shell, 'minifyWhitespace' in passes, source_map).split('EMSCRIPTEN_FUNCS();');
+      asm_shell_post = asm_shell_post.replace('});', '})');
+      pre += asm_shell_pre + '\n' + start_funcs_marker
+      post = end_funcs_marker + asm_shell_post + post
+
+      minify_info = minifier.serialize()
+      #if DEBUG: print >> sys.stderr, 'minify info:', minify_info
+    # remove suffix if no longer needed
+    if suffix and 'last' in passes:
+      suffix_start = post.find(suffix_marker)
+      suffix_end = post.find('\n', suffix_start)
+      post = post[:suffix_start] + post[suffix_end:]
+
+  else:
+    pre = ''
+    post = ''
+
+  # Pick where to split into chunks, so that (1) they do not oom in node/uglify, and (2) we can run them in parallel
+  # If we have metadata, we split only the generated code, and save the pre and post on the side (and do not optimize them)
+  parts = map(lambda part: part, js.split('\n}\n'))
+  funcs = []
+  for i in range(len(parts)):
+    func = parts[i]
+    if i < len(parts)-1: func += '\n}\n' # last part needs no }
+    m = func_sig.search(func)
+    if m:
+      ident = m.group(2)
+    else:
+      if know_generated: continue # ignore whitespace
+      ident = 'anon_%d' % i
+    assert ident
+    funcs.append((ident, func))
+  parts = None
+  total_size = len(js)
+  js = None
+
+  # if we are making source maps, we want our debug numbering to start from the
+  # top of the file, so avoid breaking the JS into chunks
+  cores = 1 if source_map else int(os.environ.get('EMCC_CORES') or multiprocessing.cpu_count())
+  intended_num_chunks = int(round(cores * NUM_CHUNKS_PER_CORE))
+  chunk_size = min(MAX_CHUNK_SIZE, max(MIN_CHUNK_SIZE, total_size / intended_num_chunks))
+
+  chunks = shared.chunkify(funcs, chunk_size, jcache.get_cachename('jsopt') if jcache else None)
+
+  if jcache:
+    # load chunks from cache where we can # TODO: ignore small chunks
+    cached_outputs = []
+    def load_from_cache(chunk):
+      keys = [chunk]
+      shortkey = shared.JCache.get_shortkey(keys) # TODO: share shortkeys with later code
+      out = shared.JCache.get(shortkey, keys)
+      if out:
+        cached_outputs.append(out)
+        return False
+      return True
+    chunks = filter(load_from_cache, chunks)
+    if len(cached_outputs) > 0:
+      if DEBUG: print >> sys.stderr, '  loading %d jsfuncchunks from jcache' % len(cached_outputs)
+    else:
+      cached_outputs = []
+
+  if len(chunks) > 0:
+    def write_chunk(chunk, i):
+      temp_file = temp_files.get('.jsfunc_%d.js' % i).name
+      f = open(temp_file, 'w')
+      f.write(chunk)
+      f.write(suffix_marker)
+      if minify_globals:
+        assert not extra_info
+        f.write('\n')
+        f.write('// EXTRA_INFO:' + minify_info)
+      elif extra_info:
+        f.write('\n')
+        f.write('// EXTRA_INFO:' + json.dumps(extra_info))
+      f.close()
+      return temp_file
+    filenames = [write_chunk(chunks[i], i) for i in range(len(chunks))]
+  else:
+    filenames = []
+
+  if len(filenames) > 0:
+    # XXX Use '--nocrankshaft' to disable crankshaft to work around v8 bug 1895, needed for older v8/node (node 0.6.8+ should be ok)
+    commands = map(lambda filename: js_engine +
+        [JS_OPTIMIZER, filename, 'noPrintMetadata'] +
+        (['--debug'] if source_map else []) + passes, filenames)
+    #print [' '.join(command) for command in commands]
+
+    cores = min(cores, filenames)
+    if len(chunks) > 1 and cores >= 2:
+      # We can parallelize
+      if DEBUG: print >> sys.stderr, 'splitting up js optimization into %d chunks of size %d, using %d cores  (total: %.2f MB)' % (len(chunks), chunk_size, cores, total_size/(1024*1024.))
+      pool = multiprocessing.Pool(processes=cores)
+      filenames = pool.map(run_on_chunk, commands, chunksize=1)
+    else:
+      # We can't parallize, but still break into chunks to avoid uglify/node memory issues
+      if len(chunks) > 1 and DEBUG: print >> sys.stderr, 'splitting up js optimization into %d chunks of size %d' % (len(chunks), chunk_size)
+      filenames = [run_on_chunk(command) for command in commands]
+  else:
+    filenames = []
+
+  for filename in filenames: temp_files.note(filename)
+
+  if closure:
+    # run closure on the shell code, everything but what we js-optimize
+    start_asm = '// EMSCRIPTEN_START_ASM\n'
+    end_asm = '// EMSCRIPTEN_END_ASM\n'
+    closure_sep = 'wakaUnknownBefore(); var asm=wakaUnknownAfter(global,env,buffer)\n'
+
+    closuree = temp_files.get('.closure.js').name
+    c = open(closuree, 'w')
+    pre_1, pre_2 = pre.split(start_asm)
+    post_1, post_2 = post.split(end_asm)
+    c.write(pre_1)
+    c.write(closure_sep)
+    c.write(post_2)
+    c.close()
+    closured = shared.Building.closure_compiler(closuree, pretty='minifyWhitespace' not in passes)
+    temp_files.note(closured)
+    coutput = open(closured).read()
+    coutput = coutput.replace('wakaUnknownBefore();', '')
+    after = 'wakaUnknownAfter'
+    start = coutput.find(after)
+    end = coutput.find(')', start)
+    pre = coutput[:start] + '(function(global,env,buffer) {\n' + start_asm + pre_2[pre_2.find('{')+1:]
+    post = post_1[:post_1.rfind('}')] + '\n' + end_asm + '\n})' + coutput[end+1:]
+
+  filename += '.jo.js'
+  f = open(filename, 'w')
+  f.write(pre);
+  for out_file in filenames:
+    f.write(open(out_file).read())
+    f.write('\n')
+  if jcache:
+    for cached in cached_outputs:
+      f.write(cached); # TODO: preserve order
+      f.write('\n')
+  f.write(post);
+  # No need to write suffix: if there was one, it is inside post which exists when suffix is there
+  f.write('\n')
+  f.close()
+
+  if jcache:
+    # save chunks to cache
+    for i in range(len(chunks)):
+      chunk = chunks[i]
+      keys = [chunk]
+      shortkey = shared.JCache.get_shortkey(keys)
+      shared.JCache.set(shortkey, keys, open(filenames[i]).read())
+    if DEBUG and len(chunks) > 0: print >> sys.stderr, '  saving %d jsfuncchunks to jcache' % len(chunks)
+
+  return filename
+
+def run(filename, passes, js_engine, jcache, source_map=False, extra_info=None):
+  return temp_files.run_and_clean(lambda: run_on_js(filename, passes, js_engine, jcache, source_map, extra_info))
+

data/modules/emscripten/tools/jsrun.py

@@ -0,0 +1,27 @@
+import time
+from subprocess import Popen, PIPE, STDOUT
+
+def timeout_run(proc, timeout, note='unnamed process', full_output=False):
+  start = time.time()
+  if timeout is not None:
+    while time.time() - start < timeout and proc.poll() is None:
+      time.sleep(0.1)
+    if proc.poll() is None:
+      proc.kill() # XXX bug: killing emscripten.py does not kill it's child process!
+      raise Exception("Timed out: " + note)
+  out = proc.communicate()
+  return '\n'.join(out) if full_output else out[0]
+
+def run_js(filename, engine=None, args=[], check_timeout=False, stdout=PIPE, stderr=None, cwd=None, full_output=False):
+  if type(engine) is not list:
+    engine = [engine]
+  command = engine + [filename] + (['--'] if 'd8' in engine[0] else []) + args
+  return timeout_run(
+    Popen(
+      command,
+      stdout=stdout,
+      stderr=stderr,
+      cwd=cwd),
+    15*60 if check_timeout else None,
+    'Execution',
+    full_output=full_output)

data/modules/emscripten/tools/ll-strip.py

@@ -0,0 +1,56 @@
+#!/usr/bin/python2
+
+import sys, re
+
+def print_usage():
+  print >> sys.stderr, "Usage: ll-strip.py file from to"
+  print >> sys.stderr, "\tStrip function bodies in all ll file in the [from, to] range"
+  sys.exit(1)
+
+try:
+  range_from = int(sys.argv[2])
+  range_to = int(sys.argv[3])
+  if range_from >= range_to:
+    raise "error"
+  file = open(sys.argv[1])
+except:
+  print_usage()
+
+func_start = re.compile("^define\s")
+func_end = re.compile("^}$")
+
+function_counter = 0
+in_function = False
+line_number = 0
+skip = False
+dummy_stmt = "unreachable"
+for orig_line in file:
+  line = orig_line.strip()
+  if func_start.match(line):
+    if in_function:
+      print >> sys.stderr, "Discovered a function inside another function!"
+      sys.exit(1)
+    in_function = True
+    line_number = 0
+    skip = False
+    function_counter = function_counter + 1
+  elif func_end.match(line):
+    if not in_function:
+      print >> sys.stderr, "Discovered a function end without a matching beginning!"
+      sys.exit(1)
+    in_function = False
+    line_number = 0
+    skip = False
+  elif in_function:
+    line_number = line_number + 1
+    if not skip and line_number == 1:
+      if line == dummy_stmt:
+        function_counter = function_counter - 1
+      if range_from <= function_counter <= range_to and line_number == 1:
+        #import pdb;pdb.set_trace()
+        if line != dummy_stmt:
+          skip = True
+          print dummy_stmt
+  if not skip:
+    print orig_line.rstrip("\n")
+

data/modules/emscripten/tools/make_file.py

@@ -0,0 +1,19 @@
+'''
+Takes the output from a JS test, and creates a file from it. So if
+you do JSON.stringify() of an array in JS, this script will take
+that and make a proper file out of it
+'''
+
+import os, sys, re
+
+data = open(sys.argv[1], 'r').read()
+m = re.search('\[[\d, -]*\]', data)
+data = eval(m.group(0))
+data = [x&0xff for x in data]
+string = ''.join([chr(item) for item in data])
+out = open(sys.argv[1]+'.' + (sys.argv[2] if len(sys.argv) >= 3 else 'raw'), 'wb')
+print data[0:80]
+print string[0:80]
+out.write(string)
+out.close()
+

data/modules/emscripten/tools/make_minigzip.py

@@ -0,0 +1,13 @@
+import os, sys
+from subprocess import Popen, PIPE, STDOUT
+
+import shared
+
+print 'Building zlib'
+
+zlib = shared.Building.build_library('zlib', shared.EMSCRIPTEN_TEMP_DIR, shared.EMSCRIPTEN_TEMP_DIR, ['libz.a'], make_args=['libz.a'], copy_project=True, source_dir=shared.path_from_root('tests', 'zlib'))[0]
+
+print 'Building minigzip'
+
+Popen(['python2', shared.EMCC, '-O2', shared.path_from_root('tests', 'zlib', 'minigzip.c'), zlib, '-o', shared.path_from_root('tools', 'minigzip.js')]).communicate()
+

data/modules/emscripten/tools/namespacer.py

@@ -0,0 +1,95 @@
+#!/usr/bin/python2
+
+'''
+Tool that generates namespace boilerplate. Given
+
+  _mangled_name1_ = MyClass::MyClass()
+  _mangled_name2_ = MyClass::~MyClass()
+  _mangled_name3_ = MyClass::DoSomething(int)
+
+the tool will generate
+
+  MyClass = {
+    'MyClass':     _mangled_name1_,
+    '~MyClass':  _mangled_name2_,
+    'DoSomething': _mangled_name3_
+  };
+
+You can then do the following in JavaScript:
+
+  MyClass.MyClass(ptr);
+  MyClass['~MyClass'](ptr); // Need string here, due to |~|
+  MyClass.DoSomething(ptr, 17);
+
+Note that you need to send the |this| pointer yourself. TODO:
+a more OO boilerplate on top of that.
+'''
+
+import os, sys, json
+
+js = open(sys.argv[1], 'r').read()
+data = open(sys.argv[2], 'r').readlines()
+
+space = {}
+
+counts = {}
+
+for line in data:
+  line = line.rstrip()
+
+  realname, signature = line.split(' = ')
+  signature = signature.replace(') const', ')')
+  signature = signature[:-1].split('(')
+  func, params = signature[0], '('.join(signature[1:])
+
+  if ' ' in func:
+    i = func.index(' ')
+    ret = func[:i]
+    if '<' not in ret and '[' not in ret and '(' not in ret:
+      func = func[i+1:]
+
+  #funcparts = ['Namespace'] + func.split('::')
+  funcparts = func.split('::')
+
+  currspace = space
+  for part in funcparts[:-1]:
+    currspace = currspace.setdefault(part, {})
+
+  finalname = funcparts[-1]
+  key = str(funcparts)
+  if key in counts:
+    i = counts[key]
+    counts[key] += 1
+    finalname += '_' + str(i)
+  else:
+    i = 0
+    counts[key] = 1
+  currspace[finalname] = realname
+  currspace[finalname + '__params'] = params
+  if len(funcparts) >= 2 and funcparts[-1] == funcparts[-2]:
+    found = False
+    for what in ['struct', 'class']:
+      size = '$%s_%s' % (what, '__'.join(funcparts[:-1]))
+      if len(funcparts) > 2:
+        size = '_' + size + '_'
+      size = size + '___SIZE'
+      if size in js:
+        found = True
+        break
+    if not found:
+      #print '// Warning: cannot find %s' % ('[_]$[class|struct]' + '__'.join(funcparts[:-1]) + '[_]___SIZE')
+      continue
+    currspace['__new__' + ('' if i == 0 else str(i))] = 'function() { var ret = _malloc(%s); Module._.%s.%s.apply(null, [ret].concat(Array.prototype.slice.apply(arguments))); return ret; }' % (
+      size, '.'.join(funcparts[:-1]), finalname
+    )
+
+def finalize(line):
+  try:
+    key, val = line.split(': ')
+    assert val != '}' and '_params"' not in key
+    return key + ': ' + val.replace('"', '')
+  except:
+    return line
+
+print 'var ModuleNames = ' + '\n'.join(map(finalize, json.dumps(space, sort_keys=True, indent=2).split('\n')))
+

data/modules/emscripten/tools/nativize_llvm.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python2
+
+'''
+Small utility to build some llvm bitcode into native code. Useful when lli (called
+from exec_llvm) fails for some reason.
+
+ * Use llc to generate x86 asm
+ * Use as to generate an object file
+ * Use g++ to link it to an executable
+'''
+
+import os, sys
+from subprocess import Popen, PIPE, STDOUT
+
+__rootpath__ = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
+def path_from_root(*pathelems):
+  return os.path.join(__rootpath__, *pathelems)
+exec(open(path_from_root('tools', 'shared.py'), 'r').read())
+
+filename = sys.argv[1]
+libs = sys.argv[2:] # e.g.: dl for dlopen/dlclose, util for openpty/forkpty
+
+print 'bc => clean bc'
+Popen([LLVM_OPT, filename, '-strip-debug', '-o=' + filename + '.clean.bc']).communicate()[0]
+print 'bc => s'
+for params in [[], ['-march=x86-64']]: # try x86, then x86-64 FIXME
+  print 'params', params
+  Popen([LLVM_COMPILER] + params + [filename + '.clean.bc', '-o=' + filename + '.s']).communicate()[0]
+  print 's => o'
+  Popen(['as', filename + '.s', '-o', filename + '.o']).communicate()[0]
+  if os.path.exists(filename + '.o'): break
+print 'o => runnable'
+Popen(['g++', path_from_root('system', 'lib', 'debugging.cpp'), filename + '.o', '-o', filename + '.run'] + ['-l' + lib for lib in libs]).communicate()[0]
+

data/modules/emscripten/tools/node_modules/source-map/CHANGELOG.md

@@ -0,0 +1,58 @@
+# Change Log
+
+## 0.1.22
+
+* Ignore duplicate mappings in SourceMapGenerator. Fixes github issue 21.
+
+## 0.1.21
+
+* Fixed handling of sources that start with a slash so that they are relative to
+  the source root's host.
+
+## 0.1.20
+
+* Fixed github issue #43: absolute URLs aren't joined with the source root
+  anymore.
+
+## 0.1.19
+
+* Using Travis CI to run tests.
+
+## 0.1.18
+
+* Fixed a bug in the handling of sourceRoot.
+
+## 0.1.17
+
+* Added SourceNode.fromStringWithSourceMap.
+
+## 0.1.16
+
+* Added missing documentation.
+
+* Fixed the generating of empty mappings in SourceNode.
+
+## 0.1.15
+
+* Added SourceMapGenerator.applySourceMap.
+
+## 0.1.14
+
+* The sourceRoot is now handled consistently.
+
+## 0.1.13
+
+* Added SourceMapGenerator.fromSourceMap.
+
+## 0.1.12
+
+* SourceNode now generates empty mappings too.
+
+## 0.1.11
+
+* Added name support to SourceNode.
+
+## 0.1.10
+
+* Added sourcesContent support to the customer and generator.
+

data/modules/emscripten/tools/node_modules/source-map/LICENSE

@@ -0,0 +1,28 @@
+
+Copyright (c) 2009-2011, Mozilla Foundation and contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the names of the Mozilla Foundation nor the names of project
+  contributors may be used to endorse or promote products derived from this
+  software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.